← Back to branch summary

~ubuntu-branches/ubuntu/quantal/nova/quantal-proposed

« back to all changes in this revision

Viewing changes to nova/tests/scheduler/test_chance_scheduler.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-08-16 14:04:11 UTC
  • mto: This revision was merged to the branch mainline in revision 84.
  • Revision ID: package-import@ubuntu.com-20120816140411-0mr4n241wmk30t9l
Tags: upstream-2012.2~f3
Import upstream version 2012.2~f3

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/scheduler/test_chance_scheduler.py
22
22
 
23
23
import mox
24
24
 
 
25
from nova.compute import rpcapi as compute_rpcapi
25
26
from nova import context
26
27
from nova import exception
27
28
from nova.scheduler import chance
62
63
        ctxt = context.RequestContext('fake', 'fake', False)
63
64
        ctxt_elevated = 'fake-context-elevated'
64
65
        fake_args = (1, 2, 3)
65
 
        fake_kwargs = {'fake_kwarg1': 'fake_value1',
66
 
                       'fake_kwarg2': 'fake_value2'}
67
66
        instance_opts = {'fake_opt1': 'meow'}
68
67
        request_spec = {'num_instances': 2,
69
68
                        'instance_properties': instance_opts}
85
84
        self.mox.StubOutWithMock(self.driver, 'hosts_up')
86
85
        self.mox.StubOutWithMock(random, 'random')
87
86
        self.mox.StubOutWithMock(self.driver, 'create_instance_db_entry')
88
 
        self.mox.StubOutWithMock(driver, 'cast_to_compute_host')
89
87
        self.mox.StubOutWithMock(driver, 'encode_instance')
 
88
        self.mox.StubOutWithMock(driver, 'instance_update_db')
 
89
        self.mox.StubOutWithMock(compute_rpcapi.ComputeAPI, 'run_instance')
90
90
 
91
91
        ctxt.elevated().AndReturn(ctxt_elevated)
92
92
        # instance 1
96
96
        self.driver.create_instance_db_entry(ctxt, request_spec,
97
97
                reservations).WithSideEffects(_add_uuid1).AndReturn(
98
98
                instance1)
99
 
        driver.cast_to_compute_host(ctxt, 'host3', 'run_instance',
100
 
                instance_uuid=instance1['uuid'], **fake_kwargs)
 
99
        driver.instance_update_db(ctxt, instance1['uuid'],
 
100
                'host3').AndReturn(instance1)
 
101
        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host3',
 
102
                instance=instance1, requested_networks=None,
 
103
                injected_files=None, admin_password=None, is_first_time=None,
 
104
                request_spec=request_spec, filter_properties={})
 
105
 
101
106
        driver.encode_instance(instance1).AndReturn(instance1_encoded)
102
107
        # instance 2
103
108
        ctxt.elevated().AndReturn(ctxt_elevated)
107
112
        self.driver.create_instance_db_entry(ctxt, request_spec,
108
113
                reservations).WithSideEffects(_add_uuid2).AndReturn(
109
114
                instance2)
110
 
        driver.cast_to_compute_host(ctxt, 'host1', 'run_instance',
111
 
                instance_uuid=instance2['uuid'], **fake_kwargs)
 
115
        driver.instance_update_db(ctxt, instance2['uuid'],
 
116
                'host1').AndReturn(instance2)
 
117
        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host1',
 
118
                instance=instance2, requested_networks=None,
 
119
                injected_files=None, admin_password=None, is_first_time=None,
 
120
                request_spec=request_spec, filter_properties={})
 
121
 
112
122
        driver.encode_instance(instance2).AndReturn(instance2_encoded)
113
123
 
114
124
        self.mox.ReplayAll()
115
125
        result = self.driver.schedule_run_instance(ctxt, request_spec,
116
 
                reservations, *fake_args, **fake_kwargs)
 
126
                None, None, None, None, {}, reservations)
117
127
        expected = [instance1_encoded, instance2_encoded]
118
128
        self.assertEqual(result, expected)
119
129
 
120
130
    def test_scheduler_includes_launch_index(self):
121
 
        ctxt = "fake-context"
 
131
        ctxt = context.RequestContext('fake', 'fake', False)
122
132
        instance_opts = {'fake_opt1': 'meow'}
123
133
        request_spec = {'num_instances': 2,
124
134
                        'instance_properties': instance_opts}
146
156
 
147
157
        self.mox.StubOutWithMock(self.driver, '_schedule')
148
158
        self.mox.StubOutWithMock(self.driver, 'create_instance_db_entry')
149
 
        self.mox.StubOutWithMock(driver, 'cast_to_compute_host')
150
159
        self.mox.StubOutWithMock(driver, 'encode_instance')
 
