← Back to branch summary

~ubuntu-branches/ubuntu/wily/nova-compute-lxd/wily-proposed

« back to all changes in this revision

Viewing changes to debian/patches/fix-container-migration.patch

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2015-10-18 11:40:01 UTC
  • Revision ID: package-import@ubuntu.com-20151018114001-ani8wh2lee8vksve
Tags: 0.18-0ubuntu3
https://launchpad.net/bugs/1507706
debian/patches/fix-container-migration.patch: Fix container resize
and migration. (LP: #1507706)

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/patches/fix-container-migration.patch
 
1
diff -Naurp nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/container_config.py nova-compute-lxd-0.18/nclxd/nova/virt/lxd/container_config.py
 
2
--- nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/container_config.py  2015-10-01 21:15:23.000000000 -0400
 
3
+++ nova-compute-lxd-0.18/nclxd/nova/virt/lxd/container_config.py       2015-10-18 11:36:16.160291157 -0400
 
4
@@ -238,20 +238,21 @@ class LXDContainerConfig(object):
 
5
                   'type': 'nic'})
 
6
         return container_config
 
7
 
 
8
-    def configure_container_migrate(self, instance, container_ws):
 
9
+    def configure_container_migrate(self, instance, container_ws, host):
 
10
         LOG.debug('Creating container config for migration.')
 
11
-        container_config = self.get_container_config(instance)
 
12
+        container_config = self.get_container_config(instance, host=host)
 
13
 
 
14
         container_config = self.add_config(container_config, 'source',
 
15
                                            self.configure_lxd_ws(
 
16
                                                container_config,
 
17
-                                               container_ws))
 
18
+                                               container_ws,
 
19
+                                               host))
 
20
 
 
21
         return container_config
 
22
 
 
23
-    def configure_lxd_ws(self, container_config, container_ws):
 
24
+    def configure_lxd_ws(self, container_config, container_ws, host):
 
25
         container_url = ('wss://%s:8443/1.0/operations/%s/websocket'
 
26
-                         % (CONF.my_ip, container_ws['operation']))
 
27
+                         % (host, container_ws['operation']))
 
28
         container_migrate = {'base-image': '',
 
29
                              "mode": "pull",
 
30
                              "operation": container_url,
 
31
@@ -265,13 +266,16 @@ class LXDContainerConfig(object):
 
32
                                             container_migrate))
 
33
         return container_config
 
34
 
 
35
-    def get_container_config(self, instance):
 
36
+    def get_container_config(self, instance, host=None):
 
37
         LOG.debug('Fetching LXD configuration')
 
38
         container_update = self._init_container_config()
 
39
 
 
40
+        if host is None:
 
41
+            host = instance.host
 
42
+
 
43
         container_old = self.container_client.client(
 
44
             'config', instance=instance.name,
 
45
-            host=instance.host)
 
46
+            host=host)
 
47
 
 
48
         container_config = self._convert(container_old['config'])
 
49
         container_devices = self._convert(container_old['devices'])
 
50
diff -Naurp nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/container_migrate.py nova-compute-lxd-0.18/nclxd/nova/virt/lxd/container_migrate.py
 
51
--- nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/container_migrate.py 2015-10-01 21:15:23.000000000 -0400
 
52
+++ nova-compute-lxd-0.18/nclxd/nova/virt/lxd/container_migrate.py      2015-10-18 11:36:16.160291157 -0400
 
53
@@ -14,8 +14,6 @@
 
54
 #    under the License.
 
55
 
 
56
 from nova import i18n
 
57
-from nova import utils
 
58
-import pprint
 
59
 
 
60
 from oslo_config import cfg
 
61
 from oslo_log import log as logging
 
62
@@ -52,21 +50,7 @@ class LXDContainerMigrate(object):
 
63
                                    retry_interval=0):
 
64
         LOG.debug("migrate_disk_and_power_off called", instance=instance)
 
65
 
 
66
-        try:
 
67
-            self.utils.container_stop(instance.name, instance.host)
 
68
-
 
69
-            container_ws = self.utils.container_migrate(instance.name,
 
70
-                                                        instance)
 
71
-            container_config = (
 
72
-                self.config.configure_container_migrate(
 
73
-                    instance, container_ws))
 
74
-            utils.spawn(
 
75
-                self.utils.container_init,
 
76
-                container_config, instance, dest)
 
77
-        except Exception as ex:
 
