← Back to branch summary

~ubuntu-branches/ubuntu/trusty/horizon/trusty-updates

« back to all changes in this revision

Viewing changes to openstack_dashboard/dashboards/admin/metering/tables.py

  • Committer: Package Import Robot
  • Author(s): Adam Gandelman
  • Date: 2013-09-06 11:59:43 UTC
  • mfrom: (1.1.30)
  • Revision ID: package-import@ubuntu.com-20130906115943-h3td0l7tp16mb9oc
Tags: 1:2013.2~b3-0ubuntu1
* New upstream release.
* debian/control: Minimum python-openstack-auth version >= 1.1.1.
* debian/control: Add python-troveclient.
* debian/static: Refresh static assets for 2013.2~b3.
* debian/patches: ubuntu_local_settings.patch -> ubuntu_settings.patch, also
  patch location of secret key in openstack_dashboard/settings.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
openstack_dashboard/dashboards/admin/metering/tables.py
 
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
 
2
#
 
3
# Licensed under the Apache License, Version 2.0 (the "License"); you may
 
4
# not use this file except in compliance with the License. You may obtain
 
5
# a copy of the License at
 
6
#
 
7
#      http://www.apache.org/licenses/LICENSE-2.0
 
8
#
 
9
# Unless required by applicable law or agreed to in writing, software
 
10
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
11
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
12
# License for the specific language governing permissions and limitations
 
13
# under the License.
 
14
 
 
15
import logging
 
16
 
 
17
from django.template.defaultfilters import filesizeformat  # noqa
 
18
from django.utils.translation import ugettext_lazy as _  # noqa
 
19
 
 
20
from horizon import exceptions
 
21
from horizon import tables
 
22
from openstack_dashboard import api
 
23
 
 
24
 
 
25
LOG = logging.getLogger(__name__)
 
26
 
 
27
 
 
28
class CommonFilterAction(tables.FilterAction):
 
29
    def filter(self, table, resources, filter_string):
 
30
        q = filter_string.lower()
 
31
        return [resource for resource in resources
 
32
                if q in resource.resource.lower() or
 
33
                   q in resource.tenant.lower() or
 
34
                   q in resource.user.lower()]
 
35
 
 
36
 
 
37
def get_status(fields):
 
38
    # TODO(lsmola) it should periodically renew the tables I guess
 
39
    def transform(datum):
 
40
        if any([getattr(datum, field, None) is 0 or getattr(datum, field, None)
 
41
                for field in fields]):
 
42
            return _("up")
 
43
        else:
 
44
            return _("none")
 
45
    return transform
 
46
 
 
47
 
 
48
class GlobalUsageTable(tables.DataTable):
 
49
    tenant = tables.Column("tenant", verbose_name=_("Tenant"), sortable=True,
 
50
                           filters=(lambda (t): getattr(t, 'name', ""),))
 
51
    user = tables.Column("user", verbose_name=_("User"), sortable=True,
 
52
                         filters=(lambda (u): getattr(u, 'name', ""),))
 
53
    instance = tables.Column("resource",
 
54
                             verbose_name=_("Resource"),
 
55
                             sortable=True)
 
56
 
 
57
 
 
58
class GlobalDiskUsageTable(tables.DataTable):
 
59
    tenant = tables.Column("id", verbose_name=_("Tenant"), sortable=True)
 
60
    disk_read_bytes = tables.Column("disk_read_bytes",
 
61
                                    filters=(filesizeformat,),
 
62
                                    verbose_name=_("Disk Read Bytes"),
 
63
                                    sortable=True)
 
64
    disk_read_requests = tables.Column("disk_read_requests",
 
65
                                       verbose_name=_("Disk Read Requests"),
 
66
                                       sortable=True)
 
67
    disk_write_bytes = tables.Column("disk_write_bytes",
 
68
                                     verbose_name=_("Disk Write Bytes"),
 
69
                                     filters=(filesizeformat,),
 
70
                                     sortable=True)
 
71
    disk_write_requests = tables.Column("disk_write_requests",
 
72
                                        verbose_name=_("Disk Write Requests"),
 
73
                                        sortable=True)
 
74
 
 
75
    class Meta:
 
76
        name = "global_disk_usage"
 
77
        verbose_name = _("Global Disk Usage (average of last 30 days)")
 
78
        table_actions = (CommonFilterAction,)
 
79
        multi_select = False
 
80
 
 
81
 
 
82
class GlobalNetworkTrafficUsageTable(tables.DataTable):
 
83
    tenant = tables.Column("id", verbose_name=_("Tenant"), sortable=True)
 
84
    network_incoming_bytes = tables\
 
85
            .Column("network_incoming_bytes",
 
86
                    verbose_name=_("Network Incoming Bytes"),
 
87
                    filters=(filesizeformat,),
 
88
                    sortable=True)
 
89
    network_incoming_packets = tables\
 
90
            .Column("network_incoming_packets",
 
91
                    verbose_name=_("Network Incoming Packets"),
 
92
                    sortable=True)
 
93
    network_outgoing_bytes = tables\
 
94
            .Column("network_outgoing_bytes",
 
95
                    verbose_name=_("Network Outgoing Bytes"),
 
96
                    filters=(filesizeformat,),
 
97
                    sortable=True)
 
98
    network_outgoing_packets = tables\
 
99
            .Column("network_outgoing_packets",
 
100
                    verbose_name=_("Network Outgoing Packets"),
 
101
                    sortable=True)
 