160
        self.mox.StubOutWithMock(driver, 'instance_update_db')
 
161
        self.mox.StubOutWithMock(compute_rpcapi.ComputeAPI, 'run_instance')
 
162
 
151
163
        # instance 1
152
 
        self.driver._schedule(ctxt, 'compute', request_spec).AndReturn('host')
 
164
        self.driver._schedule(ctxt, 'compute', request_spec,
 
165
                              {}).AndReturn('host')
153
166
        self.driver.create_instance_db_entry(
154
167
            ctxt, mox.Func(_has_launch_index(0)), None
155
168
            ).WithSideEffects(_add_uuid(1)).AndReturn(instance1)
156
 
        driver.cast_to_compute_host(ctxt, 'host', 'run_instance',
157
 
                                    instance_uuid=instance1['uuid'])
 
169
        driver.instance_update_db(ctxt, instance1['uuid'],
 
170
                'host').AndReturn(instance1)
 
171
        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host',
 
172
                instance=instance1, requested_networks=None,
 
173
                injected_files=None, admin_password=None, is_first_time=None,
 
174
                request_spec=request_spec, filter_properties={})
158
175
        driver.encode_instance(instance1).AndReturn(instance1)
159
176
        # instance 2
160
 
        self.driver._schedule(ctxt, 'compute', request_spec).AndReturn('host')
 
177
        self.driver._schedule(ctxt, 'compute', request_spec,
 
178
                              {}).AndReturn('host')
161
179
        self.driver.create_instance_db_entry(
162
180
            ctxt, mox.Func(_has_launch_index(1)), None
163
181
            ).WithSideEffects(_add_uuid(2)).AndReturn(instance2)
164
 
        driver.cast_to_compute_host(ctxt, 'host', 'run_instance',
165
 
                                    instance_uuid=instance2['uuid'])
 
182
        driver.instance_update_db(ctxt, instance2['uuid'],
 
183
                'host').AndReturn(instance2)
 
184
        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host',
 
185
                instance=instance2, requested_networks=None,
 
186
                injected_files=None, admin_password=None, is_first_time=None,
 
187
                request_spec=request_spec, filter_properties={})
166
188
        driver.encode_instance(instance2).AndReturn(instance2)
167
189
        self.mox.ReplayAll()
168
190
 
169
 
        self.driver.schedule_run_instance(ctxt, request_spec, None)
 
191
        self.driver.schedule_run_instance(ctxt, request_spec, None, None,
 
192
                None, None, {}, None)
170
193
 
171
194
    def test_basic_schedule_run_instance_no_hosts(self):
172
195
        ctxt = context.RequestContext('fake', 'fake', False)
173
196
        ctxt_elevated = 'fake-context-elevated'
174
197
        fake_args = (1, 2, 3)
175
 
        fake_kwargs = {'fake_kwarg1': 'fake_value1',
176
 
                       'fake_kwarg2': 'fake_value2'}
177
198
        instance_opts = 'fake_instance_opts'
178
199
        request_spec = {'num_instances': 2,
179
200
                        'instance_properties': instance_opts}
188
209
        self.mox.ReplayAll()
189
210
        self.assertRaises(exception.NoValidHost,
190
211
                self.driver.schedule_run_instance, ctxt, request_spec,
191
 
                *fake_args, **fake_kwargs)
 
212
                None, None, None, None, {}, None)
192
213
 
193
214
    def test_basic_schedule_fallback(self):
194
215
        ctxt = context.RequestContext('fake', 'fake', False)
232
253
        self.assertRaises(exception.NoValidHost,
233
254
                self.driver.schedule, ctxt, topic, method,
234
255
                *fake_args, **fake_kwargs)
 
256
 
 
257
    def test_schedule_prep_resize_doesnt_update_host(self):
 
258
        fake_context = context.RequestContext('user', 'project',
 
259
                is_admin=True)
 
260
 
 
261
        def _return_host(*args, **kwargs):
 
262
            return 'host2'
 
263
 
 
264
        self.stubs.Set(self.driver, '_schedule', _return_host)
 
265
 
 
266
        info = {'called': 0}
 
267
 
 
268
        def _fake_instance_update_db(*args, **kwargs):
 
269
            # This should not be called
 
270
            info['called'] = 1
 
271
 
 
272
        self.stubs.Set(driver, 'instance_update_db',
 
273
                _fake_instance_update_db)
 
274
 
 
275
        instance = {'uuid': 'fake-uuid', 'host': 'host1'}
 
276
 
 
277
        self.driver.schedule_prep_resize(fake_context, {}, {}, {},
 
278
                instance, {})
 
279
        self.assertEqual(info['called'], 0)