ceph/src/ceph-volume/ceph_volume/tests/devices/lvm/test_migrate.py

   1 import pytest
   2 from mock.mock import patch
   3 from ceph_volume import process
   4 from ceph_volume.api import lvm as api
   5 from ceph_volume.devices.lvm import migrate
   6 from ceph_volume.util.device import Device
   7 from ceph_volume.util import system
   8
   9 class TestGetClusterName(object):
  10
  11     mock_volumes = []
  12     def mock_get_lvs(self, *args, **kwargs):
  13         return self.mock_volumes.pop(0)
  14
  15     def test_cluster_found(self, monkeypatch):
  16         tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=data,ceph.osd_fsid=1234,ceph.cluster_name=name_of_the_cluster'
  17         vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='',
  18                          lv_path='/dev/VolGroup/lv1', lv_tags=tags)
  19         self.mock_volumes = []
  20         self.mock_volumes.append([vol])
  21
  22         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
  23         monkeypatch.setattr(process, 'call', lambda x, **kw: ('', '', 0))
  24
  25         result = migrate.get_cluster_name(osd_id='0', osd_fsid='1234')
  26         assert "name_of_the_cluster" == result
  27
  28     def test_cluster_not_found(self, monkeypatch, capsys):
  29         self.mock_volumes = []
  30         self.mock_volumes.append([])
  31
  32         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
  33         monkeypatch.setattr(process, 'call', lambda x, **kw: ('', '', 0))
  34
  35         with pytest.raises(SystemExit) as error:
  36             migrate.get_cluster_name(osd_id='0', osd_fsid='1234')
  37         stdout, stderr = capsys.readouterr()
  38         expected = 'Unexpected error, terminating'
  39         assert expected in str(error.value)
  40         expected = 'Unable to find any LV for source OSD: id:0 fsid:1234'
  41         assert expected in stderr
  42
  43 class TestFindAssociatedDevices(object):
  44
  45     mock_volumes = []
  46     def mock_get_lvs(self, *args, **kwargs):
  47         return self.mock_volumes.pop(0)
  48
  49     mock_single_volumes = {}
  50     def mock_get_single_lv(self, *args, **kwargs):
  51         p = kwargs['filters']['lv_path']
  52         return self.mock_single_volumes[p]
  53
  54     def test_lv_is_matched_id(self, monkeypatch):
  55         tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=data,ceph.osd_fsid=1234'
  56         vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='',
  57                          lv_path='/dev/VolGroup/lv1', lv_tags=tags)
  58         self.mock_volumes = []
  59         self.mock_volumes.append([vol])
  60         self.mock_volumes.append([vol])
  61         self.mock_volumes.append([])
  62         self.mock_volumes.append([])
  63
  64         self.mock_single_volumes = {'/dev/VolGroup/lv1': vol}
  65
  66         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
  67         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
  68         monkeypatch.setattr(process, 'call', lambda x, **kw: ('', '', 0))
  69
  70         result = migrate.find_associated_devices(osd_id='0', osd_fsid='1234')
  71         assert len(result) == 1
  72         assert result[0][0].path == '/dev/VolGroup/lv1'
  73         assert result[0][0].lvs == [vol]
  74         assert result[0][1] == 'block'
  75
  76     def test_lv_is_matched_id2(self, monkeypatch):
  77         tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=data,ceph.osd_fsid=1234'
  78         vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='vg',
  79                          lv_path='/dev/VolGroup/lv1', lv_tags=tags)
  80         tags2 = 'ceph.osd_id=0,ceph.journal_uuid=xx,ceph.type=wal,ceph.osd_fsid=1234'
  81         vol2 = api.Volume(lv_name='volume2', lv_uuid='z', vg_name='vg',
  82                          lv_path='/dev/VolGroup/lv2', lv_tags=tags2)
  83         self.mock_volumes = []
  84         self.mock_volumes.append([vol])
  85         self.mock_volumes.append([vol])
  86         self.mock_volumes.append([])
  87         self.mock_volumes.append([vol2])
  88
  89         self.mock_single_volumes = {'/dev/VolGroup/lv1': vol, '/dev/VolGroup/lv2': vol2}
  90
  91         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
  92         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
  93         monkeypatch.setattr(process, 'call', lambda x, **kw: ('', '', 0))
  94
  95         result = migrate.find_associated_devices(osd_id='0', osd_fsid='1234')
  96         assert len(result) == 2
  97         for d in result:
  98           if d[1] == 'block':
  99             assert d[0].path == '/dev/VolGroup/lv1'
 100             assert d[0].lvs == [vol]
 101           elif d[1] == 'wal':
 102             assert d[0].path == '/dev/VolGroup/lv2'
 103             assert d[0].lvs == [vol2]
 104           else:
 105             assert False
 106
 107     def test_lv_is_matched_id3(self, monkeypatch):
 108         tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=data,ceph.osd_fsid=1234'
 109         vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='vg',
 110                          lv_path='/dev/VolGroup/lv1', lv_tags=tags)
 111         tags2 = 'ceph.osd_id=0,ceph.journal_uuid=xx,ceph.type=wal,ceph.osd_fsid=1234'
 112         vol2 = api.Volume(lv_name='volume2', lv_uuid='z', vg_name='vg',
 113                          lv_path='/dev/VolGroup/lv2', lv_tags=tags2)
 114         tags3 = 'ceph.osd_id=0,ceph.journal_uuid=xx,ceph.type=db,ceph.osd_fsid=1234'
 115         vol3 = api.Volume(lv_name='volume3', lv_uuid='z', vg_name='vg',
 116                          lv_path='/dev/VolGroup/lv3', lv_tags=tags3)
 117
 118         self.mock_volumes = []
 119         self.mock_volumes.append([vol])
 120         self.mock_volumes.append([vol])
 121         self.mock_volumes.append([vol3])
 122         self.mock_volumes.append([vol2])
 123
 124         self.mock_single_volumes = {'/dev/VolGroup/lv1': vol,
 125                                     '/dev/VolGroup/lv2': vol2,
 126                                     '/dev/VolGroup/lv3': vol3}
 127
 128         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 129         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 130         monkeypatch.setattr(process, 'call', lambda x, **kw: ('', '', 0))
 131
 132         result = migrate.find_associated_devices(osd_id='0', osd_fsid='1234')
 133         assert len(result) == 3
 134         for d in result:
 135           if d[1] == 'block':
 136             assert d[0].path == '/dev/VolGroup/lv1'
 137             assert d[0].lvs == [vol]
 138           elif d[1] == 'wal':
 139             assert d[0].path == '/dev/VolGroup/lv2'
 140             assert d[0].lvs == [vol2]
 141           elif d[1] == 'db':
 142             assert d[0].path == '/dev/VolGroup/lv3'
 143             assert d[0].lvs == [vol3]
 144           else:
 145             assert False
 146
 147     def test_lv_is_not_matched(self, monkeypatch, capsys):
 148         self.mock_volumes = [None]
 149         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 150         monkeypatch.setattr(process, 'call', lambda x, **kw: ('', '', 0))
 151
 152         with pytest.raises(SystemExit) as error:
 153             migrate.find_associated_devices(osd_id='1', osd_fsid='1234')
 154         stdout, stderr = capsys.readouterr()
 155         expected = 'Unexpected error, terminating'
 156         assert expected in str(error.value)
 157         expected = 'Unable to find any LV for source OSD: id:1 fsid:1234'
 158         assert expected in stderr
 159
 160 class TestVolumeTagTracker(object):
 161     mock_single_volumes = {}
 162     def mock_get_single_lv(self, *args, **kwargs):
 163         p = kwargs['filters']['lv_path']
 164         return self.mock_single_volumes[p]
 165
 166     mock_process_input = []
 167     def mock_process(self, *args, **kwargs):
 168         self.mock_process_input.append(args[0]);
 169         return ('', '', 0)
 170
 171     def test_init(self, monkeypatch):
 172         source_tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=data,ceph.osd_fsid=1234'
 173         source_db_tags = 'ceph.osd_id=0,journal_uuid=x,ceph.type=db, osd_fsid=1234'
 174         source_wal_tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=wal'
 175         target_tags="ceph.a=1,ceph.b=2,c=3,ceph.d=4" # 'c' to be bypassed
 176         devices=[]
 177
 178         data_vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='vg',
 179                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 180         db_vol = api.Volume(lv_name='volume2', lv_uuid='y', vg_name='vg',
 181                          lv_path='/dev/VolGroup/lv2', lv_tags=source_db_tags)
 182         wal_vol = api.Volume(lv_name='volume3', lv_uuid='y', vg_name='vg',
 183                          lv_path='/dev/VolGroup/lv3', lv_tags=source_wal_tags)
 184
 185         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 186                                     '/dev/VolGroup/lv2': db_vol,
 187                                     '/dev/VolGroup/lv3': wal_vol}
 188         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 189
 190         self.mock_process_input = []
 191         monkeypatch.setattr(process, 'call', self.mock_process)
 192
 193         data_device = Device(path = '/dev/VolGroup/lv1')
 194         db_device = Device(path = '/dev/VolGroup/lv2')
 195         wal_device = Device(path = '/dev/VolGroup/lv3')
 196         devices.append([data_device, 'block'])
 197         devices.append([db_device, 'db'])
 198         devices.append([wal_device, 'wal'])
 199
 200         target = api.Volume(lv_name='target_name', lv_tags=target_tags,
 201             lv_path='/dev/VolGroup/lv_target')
 202         t = migrate.VolumeTagTracker(devices, target);
 203
 204         assert 3 == len(t.old_target_tags)
 205
 206         assert data_device == t.data_device
 207         assert 4 == len(t.old_data_tags)
 208         assert 'data' == t.old_data_tags['ceph.type']
 209
 210         assert db_device == t.db_device
 211         assert 2 == len(t.old_db_tags)
 212         assert 'db' == t.old_db_tags['ceph.type']
 213
 214         assert wal_device == t.wal_device
 215         assert 3 == len(t.old_wal_tags)
 216         assert 'wal' == t.old_wal_tags['ceph.type']
 217
 218     def test_update_tags_when_lv_create(self, monkeypatch):
 219         source_tags = \
 220         'ceph.osd_id=0,ceph.journal_uuid=x,' \
 221         'ceph.type=data,ceph.osd_fsid=1234'
 222         source_db_tags = \
 223         'ceph.osd_id=0,journal_uuid=x,ceph.type=db,' \
 224         'osd_fsid=1234'
 225
 226         devices=[]
 227
 228         data_vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='vg',
 229                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 230         db_vol = api.Volume(lv_name='volume2', lv_uuid='y', vg_name='vg',
 231                          lv_path='/dev/VolGroup/lv2', lv_tags=source_db_tags)
 232
 233         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 234                                     '/dev/VolGroup/lv2': db_vol}
 235
 236         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 237
 238         self.mock_process_input = []
 239         monkeypatch.setattr(process, 'call', self.mock_process)
 240
 241         data_device = Device(path = '/dev/VolGroup/lv1')
 242         db_device = Device(path = '/dev/VolGroup/lv2')
 243         devices.append([data_device, 'block'])
 244         devices.append([db_device, 'db'])
 245
 246         target = api.Volume(lv_name='target_name', lv_tags='',
 247             lv_uuid='wal_uuid',
 248             lv_path='/dev/VolGroup/lv_target')
 249         t = migrate.VolumeTagTracker(devices, target);
 250
 251         self.mock_process_input = []
 252         t.update_tags_when_lv_create('wal')
 253
 254         assert 3 == len(self.mock_process_input)
 255
 256         assert ['lvchange',
 257                 '--addtag', 'ceph.wal_uuid=wal_uuid',
 258                 '--addtag', 'ceph.wal_device=/dev/VolGroup/lv_target',
 259                 '/dev/VolGroup/lv1'] == self.mock_process_input[0]
 260
 261         assert  self.mock_process_input[1].sort() == [
 262                 'lvchange',
 263                 '--addtag', 'ceph.osd_id=0',
 264                 '--addtag', 'ceph.journal_uuid=x',
 265                 '--addtag', 'ceph.type=wal',
 266                 '--addtag', 'ceph.osd_fsid=1234',
 267                 '--addtag', 'ceph.wal_uuid=wal_uuid',
 268                 '--addtag', 'ceph.wal_device=/dev/VolGroup/lv_target',
 269                 '/dev/VolGroup/lv_target'].sort()
 270
 271         assert ['lvchange',
 272                 '--addtag', 'ceph.wal_uuid=wal_uuid',
 273                 '--addtag', 'ceph.wal_device=/dev/VolGroup/lv_target',
 274                 '/dev/VolGroup/lv2'] == self.mock_process_input[2]
 275
 276     def test_remove_lvs(self, monkeypatch):
 277         source_tags = \
 278         'ceph.osd_id=0,ceph.journal_uuid=x,' \
 279         'ceph.type=data,ceph.osd_fsid=1234,ceph.wal_uuid=aaaaa'
 280         source_db_tags = \
 281         'ceph.osd_id=0,journal_uuid=x,ceph.type=db,' \
 282         'osd_fsid=1234,ceph.wal_device=aaaaa'
 283         source_wal_tags = \
 284         'ceph.wal_uuid=uuid,ceph.wal_device=device,' \
 285         'ceph.osd_id=0,ceph.type=wal'
 286
 287         devices=[]
 288
 289         data_vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='vg',
 290                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 291         db_vol = api.Volume(lv_name='volume2', lv_uuid='y', vg_name='vg',
 292                          lv_path='/dev/VolGroup/lv2', lv_tags=source_db_tags)
 293         wal_vol = api.Volume(lv_name='volume3', lv_uuid='y', vg_name='vg',
 294                          lv_path='/dev/VolGroup/lv3', lv_tags=source_wal_tags)
 295
 296         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 297                                     '/dev/VolGroup/lv2': db_vol,
 298                                     '/dev/VolGroup/lv3': wal_vol}
 299
 300         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 301
 302         self.mock_process_input = []
 303         monkeypatch.setattr(process, 'call', self.mock_process)
 304
 305         data_device = Device(path = '/dev/VolGroup/lv1')
 306         db_device = Device(path = '/dev/VolGroup/lv2')
 307         wal_device = Device(path = '/dev/VolGroup/lv3')
 308         devices.append([data_device, 'block'])
 309         devices.append([db_device, 'db'])
 310         devices.append([wal_device, 'wal'])
 311
 312         target = api.Volume(lv_name='target_name', lv_tags='',
 313             lv_path='/dev/VolGroup/lv_target')
 314         t = migrate.VolumeTagTracker(devices, target);
 315
 316         device_to_remove = devices.copy()
 317
 318         self.mock_process_input = []
 319         t.remove_lvs(device_to_remove, 'db')
 320
 321         assert 3 == len(self.mock_process_input)
 322         assert ['lvchange',
 323                 '--deltag', 'ceph.wal_uuid=uuid',
 324                 '--deltag', 'ceph.wal_device=device',
 325                 '--deltag', 'ceph.osd_id=0',
 326                 '--deltag', 'ceph.type=wal',
 327                 '/dev/VolGroup/lv3'] == self.mock_process_input[0]
 328         assert ['lvchange',
 329                 '--deltag', 'ceph.wal_uuid=aaaaa',
 330                 '/dev/VolGroup/lv1'] == self.mock_process_input[1]
 331         assert ['lvchange',
 332                 '--deltag', 'ceph.wal_device=aaaaa',
 333                 '/dev/VolGroup/lv2'] == self.mock_process_input[2]
 334
 335     def test_replace_lvs(self, monkeypatch):
 336         source_tags = \
 337         'ceph.osd_id=0,ceph.type=data,ceph.osd_fsid=1234,'\
 338         'ceph.wal_uuid=wal_uuid,ceph.db_device=/dbdevice'
 339         source_db_tags = \
 340         'ceph.osd_id=0,ceph.type=db,ceph.osd_fsid=1234'
 341         source_wal_tags = \
 342         'ceph.wal_uuid=uuid,ceph.wal_device=device,' \
 343         'ceph.osd_id=0,ceph.type=wal'
 344
 345         devices=[]
 346
 347         data_vol = api.Volume(lv_name='volume1', lv_uuid='datauuid', vg_name='vg',
 348                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 349         db_vol = api.Volume(lv_name='volume2', lv_uuid='dbuuid', vg_name='vg',
 350                          lv_path='/dev/VolGroup/lv2', lv_tags=source_db_tags)
 351         wal_vol = api.Volume(lv_name='volume3', lv_uuid='waluuid', vg_name='vg',
 352                          lv_path='/dev/VolGroup/lv3', lv_tags=source_wal_tags)
 353
 354         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 355                                     '/dev/VolGroup/lv2': db_vol,
 356                                     '/dev/VolGroup/lv3': wal_vol}
 357
 358         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 359
 360         self.mock_process_input = []
 361         monkeypatch.setattr(process, 'call', self.mock_process)
 362
 363         data_device = Device(path = '/dev/VolGroup/lv1')
 364         db_device = Device(path = '/dev/VolGroup/lv2')
 365         wal_device = Device(path = '/dev/VolGroup/lv3')
 366         devices.append([data_device, 'block'])
 367         devices.append([db_device, 'db'])
 368         devices.append([wal_device, 'wal'])
 369
 370         target = api.Volume(lv_name='target_name',
 371             lv_uuid='ttt',
 372             lv_tags='ceph.tag_to_remove=aaa',
 373             lv_path='/dev/VolGroup/lv_target')
 374         t = migrate.VolumeTagTracker(devices, target);
 375
 376         self.mock_process_input = []
 377         t.replace_lvs(devices, 'db')
 378
 379         assert 5 == len(self.mock_process_input)
 380
 381         assert ['lvchange',
 382                 '--deltag', 'ceph.osd_id=0',
 383                 '--deltag', 'ceph.type=db',
 384                 '--deltag', 'ceph.osd_fsid=1234',
 385                 '/dev/VolGroup/lv2'] == self.mock_process_input[0]
 386         assert ['lvchange',
 387                 '--deltag', 'ceph.wal_uuid=uuid',
 388                 '--deltag', 'ceph.wal_device=device',
 389                 '--deltag', 'ceph.osd_id=0',
 390                 '--deltag', 'ceph.type=wal',
 391                 '/dev/VolGroup/lv3'] == self.mock_process_input[1]
 392         assert ['lvchange',
 393                 '--deltag', 'ceph.db_device=/dbdevice',
 394                 '--deltag', 'ceph.wal_uuid=wal_uuid',
 395                 '/dev/VolGroup/lv1'] == self.mock_process_input[2]
 396
 397         assert ['lvchange',
 398                 '--addtag', 'ceph.db_uuid=ttt',
 399                 '--addtag', 'ceph.db_device=/dev/VolGroup/lv_target',
 400                 '/dev/VolGroup/lv1'] == self.mock_process_input[3]
 401
 402         assert self.mock_process_input[4].sort() == [
 403             'lvchange',
 404             '--addtag', 'ceph.osd_id=0',
 405             '--addtag', 'ceph.osd_fsid=1234',
 406             '--addtag', 'ceph.type=db',
 407             '--addtag', 'ceph.db_uuid=ttt',
 408             '--addtag', 'ceph.db_device=/dev/VolGroup/lv_target',
 409             '/dev/VolGroup/lv_target'].sort()
 410
 411     def test_undo(self, monkeypatch):
 412         source_tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=data,ceph.osd_fsid=1234'
 413         source_db_tags = 'ceph.osd_id=0,journal_uuid=x,ceph.type=db, osd_fsid=1234'
 414         source_wal_tags = 'ceph.osd_id=0,ceph.journal_uuid=x,ceph.type=wal'
 415         target_tags=""
 416         devices=[]
 417
 418         data_vol = api.Volume(lv_name='volume1', lv_uuid='y', vg_name='vg',
 419                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 420         db_vol = api.Volume(lv_name='volume2', lv_uuid='y', vg_name='vg',
 421                          lv_path='/dev/VolGroup/lv2', lv_tags=source_db_tags)
 422         wal_vol = api.Volume(lv_name='volume3', lv_uuid='y', vg_name='vg',
 423                          lv_path='/dev/VolGroup/lv3', lv_tags=source_wal_tags)
 424
 425         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 426                                     '/dev/VolGroup/lv2': db_vol,
 427                                     '/dev/VolGroup/lv3': wal_vol}
 428
 429         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 430
 431         self.mock_process_input = []
 432         monkeypatch.setattr(process, 'call', self.mock_process)
 433
 434         data_device = Device(path = '/dev/VolGroup/lv1')
 435         db_device = Device(path = '/dev/VolGroup/lv2')
 436         wal_device = Device(path = '/dev/VolGroup/lv3')
 437         devices.append([data_device, 'block'])
 438         devices.append([db_device, 'db'])
 439         devices.append([wal_device, 'wal'])
 440
 441         target = api.Volume(lv_name='target_name', lv_tags=target_tags,
 442             lv_path='/dev/VolGroup/lv_target')
 443         t = migrate.VolumeTagTracker(devices, target);
 444
 445         target.tags['ceph.a'] = 'aa';
 446         target.tags['ceph.b'] = 'bb';
 447
 448         data_vol.tags['ceph.journal_uuid'] = 'z';
 449
 450         db_vol.tags.pop('ceph.type')
 451
 452         wal_vol.tags.clear()
 453
 454         assert 2 == len(target.tags)
 455         assert 4 == len(data_vol.tags)
 456         assert 1 == len(db_vol.tags)
 457
 458         self.mock_process_input = []
 459         t.undo()
 460
 461         assert 0 == len(target.tags)
 462         assert 4 == len(data_vol.tags)
 463         assert 'x' == data_vol.tags['ceph.journal_uuid']
 464
 465         assert 2 == len(db_vol.tags)
 466         assert 'db' == db_vol.tags['ceph.type']
 467
 468         assert 3 == len(wal_vol.tags)
 469         assert 'wal' == wal_vol.tags['ceph.type']
 470
 471         assert 6 == len(self.mock_process_input)
 472         assert 'lvchange' in self.mock_process_input[0]
 473         assert '--deltag' in self.mock_process_input[0]
 474         assert 'ceph.journal_uuid=z' in self.mock_process_input[0]
 475         assert '/dev/VolGroup/lv1' in self.mock_process_input[0]
 476
 477         assert 'lvchange' in self.mock_process_input[1]
 478         assert '--addtag' in self.mock_process_input[1]
 479         assert 'ceph.journal_uuid=x' in self.mock_process_input[1]
 480         assert '/dev/VolGroup/lv1' in self.mock_process_input[1]
 481
 482         assert 'lvchange' in self.mock_process_input[2]
 483         assert '--deltag' in self.mock_process_input[2]
 484         assert 'ceph.osd_id=0' in self.mock_process_input[2]
 485         assert '/dev/VolGroup/lv2' in self.mock_process_input[2]
 486
 487         assert 'lvchange' in self.mock_process_input[3]
 488         assert '--addtag' in self.mock_process_input[3]
 489         assert 'ceph.type=db' in self.mock_process_input[3]
 490         assert '/dev/VolGroup/lv2' in self.mock_process_input[3]
 491
 492         assert 'lvchange' in self.mock_process_input[4]
 493         assert '--addtag' in self.mock_process_input[4]
 494         assert 'ceph.type=wal' in self.mock_process_input[4]
 495         assert '/dev/VolGroup/lv3' in self.mock_process_input[4]
 496
 497         assert 'lvchange' in self.mock_process_input[5]
 498         assert '--deltag' in self.mock_process_input[5]
 499         assert 'ceph.a=aa' in self.mock_process_input[5]
 500         assert 'ceph.b=bb' in self.mock_process_input[5]
 501         assert '/dev/VolGroup/lv_target' in self.mock_process_input[5]
 502
 503 class TestNew(object):
 504
 505     mock_volume = None
 506     def mock_get_lv_by_fullname(self, *args, **kwargs):
 507         return self.mock_volume
 508
 509     mock_process_input = []
 510     def mock_process(self, *args, **kwargs):
 511         self.mock_process_input.append(args[0]);
 512         return ('', '', 0)
 513
 514     mock_single_volumes = {}
 515     def mock_get_single_lv(self, *args, **kwargs):
 516         p = kwargs['filters']['lv_path']
 517         return self.mock_single_volumes[p]
 518
 519     mock_volumes = []
 520     def mock_get_lvs(self, *args, **kwargs):
 521         return self.mock_volumes.pop(0)
 522
 523     def test_newdb_non_root(self):
 524         with pytest.raises(Exception) as error:
 525             migrate.NewDB(argv=[
 526                 '--osd-id', '1',
 527                 '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 528                 '--target', 'vgname/new_db']).main()
 529         expected = 'This command needs to be executed with sudo or as root'
 530         assert expected in str(error.value)
 531
 532     @patch('os.getuid')
 533     def test_newdb_not_target_lvm(self, m_getuid, capsys):
 534         m_getuid.return_value = 0
 535         with pytest.raises(SystemExit) as error:
 536             migrate.NewDB(argv=[
 537                 '--osd-id', '1',
 538                 '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 539                 '--target', 'vgname/new_db']).main()
 540         stdout, stderr = capsys.readouterr()
 541         expected = 'Unable to attach new volume : vgname/new_db'
 542         assert expected in str(error.value)
 543         expected = 'Target path vgname/new_db is not a Logical Volume'
 544         assert expected in stderr
 545
 546
 547     @patch('os.getuid')
 548     def test_newdb_already_in_use(self, m_getuid, monkeypatch, capsys):
 549         m_getuid.return_value = 0
 550
 551         self.mock_volume = api.Volume(lv_name='volume1',
 552                                       lv_uuid='y',
 553                                       vg_name='vg',
 554                                       lv_path='/dev/VolGroup/lv1',
 555                                       lv_tags='ceph.osd_id=5') # this results in set used_by_ceph
 556         monkeypatch.setattr(api, 'get_lv_by_fullname', self.mock_get_lv_by_fullname)
 557
 558         with pytest.raises(SystemExit) as error:
 559             migrate.NewDB(argv=[
 560                 '--osd-id', '1',
 561                 '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 562                 '--target', 'vgname/new_db']).main()
 563         stdout, stderr = capsys.readouterr()
 564         expected = 'Unable to attach new volume : vgname/new_db'
 565         assert expected in str(error.value)
 566         expected = 'Target Logical Volume is already used by ceph: vgname/new_db'
 567         assert expected in stderr
 568
 569     @patch('os.getuid')
 570     def test_newdb(self, m_getuid, monkeypatch, capsys):
 571         m_getuid.return_value = 0
 572
 573         source_tags = \
 574         'ceph.osd_id=0,ceph.type=data,ceph.osd_fsid=1234,'\
 575         'ceph.wal_uuid=wal_uuid,ceph.db_device=/dbdevice'
 576         source_wal_tags = \
 577         'ceph.wal_uuid=uuid,ceph.wal_device=device,' \
 578         'ceph.osd_id=0,ceph.type=wal'
 579
 580         data_vol = api.Volume(lv_name='volume1', lv_uuid='datauuid',
 581                               vg_name='vg',
 582                               lv_path='/dev/VolGroup/lv1',
 583                               lv_tags=source_tags)
 584         wal_vol = api.Volume(lv_name='volume3',
 585                              lv_uuid='waluuid',
 586                              vg_name='vg',
 587                              lv_path='/dev/VolGroup/lv3',
 588                              lv_tags=source_wal_tags)
 589
 590         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 591                                     '/dev/VolGroup/lv3': wal_vol}
 592
 593         monkeypatch.setattr(migrate.api, 'get_single_lv',
 594             self.mock_get_single_lv)
 595
 596         self.mock_process_input = []
 597         monkeypatch.setattr(process, 'call', self.mock_process)
 598
 599         self.mock_volume = api.Volume(lv_name='target_volume1', lv_uuid='y',
 600                                       vg_name='vg',
 601                                       lv_path='/dev/VolGroup/target_volume',
 602                                       lv_tags='')
 603         monkeypatch.setattr(api, 'get_lv_by_fullname',
 604             self.mock_get_lv_by_fullname)
 605
 606         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
 607             lambda id: False)
 608
 609         #find_associated_devices will call get_lvs() 4 times
 610         # and it this needs results to be arranged that way
 611         self.mock_volumes = []
 612         self.mock_volumes.append([data_vol, wal_vol])
 613         self.mock_volumes.append([data_vol])
 614         self.mock_volumes.append([])
 615         self.mock_volumes.append([wal_vol])
 616
 617         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 618
 619         monkeypatch.setattr(migrate, 'get_cluster_name',
 620             lambda osd_id, osd_fsid: 'ceph_cluster')
 621         monkeypatch.setattr(system, 'chown', lambda path: 0)
 622
 623         migrate.NewDB(argv=[
 624             '--osd-id', '1',
 625             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 626             '--target', 'vgname/new_db']).main()
 627
 628         n = len(self.mock_process_input)
 629         assert n >= 5
 630
 631         assert self.mock_process_input[n - 5] == [
 632             'lvchange',
 633             '--deltag', 'ceph.db_device=/dbdevice',
 634             '/dev/VolGroup/lv1']
 635         assert self.mock_process_input[n - 4] == [
 636             'lvchange',
 637             '--addtag', 'ceph.db_uuid=y',
 638             '--addtag', 'ceph.db_device=/dev/VolGroup/target_volume',
 639             '/dev/VolGroup/lv1']
 640
 641         assert self.mock_process_input[n - 3].sort() == [
 642             'lvchange',
 643             '--addtag', 'ceph.wal_uuid=uuid',
 644             '--addtag', 'ceph.osd_id=0',
 645             '--addtag', 'ceph.type=db',
 646             '--addtag', 'ceph.osd_fsid=1234',
 647             '--addtag', 'ceph.db_uuid=y',
 648             '--addtag', 'ceph.db_device=/dev/VolGroup/target_volume',
 649             '/dev/VolGroup/target_volume'].sort()
 650
 651         assert self.mock_process_input[n - 2] == [
 652             'lvchange',
 653             '--addtag', 'ceph.db_uuid=y',
 654             '--addtag', 'ceph.db_device=/dev/VolGroup/target_volume',
 655             '/dev/VolGroup/lv3']
 656
 657         assert self.mock_process_input[n - 1] == [
 658             'ceph-bluestore-tool',
 659             '--path', '/var/lib/ceph/osd/ceph_cluster-1',
 660             '--dev-target', '/dev/VolGroup/target_volume',
 661             '--command', 'bluefs-bdev-new-db']
 662
 663     def test_newdb_active_systemd(self, is_root, monkeypatch, capsys):
 664         source_tags = \
 665         'ceph.osd_id=0,ceph.type=data,ceph.osd_fsid=1234,'\
 666         'ceph.wal_uuid=wal_uuid,ceph.db_device=/dbdevice'
 667         source_wal_tags = \
 668         'ceph.wal_uuid=uuid,ceph.wal_device=device,' \
 669         'ceph.osd_id=0,ceph.type=wal'
 670
 671         data_vol = api.Volume(lv_name='volume1', lv_uuid='datauuid',
 672                               vg_name='vg',
 673                               lv_path='/dev/VolGroup/lv1',
 674                               lv_tags=source_tags)
 675         wal_vol = api.Volume(lv_name='volume3',
 676                              lv_uuid='waluuid',
 677                              vg_name='vg',
 678                              lv_path='/dev/VolGroup/lv3',
 679                              lv_tags=source_wal_tags)
 680
 681         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 682                                     '/dev/VolGroup/lv3': wal_vol}
 683
 684         monkeypatch.setattr(migrate.api, 'get_single_lv',
 685             self.mock_get_single_lv)
 686
 687         self.mock_process_input = []
 688         monkeypatch.setattr(process, 'call', self.mock_process)
 689
 690         self.mock_volume = api.Volume(lv_name='target_volume1', lv_uuid='y',
 691                                       vg_name='vg',
 692                                       lv_path='/dev/VolGroup/target_volume',
 693                                       lv_tags='')
 694         monkeypatch.setattr(api, 'get_lv_by_fullname',
 695             self.mock_get_lv_by_fullname)
 696
 697         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
 698             lambda id: True)
 699
 700         #find_associated_devices will call get_lvs() 4 times
 701         # and it this needs results to be arranged that way
 702         self.mock_volumes = []
 703         self.mock_volumes.append([data_vol, wal_vol])
 704         self.mock_volumes.append([data_vol])
 705         self.mock_volumes.append([])
 706         self.mock_volumes.append([wal_vol])
 707
 708         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 709
 710         monkeypatch.setattr(migrate, 'get_cluster_name',
 711             lambda osd_id, osd_fsid: 'ceph_cluster')
 712         monkeypatch.setattr(system, 'chown', lambda path: 0)
 713
 714         m = migrate.NewDB(argv=[
 715             '--osd-id', '1',
 716             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 717             '--target', 'vgname/new_db'])
 718
 719         with pytest.raises(SystemExit) as error:
 720             m.main()
 721
 722         stdout, stderr = capsys.readouterr()
 723
 724         assert 'Unable to attach new volume for OSD: 1' == str(error.value)
 725         assert '--> OSD ID is running, stop it with: systemctl stop ceph-osd@1' == stderr.rstrip()
 726         assert not stdout
 727
 728     def test_newdb_no_systemd(self, is_root, monkeypatch):
 729         source_tags = \
 730         'ceph.osd_id=0,ceph.type=data,ceph.osd_fsid=1234,'\
 731         'ceph.wal_uuid=wal_uuid,ceph.db_device=/dbdevice'
 732         source_wal_tags = \
 733         'ceph.wal_uuid=uuid,ceph.wal_device=device,' \
 734         'ceph.osd_id=0,ceph.type=wal'
 735
 736         data_vol = api.Volume(lv_name='volume1', lv_uuid='datauuid',
 737                               vg_name='vg',
 738                               lv_path='/dev/VolGroup/lv1',
 739                               lv_tags=source_tags)
 740         wal_vol = api.Volume(lv_name='volume3',
 741                              lv_uuid='waluuid',
 742                              vg_name='vg',
 743                              lv_path='/dev/VolGroup/lv3',
 744                              lv_tags=source_wal_tags)
 745
 746         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol,
 747                                     '/dev/VolGroup/lv3': wal_vol}
 748
 749         monkeypatch.setattr(migrate.api, 'get_single_lv',
 750             self.mock_get_single_lv)
 751
 752         self.mock_process_input = []
 753         monkeypatch.setattr(process, 'call', self.mock_process)
 754
 755         self.mock_volume = api.Volume(lv_name='target_volume1', lv_uuid='y',
 756                                       vg_name='vg',
 757                                       lv_path='/dev/VolGroup/target_volume',
 758                                       lv_tags='')
 759         monkeypatch.setattr(api, 'get_lv_by_fullname',
 760             self.mock_get_lv_by_fullname)
 761
 762         #find_associated_devices will call get_lvs() 4 times
 763         # and it this needs results to be arranged that way
 764         self.mock_volumes = []
 765         self.mock_volumes.append([data_vol, wal_vol])
 766         self.mock_volumes.append([data_vol])
 767         self.mock_volumes.append([])
 768         self.mock_volumes.append([wal_vol])
 769
 770         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 771
 772         monkeypatch.setattr(migrate, 'get_cluster_name',
 773             lambda osd_id, osd_fsid: 'ceph_cluster')
 774         monkeypatch.setattr(system, 'chown', lambda path: 0)
 775
 776         migrate.NewDB(argv=[
 777             '--osd-id', '1',
 778             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 779             '--target', 'vgname/new_db',
 780             '--no-systemd']).main()
 781
 782         n = len(self.mock_process_input)
 783         assert n >= 5
 784
 785         assert self.mock_process_input[n - 5] == [
 786             'lvchange',
 787             '--deltag', 'ceph.db_device=/dbdevice',
 788             '/dev/VolGroup/lv1']
 789         assert self.mock_process_input[n - 4] == [
 790             'lvchange',
 791             '--addtag', 'ceph.db_uuid=y',
 792             '--addtag', 'ceph.db_device=/dev/VolGroup/target_volume',
 793             '/dev/VolGroup/lv1']
 794
 795         assert self.mock_process_input[n - 3].sort() == [
 796             'lvchange',
 797             '--addtag', 'ceph.wal_uuid=uuid',
 798             '--addtag', 'ceph.osd_id=0',
 799             '--addtag', 'ceph.type=db',
 800             '--addtag', 'ceph.osd_fsid=1234',
 801             '--addtag', 'ceph.db_uuid=y',
 802             '--addtag', 'ceph.db_device=/dev/VolGroup/target_volume',
 803             '/dev/VolGroup/target_volume'].sort()
 804
 805         assert self.mock_process_input[n - 2] == [
 806             'lvchange',
 807             '--addtag', 'ceph.db_uuid=y',
 808             '--addtag', 'ceph.db_device=/dev/VolGroup/target_volume',
 809             '/dev/VolGroup/lv3']
 810
 811         assert self.mock_process_input[n - 1] == [
 812             'ceph-bluestore-tool',
 813             '--path', '/var/lib/ceph/osd/ceph_cluster-1',
 814             '--dev-target', '/dev/VolGroup/target_volume',
 815             '--command', 'bluefs-bdev-new-db']
 816
 817     @patch('os.getuid')
 818     def test_newwal(self, m_getuid, monkeypatch, capsys):
 819         m_getuid.return_value = 0
 820
 821         source_tags = \
 822         'ceph.osd_id=0,ceph.type=data,ceph.osd_fsid=1234'
 823
 824         data_vol = api.Volume(lv_name='volume1', lv_uuid='datauuid', vg_name='vg',
 825                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 826
 827         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol}
 828
 829         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 830
 831         self.mock_process_input = []
 832         monkeypatch.setattr(process, 'call', self.mock_process)
 833
 834         self.mock_volume = api.Volume(lv_name='target_volume1', lv_uuid='y', vg_name='vg',
 835                                       lv_path='/dev/VolGroup/target_volume',
 836                                       lv_tags='')
 837         monkeypatch.setattr(api, 'get_lv_by_fullname', self.mock_get_lv_by_fullname)
 838
 839         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active", lambda id: False)
 840
 841         #find_associated_devices will call get_lvs() 4 times
 842         # and it this needs results to be arranged that way
 843         self.mock_volumes = []
 844         self.mock_volumes.append([data_vol])
 845         self.mock_volumes.append([data_vol])
 846         self.mock_volumes.append([])
 847         self.mock_volumes.append([])
 848
 849         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 850
 851         monkeypatch.setattr(migrate, 'get_cluster_name', lambda osd_id, osd_fsid: 'cluster')
 852         monkeypatch.setattr(system, 'chown', lambda path: 0)
 853
 854         migrate.NewWAL(argv=[
 855             '--osd-id', '2',
 856             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 857             '--target', 'vgname/new_wal']).main()
 858
 859         n = len(self.mock_process_input)
 860         assert n >= 3
 861
 862         assert self.mock_process_input[n - 3] == [
 863             'lvchange',
 864             '--addtag', 'ceph.wal_uuid=y',
 865             '--addtag', 'ceph.wal_device=/dev/VolGroup/target_volume',
 866             '/dev/VolGroup/lv1']
 867
 868         assert self.mock_process_input[n - 2].sort() == [
 869             'lvchange',
 870             '--addtag', 'ceph.osd_id=0',
 871             '--addtag', 'ceph.type=wal',
 872             '--addtag', 'ceph.osd_fsid=1234',
 873             '--addtag', 'ceph.wal_uuid=y',
 874             '--addtag', 'ceph.wal_device=/dev/VolGroup/target_volume',
 875             '/dev/VolGroup/target_volume'].sort()
 876
 877         assert self.mock_process_input[n - 1] == [
 878             'ceph-bluestore-tool',
 879             '--path', '/var/lib/ceph/osd/cluster-2',
 880             '--dev-target', '/dev/VolGroup/target_volume',
 881             '--command', 'bluefs-bdev-new-wal']
 882
 883     def test_newwal_active_systemd(self, is_root, monkeypatch, capsys):
 884         source_tags = \
 885         'ceph.osd_id=0,ceph.type=data,ceph.osd_fsid=1234'
 886
 887         data_vol = api.Volume(lv_name='volume1', lv_uuid='datauuid', vg_name='vg',
 888                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 889
 890         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol}
 891
 892         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 893
 894         self.mock_process_input = []
 895         monkeypatch.setattr(process, 'call', self.mock_process)
 896
 897         self.mock_volume = api.Volume(lv_name='target_volume1', lv_uuid='y', vg_name='vg',
 898                                       lv_path='/dev/VolGroup/target_volume',
 899                                       lv_tags='')
 900         monkeypatch.setattr(api, 'get_lv_by_fullname', self.mock_get_lv_by_fullname)
 901
 902         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active", lambda id: True)
 903
 904         #find_associated_devices will call get_lvs() 4 times
 905         # and it this needs results to be arranged that way
 906         self.mock_volumes = []
 907         self.mock_volumes.append([data_vol])
 908         self.mock_volumes.append([data_vol])
 909         self.mock_volumes.append([])
 910         self.mock_volumes.append([])
 911
 912         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 913
 914         monkeypatch.setattr(migrate, 'get_cluster_name', lambda osd_id, osd_fsid: 'cluster')
 915         monkeypatch.setattr(system, 'chown', lambda path: 0)
 916
 917         m = migrate.NewWAL(argv=[
 918             '--osd-id', '2',
 919             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 920             '--target', 'vgname/new_wal'])
 921
 922         with pytest.raises(SystemExit) as error:
 923             m.main()
 924
 925         stdout, stderr = capsys.readouterr()
 926
 927         assert 'Unable to attach new volume for OSD: 2' == str(error.value)
 928         assert '--> OSD ID is running, stop it with: systemctl stop ceph-osd@2' == stderr.rstrip()
 929         assert not stdout
 930
 931     def test_newwal_no_systemd(self, is_root, monkeypatch):
 932         source_tags = \
 933         'ceph.osd_id=0,ceph.type=data,ceph.osd_fsid=1234'
 934
 935         data_vol = api.Volume(lv_name='volume1', lv_uuid='datauuid', vg_name='vg',
 936                          lv_path='/dev/VolGroup/lv1', lv_tags=source_tags)
 937
 938         self.mock_single_volumes = {'/dev/VolGroup/lv1': data_vol}
 939
 940         monkeypatch.setattr(migrate.api, 'get_single_lv', self.mock_get_single_lv)
 941
 942         self.mock_process_input = []
 943         monkeypatch.setattr(process, 'call', self.mock_process)
 944
 945         self.mock_volume = api.Volume(lv_name='target_volume1', lv_uuid='y', vg_name='vg',
 946                                       lv_path='/dev/VolGroup/target_volume',
 947                                       lv_tags='')
 948         monkeypatch.setattr(api, 'get_lv_by_fullname', self.mock_get_lv_by_fullname)
 949
 950         #find_associated_devices will call get_lvs() 4 times
 951         # and it this needs results to be arranged that way
 952         self.mock_volumes = []
 953         self.mock_volumes.append([data_vol])
 954         self.mock_volumes.append([data_vol])
 955         self.mock_volumes.append([])
 956         self.mock_volumes.append([])
 957
 958         monkeypatch.setattr(migrate.api, 'get_lvs', self.mock_get_lvs)
 959
 960         monkeypatch.setattr(migrate, 'get_cluster_name', lambda osd_id, osd_fsid: 'cluster')
 961         monkeypatch.setattr(system, 'chown', lambda path: 0)
 962
 963         migrate.NewWAL(argv=[
 964             '--osd-id', '2',
 965             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
 966             '--target', 'vgname/new_wal',
 967             '--no-systemd']).main()
 968
 969         n = len(self.mock_process_input)
 970         assert n >= 3
 971
 972         assert self.mock_process_input[n - 3] == [
 973             'lvchange',
 974             '--addtag', 'ceph.wal_uuid=y',
 975             '--addtag', 'ceph.wal_device=/dev/VolGroup/target_volume',
 976             '/dev/VolGroup/lv1']
 977
 978         assert self.mock_process_input[n - 2].sort() == [
 979             'lvchange',
 980             '--addtag', 'ceph.osd_id=0',
 981             '--addtag', 'ceph.type=wal',
 982             '--addtag', 'ceph.osd_fsid=1234',
 983             '--addtag', 'ceph.wal_uuid=y',
 984             '--addtag', 'ceph.wal_device=/dev/VolGroup/target_volume',
 985             '/dev/VolGroup/target_volume'].sort()
 986
 987         assert self.mock_process_input[n - 1] == [
 988             'ceph-bluestore-tool',
 989             '--path', '/var/lib/ceph/osd/cluster-2',
 990             '--dev-target', '/dev/VolGroup/target_volume',
 991             '--command', 'bluefs-bdev-new-wal']
 992
 993 class TestMigrate(object):
 994
 995     def test_invalid_osd_id_passed(self, is_root):
 996         with pytest.raises(SystemExit):
 997             migrate.Migrate(argv=['--osd-fsid', '123', '--from', 'data', '--target', 'foo', '--osd-id', 'foo']).main()
 998
 999     mock_volume = None
1000     def mock_get_lv_by_fullname(self, *args, **kwargs):
1001         return self.mock_volume
1002
1003     mock_process_input = []
1004     def mock_process(self, *args, **kwargs):
1005         self.mock_process_input.append(args[0])
1006         return ('', '', 0)
1007
1008     mock_single_volumes = {}
1009     def mock_get_single_lv(self, *args, **kwargs):
1010         p = kwargs['filters']['lv_path']
1011         return self.mock_single_volumes[p]
1012
1013     mock_volumes = []
1014     def mock_get_lvs(self, *args, **kwargs):
1015         return self.mock_volumes.pop(0)
1016
1017     def test_get_source_devices(self, monkeypatch):
1018
1019         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234'
1020         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234'
1021         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234'
1022
1023         data_vol = api.Volume(lv_name='volume1',
1024                               lv_uuid='datauuid',
1025                               vg_name='vg',
1026                               lv_path='/dev/VolGroup/lv1',
1027                               lv_tags=source_tags)
1028         db_vol = api.Volume(lv_name='volume2',
1029                             lv_uuid='datauuid',
1030                             vg_name='vg',
1031                             lv_path='/dev/VolGroup/lv2',
1032                             lv_tags=source_db_tags)
1033
1034         wal_vol = api.Volume(lv_name='volume3',
1035                              lv_uuid='datauuid',
1036                              vg_name='vg',
1037                              lv_path='/dev/VolGroup/lv3',
1038                              lv_tags=source_wal_tags)
1039
1040         self.mock_single_volumes = {
1041             '/dev/VolGroup/lv1': data_vol,
1042             '/dev/VolGroup/lv2': db_vol,
1043             '/dev/VolGroup/lv3': wal_vol,
1044         }
1045         monkeypatch.setattr(migrate.api, 'get_single_lv',
1046             self.mock_get_single_lv)
1047
1048         self.mock_volume = api.Volume(lv_name='volume2', lv_uuid='y',
1049                                       vg_name='vg',
1050                                       lv_path='/dev/VolGroup/lv2',
1051                                       lv_tags='ceph.osd_id=5,ceph.osd_type=db')
1052         monkeypatch.setattr(api, 'get_lv_by_fullname',
1053             self.mock_get_lv_by_fullname)
1054
1055         self.mock_process_input = []
1056         monkeypatch.setattr(process, 'call', self.mock_process)
1057
1058         devices = []
1059         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1060         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1061         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
1062
1063         monkeypatch.setattr(migrate, 'find_associated_devices',
1064             lambda osd_id, osd_fsid: devices)
1065
1066
1067         argv = [
1068             '--osd-id', '2',
1069             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
1070             '--from', 'data', 'wal',
1071             '--target', 'vgname/new_wal'
1072         ]
1073         m = migrate.Migrate(argv=argv)
1074         m.args = m.make_parser('ceph-volume lvm migation', 'help').parse_args(argv)
1075         res_devices = m.get_source_devices(devices)
1076
1077         assert 2 == len(res_devices)
1078         assert devices[0] == res_devices[0]
1079         assert devices[2] == res_devices[1]
1080
1081         argv = [
1082             '--osd-id', '2',
1083             '--osd-fsid', '55BD4219-16A7-4037-BC20-0F158EFCC83D',
1084             '--from', 'db', 'wal', 'data',
1085             '--target', 'vgname/new_wal'
1086         ]
1087         m = migrate.Migrate(argv=argv)
1088         m.args = m.make_parser('ceph-volume lvm migation', 'help').parse_args(argv)
1089         res_devices = m.get_source_devices(devices)
1090
1091         assert 3 == len(res_devices)
1092         assert devices[0] == res_devices[0]
1093         assert devices[1] == res_devices[1]
1094         assert devices[2] == res_devices[2]
1095
1096
1097     def test_migrate_without_args(self, capsys):
1098         help_msg = """
1099 Moves BlueFS data from source volume(s) to the target one, source
1100 volumes (except the main (i.e. data or block) one) are removed on
1101 success. LVM volumes are permitted for Target only, both already
1102 attached or new logical one. In the latter case it is attached to OSD
1103 replacing one of the source devices. Following replacement rules apply
1104 (in the order of precedence, stop on the first match):
1105 * if source list has DB volume - target device replaces it.
1106 * if source list has WAL volume - target device replace it.
1107 * if source list has slow volume only - operation is not permitted,
1108   requires explicit allocation via new-db/new-wal command.
1109
1110 Example calls for supported scenarios:
1111
1112   Moves BlueFS data from main device to LV already attached as DB:
1113
1114     ceph-volume lvm migrate --osd-id 1 --osd-fsid <uuid> --from data --target vgname/db
1115
1116   Moves BlueFS data from shared main device to LV which will be attached
1117    as a new DB:
1118
1119     ceph-volume lvm migrate --osd-id 1 --osd-fsid <uuid> --from data --target vgname/new_db
1120
1121   Moves BlueFS data from DB device to new LV, DB is replaced:
1122
1123     ceph-volume lvm migrate --osd-id 1 --osd-fsid <uuid> --from db --target vgname/new_db
1124
1125   Moves BlueFS data from main and DB devices to new LV, DB is replaced:
1126
1127     ceph-volume lvm migrate --osd-id 1 --osd-fsid <uuid> --from data db --target vgname/new_db
1128
1129   Moves BlueFS data from main, DB and WAL devices to new LV, WAL is
1130    removed and DB is replaced:
1131
1132     ceph-volume lvm migrate --osd-id 1 --osd-fsid <uuid> --from data db wal --target vgname/new_db
1133
1134   Moves BlueFS data from main, DB and WAL devices to main device, WAL
1135    and DB are removed:
1136
1137     ceph-volume lvm migrate --osd-id 1 --osd-fsid <uuid> --from db wal --target vgname/data
1138
1139 """
1140         m = migrate.Migrate(argv=[])
1141         m.main()
1142         stdout, stderr = capsys.readouterr()
1143         assert help_msg in stdout
1144         assert not stderr
1145
1146
1147     @patch('os.getuid')
1148     def test_migrate_data_db_to_new_db(self, m_getuid, monkeypatch):
1149         m_getuid.return_value = 0
1150
1151         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1152         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1153         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1154         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1155
1156         data_vol = api.Volume(lv_name='volume1',
1157                               lv_uuid='datauuid',
1158                               vg_name='vg',
1159                               lv_path='/dev/VolGroup/lv1',
1160                               lv_tags=source_tags)
1161         db_vol = api.Volume(lv_name='volume2',
1162                             lv_uuid='dbuuid',
1163                             vg_name='vg',
1164                             lv_path='/dev/VolGroup/lv2',
1165                             lv_tags=source_db_tags)
1166
1167         self.mock_single_volumes = {
1168             '/dev/VolGroup/lv1': data_vol,
1169             '/dev/VolGroup/lv2': db_vol,
1170         }
1171         monkeypatch.setattr(migrate.api, 'get_single_lv',
1172             self.mock_get_single_lv)
1173
1174         self.mock_volume = api.Volume(lv_name='volume2_new', lv_uuid='new-db-uuid',
1175                                       vg_name='vg',
1176                                       lv_path='/dev/VolGroup/lv2_new',
1177                                       lv_tags='')
1178         monkeypatch.setattr(api, 'get_lv_by_fullname',
1179             self.mock_get_lv_by_fullname)
1180
1181         self.mock_process_input = []
1182         monkeypatch.setattr(process, 'call', self.mock_process)
1183
1184         devices = []
1185         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1186         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1187
1188         monkeypatch.setattr(migrate, 'find_associated_devices',
1189             lambda osd_id, osd_fsid: devices)
1190
1191
1192         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1193             lambda id: False)
1194
1195         monkeypatch.setattr(migrate, 'get_cluster_name',
1196             lambda osd_id, osd_fsid: 'ceph')
1197         monkeypatch.setattr(system, 'chown', lambda path: 0)
1198         m = migrate.Migrate(argv=[
1199             '--osd-id', '2',
1200             '--osd-fsid', '1234',
1201             '--from', 'data', 'db', 'wal',
1202             '--target', 'vgname/new_wal'])
1203         m.main()
1204
1205         n = len(self.mock_process_input)
1206         assert n >= 5
1207
1208         assert self. mock_process_input[n-5] == [
1209             'lvchange',
1210             '--deltag', 'ceph.osd_id=2',
1211             '--deltag', 'ceph.type=db',
1212             '--deltag', 'ceph.osd_fsid=1234',
1213             '--deltag', 'ceph.cluster_name=ceph',
1214             '--deltag', 'ceph.db_uuid=dbuuid',
1215             '--deltag', 'ceph.db_device=db_dev',
1216             '/dev/VolGroup/lv2']
1217
1218         assert self. mock_process_input[n-4] == [
1219             'lvchange',
1220             '--deltag', 'ceph.db_uuid=dbuuid',
1221             '--deltag', 'ceph.db_device=db_dev',
1222             '/dev/VolGroup/lv1']
1223
1224         assert self. mock_process_input[n-3] == [
1225             'lvchange',
1226             '--addtag', 'ceph.db_uuid=new-db-uuid',
1227             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1228             '/dev/VolGroup/lv1']
1229
1230         assert self. mock_process_input[n-2] == [
1231             'lvchange',
1232             '--addtag', 'ceph.osd_id=2',
1233             '--addtag', 'ceph.type=db',
1234             '--addtag', 'ceph.osd_fsid=1234',
1235             '--addtag', 'ceph.cluster_name=ceph',
1236             '--addtag', 'ceph.db_uuid=new-db-uuid',
1237             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1238             '/dev/VolGroup/lv2_new']
1239
1240         assert self. mock_process_input[n-1] == [
1241             'ceph-bluestore-tool',
1242             '--path', '/var/lib/ceph/osd/ceph-2',
1243             '--dev-target', '/dev/VolGroup/lv2_new',
1244             '--command', 'bluefs-bdev-migrate',
1245             '--devs-source', '/var/lib/ceph/osd/ceph-2/block',
1246             '--devs-source', '/var/lib/ceph/osd/ceph-2/block.db']
1247
1248     def test_migrate_data_db_to_new_db_active_systemd(self, is_root, monkeypatch, capsys):
1249         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1250         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1251         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1252         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1253
1254         data_vol = api.Volume(lv_name='volume1',
1255                               lv_uuid='datauuid',
1256                               vg_name='vg',
1257                               lv_path='/dev/VolGroup/lv1',
1258                               lv_tags=source_tags)
1259         db_vol = api.Volume(lv_name='volume2',
1260                             lv_uuid='dbuuid',
1261                             vg_name='vg',
1262                             lv_path='/dev/VolGroup/lv2',
1263                             lv_tags=source_db_tags)
1264
1265         self.mock_single_volumes = {
1266             '/dev/VolGroup/lv1': data_vol,
1267             '/dev/VolGroup/lv2': db_vol,
1268         }
1269         monkeypatch.setattr(migrate.api, 'get_single_lv',
1270             self.mock_get_single_lv)
1271
1272         self.mock_volume = api.Volume(lv_name='volume2_new', lv_uuid='new-db-uuid',
1273                                       vg_name='vg',
1274                                       lv_path='/dev/VolGroup/lv2_new',
1275                                       lv_tags='')
1276         monkeypatch.setattr(api, 'get_lv_by_fullname',
1277             self.mock_get_lv_by_fullname)
1278
1279         self.mock_process_input = []
1280         monkeypatch.setattr(process, 'call', self.mock_process)
1281
1282         devices = []
1283         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1284         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1285
1286         monkeypatch.setattr(migrate, 'find_associated_devices',
1287             lambda osd_id, osd_fsid: devices)
1288
1289
1290         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1291             lambda id: True)
1292
1293         monkeypatch.setattr(migrate, 'get_cluster_name',
1294             lambda osd_id, osd_fsid: 'ceph')
1295         monkeypatch.setattr(system, 'chown', lambda path: 0)
1296         m = migrate.Migrate(argv=[
1297             '--osd-id', '2',
1298             '--osd-fsid', '1234',
1299             '--from', 'data', 'db', 'wal',
1300             '--target', 'vgname/new_wal'])
1301
1302         with pytest.raises(SystemExit) as error:
1303             m.main()
1304
1305         stdout, stderr = capsys.readouterr()
1306
1307         assert 'Unable to migrate devices associated with OSD ID: 2' == str(error.value)
1308         assert '--> OSD is running, stop it with: systemctl stop ceph-osd@2' == stderr.rstrip()
1309         assert not stdout
1310
1311     def test_migrate_data_db_to_new_db_no_systemd(self, is_root, monkeypatch):
1312         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1313         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1314         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1315         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1316
1317         data_vol = api.Volume(lv_name='volume1',
1318                               lv_uuid='datauuid',
1319                               vg_name='vg',
1320                               lv_path='/dev/VolGroup/lv1',
1321                               lv_tags=source_tags)
1322         db_vol = api.Volume(lv_name='volume2',
1323                             lv_uuid='dbuuid',
1324                             vg_name='vg',
1325                             lv_path='/dev/VolGroup/lv2',
1326                             lv_tags=source_db_tags)
1327
1328         self.mock_single_volumes = {
1329             '/dev/VolGroup/lv1': data_vol,
1330             '/dev/VolGroup/lv2': db_vol,
1331         }
1332         monkeypatch.setattr(migrate.api, 'get_single_lv',
1333             self.mock_get_single_lv)
1334
1335         self.mock_volume = api.Volume(lv_name='volume2_new', lv_uuid='new-db-uuid',
1336                                       vg_name='vg',
1337                                       lv_path='/dev/VolGroup/lv2_new',
1338                                       lv_tags='')
1339         monkeypatch.setattr(api, 'get_lv_by_fullname',
1340             self.mock_get_lv_by_fullname)
1341
1342         self.mock_process_input = []
1343         monkeypatch.setattr(process, 'call', self.mock_process)
1344
1345         devices = []
1346         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1347         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1348
1349         monkeypatch.setattr(migrate, 'find_associated_devices',
1350             lambda osd_id, osd_fsid: devices)
1351
1352
1353         monkeypatch.setattr(migrate, 'get_cluster_name',
1354             lambda osd_id, osd_fsid: 'ceph')
1355         monkeypatch.setattr(system, 'chown', lambda path: 0)
1356         m = migrate.Migrate(argv=[
1357             '--osd-id', '2',
1358             '--osd-fsid', '1234',
1359             '--from', 'data', 'db', 'wal',
1360             '--target', 'vgname/new_wal',
1361             '--no-systemd'])
1362         m.main()
1363
1364         n = len(self.mock_process_input)
1365         assert n >= 5
1366
1367         assert self. mock_process_input[n-5] == [
1368             'lvchange',
1369             '--deltag', 'ceph.osd_id=2',
1370             '--deltag', 'ceph.type=db',
1371             '--deltag', 'ceph.osd_fsid=1234',
1372             '--deltag', 'ceph.cluster_name=ceph',
1373             '--deltag', 'ceph.db_uuid=dbuuid',
1374             '--deltag', 'ceph.db_device=db_dev',
1375             '/dev/VolGroup/lv2']
1376
1377         assert self. mock_process_input[n-4] == [
1378             'lvchange',
1379             '--deltag', 'ceph.db_uuid=dbuuid',
1380             '--deltag', 'ceph.db_device=db_dev',
1381             '/dev/VolGroup/lv1']
1382
1383         assert self. mock_process_input[n-3] == [
1384             'lvchange',
1385             '--addtag', 'ceph.db_uuid=new-db-uuid',
1386             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1387             '/dev/VolGroup/lv1']
1388
1389         assert self. mock_process_input[n-2] == [
1390             'lvchange',
1391             '--addtag', 'ceph.osd_id=2',
1392             '--addtag', 'ceph.type=db',
1393             '--addtag', 'ceph.osd_fsid=1234',
1394             '--addtag', 'ceph.cluster_name=ceph',
1395             '--addtag', 'ceph.db_uuid=new-db-uuid',
1396             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1397             '/dev/VolGroup/lv2_new']
1398
1399         assert self. mock_process_input[n-1] == [
1400             'ceph-bluestore-tool',
1401             '--path', '/var/lib/ceph/osd/ceph-2',
1402             '--dev-target', '/dev/VolGroup/lv2_new',
1403             '--command', 'bluefs-bdev-migrate',
1404             '--devs-source', '/var/lib/ceph/osd/ceph-2/block',
1405             '--devs-source', '/var/lib/ceph/osd/ceph-2/block.db']
1406
1407     @patch('os.getuid')
1408     def test_migrate_data_db_to_new_db_skip_wal(self, m_getuid, monkeypatch):
1409         m_getuid.return_value = 0
1410
1411         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1412         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1413         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1414         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1415         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234' \
1416         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1417
1418         data_vol = api.Volume(lv_name='volume1',
1419                               lv_uuid='datauuid',
1420                               vg_name='vg',
1421                               lv_path='/dev/VolGroup/lv1',
1422                               lv_tags=source_tags)
1423         db_vol = api.Volume(lv_name='volume2',
1424                             lv_uuid='dbuuid',
1425                             vg_name='vg',
1426                             lv_path='/dev/VolGroup/lv2',
1427                             lv_tags=source_db_tags)
1428
1429         wal_vol = api.Volume(lv_name='volume3',
1430                              lv_uuid='datauuid',
1431                              vg_name='vg',
1432                              lv_path='/dev/VolGroup/lv3',
1433                              lv_tags=source_wal_tags)
1434
1435         self.mock_single_volumes = {
1436             '/dev/VolGroup/lv1': data_vol,
1437             '/dev/VolGroup/lv2': db_vol,
1438             '/dev/VolGroup/lv3': wal_vol,
1439         }
1440         monkeypatch.setattr(migrate.api, 'get_single_lv',
1441             self.mock_get_single_lv)
1442
1443         self.mock_volume = api.Volume(lv_name='volume2_new', lv_uuid='new-db-uuid',
1444                                       vg_name='vg',
1445                                       lv_path='/dev/VolGroup/lv2_new',
1446                                       lv_tags='')
1447         monkeypatch.setattr(api, 'get_lv_by_fullname',
1448             self.mock_get_lv_by_fullname)
1449
1450         self.mock_process_input = []
1451         monkeypatch.setattr(process, 'call', self.mock_process)
1452
1453         devices = []
1454         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1455         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1456         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
1457
1458         monkeypatch.setattr(migrate, 'find_associated_devices',
1459             lambda osd_id, osd_fsid: devices)
1460
1461         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1462             lambda id: False)
1463
1464         monkeypatch.setattr(migrate, 'get_cluster_name',
1465             lambda osd_id, osd_fsid: 'ceph')
1466         monkeypatch.setattr(system, 'chown', lambda path: 0)
1467         m = migrate.Migrate(argv=[
1468             '--osd-id', '2',
1469             '--osd-fsid', '1234',
1470             '--from', 'data', 'db',
1471             '--target', 'vgname/new_wal'])
1472         m.main()
1473
1474         n = len(self.mock_process_input)
1475         assert n >= 7
1476
1477         assert self. mock_process_input[n-7] == [
1478             'lvchange',
1479             '--deltag', 'ceph.osd_id=2',
1480             '--deltag', 'ceph.type=db',
1481             '--deltag', 'ceph.osd_fsid=1234',
1482             '--deltag', 'ceph.cluster_name=ceph',
1483             '--deltag', 'ceph.db_uuid=dbuuid',
1484             '--deltag', 'ceph.db_device=db_dev',
1485             '/dev/VolGroup/lv2']
1486
1487         assert self. mock_process_input[n-6] == [
1488             'lvchange',
1489             '--deltag', 'ceph.db_uuid=dbuuid',
1490             '--deltag', 'ceph.db_device=db_dev',
1491             '/dev/VolGroup/lv1']
1492
1493         assert self. mock_process_input[n-5] == [
1494             'lvchange',
1495             '--addtag', 'ceph.db_uuid=new-db-uuid',
1496             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1497             '/dev/VolGroup/lv1']
1498
1499         assert self. mock_process_input[n-4] == [
1500             'lvchange',
1501             '--deltag', 'ceph.db_uuid=dbuuid',
1502             '--deltag', 'ceph.db_device=db_dev',
1503             '/dev/VolGroup/lv3']
1504
1505         assert self. mock_process_input[n-3] == [
1506             'lvchange',
1507             '--addtag', 'ceph.db_uuid=new-db-uuid',
1508             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1509             '/dev/VolGroup/lv3']
1510
1511         assert self. mock_process_input[n-2] == [
1512             'lvchange',
1513             '--addtag', 'ceph.osd_id=2',
1514             '--addtag', 'ceph.type=db',
1515             '--addtag', 'ceph.osd_fsid=1234',
1516             '--addtag', 'ceph.cluster_name=ceph',
1517             '--addtag', 'ceph.db_uuid=new-db-uuid',
1518             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1519             '/dev/VolGroup/lv2_new']
1520
1521         assert self. mock_process_input[n-1] == [
1522             'ceph-bluestore-tool',
1523             '--path', '/var/lib/ceph/osd/ceph-2',
1524             '--dev-target', '/dev/VolGroup/lv2_new',
1525             '--command', 'bluefs-bdev-migrate',
1526             '--devs-source', '/var/lib/ceph/osd/ceph-2/block',
1527             '--devs-source', '/var/lib/ceph/osd/ceph-2/block.db']
1528
1529     @patch('os.getuid')
1530     def test_migrate_data_db_wal_to_new_db(self, m_getuid, monkeypatch):
1531         m_getuid.return_value = 0
1532
1533         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1534         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1535         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1536         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1537         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1538         source_wal_tags = 'ceph.osd_id=0,ceph.type=wal,ceph.osd_fsid=1234,' \
1539         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1540         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1541
1542         data_vol = api.Volume(lv_name='volume1',
1543                               lv_uuid='datauuid',
1544                               vg_name='vg',
1545                               lv_path='/dev/VolGroup/lv1',
1546                               lv_tags=source_tags)
1547         db_vol = api.Volume(lv_name='volume2',
1548                             lv_uuid='dbuuid',
1549                             vg_name='vg',
1550                             lv_path='/dev/VolGroup/lv2',
1551                             lv_tags=source_db_tags)
1552
1553         wal_vol = api.Volume(lv_name='volume3',
1554                              lv_uuid='waluuid',
1555                              vg_name='vg',
1556                              lv_path='/dev/VolGroup/lv3',
1557                              lv_tags=source_wal_tags)
1558
1559         self.mock_single_volumes = {
1560             '/dev/VolGroup/lv1': data_vol,
1561             '/dev/VolGroup/lv2': db_vol,
1562             '/dev/VolGroup/lv3': wal_vol,
1563         }
1564         monkeypatch.setattr(migrate.api, 'get_single_lv',
1565             self.mock_get_single_lv)
1566
1567         self.mock_volume = api.Volume(lv_name='volume2_new', lv_uuid='new-db-uuid',
1568                                       vg_name='vg',
1569                                       lv_path='/dev/VolGroup/lv2_new',
1570                                       lv_tags='')
1571         monkeypatch.setattr(api, 'get_lv_by_fullname',
1572             self.mock_get_lv_by_fullname)
1573
1574         self.mock_process_input = []
1575         monkeypatch.setattr(process, 'call', self.mock_process)
1576
1577         devices = []
1578         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1579         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1580         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
1581
1582         monkeypatch.setattr(migrate, 'find_associated_devices',
1583             lambda osd_id, osd_fsid: devices)
1584
1585         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1586             lambda id: False)
1587
1588         monkeypatch.setattr(migrate, 'get_cluster_name',
1589             lambda osd_id, osd_fsid: 'ceph')
1590         monkeypatch.setattr(system, 'chown', lambda path: 0)
1591         m = migrate.Migrate(argv=[
1592             '--osd-id', '2',
1593             '--osd-fsid', '1234',
1594             '--from', 'data', 'db', 'wal',
1595             '--target', 'vgname/new_wal'])
1596         m.main()
1597
1598         n = len(self.mock_process_input)
1599         assert n >= 6
1600
1601         assert self. mock_process_input[n-6] == [
1602             'lvchange',
1603             '--deltag', 'ceph.osd_id=2',
1604             '--deltag', 'ceph.type=db',
1605             '--deltag', 'ceph.osd_fsid=1234',
1606             '--deltag', 'ceph.cluster_name=ceph',
1607             '--deltag', 'ceph.db_uuid=dbuuid',
1608             '--deltag', 'ceph.db_device=db_dev',
1609             '/dev/VolGroup/lv2']
1610
1611         assert self. mock_process_input[n-5] == [
1612             'lvchange',
1613             '--deltag', 'ceph.osd_id=0',
1614             '--deltag', 'ceph.type=wal',
1615             '--deltag', 'ceph.osd_fsid=1234',
1616             '--deltag', 'ceph.cluster_name=ceph',
1617             '--deltag', 'ceph.db_uuid=dbuuid',
1618             '--deltag', 'ceph.db_device=db_dev',
1619             '--deltag', 'ceph.wal_uuid=waluuid',
1620             '--deltag', 'ceph.wal_device=wal_dev',
1621             '/dev/VolGroup/lv3']
1622
1623         assert self. mock_process_input[n-4] == [
1624             'lvchange',
1625             '--deltag', 'ceph.db_uuid=dbuuid',
1626             '--deltag', 'ceph.db_device=db_dev',
1627             '--deltag', 'ceph.wal_uuid=waluuid',
1628             '--deltag', 'ceph.wal_device=wal_dev',
1629             '/dev/VolGroup/lv1']
1630
1631         assert self. mock_process_input[n-3] == [
1632             'lvchange',
1633             '--addtag', 'ceph.db_uuid=new-db-uuid',
1634             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1635             '/dev/VolGroup/lv1']
1636
1637         assert self. mock_process_input[n-2] == [
1638             'lvchange',
1639             '--addtag', 'ceph.osd_id=2',
1640             '--addtag', 'ceph.type=db',
1641             '--addtag', 'ceph.osd_fsid=1234',
1642             '--addtag', 'ceph.cluster_name=ceph',
1643             '--addtag', 'ceph.db_uuid=new-db-uuid',
1644             '--addtag', 'ceph.db_device=/dev/VolGroup/lv2_new',
1645             '/dev/VolGroup/lv2_new']
1646
1647         assert self. mock_process_input[n-1] == [
1648             'ceph-bluestore-tool',
1649             '--path', '/var/lib/ceph/osd/ceph-2',
1650             '--dev-target', '/dev/VolGroup/lv2_new',
1651             '--command', 'bluefs-bdev-migrate',
1652             '--devs-source', '/var/lib/ceph/osd/ceph-2/block',
1653             '--devs-source', '/var/lib/ceph/osd/ceph-2/block.db',
1654             '--devs-source', '/var/lib/ceph/osd/ceph-2/block.wal']
1655
1656     @patch('os.getuid')
1657     def test_dont_migrate_data_db_wal_to_new_data(self,
1658                                                   m_getuid,
1659                                                   monkeypatch,
1660                                                   capsys):
1661         m_getuid.return_value = 0
1662
1663         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1664         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1665         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1666         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1667
1668         data_vol = api.Volume(lv_name='volume1',
1669                               lv_uuid='datauuid',
1670                               vg_name='vg',
1671                               lv_path='/dev/VolGroup/lv1',
1672                               lv_tags=source_tags)
1673         db_vol = api.Volume(lv_name='volume2',
1674                             lv_uuid='dbuuid',
1675                             vg_name='vg',
1676                             lv_path='/dev/VolGroup/lv2',
1677                             lv_tags=source_db_tags)
1678
1679         self.mock_single_volumes = {
1680             '/dev/VolGroup/lv1': data_vol,
1681             '/dev/VolGroup/lv2': db_vol,
1682         }
1683         monkeypatch.setattr(migrate.api, 'get_single_lv',
1684             self.mock_get_single_lv)
1685
1686         self.mock_volume = api.Volume(lv_name='volume2_new', lv_uuid='new-db-uuid',
1687                                       vg_name='vg',
1688                                       lv_path='/dev/VolGroup/lv2_new',
1689                                       lv_tags='')
1690         monkeypatch.setattr(api, 'get_lv_by_fullname',
1691             self.mock_get_lv_by_fullname)
1692
1693         self.mock_process_input = []
1694         monkeypatch.setattr(process, 'call', self.mock_process)
1695
1696         devices = []
1697         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1698         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1699
1700         monkeypatch.setattr(migrate, 'find_associated_devices',
1701             lambda osd_id, osd_fsid: devices)
1702
1703         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1704             lambda id: False)
1705
1706         monkeypatch.setattr(migrate, 'get_cluster_name',
1707             lambda osd_id, osd_fsid: 'ceph')
1708         monkeypatch.setattr(system, 'chown', lambda path: 0)
1709         m = migrate.Migrate(argv=[
1710             '--osd-id', '2',
1711             '--osd-fsid', '1234',
1712             '--from', 'data',
1713             '--target', 'vgname/new_data'])
1714
1715         with pytest.raises(SystemExit) as error:
1716             m.main()
1717         stdout, stderr = capsys.readouterr()
1718         expected = 'Unable to migrate to : vgname/new_data'
1719         assert expected in str(error.value)
1720         expected = 'Unable to determine new volume type,'
1721         ' please use new-db or new-wal command before.'
1722         assert expected in stderr
1723
1724     @patch('os.getuid')
1725     def test_dont_migrate_db_to_wal(self,
1726                                     m_getuid,
1727                                     monkeypatch,
1728                                     capsys):
1729         m_getuid.return_value = 0
1730
1731         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1732         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1733         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1734         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1735         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1736         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234,' \
1737         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1738         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1739
1740         data_vol = api.Volume(lv_name='volume1',
1741                               lv_uuid='datauuid',
1742                               vg_name='vg',
1743                               lv_path='/dev/VolGroup/lv1',
1744                               lv_tags=source_tags)
1745         db_vol = api.Volume(lv_name='volume2',
1746                             lv_uuid='dbuuid',
1747                             vg_name='vg',
1748                             lv_path='/dev/VolGroup/lv2',
1749                             lv_tags=source_db_tags)
1750
1751         wal_vol = api.Volume(lv_name='volume3',
1752                              lv_uuid='waluuid',
1753                              vg_name='vg',
1754                              lv_path='/dev/VolGroup/lv3',
1755                              lv_tags=source_wal_tags)
1756
1757         self.mock_single_volumes = {
1758             '/dev/VolGroup/lv1': data_vol,
1759             '/dev/VolGroup/lv2': db_vol,
1760             '/dev/VolGroup/lv3': wal_vol,
1761         }
1762         monkeypatch.setattr(migrate.api, 'get_single_lv',
1763             self.mock_get_single_lv)
1764
1765         self.mock_volume = wal_vol
1766         monkeypatch.setattr(api, 'get_lv_by_fullname',
1767             self.mock_get_lv_by_fullname)
1768
1769         self.mock_process_input = []
1770         monkeypatch.setattr(process, 'call', self.mock_process)
1771
1772         devices = []
1773         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1774         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1775         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
1776
1777         monkeypatch.setattr(migrate, 'find_associated_devices',
1778             lambda osd_id, osd_fsid: devices)
1779
1780         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1781             lambda id: False)
1782
1783         monkeypatch.setattr(migrate, 'get_cluster_name',
1784             lambda osd_id, osd_fsid: 'ceph')
1785         monkeypatch.setattr(system, 'chown', lambda path: 0)
1786         m = migrate.Migrate(argv=[
1787             '--osd-id', '2',
1788             '--osd-fsid', '1234',
1789             '--from', 'db',
1790             '--target', 'vgname/wal'])
1791
1792         with pytest.raises(SystemExit) as error:
1793             m.main()
1794         stdout, stderr = capsys.readouterr()
1795         expected = 'Unable to migrate to : vgname/wal'
1796         assert expected in str(error.value)
1797         expected = 'Migrate to WAL is not supported'
1798         assert expected in stderr
1799
1800     @patch('os.getuid')
1801     def test_migrate_data_db_to_db(self,
1802                                     m_getuid,
1803                                     monkeypatch,
1804                                     capsys):
1805         m_getuid.return_value = 0
1806
1807         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1808         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1809         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1810         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1811         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1812         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234,' \
1813         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1814         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1815
1816         data_vol = api.Volume(lv_name='volume1',
1817                               lv_uuid='datauuid',
1818                               vg_name='vg',
1819                               lv_path='/dev/VolGroup/lv1',
1820                               lv_tags=source_tags)
1821         db_vol = api.Volume(lv_name='volume2',
1822                             lv_uuid='dbuuid',
1823                             vg_name='vg',
1824                             lv_path='/dev/VolGroup/lv2',
1825                             lv_tags=source_db_tags)
1826
1827         wal_vol = api.Volume(lv_name='volume3',
1828                              lv_uuid='waluuid',
1829                              vg_name='vg',
1830                              lv_path='/dev/VolGroup/lv3',
1831                              lv_tags=source_wal_tags)
1832
1833         self.mock_single_volumes = {
1834             '/dev/VolGroup/lv1': data_vol,
1835             '/dev/VolGroup/lv2': db_vol,
1836             '/dev/VolGroup/lv3': wal_vol,
1837         }
1838         monkeypatch.setattr(migrate.api, 'get_single_lv',
1839             self.mock_get_single_lv)
1840
1841         self.mock_volume = db_vol
1842         monkeypatch.setattr(api, 'get_lv_by_fullname',
1843             self.mock_get_lv_by_fullname)
1844
1845         self.mock_process_input = []
1846         monkeypatch.setattr(process, 'call', self.mock_process)
1847
1848         devices = []
1849         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1850         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1851         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
1852
1853         monkeypatch.setattr(migrate, 'find_associated_devices',
1854             lambda osd_id, osd_fsid: devices)
1855
1856         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1857             lambda id: False)
1858
1859         monkeypatch.setattr(migrate, 'get_cluster_name',
1860             lambda osd_id, osd_fsid: 'ceph')
1861         monkeypatch.setattr(system, 'chown', lambda path: 0)
1862         m = migrate.Migrate(argv=[
1863             '--osd-id', '2',
1864             '--osd-fsid', '1234',
1865             '--from', 'db', 'data',
1866             '--target', 'vgname/db'])
1867
1868         m.main()
1869
1870         n = len(self.mock_process_input)
1871         assert n >= 1
1872         for s in self.mock_process_input:
1873             print(s)
1874
1875         assert self. mock_process_input[n-1] == [
1876             'ceph-bluestore-tool',
1877             '--path', '/var/lib/ceph/osd/ceph-2',
1878             '--dev-target', '/var/lib/ceph/osd/ceph-2/block.db',
1879             '--command', 'bluefs-bdev-migrate',
1880             '--devs-source', '/var/lib/ceph/osd/ceph-2/block']
1881
1882     def test_migrate_data_db_to_db_active_systemd(self, is_root, monkeypatch, capsys):
1883         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1884         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1885         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1886         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1887         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1888         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234,' \
1889         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1890         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1891
1892         data_vol = api.Volume(lv_name='volume1',
1893                               lv_uuid='datauuid',
1894                               vg_name='vg',
1895                               lv_path='/dev/VolGroup/lv1',
1896                               lv_tags=source_tags)
1897         db_vol = api.Volume(lv_name='volume2',
1898                             lv_uuid='dbuuid',
1899                             vg_name='vg',
1900                             lv_path='/dev/VolGroup/lv2',
1901                             lv_tags=source_db_tags)
1902
1903         wal_vol = api.Volume(lv_name='volume3',
1904                              lv_uuid='waluuid',
1905                              vg_name='vg',
1906                              lv_path='/dev/VolGroup/lv3',
1907                              lv_tags=source_wal_tags)
1908
1909         self.mock_single_volumes = {
1910             '/dev/VolGroup/lv1': data_vol,
1911             '/dev/VolGroup/lv2': db_vol,
1912             '/dev/VolGroup/lv3': wal_vol,
1913         }
1914         monkeypatch.setattr(migrate.api, 'get_single_lv',
1915             self.mock_get_single_lv)
1916
1917         self.mock_volume = db_vol
1918         monkeypatch.setattr(api, 'get_lv_by_fullname',
1919             self.mock_get_lv_by_fullname)
1920
1921         self.mock_process_input = []
1922         monkeypatch.setattr(process, 'call', self.mock_process)
1923
1924         devices = []
1925         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1926         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1927         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
1928
1929         monkeypatch.setattr(migrate, 'find_associated_devices',
1930             lambda osd_id, osd_fsid: devices)
1931
1932         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
1933             lambda id: True)
1934
1935         monkeypatch.setattr(migrate, 'get_cluster_name',
1936             lambda osd_id, osd_fsid: 'ceph')
1937         monkeypatch.setattr(system, 'chown', lambda path: 0)
1938         m = migrate.Migrate(argv=[
1939             '--osd-id', '2',
1940             '--osd-fsid', '1234',
1941             '--from', 'db', 'data',
1942             '--target', 'vgname/db'])
1943
1944         with pytest.raises(SystemExit) as error:
1945             m.main()
1946
1947         stdout, stderr = capsys.readouterr()
1948
1949         assert 'Unable to migrate devices associated with OSD ID: 2' == str(error.value)
1950         assert '--> OSD is running, stop it with: systemctl stop ceph-osd@2' == stderr.rstrip()
1951         assert not stdout
1952
1953     def test_migrate_data_db_to_db_no_systemd(self, is_root, monkeypatch):
1954         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
1955         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1956         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1957         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
1958         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev'
1959         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234,' \
1960         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
1961         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
1962
1963         data_vol = api.Volume(lv_name='volume1',
1964                               lv_uuid='datauuid',
1965                               vg_name='vg',
1966                               lv_path='/dev/VolGroup/lv1',
1967                               lv_tags=source_tags)
1968         db_vol = api.Volume(lv_name='volume2',
1969                             lv_uuid='dbuuid',
1970                             vg_name='vg',
1971                             lv_path='/dev/VolGroup/lv2',
1972                             lv_tags=source_db_tags)
1973
1974         wal_vol = api.Volume(lv_name='volume3',
1975                              lv_uuid='waluuid',
1976                              vg_name='vg',
1977                              lv_path='/dev/VolGroup/lv3',
1978                              lv_tags=source_wal_tags)
1979
1980         self.mock_single_volumes = {
1981             '/dev/VolGroup/lv1': data_vol,
1982             '/dev/VolGroup/lv2': db_vol,
1983             '/dev/VolGroup/lv3': wal_vol,
1984         }
1985         monkeypatch.setattr(migrate.api, 'get_single_lv',
1986             self.mock_get_single_lv)
1987
1988         self.mock_volume = db_vol
1989         monkeypatch.setattr(api, 'get_lv_by_fullname',
1990             self.mock_get_lv_by_fullname)
1991
1992         self.mock_process_input = []
1993         monkeypatch.setattr(process, 'call', self.mock_process)
1994
1995         devices = []
1996         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
1997         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
1998         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
1999
2000         monkeypatch.setattr(migrate, 'find_associated_devices',
2001             lambda osd_id, osd_fsid: devices)
2002
2003         monkeypatch.setattr(migrate, 'get_cluster_name',
2004             lambda osd_id, osd_fsid: 'ceph')
2005         monkeypatch.setattr(system, 'chown', lambda path: 0)
2006         m = migrate.Migrate(argv=[
2007             '--osd-id', '2',
2008             '--osd-fsid', '1234',
2009             '--from', 'db', 'data',
2010             '--target', 'vgname/db',
2011             '--no-systemd'])
2012
2013         m.main()
2014
2015         n = len(self.mock_process_input)
2016         assert n >= 1
2017         for s in self.mock_process_input:
2018             print(s)
2019
2020         assert self. mock_process_input[n-1] == [
2021             'ceph-bluestore-tool',
2022             '--path', '/var/lib/ceph/osd/ceph-2',
2023             '--dev-target', '/var/lib/ceph/osd/ceph-2/block.db',
2024             '--command', 'bluefs-bdev-migrate',
2025             '--devs-source', '/var/lib/ceph/osd/ceph-2/block']
2026
2027     @patch('os.getuid')
2028     def test_migrate_data_wal_to_db(self,
2029                                     m_getuid,
2030                                     monkeypatch,
2031                                     capsys):
2032         m_getuid.return_value = 0
2033
2034         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
2035         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2036         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2037         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
2038         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2039         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2040         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234,' \
2041         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2042         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2043
2044         data_vol = api.Volume(lv_name='volume1',
2045                               lv_uuid='datauuid',
2046                               vg_name='vg',
2047                               lv_path='/dev/VolGroup/lv1',
2048                               lv_tags=source_tags)
2049         db_vol = api.Volume(lv_name='volume2',
2050                             lv_uuid='dbuuid',
2051                             vg_name='vg',
2052                             lv_path='/dev/VolGroup/lv2',
2053                             lv_tags=source_db_tags)
2054
2055         wal_vol = api.Volume(lv_name='volume3',
2056                              lv_uuid='waluuid',
2057                              vg_name='vg',
2058                              lv_path='/dev/VolGroup/lv3',
2059                              lv_tags=source_wal_tags)
2060
2061         self.mock_single_volumes = {
2062             '/dev/VolGroup/lv1': data_vol,
2063             '/dev/VolGroup/lv2': db_vol,
2064             '/dev/VolGroup/lv3': wal_vol,
2065         }
2066         monkeypatch.setattr(migrate.api, 'get_single_lv',
2067             self.mock_get_single_lv)
2068
2069         self.mock_volume = db_vol
2070         monkeypatch.setattr(api, 'get_lv_by_fullname',
2071             self.mock_get_lv_by_fullname)
2072
2073         self.mock_process_input = []
2074         monkeypatch.setattr(process, 'call', self.mock_process)
2075
2076         devices = []
2077         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
2078         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
2079         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
2080
2081         monkeypatch.setattr(migrate, 'find_associated_devices',
2082             lambda osd_id, osd_fsid: devices)
2083
2084         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
2085             lambda id: False)
2086
2087         monkeypatch.setattr(migrate, 'get_cluster_name',
2088             lambda osd_id, osd_fsid: 'ceph')
2089         monkeypatch.setattr(system, 'chown', lambda path: 0)
2090         m = migrate.Migrate(argv=[
2091             '--osd-id', '2',
2092             '--osd-fsid', '1234',
2093             '--from', 'db', 'data', 'wal',
2094             '--target', 'vgname/db'])
2095
2096         m.main()
2097
2098         n = len(self.mock_process_input)
2099         assert n >= 1
2100         for s in self.mock_process_input:
2101             print(s)
2102
2103         assert self. mock_process_input[n-4] == [
2104             'lvchange',
2105             '--deltag', 'ceph.osd_id=2',
2106             '--deltag', 'ceph.type=wal',
2107             '--deltag', 'ceph.osd_fsid=1234',
2108             '--deltag', 'ceph.cluster_name=ceph',
2109             '--deltag', 'ceph.db_uuid=dbuuid',
2110             '--deltag', 'ceph.db_device=db_dev',
2111             '--deltag', 'ceph.wal_uuid=waluuid',
2112             '--deltag', 'ceph.wal_device=wal_dev',
2113             '/dev/VolGroup/lv3']
2114         assert self. mock_process_input[n-3] == [
2115             'lvchange',
2116             '--deltag', 'ceph.wal_uuid=waluuid',
2117             '--deltag', 'ceph.wal_device=wal_dev',
2118             '/dev/VolGroup/lv1']
2119         assert self. mock_process_input[n-2] == [
2120             'lvchange',
2121             '--deltag', 'ceph.wal_uuid=waluuid',
2122             '--deltag', 'ceph.wal_device=wal_dev',
2123             '/dev/VolGroup/lv2']
2124         assert self. mock_process_input[n-1] == [
2125             'ceph-bluestore-tool',
2126             '--path', '/var/lib/ceph/osd/ceph-2',
2127             '--dev-target', '/var/lib/ceph/osd/ceph-2/block.db',
2128             '--command', 'bluefs-bdev-migrate',
2129             '--devs-source', '/var/lib/ceph/osd/ceph-2/block',
2130             '--devs-source', '/var/lib/ceph/osd/ceph-2/block.wal']
2131
2132     def test_migrate_data_wal_to_db_active_systemd(self, is_root, monkeypatch, capsys):
2133         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
2134         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2135         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2136         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
2137         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2138         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2139         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234,' \
2140         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2141         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2142
2143         data_vol = api.Volume(lv_name='volume1',
2144                               lv_uuid='datauuid',
2145                               vg_name='vg',
2146                               lv_path='/dev/VolGroup/lv1',
2147                               lv_tags=source_tags)
2148         db_vol = api.Volume(lv_name='volume2',
2149                             lv_uuid='dbuuid',
2150                             vg_name='vg',
2151                             lv_path='/dev/VolGroup/lv2',
2152                             lv_tags=source_db_tags)
2153
2154         wal_vol = api.Volume(lv_name='volume3',
2155                              lv_uuid='waluuid',
2156                              vg_name='vg',
2157                              lv_path='/dev/VolGroup/lv3',
2158                              lv_tags=source_wal_tags)
2159
2160         self.mock_single_volumes = {
2161             '/dev/VolGroup/lv1': data_vol,
2162             '/dev/VolGroup/lv2': db_vol,
2163             '/dev/VolGroup/lv3': wal_vol,
2164         }
2165         monkeypatch.setattr(migrate.api, 'get_single_lv',
2166             self.mock_get_single_lv)
2167
2168         self.mock_volume = db_vol
2169         monkeypatch.setattr(api, 'get_lv_by_fullname',
2170             self.mock_get_lv_by_fullname)
2171
2172         self.mock_process_input = []
2173         monkeypatch.setattr(process, 'call', self.mock_process)
2174
2175         devices = []
2176         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
2177         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
2178         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
2179
2180         monkeypatch.setattr(migrate, 'find_associated_devices',
2181             lambda osd_id, osd_fsid: devices)
2182
2183         monkeypatch.setattr("ceph_volume.systemd.systemctl.osd_is_active",
2184             lambda id: True)
2185
2186         monkeypatch.setattr(migrate, 'get_cluster_name',
2187             lambda osd_id, osd_fsid: 'ceph')
2188         monkeypatch.setattr(system, 'chown', lambda path: 0)
2189         m = migrate.Migrate(argv=[
2190             '--osd-id', '2',
2191             '--osd-fsid', '1234',
2192             '--from', 'db', 'data', 'wal',
2193             '--target', 'vgname/db'])
2194
2195         with pytest.raises(SystemExit) as error:
2196             m.main()
2197
2198         stdout, stderr = capsys.readouterr()
2199
2200         assert 'Unable to migrate devices associated with OSD ID: 2' == str(error.value)
2201         assert '--> OSD is running, stop it with: systemctl stop ceph-osd@2' == stderr.rstrip()
2202         assert not stdout
2203
2204     def test_migrate_data_wal_to_db_no_systemd(self, is_root, monkeypatch):
2205         source_tags = 'ceph.osd_id=2,ceph.type=data,ceph.osd_fsid=1234,' \
2206         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2207         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2208         source_db_tags = 'ceph.osd_id=2,ceph.type=db,ceph.osd_fsid=1234,' \
2209         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2210         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2211         source_wal_tags = 'ceph.osd_id=2,ceph.type=wal,ceph.osd_fsid=1234,' \
2212         'ceph.cluster_name=ceph,ceph.db_uuid=dbuuid,ceph.db_device=db_dev,' \
2213         'ceph.wal_uuid=waluuid,ceph.wal_device=wal_dev'
2214
2215         data_vol = api.Volume(lv_name='volume1',
2216                               lv_uuid='datauuid',
2217                               vg_name='vg',
2218                               lv_path='/dev/VolGroup/lv1',
2219                               lv_tags=source_tags)
2220         db_vol = api.Volume(lv_name='volume2',
2221                             lv_uuid='dbuuid',
2222                             vg_name='vg',
2223                             lv_path='/dev/VolGroup/lv2',
2224                             lv_tags=source_db_tags)
2225
2226         wal_vol = api.Volume(lv_name='volume3',
2227                              lv_uuid='waluuid',
2228                              vg_name='vg',
2229                              lv_path='/dev/VolGroup/lv3',
2230                              lv_tags=source_wal_tags)
2231
2232         self.mock_single_volumes = {
2233             '/dev/VolGroup/lv1': data_vol,
2234             '/dev/VolGroup/lv2': db_vol,
2235             '/dev/VolGroup/lv3': wal_vol,
2236         }
2237         monkeypatch.setattr(migrate.api, 'get_single_lv',
2238             self.mock_get_single_lv)
2239
2240         self.mock_volume = db_vol
2241         monkeypatch.setattr(api, 'get_lv_by_fullname',
2242             self.mock_get_lv_by_fullname)
2243
2244         self.mock_process_input = []
2245         monkeypatch.setattr(process, 'call', self.mock_process)
2246
2247         devices = []
2248         devices.append([Device('/dev/VolGroup/lv1'), 'block'])
2249         devices.append([Device('/dev/VolGroup/lv2'), 'db'])
2250         devices.append([Device('/dev/VolGroup/lv3'), 'wal'])
2251
2252         monkeypatch.setattr(migrate, 'find_associated_devices',
2253             lambda osd_id, osd_fsid: devices)
2254
2255         monkeypatch.setattr(migrate, 'get_cluster_name',
2256             lambda osd_id, osd_fsid: 'ceph')
2257         monkeypatch.setattr(system, 'chown', lambda path: 0)
2258         m = migrate.Migrate(argv=[
2259             '--osd-id', '2',
2260             '--osd-fsid', '1234',
2261             '--from', 'db', 'data', 'wal',
2262             '--target', 'vgname/db',
2263             '--no-systemd'])
2264
2265         m.main()
2266
2267         n = len(self.mock_process_input)
2268         assert n >= 1
2269         for s in self.mock_process_input:
2270             print(s)
2271
2272         assert self. mock_process_input[n-4] == [
2273             'lvchange',
2274             '--deltag', 'ceph.osd_id=2',
2275             '--deltag', 'ceph.type=wal',
2276             '--deltag', 'ceph.osd_fsid=1234',
2277             '--deltag', 'ceph.cluster_name=ceph',
2278             '--deltag', 'ceph.db_uuid=dbuuid',
2279             '--deltag', 'ceph.db_device=db_dev',
2280             '--deltag', 'ceph.wal_uuid=waluuid',
2281             '--deltag', 'ceph.wal_device=wal_dev',
2282             '/dev/VolGroup/lv3']
2283         assert self. mock_process_input[n-3] == [
2284             'lvchange',
2285             '--deltag', 'ceph.wal_uuid=waluuid',
2286             '--deltag', 'ceph.wal_device=wal_dev',
2287             '/dev/VolGroup/lv1']
2288         assert self. mock_process_input[n-2] == [
2289             'lvchange',
2290             '--deltag', 'ceph.wal_uuid=waluuid',
2291             '--deltag', 'ceph.wal_device=wal_dev',
2292             '/dev/VolGroup/lv2']
2293         assert self. mock_process_input[n-1] == [
2294             'ceph-bluestore-tool',
2295             '--path', '/var/lib/ceph/osd/ceph-2',
2296             '--dev-target', '/var/lib/ceph/osd/ceph-2/block.db',
2297             '--command', 'bluefs-bdev-migrate',
2298             '--devs-source', '/var/lib/ceph/osd/ceph-2/block',
2299             '--devs-source', '/var/lib/ceph/osd/ceph-2/block.wal']