78
-            with excutils.save_and_reraise_exception():
 
79
-                LOG.exception(_LE('Failed to migration container: %(e)s'),
 
80
-                              {'e': ex}, instance=instance)
 
81
+        LOG.info(_('No disk to migrate'))
 
82
 
 
83
         # disk_info is not used
 
84
         disk_info = {}
 
85
@@ -74,44 +58,48 @@ class LXDContainerMigrate(object):
 
86
 
 
87
     def confirm_migration(self, migration, instance, network_info):
 
88
         LOG.debug("confirm_migration called", instance=instance)
 
89
-        src_host = migration['source_compute']
 
90
-        dst_host = migration['dest_compute']
 
91
-        try:
 
92
-            if not self.client.client('defined', instance=instance.name,
 
93
-                                      host=dst_host):
 
94
-                LOG.exception(_LE('Failed to migrate host'))
 
95
-            LOG.info(_LI('Successfuly migrated instnace %(instance)s'),
 
96
-                     {'instance': instance.name}, instance=instance)
 
97
-        except Exception as ex:
 
98
-            with excutils.save_and_reraise_exception():
 
99
-                LOG.exception(_LE('Failed to confirm migration: %(e)s'),
 
100
-                              {'e': ex}, instance=instance)
 
101
-        finally:
 
102
-            self.utils.container_destroy(instance.name, src_host)
 
103
 
 
104
     def finish_revert_migration(self, context, instance, network_info,
 
105
                                 block_device_info=None, power_on=True):
 
106
         LOG.debug("finish_revert_migration called", instance=instance)
 
107
+        container_config = self.get_container_config(instance)
 
108
+        self.container_ops.start_container(container_config, instance,
 
109
+                                           network_info,
 
110
+                                           need_vif_plugged=True)
 
111
 
 
112
     def finish_migration(self, context, migration, instance, disk_info,
 
113
                          network_info, image_meta, resize_instance=False,
 
114
                          block_device_info=None, power_on=True):
 
115
         LOG.debug("finish_migration called", instance=instance)
 
116
 
 
117
+        self._migration(migration, instance, network_info)
 
118
+
 
119
+    def _migration(self, migration, instance, network_info):
 
120
+        src_host = migration['source_compute']
 
121
+        dst_host = migration['dest_compute']
 
122
         try:
 
123
-            container_config = self.config.get_container_config(instance)
 
124
-            LOG.debug(pprint.pprint(container_config))
 
125
+            if self.client.client('defined', instance=instance.name,
 
126
+                                  host=dst_host):
 
127
+                LOG.exception(_LE('Container already migrated'))
 
128
+            self.utils.container_stop(instance.name, src_host)
 
129
+            container_ws = self.utils.container_migrate(
 
130
+                instance.name, src_host)
 
131
+            container_config = (
 
132
+                self.config.configure_container_migrate(
 
133
+                    instance, container_ws, src_host))
 
134
+
 
135
+            self.utils.container_init(container_config,
 
136
+                                      instance, dst_host)
 
137
             self.container_ops.start_container(container_config, instance,
 
138
                                                network_info,
 
139
                                                need_vif_plugged=True)
 
140
-            LOG.info(_LI('Succesfuly migrated instnace %(instance)s '
 
141
-                         'on %(host)s'), {'instance': instance.name,
 
142
-                                          'host': migration['dest_compute']},
 
143
-                     instance=instance)
 
144
+            self.utils.container_destroy(instance.name, src_host)
 
145
         except Exception as ex:
 
146
             with excutils.save_and_reraise_exception():
 
147
-                LOG.exception(_LE('Failed to confirm migration: %(e)s'),
 
148
-                              {'e': ex}, instance=instance)
 
149
+                LOG.error(_LE('Failed to migrate container %(instance)s: '
 
150
+                              '%(reason)s'),
 
151
+                          {'instance': instance.name, 'reason': ex},
 
152
+                          instnace=instance)
 
153
 
 
154
     def live_migration(self, context, instance_ref, dest, post_method,
 
155
                        recover_method, block_migration=False,
 
156
diff -Naurp nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/container_utils.py nova-compute-lxd-0.18/nclxd/nova/virt/lxd/container_utils.py
 
157
--- nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/container_utils.py   2015-10-01 21:15:23.000000000 -0400
 
158
+++ nova-compute-lxd-0.18/nclxd/nova/virt/lxd/container_utils.py        2015-10-18 11:36:16.160291157 -0400
 
159
@@ -209,18 +209,18 @@ class LXDContainerUtils(object):
 
160
                     {'instance': instance.name,
 
161
                      'reason': ex}, instance=instance)
 
