← Back to branch summary

~ubuntu-branches/ubuntu/trusty/horizon/trusty-proposed

« back to all changes in this revision

Viewing changes to .pc/fix-host-listing-live-migration.patch/openstack_dashboard/test/test_data/nova_data.py

  • Committer: Package Import Robot
  • Author(s): Corey Bryant
  • Date: 2015-06-22 10:14:26 UTC
  • mfrom: (1.1.45)
  • Revision ID: package-import@ubuntu.com-20150622101426-2pzn67w27qdqwuq3
Tags: 1:2014.1.5-0ubuntu1
https://launchpad.net/bugs/1467533
* Resynchronize with stable/icehouse (4ff165c) (LP: #1467533):
  - [78b6f5e] Fix exponentially growing AJAX updates for table rows
  - [86a6628] Handle RequestURITooLong error in large instance table
  - [2a6fe4a] Fix host listing in live migration
  - [9109812] Exclude security group related quotas when the extension disabled
  - [4ff165c] horizon ignores region for identity service
* d/p/fix-host-listing-live-migration.patch: Dropped; Fixed upstream.
* d/p/fix-requirements.patch: Rebased

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/fix-host-listing-live-migration.patch/openstack_dashboard/test/test_data/nova_data.py
1
 
# Copyright 2012 Nebula, Inc.
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 json
16
 
import uuid
17
 
 
18
 
from novaclient.v1_1 import aggregates
19
 
from novaclient.v1_1 import availability_zones
20
 
from novaclient.v1_1 import certs
21
 
from novaclient.v1_1 import flavor_access
22
 
from novaclient.v1_1 import flavors
23
 
from novaclient.v1_1 import floating_ips
24
 
from novaclient.v1_1 import hosts
25
 
from novaclient.v1_1 import hypervisors
26
 
from novaclient.v1_1 import keypairs
27
 
from novaclient.v1_1 import quotas
28
 
from novaclient.v1_1 import security_group_rules as rules
29
 
from novaclient.v1_1 import security_groups as sec_groups
30
 
from novaclient.v1_1 import servers
31
 
from novaclient.v1_1 import services
32
 
from novaclient.v1_1 import usage
33
 
from novaclient.v1_1 import volume_snapshots as vol_snaps
34
 
from novaclient.v1_1 import volume_types
35
 
from novaclient.v1_1 import volumes
36
 
 
37
 
from openstack_dashboard.api import base
38
 
from openstack_dashboard.api import nova
39
 
from openstack_dashboard.usage import quotas as usage_quotas
40
 
 
41
 
from openstack_dashboard.test.test_data import utils
42
 
 
43
 
 
44
 
SERVER_DATA = """
45
 
{
46
 
    "server": {
47
 
        "OS-EXT-SRV-ATTR:instance_name": "instance-00000005",
48
 
        "OS-EXT-SRV-ATTR:host": "instance-host",
49
 
        "OS-EXT-STS:task_state": null,
50
 
        "addresses": {
51
 
            "private": [
52
 
                {
53
 
                    "version": 4,
54
 
                    "addr": "10.0.0.1"
55
 
                }
56
 
            ]
57
 
        },
58
 
        "links": [
59
 
            {
60
 
                "href": "%(host)s/v1.1/%(tenant_id)s/servers/%(server_id)s",
61
 
                "rel": "self"
62
 
            },
63
 
            {
64
 
                "href": "%(host)s/%(tenant_id)s/servers/%(server_id)s",
65
 
                "rel": "bookmark"
66
 
            }
67
 
        ],
68
 
        "image": {
69
 
            "id": "%(image_id)s",
70
 
            "links": [
71
 
                {
72
 
                    "href": "%(host)s/%(tenant_id)s/images/%(image_id)s",
73
 
                    "rel": "bookmark"
74
 
                }
75
 
            ]
76
 
        },
77
 
        "OS-EXT-STS:vm_state": "active",
78
 
        "flavor": {
79
 
            "id": "%(flavor_id)s",
80
 
            "links": [
81
 
                {
82
 
                    "href": "%(host)s/%(tenant_id)s/flavors/%(flavor_id)s",
83
 
                    "rel": "bookmark"
84
 
                }
85
 
            ]
86
 
        },
87
 
        "id": "%(server_id)s",
88
 
        "user_id": "%(user_id)s",
89
 
        "OS-DCF:diskConfig": "MANUAL",
90
 
        "accessIPv4": "",
91
 
        "accessIPv6": "",
92
 
        "progress": null,
93
 
        "OS-EXT-STS:power_state": 1,
94
 
        "config_drive": "",
95
 
        "status": "%(status)s",
96
 
        "updated": "2012-02-28T19:51:27Z",
97
 
        "hostId": "c461ea283faa0ab5d777073c93b126c68139e4e45934d4fc37e403c2",
98
 
        "key_name": "%(key_name)s",
99
 
        "name": "%(name)s",
100
 
        "created": "2012-02-28T19:51:17Z",
101
 
        "tenant_id": "%(tenant_id)s",
102
 
        "metadata": {"someMetaLabel": "someMetaData",
103
 
                     "some<b>html</b>label": "<!--",
104
 
                     "empty": ""}
105
 
    }
106
 
}
107
 
"""
108
 
 
109
 
 
110
 
USAGE_DATA = """
111
 
{
112
 
    "total_memory_mb_usage": 64246.89777777778,
113
 
    "total_vcpus_usage": 125.48222222222223,
114
 
    "total_hours": 125.48222222222223,
115
 
    "total_local_gb_usage": 0,
116
 
    "tenant_id": "%(tenant_id)s",
117
 
    "stop": "2012-01-31 23:59:59",
118
 
    "start": "2012-01-01 00:00:00",
119
 
    "server_usages": [
120
 
        {
121
 
            "memory_mb": %(flavor_ram)s,
122
 
            "uptime": 442321,
123
 
            "started_at": "2012-01-26 20:38:21",
124
 
            "ended_at": null,
125
 
            "name": "%(instance_name)s",
126
 
            "tenant_id": "%(tenant_id)s",
127
 
            "state": "active",
128
 
            "hours": 122.87361111111112,
129
 
            "vcpus": %(flavor_vcpus)s,
130
 
            "flavor": "%(flavor_name)s",
131
 
            "local_gb": %(flavor_disk)s
132
 
        },
133
 
        {
134
 
            "memory_mb": %(flavor_ram)s,
135
 
            "uptime": 9367,
136
 
            "started_at": "2012-01-31 20:54:15",
137
 
            "ended_at": null,
138
 
            "name": "%(instance_name)s",
139
 
            "tenant_id": "%(tenant_id)s",
140
 
            "state": "active",
141
 
            "hours": 2.608611111111111,
142
 
            "vcpus": %(flavor_vcpus)s,
143
 
            "flavor": "%(flavor_name)s",
144
 
            "local_gb": %(flavor_disk)s
145
 
        }
146
 
    ]
147
 
}
148
 
"""
149
 
 
150
 
 
151
 
def data(TEST):
152
 
    TEST.servers = utils.TestDataContainer()
153
 
    TEST.flavors = utils.TestDataContainer()
154
 
    TEST.flavor_access = utils.TestDataContainer()
155
 
    TEST.keypairs = utils.TestDataContainer()
156
 
    TEST.security_groups = utils.TestDataContainer()
157
 
    TEST.security_groups_uuid = utils.TestDataContainer()
158
 
    TEST.security_group_rules = utils.TestDataContainer()
159
 
    TEST.security_group_rules_uuid = utils.TestDataContainer()
160
 
    TEST.volumes = utils.TestDataContainer()
161
 
    TEST.quotas = utils.TestDataContainer()
162
 
    TEST.quota_usages = utils.TestDataContainer()
163
 
    TEST.disabled_quotas = utils.TestDataContainer()
164
 
    TEST.floating_ips = utils.TestDataContainer()
165
 
    TEST.floating_ips_uuid = utils.TestDataContainer()
166
 
    TEST.usages = utils.TestDataContainer()
167
 
    TEST.certs = utils.TestDataContainer()
168
 
    TEST.volume_snapshots = utils.TestDataContainer()
169
 
    TEST.volume_types = utils.TestDataContainer()
170
 
    TEST.availability_zones = utils.TestDataContainer()
171
 
    TEST.hypervisors = utils.TestDataContainer()
172
 
    TEST.services = utils.TestDataContainer()
173
 
    TEST.aggregates = utils.TestDataContainer()
174
 
    TEST.hosts = utils.TestDataContainer()
175
 
 
176
 
    # Data return by novaclient.
177
 
    # It is used if API layer does data conversion.
178
 
    TEST.api_floating_ips = utils.TestDataContainer()
179
 
    TEST.api_floating_ips_uuid = utils.TestDataContainer()
180
 
 
181
 
    # Volumes
182
 
    volume = volumes.Volume(volumes.VolumeManager(None),
183
 
                            dict(id="41023e92-8008-4c8b-8059-7f2293ff3775",
184
 
                                 name='test_volume',
185
 
                                 status='available',
186
 
                                 size=40,
187
 
                                 display_name='Volume name',
188
 
                                 created_at='2012-04-01 10:30:00',
189
 
                                 volume_type=None,
190
 
                                 attachments=[]))
191
 
    nameless_volume = volumes.Volume(volumes.VolumeManager(None),
192
 
                         dict(id="3b189ac8-9166-ac7f-90c9-16c8bf9e01ac",
193
 
                              name='',
194
 
                              status='in-use',
195
 
                              size=10,
196
 
                              display_name='',
197
 
                              display_description='',
198
 
                              device="/dev/hda",
199
 
                              created_at='2010-11-21 18:34:25',
200
 
                              volume_type='vol_type_1',
201
 
                              attachments=[{"id": "1", "server_id": '1',
202
 
                                            "device": "/dev/hda"}]))
203
 
    attached_volume = volumes.Volume(volumes.VolumeManager(None),
204
 
                         dict(id="8cba67c1-2741-6c79-5ab6-9c2bf8c96ab0",
205
 
                              name='my_volume',
206
 
                              status='in-use',
207
 
                              size=30,
208
 
                              display_name='My Volume',
209
 
                              display_description='',
210
 
                              device="/dev/hdk",
211
 
                              created_at='2011-05-01 11:54:33',
212
 
                              volume_type='vol_type_2',
213
 
                              attachments=[{"id": "2", "server_id": '1',
214
 
                                            "device": "/dev/hdk"}]))
215
 
    TEST.volumes.add(volume)
216
 
    TEST.volumes.add(nameless_volume)
217
 
    TEST.volumes.add(attached_volume)
218
 
 
219
 
    vol_type1 = volume_types.VolumeType(volume_types.VolumeTypeManager(None),
220
 
                                        {'id': 1,
221
 
                                         'name': 'vol_type_1'})
222
 
    vol_type2 = volume_types.VolumeType(volume_types.VolumeTypeManager(None),
223
 
                                        {'id': 2,
224
 
                                         'name': 'vol_type_2'})
225
 
    TEST.volume_types.add(vol_type1, vol_type2)
226
 
 
227
 
    # Flavors
228
 
    flavor_1 = flavors.Flavor(flavors.FlavorManager(None),
229
 
                              {'id': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
230
 
                               'name': 'm1.tiny',
231
 
                               'vcpus': 1,
232
 
                               'disk': 0,
233
 
                               'ram': 512,
234
 
                               'swap': 0,
235
 
                               'extra_specs': {},
236
 
                               'os-flavor-access:is_public': True,
237
 
                               'OS-FLV-EXT-DATA:ephemeral': 0})
238
 
    flavor_2 = flavors.Flavor(flavors.FlavorManager(None),
239
 
                              {'id': "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
240
 
                               'name': 'm1.massive',
241
 
                               'vcpus': 1000,
242
 
                               'disk': 1024,
243
 
                               'ram': 10000,
244
 
                               'swap': 0,
245
 
                               'extra_specs': {'Trusted': True, 'foo': 'bar'},
246
 
                               'os-flavor-access:is_public': True,
247
 
                               'OS-FLV-EXT-DATA:ephemeral': 2048})
248
 
    flavor_3 = flavors.Flavor(flavors.FlavorManager(None),
249
 
                              {'id': "dddddddd-dddd-dddd-dddd-dddddddddddd",
250
 
                               'name': 'm1.secret',
251
 
                               'vcpus': 1000,
252
 
                               'disk': 1024,
253
 
                               'ram': 10000,
254
 
                               'swap': 0,
255
 
                               'extra_specs': {},
256
 
                               'os-flavor-access:is_public': False,
257
 
                               'OS-FLV-EXT-DATA:ephemeral': 2048})
258
 
    TEST.flavors.add(flavor_1, flavor_2, flavor_3)
259
 
 
260
 
    flavor_access_manager = flavor_access.FlavorAccessManager(None)
261
 
    flavor_access_1 = flavor_access.FlavorAccess(flavor_access_manager,
262
 
            {"tenant_id": "1",
263
 
             "flavor_id": "dddddddd-dddd-dddd-dddd-dddddddddddd"})
264
 
    flavor_access_2 = flavor_access.FlavorAccess(flavor_access_manager,
265
 
            {"tenant_id": "2",
266
 
             "flavor_id": "dddddddd-dddd-dddd-dddd-dddddddddddd"})
267
 
    TEST.flavor_access.add(flavor_access_1, flavor_access_2)
268
 
 
269
 
    # Key pairs
270
 
    keypair = keypairs.Keypair(keypairs.KeypairManager(None),
271
 
                               dict(name='keyName'))
272
 
    TEST.keypairs.add(keypair)
273
 
 
274
 
    # Security Groups and Rules
275
 
    def generate_security_groups(is_uuid=False):
276
 
 
277
 
        def get_id(is_uuid):
278
 
            global current_int_id
279
 
            if is_uuid:
280
 
                return str(uuid.uuid4())
281
 
            else:
282
 
                get_id.current_int_id += 1
283
 
                return get_id.current_int_id
284
 
 
285
 
        get_id.current_int_id = 0
286
 
 
287
 
        sg_manager = sec_groups.SecurityGroupManager(None)
288
 
        rule_manager = rules.SecurityGroupRuleManager(None)
289
 
 
290
 
        sec_group_1 = sec_groups.SecurityGroup(sg_manager,
291
 
                                               {"rules": [],
292
 
                                                "tenant_id": TEST.tenant.id,
293
 
                                                "id": get_id(is_uuid),
294
 
                                                "name": u"default",
295
 
                                                "description": u"default"})
296
 
        sec_group_2 = sec_groups.SecurityGroup(sg_manager,
297
 
                                               {"rules": [],
298
 
                                                "tenant_id": TEST.tenant.id,
299
 
                                                "id": get_id(is_uuid),
300
 
                                                "name": u"other_group",
301
 
                                                "description": u"NotDefault."})
302
 
        sec_group_3 = sec_groups.SecurityGroup(sg_manager,
303
 
                                               {"rules": [],
304
 
                                                "tenant_id": TEST.tenant.id,
305
 
                                                "id": get_id(is_uuid),
306
 
                                                "name": u"another_group",
307
 
                                                "description": u"NotDefault."})
308
 
 
309
 
        rule = {'id': get_id(is_uuid),
310
 
                'group': {},
311
 
                'ip_protocol': u"tcp",
312
 
                'from_port': u"80",
313
 
                'to_port': u"80",
314
 
                'parent_group_id': sec_group_1.id,
315
 
                'ip_range': {'cidr': u"0.0.0.0/32"}}
316
 
 
317
 
        icmp_rule = {'id': get_id(is_uuid),
318
 
                     'group': {},
319
 
                     'ip_protocol': u"icmp",
320
 
                     'from_port': u"9",
321
 
                     'to_port': u"5",
322
 
                     'parent_group_id': sec_group_1.id,
323
 
                     'ip_range': {'cidr': u"0.0.0.0/32"}}
324
 
 
325
 
        group_rule = {'id': 3,
326
 
                      'group': {},
327
 
                      'ip_protocol': u"tcp",
328
 
                      'from_port': u"80",
329
 
                      'to_port': u"80",
330
 
                      'parent_group_id': sec_group_1.id,
331
 
                      'source_group_id': sec_group_1.id}
332
 
 
333
 
        rule_obj = rules.SecurityGroupRule(rule_manager, rule)
334
 
        rule_obj2 = rules.SecurityGroupRule(rule_manager, icmp_rule)
335
 
        rule_obj3 = rules.SecurityGroupRule(rule_manager, group_rule)
336
 
 
337
 
        sec_group_1.rules = [rule_obj]
338
 
        sec_group_2.rules = [rule_obj]
339
 
 
340
 
        return {"rules": [rule_obj, rule_obj2, rule_obj3],
341
 
                "groups": [sec_group_1, sec_group_2, sec_group_3]}
342
 
 
343
 
    sg_data = generate_security_groups()
344
 
    TEST.security_group_rules.add(*sg_data["rules"])
345
 
    TEST.security_groups.add(*sg_data["groups"])
346
 
 
347
 
    sg_uuid_data = generate_security_groups(is_uuid=True)
348
 
    TEST.security_group_rules_uuid.add(*sg_uuid_data["rules"])
349
 
    TEST.security_groups_uuid.add(*sg_uuid_data["groups"])
350
 
 
351
 
    # Quota Sets
352
 
    quota_data = dict(metadata_items='1',
353
 
                      injected_file_content_bytes='1',
354
 
                      volumes='1',
355
 
                      gigabytes='1000',
356
 
                      ram=10000,
357
 
                      floating_ips='1',
358
 
                      fixed_ips='10',
359
 
                      instances='10',
360
 
                      injected_files='1',
361
 
                      cores='10',
362
 
                      security_groups='10',
363
 
                      security_group_rules='20')
364
 
    quota = quotas.QuotaSet(quotas.QuotaSetManager(None), quota_data)
365
 
    TEST.quotas.nova = base.QuotaSet(quota)
366
 
    TEST.quotas.add(base.QuotaSet(quota))
367
 
 
368
 
    # nova quotas disabled when neutron is enabled
369
 
    disabled_quotas_nova = ['floating_ips', 'fixed_ips',
370
 
                            'security_groups', 'security_group_rules']
371
 
    TEST.disabled_quotas.add(disabled_quotas_nova)
372
 
 
373
 
    # Quota Usages
374
 
    quota_usage_data = {'gigabytes': {'used': 0,
375
 
                                      'quota': 1000},
376
 
                        'instances': {'used': 0,
377
 
                                      'quota': 10},
378
 
                        'ram': {'used': 0,
379
 
                                'quota': 10000},
380
 
                        'cores': {'used': 0,
381
 
                                  'quota': 20},
382
 
                        'floating_ips': {'used': 0,
383
 
                                         'quota': 10},
384
 
                        'volumes': {'used': 0,
385
 
                                    'quota': 10}}
386
 
    quota_usage = usage_quotas.QuotaUsage()
387
 
    for k, v in quota_usage_data.items():
388
 
        quota_usage.add_quota(base.Quota(k, v['quota']))
389
 
        quota_usage.tally(k, v['used'])
390
 
 
391
 
    TEST.quota_usages.add(quota_usage)
392
 
 
393
 
    # Limits
394
 
    limits = {"absolute": {"maxImageMeta": 128,
395
 
                           "maxPersonality": 5,
396
 
                           "maxPersonalitySize": 10240,
397
 
                           "maxSecurityGroupRules": 20,
398
 
                           "maxSecurityGroups": 10,
399
 
                           "maxServerMeta": 128,
400
 
                           "maxTotalCores": 20,
401
 
                           "maxTotalFloatingIps": 10,
402
 
                           "maxTotalInstances": 10,
403
 
                           "maxTotalKeypairs": 100,
404
 
                           "maxTotalRAMSize": 10000,
405
 
                           "totalCoresUsed": 0,
406
 
                           "totalInstancesUsed": 0,
407
 
                           "totalKeyPairsUsed": 0,
408
 
                           "totalRAMUsed": 0,
409
 
                           "totalSecurityGroupsUsed": 0}}
410
 
    TEST.limits = limits
411
 
 
412
 
    # Servers
413
 
    tenant3 = TEST.tenants.list()[2]
414
 
 
415
 
    vals = {"host": "http://nova.example.com:8774",
416
 
            "name": "server_1",
417
 
            "status": "ACTIVE",
418
 
            "tenant_id": TEST.tenants.first().id,
419
 
            "user_id": TEST.user.id,
420
 
            "server_id": "1",
421
 
            "flavor_id": flavor_1.id,
422
 
            "image_id": TEST.images.first().id,
423
 
            "key_name": keypair.name}
424
 
    server_1 = servers.Server(servers.ServerManager(None),
425
 
                              json.loads(SERVER_DATA % vals)['server'])
426
 
    vals.update({"name": "server_2",
427
 
                 "status": "BUILD",
428
 
                 "server_id": "2"})
429
 
    server_2 = servers.Server(servers.ServerManager(None),
430
 
                              json.loads(SERVER_DATA % vals)['server'])
431
 
    vals.update({"name": u'\u4e91\u89c4\u5219',
432
 
                 "status": "ACTIVE",
433
 
                 "tenant_id": tenant3.id,
434
 
                "server_id": "3"})
435
 
    server_3 = servers.Server(servers.ServerManager(None),
436
 
                              json.loads(SERVER_DATA % vals)['server'])
437
 
    TEST.servers.add(server_1, server_2, server_3)
438
 
 
439
 
    # VNC Console Data
440
 
    console = {u'console': {u'url': u'http://example.com:6080/vnc_auto.html',
441
 
                            u'type': u'novnc'}}
442
 
    TEST.servers.vnc_console_data = console
443
 
    # SPICE Console Data
444
 
    console = {u'console': {u'url': u'http://example.com:6080/spice_auto.html',
445
 
                            u'type': u'spice'}}
446
 
    TEST.servers.spice_console_data = console
447
 
    # RDP Console Data
448
 
    console = {u'console': {u'url': u'http://example.com:6080/rdp_auto.html',
449
 
                            u'type': u'rdp'}}
450
 
    TEST.servers.rdp_console_data = console
451
 
 
452
 
    # Floating IPs
453
 
    def generate_fip(conf):
454
 
        return floating_ips.FloatingIP(floating_ips.FloatingIPManager(None),
455
 
                                       conf)
456
 
 
457
 
    fip_1 = {'id': 1,
458
 
             'fixed_ip': '10.0.0.4',
459
 
             'instance_id': server_1.id,
460
 
             'ip': '58.58.58.58',
461
 
             'pool': 'pool1'}
462
 
    fip_2 = {'id': 2,
463
 
             'fixed_ip': None,
464
 
             'instance_id': None,
465
 
             'ip': '58.58.58.58',
466
 
             'pool': 'pool2'}
467
 
    TEST.api_floating_ips.add(generate_fip(fip_1), generate_fip(fip_2))
468
 
 
469
 
    TEST.floating_ips.add(nova.FloatingIp(generate_fip(fip_1)),
470
 
                          nova.FloatingIp(generate_fip(fip_2)))
471
 
 
472
 
    # Floating IP with UUID id (for Floating IP with Neutron Proxy)
473
 
    fip_3 = {'id': str(uuid.uuid4()),
474
 
             'fixed_ip': '10.0.0.4',
475
 
             'instance_id': server_1.id,
476
 
             'ip': '58.58.58.58',
477
 
             'pool': 'pool1'}
478
 
    fip_4 = {'id': str(uuid.uuid4()),
479
 
             'fixed_ip': None,
480
 
             'instance_id': None,
481
 
             'ip': '58.58.58.58',
482
 
             'pool': 'pool2'}
483
 
    TEST.api_floating_ips_uuid.add(generate_fip(fip_3), generate_fip(fip_4))
484
 
 
485
 
    TEST.floating_ips_uuid.add(nova.FloatingIp(generate_fip(fip_3)),
486
 
                               nova.FloatingIp(generate_fip(fip_4)))
487
 
 
488
 
    # Usage
489
 
    usage_vals = {"tenant_id": TEST.tenant.id,
490
 
                  "instance_name": server_1.name,
491
 
                  "flavor_name": flavor_1.name,
492
 
                  "flavor_vcpus": flavor_1.vcpus,
493
 
                  "flavor_disk": flavor_1.disk,
494
 
                  "flavor_ram": flavor_1.ram}
495
 
    usage_obj = usage.Usage(usage.UsageManager(None),
496
 
                            json.loads(USAGE_DATA % usage_vals))
497
 
    TEST.usages.add(usage_obj)
498
 
 
499
 
    usage_2_vals = {"tenant_id": tenant3.id,
500
 
                    "instance_name": server_3.name,
501
 
                    "flavor_name": flavor_1.name,
502
 
                    "flavor_vcpus": flavor_1.vcpus,
503
 
                    "flavor_disk": flavor_1.disk,
504
 
                    "flavor_ram": flavor_1.ram}
505
 
    usage_obj_2 = usage.Usage(usage.UsageManager(None),
506
 
                               json.loads(USAGE_DATA % usage_2_vals))
507
 
    TEST.usages.add(usage_obj_2)
508
 
 
509
 
    volume_snapshot = vol_snaps.Snapshot(vol_snaps.SnapshotManager(None),
510
 
                        {'id': '40f3fabf-3613-4f5e-90e5-6c9a08333fc3',
511
 
                         'display_name': 'test snapshot',
512
 
                         'display_description': 'vol snap!',
513
 
                         'size': 40,
514
 
                         'status': 'available',
515
 
                         'volume_id': '41023e92-8008-4c8b-8059-7f2293ff3775'})
516
 
    volume_snapshot2 = vol_snaps.Snapshot(vol_snaps.SnapshotManager(None),
517
 
                        {'id': 'a374cbb8-3f99-4c3f-a2ef-3edbec842e31',
518
 
                         'display_name': '',
519
 
                         'display_description': 'vol snap 2!',
520
 
                         'size': 80,
521
 
                         'status': 'available',
522
 
                         'volume_id': '3b189ac8-9166-ac7f-90c9-16c8bf9e01ac'})
523
 
    TEST.volume_snapshots.add(volume_snapshot)
524
 
    TEST.volume_snapshots.add(volume_snapshot2)
525
 
 
526
 
    cert_data = {'private_key': 'private',
527
 
                 'data': 'certificate_data'}
528
 
    certificate = certs.Certificate(certs.CertificateManager(None), cert_data)
529
 
    TEST.certs.add(certificate)
530
 
 
531
 
    # Availability Zones
532
 
    TEST.availability_zones.add(
533
 
        availability_zones.AvailabilityZone(
534
 
            availability_zones.AvailabilityZoneManager(None),
535
 
            {
536
 
                'zoneName': 'nova',
537
 
                'zoneState': {'available': True},
538
 
                'hosts': {
539
 
                    "host001": {
540
 
                        "nova-network": {
541
 
                            "active": True,
542
 
                            "available": True
543
 
                        }
544
 
                    }
545
 
                }
546
 
            }
547
 
        )
548
 
    )
549
 
 
550
 
    # hypervisors
551
 
    hypervisor_1 = hypervisors.Hypervisor(hypervisors.HypervisorManager(None),
552
 
        {
553
 
            "service": {"host": "devstack001", "id": 3},
554
 
            "vcpus_used": 1,
555
 
            "hypervisor_type": "QEMU",
556
 
            "local_gb_used": 20,
557
 
            "hypervisor_hostname": "devstack001",
558
 
            "memory_mb_used": 1500,
559
 
            "memory_mb": 2000,
560
 
            "current_workload": 0,
561
 
            "vcpus": 1,
562
 
            "cpu_info": '{"vendor": "Intel", "model": "core2duo",'
563
 
                        '"arch": "x86_64", "features": ["lahf_lm"'
564
 
                        ', "rdtscp"], "topology": {"cores": 1, "t'
565
 
                        'hreads": 1, "sockets": 1}}',
566
 
            "running_vms": 1,
567
 
            "free_disk_gb": 9,
568
 
            "hypervisor_version": 1002000,
569
 
            "disk_available_least": 6,
570
 
            "local_gb": 29,
571
 
            "free_ram_mb": 500,
572
 
            "id": 1
573
 
        }
574
 
    )
575
 
 
576
 
    hypervisor_2 = hypervisors.Hypervisor(hypervisors.HypervisorManager(None),
577
 
        {
578
 
            "service": {"host": "devstack002", "id": 4},
579
 
            "vcpus_used": 1,
580
 
            "hypervisor_type": "QEMU",
581
 
            "local_gb_used": 20,
582
 
            "hypervisor_hostname": "devstack002",
583
 
            "memory_mb_used": 1500,
584
 
            "memory_mb": 2000,
585
 
            "current_workload": 0,
586
 
            "vcpus": 1,
587
 
            "cpu_info": '{"vendor": "Intel", "model": "core2duo",'
588
 
                        '"arch": "x86_64", "features": ["lahf_lm"'
589
 
                        ', "rdtscp"], "topology": {"cores": 1, "t'
590
 
                        'hreads": 1, "sockets": 1}}',
591
 
            "running_vms": 1,
592
 
            "free_disk_gb": 9,
593
 
            "hypervisor_version": 1002000,
594
 
            "disk_available_least": 6,
595
 
            "local_gb": 29,
596
 
            "free_ram_mb": 500,
597
 
            "id": 2
598
 
        }
599
 
    )
600
 
    hypervisor_3 = hypervisors.Hypervisor(hypervisors.HypervisorManager(None),
601
 
        {
602
 
            "service": {"host": "instance-host", "id": 5},
603
 
            "vcpus_used": 1,
604
 
            "hypervisor_type": "QEMU",
605
 
            "local_gb_used": 20,
606
 
            "hypervisor_hostname": "devstack003",
607
 
            "memory_mb_used": 1500,
608
 
            "memory_mb": 2000,
609
 
            "current_workload": 0,
610
 
            "vcpus": 1,
611
 
            "cpu_info": '{"vendor": "Intel", "model": "core2duo",'
612
 
                        '"arch": "x86_64", "features": ["lahf_lm"'
613
 
                        ', "rdtscp"], "topology": {"cores": 1, "t'
614
 
                        'hreads": 1, "sockets": 1}}',
615
 
            "running_vms": 1,
616
 
            "free_disk_gb": 9,
617
 
            "hypervisor_version": 1002000,
618
 
            "disk_available_least": 6,
619
 
            "local_gb": 29,
620
 
            "free_ram_mb": 500,
621
 
            "id": 3
622
 
        }
623
 
    )
624
 
    TEST.hypervisors.add(hypervisor_1)
625
 
    TEST.hypervisors.add(hypervisor_2)
626
 
    TEST.hypervisors.add(hypervisor_3)
627
 
 
628
 
    TEST.hypervisors.stats = {
629
 
        "hypervisor_statistics": {
630
 
            "count": 5,
631
 
            "vcpus_used": 3,
632
 
            "local_gb_used": 15,
633
 
            "memory_mb": 483310,
634
 
            "current_workload": 0,
635
 
            "vcpus": 160,
636
 
            "running_vms": 3,
637
 
            "free_disk_gb": 12548,
638
 
            "disk_available_least": 12556,
639
 
            "local_gb": 12563,
640
 
            "free_ram_mb": 428014,
641
 
            "memory_mb_used": 55296
642
 
        }
643
 
    }
644
 
 
645
 
    # Services
646
 
    service_1 = services.Service(services.ServiceManager(None),
647
 
        {
648
 
            "status": "enabled",
649
 
            "binary": "nova-conductor",
650
 
            "zone": "internal",
651
 
            "state": "up",
652
 
            "updated_at": "2013-07-08T05:21:00.000000",
653
 
            "host": "devstack001",
654
 
            "disabled_reason": None
655
 
        }
656
 
    )
657
 
 
658
 
    service_2 = services.Service(services.ServiceManager(None),
659
 
        {
660
 
            "status": "enabled",
661
 
            "binary": "nova-compute",
662
 
            "zone": "nova",
663
 
            "state": "up",
664
 
            "updated_at": "2013-07-08T05:20:51.000000",
665
 
            "host": "devstack001",
666
 
            "disabled_reason": None
667
 
        }
668
 
    )
669
 
    TEST.services.add(service_1)
670
 
    TEST.services.add(service_2)
671
 
 
672
 
    # Aggregates
673
 
    aggregate_1 = aggregates.Aggregate(aggregates.AggregateManager(None),
674
 
        {
675
 
            "name": "foo",
676
 
            "availability_zone": "testing",
677
 
            "deleted": 0,
678
 
            "created_at": "2013-07-04T13:34:38.000000",
679
 
            "updated_at": None,
680
 
            "hosts": ["foo", "bar"],
681
 
            "deleted_at": None,
682
 
            "id": 1,
683
 
            "metadata": {
684
 
                "foo": "testing",
685
 
                "bar": "testing"
686
 
            }
687
 
        }
688
 
    )
689
 
 
690
 
    aggregate_2 = aggregates.Aggregate(aggregates.AggregateManager(None),
691
 
        {
692
 
            "name": "bar",
693
 
            "availability_zone": "testing",
694
 
            "deleted": 0,
695
 
            "created_at": "2013-07-04T13:34:38.000000",
696
 
            "updated_at": None,
697
 
            "hosts": ["foo", "bar"],
698
 
            "deleted_at": None,
699
 
            "id": 2,
700
 
            "metadata": {
701
 
                "foo": "testing",
702
 
                "bar": "testing"
703
 
            }
704
 
        }
705
 
    )
706
 
 
707
 
    TEST.aggregates.add(aggregate_1)
708
 
    TEST.aggregates.add(aggregate_2)
709
 
 
710
 
    host1 = hosts.Host(hosts.HostManager(None),
711
 
        {
712
 
            "host_name": "devstack001",
713
 
            "service": "compute",
714
 
            "zone": "testing"
715
 
        }
716
 
    )
717
 
 
718
 
    host2 = hosts.Host(hosts.HostManager(None),
719
 
        {
720
 
            "host_name": "devstack002",
721
 
            "service": "nova-conductor",
722
 
            "zone": "testing"
723
 
        }
724
 
    )
725
 
 
726
 
    host3 = hosts.Host(hosts.HostManager(None),
727
 
        {
728
 
            "host_name": "devstack003",
729
 
            "service": "compute",
730
 
            "zone": "testing"
731
 
        }
732
 
    )
733
 
    TEST.hosts.add(host1)
734
 
    TEST.hosts.add(host2)
735
 
    TEST.hosts.add(host3)