102
 
 
103
    class Meta:
 
104
        name = "global_network_traffic_usage"
 
105
        verbose_name = _("Global Network Traffic Usage (average "
 
106
                         "of last 30 days)")
 
107
        table_actions = (CommonFilterAction,)
 
108
        multi_select = False
 
109
 
 
110
 
 
111
class GlobalNetworkUsageTable(tables.DataTable):
 
112
    tenant = tables.Column("id", verbose_name=_("Tenant"), sortable=True)
 
113
    network_duration = tables.Column("network",
 
114
                                     verbose_name=_("Network Duration"),
 
115
                                     sortable=True)
 
116
    network_creation_requests = tables\
 
117
            .Column("network_create",
 
118
                    verbose_name=_("Network Creation Requests"),
 
119
                    sortable=True)
 
120
    subnet_duration = tables.Column("subnet",
 
121
                                    verbose_name=_("Subnet Duration"),
 
122
                                    sortable=True)
 
123
    subnet_creation = tables.Column("subnet_create",
 
124
                                    verbose_name=_("Subnet Creation Requests"),
 
125
                                    sortable=True)
 
126
    port_duration = tables.Column("port",
 
127
                                  verbose_name=_("Port Duration"),
 
128
                                  sortable=True)
 
129
    port_creation = tables.Column("port_create",
 
130
                                  verbose_name=_("Port Creation Requests"),
 
131
                                  sortable=True)
 
132
    router_duration = tables.Column("router",
 
133
                                    verbose_name=_("Router Duration"),
 
134
                                    sortable=True)
 
135
    router_creation = tables.Column("router_create",
 
136
                                    verbose_name=_("Router Creation Requests"),
 
137
                                    sortable=True)
 
138
    port_duration = tables.Column("port",
 
139
                                  verbose_name=_("Port Duration"),
 
140
                                  sortable=True)
 
141
    port_creation = tables.Column("port_create",
 
142
                                  verbose_name=_("Port Creation Requests"),
 
143
                                  sortable=True)
 
144
    ip_floating_duration = tables\
 
145
            .Column("ip_floating",
 
146
                    verbose_name=_("Floating IP Duration"),
 
147
                    sortable=True)
 
148
    ip_floating_creation = tables\
 
149
            .Column("ip_floating_create",
 
150
                    verbose_name=_("Floating IP Creation Requests"),
 
151
                    sortable=True)
 
152
 
 
153
    class Meta:
 
154
        name = "global_network_usage"
 
155
        verbose_name = _("Global Network Usage (average of last 30 days)")
 
156
        table_actions = (CommonFilterAction,)
 
157
        multi_select = False
 
158
 
 
159
 
 
160
class GlobalObjectStoreUsageUpdateRow(tables.Row):
 
161
    ajax = True
 
162
 
 
163
    def get_data(self, request, object_id):
 
164
        ceilometer_usage = api.ceilometer.CeilometerUsage(request)
 
165
 
 
166
        query = ceilometer_usage.query_from_object_id(object_id)
 
167
        try:
 
168
            data = ceilometer_usage.global_object_store_usage(
 
169
                query,
 
170
                with_statistics=True)
 
171
        except Exception:
 
172
            data = []
 
173
            exceptions.handle(request,
 
174
                              _('Unable to retrieve statistics.'))
 
175
            return None
 
176
        return data[0]
 
177
 
 
178
 
 
179
class GlobalObjectStoreUsageTable(tables.DataTable):
 
180
    tenant = tables.Column("tenant", verbose_name=_("Tenant"), sortable=True,
 
181
                           filters=(lambda (t): getattr(t, 'name', ""),))
 
182
    status = tables.Column(get_status(["storage_objects",
 
183
                                       "storage_objects_size",
 
184
                                       "storage_objects_incoming_bytes",
 
185
                                       "storage_objects_outgoing_bytes"]),
 
186
                           verbose_name=_("Status"),
 
187
                           hidden=True)
 
188
    resource = tables.Column("resource",
 
189
                             verbose_name=_("Resource"),
 
190
                             sortable=True)
 
191
    storage_incoming_bytes = tables.Column(
 
192
        "storage_objects_incoming_bytes",
 
193
        verbose_name=_("Object Storage Incoming Bytes"),
 
194
        filters=(filesizeformat,),
 
195
        sortable=True)
 
196
    storage_outgoing_bytes = tables.Column(
 
197
        "storage_objects_outgoing_bytes",
 
198
        verbose_name=_("Object Storage Outgoing Bytes"),
 
199
        filters=(filesizeformat,),
 
200
        sortable=True)
 
201
    storage_objects = tables.Column(
 
202
        "storage_objects",
 
203
        verbose_name=_("Total Number of Objects"),
 
204
        sortable=True)
 
205
    storage_objects_size = tables.Column(
 
206
        "storage_objects_size",
 
207
        filters=(filesizeformat,),
 
208
        verbose_name=_("Total Size of Objects "),
 
209
        sortable=True)
 
210
 
 
211
    class Meta:
 
212
        name = "global_object_store_usage"
 
213
        verbose_name = _("Global Object Store Usage (average of last 30 days)")
 
214
        table_actions = (CommonFilterAction,)
 
215
        row_class = GlobalObjectStoreUsageUpdateRow
 
216
        status_columns = ["status"]
 
217
        multi_select = False