162
 
 
163
-    def container_migrate(self, instance_name, instance):
 
164
+    def container_migrate(self, instance_name, host):
 
165
         LOG.debug('Migrate contianer')
 
166
         try:
 
167
             return self.client.client('migrate',
 
168
                                       instance=instance_name,
 
169
-                                      host=instance.host)
 
170
+                                      host=host)
 
171
         except Exception as ex:
 
172
             with excutils.save_and_reraise_exception():
 
173
                 LOG.error(
 
174
                     _LE('Failed to rename container %(instance): %(reason)s'),
 
175
                     {'instance': instance_name,
 
176
-                     'reason': ex}, instance=instance)
 
177
+                     'reason': ex})
 
178
 
 
179
     def container_init(self, config, instance, host):
 
180
         LOG.debug('Initializing container')
 
181
diff -Naurp nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/driver.py nova-compute-lxd-0.18/nclxd/nova/virt/lxd/driver.py
 
182
--- nova-compute-lxd-0.18.orig/nclxd/nova/virt/lxd/driver.py    2015-10-01 21:15:23.000000000 -0400
 
183
+++ nova-compute-lxd-0.18/nclxd/nova/virt/lxd/driver.py 2015-10-18 11:36:16.160291157 -0400
 
184
@@ -42,9 +42,6 @@ lxd_opts = [
 
185
     cfg.StrOpt('default_profile',
 
186
                default='nclxd-profile',
 
187
                help='Default LXD profile'),
 
188
-    cfg.StrOpt('lxd_port',
 
189
-               default=8443,
 
190
-               help='Default LXD Port'),
 
191
     cfg.IntOpt('retry_interval',
 
192
                default=2,
 
193
                help='How often to retry in seconds when a'
 
194
@@ -63,7 +60,7 @@ class LXDDriver(driver.ComputeDriver):
 
195
     capabilities = {
 
196
         "has_imagecache": False,
 
197
         "supports_recreate": False,
 
198
-        "supports_migrate_to_same_host": True,
 
199
+        "supports_migrate_to_same_host": False,
 
200
     }
 
201
 
 
202
     def __init__(self, virtapi):
 
203
diff -Naurp nova-compute-lxd-0.18.orig/nclxd/tests/test_container_migration.py nova-compute-lxd-0.18/nclxd/tests/test_container_migration.py
 
204
--- nova-compute-lxd-0.18.orig/nclxd/tests/test_container_migration.py  2015-10-01 21:15:23.000000000 -0400
 
205
+++ nova-compute-lxd-0.18/nclxd/tests/test_container_migration.py       2015-10-18 11:36:26.348461211 -0400
 
206
@@ -18,13 +18,10 @@ import contextlib
 
207
 import mock
 
208
 
 
209
 from nova import test
 
210
-from nova import utils
 
211
 from nova.virt import fake
 
212
 
 
213
 from nclxd.nova.virt.lxd import container_client
 
214
-from nclxd.nova.virt.lxd import container_config
 
215
 from nclxd.nova.virt.lxd import container_migrate
 
216
-from nclxd.nova.virt.lxd import container_ops
 
217
 from nclxd.nova.virt.lxd import container_utils
 
218
 from nclxd.tests import stubs
 
219
 
 
220
@@ -39,65 +36,6 @@ class LXDTestContainerMigrate(test.NoDBT
 
221
         self.migrate = container_migrate.LXDContainerMigrate(
 
222
             fake.FakeVirtAPI())
 
223
 
 
224
-    def test_migrate_disk_and_power_off(self):
 
225
-        instance = stubs._fake_instance()
 
226
-        context = mock.Mock()
 
227
-        dest = mock.Mock()
 
228
-        flavor = mock.Mock()
 
229
-        network_info = mock.Mock()
 
230
-        container_config = mock.Mock()
 
231
-        with contextlib.nested(
 
232
-            mock.patch.object(container_utils.LXDContainerUtils,
 
233
-                              'container_stop'),
 
234
-            mock.patch.object(container_utils.LXDContainerUtils,
 
235
-                              'container_migrate'),
 
236
-            mock.patch.object(container_config.LXDContainerConfig,
 
237
-                              'get_container_config'),
 
238
-            mock.patch.object(container_client.LXDContainerClient,
 
239
-                              'container_config'),
 
240
-            mock.patch.object(container_config.LXDContainerConfig,
 
241
-                              'configure_container_migrate'),
 
242
-            mock.patch.object(container_utils.LXDContainerUtils,
 
243
-                              'container_init'),
 
244
-            mock.patch.object(utils, 'spawn')
 
245
-        ) as (
 
246
-            container_stop,
 
247
-            container_migrate,
 
248
-            container_migrate_config,
 
249
-            get_container_config,
 
250
-            container_config,
 
251
-            container_init,
 
252
-            spawn
 
253
-        ):
 
254
-            self.assertEqual({},
 
255
-                             self.migrate.migrate_disk_and_power_off(
 
256
-                context, instance, dest, flavor, network_info))
 
257
-            container_stop.assert_called_once_with(
 
258
-                instance.name, instance.host)
 
259
-
 
260
-    def test_confirm_migration(self):
 
261
-        instance = stubs._fake_instance()
 
262
-        migration = mock.Mock()
 
263
-        network_info = mock.Mock()
 
264
-        migration = {'source_compute': 'fake-source',
 
265
-                     'dest_compute': 'fake-dest'}
 
266
-        src = migration['source_compute']
 
267
-        with contextlib.nested(
 
268
-            mock.patch.object(container_client.LXDContainerClient,
 
269
-                              'client'),
 
270
-            mock.patch.object(container_utils.LXDContainerUtils,
 
271
-                              'container_destroy')
 
272
-        ) as (
 
273
-            container_defined,
 
274
-            container_destroy
 
275
-        ):
 
276
-            self.assertEqual(None,
 
277
-                             (self.migrate.confirm_migration(migration,
 
278
-                                                             instance,
 
279
-                                                             network_info)))
 
280
-            container_destroy.assert_called_once_with(instance.name,
 
281
-                                                      src)
 
282
-
 
283
     def test_finish_migration(self):
 
284
         context = mock.Mock()
 
285
         migration = {'source_compute': 'fake-source',
 
286
@@ -107,16 +45,19 @@ class LXDTestContainerMigrate(test.NoDBT
 
287
         disk_info = mock.Mock()
 
288
         network_info = mock.Mock()
 
289
         with contextlib.nested(
 
290
-            mock.patch.object(container_config.LXDContainerConfig,
 
291
-                              'get_container_config'),
 
292
             mock.patch.object(container_client.LXDContainerClient,
 
293
                               'client'),
 
294
-            mock.patch.object(container_ops.LXDContainerOperations,
 
295
-                              'start_container')
 
296
+            mock.patch.object(container_utils.LXDContainerUtils,
 
297
+                              'container_stop'),
 
298
+            mock.patch.object(container_utils.LXDContainerUtils,
 
299
+                              'container_init'),
 
300
+            mock.patch.object(container_utils.LXDContainerUtils,
 
301
+                              'container_destroy'),
 
302
         ) as (
 
303
-            get_container_config,
 
304
-            container_mock_client,
 
305
-            container_start
 
306
+            container_defined,
 
307
+            container_stop,
 
308
+            container_init,
 
309
+            container_destroy
 
310
         ):
 
311
             self.assertEqual(None,
 
312
                              (self.migrate.finish_migration(context,
 
313
diff -Naurp nova-compute-lxd-0.18.orig/nclxd/tests/test_driver_api.py nova-compute-lxd-0.18/nclxd/tests/test_driver_api.py
 
314
--- nova-compute-lxd-0.18.orig/nclxd/tests/test_driver_api.py   2015-10-01 21:15:23.000000000 -0400
 
315
+++ nova-compute-lxd-0.18/nclxd/tests/test_driver_api.py        2015-10-18 11:36:16.160291157 -0400
 
316
@@ -73,7 +73,7 @@ class LXDTestDriver(test.NoDBTestCase):
 
317
     def test_capabilities(self):
 
318
         self.assertFalse(self.connection.capabilities['has_imagecache'])
 
319
         self.assertFalse(self.connection.capabilities['supports_recreate'])
 
320
-        self.assertTrue(
 
321
+        self.assertFalse(
 
322
             self.connection.capabilities['supports_migrate_to_same_host'])
 
323
 
 
324
     def test_init_host(self):