1
diff --git a/curtin/block/multipath.py b/curtin/block/multipath.py
2
index e317184..0f9170e 100644
3
--- a/curtin/block/multipath.py
4
+++ b/curtin/block/multipath.py
5
@@ -65,11 +65,10 @@ def is_mpath_device(devpath, info=None):
6
65
def is_mpath_member(devpath, info=None):
65
def is_mpath_member(devpath, info=None):
7
66
    """ Check if a device is a multipath member (a path), returns boolean. """
66
    """ Check if a device is a multipath member (a path), returns boolean. """
8
67
    result = False
67
    result = False
11
68
    try:
68
    if not info:
12
69
        util.subp(['multipath', '-c', devpath], capture=True)
69
        info = udev.udevadm_info(devpath)
13
70
    if info.get("DM_MULTIPATH_DEVICE_PATH") == "1":
14
70
        result = True
71
        result = True
15
71
    except util.ProcessExecutionError:
16
72
        pass
17
73
72
18
74
    LOG.debug('%s is multipath device member? %s', devpath, result)
73
    LOG.debug('%s is multipath device member? %s', devpath, result)
19
75
    return result
74
    return result
20
@@ -81,7 +80,7 @@ def is_mpath_partition(devpath, info=None):
21
81
    if devpath.startswith('/dev/dm-'):
80
    if devpath.startswith('/dev/dm-'):
22
82
        if not info:
81
        if not info:
23
83
            info = udev.udevadm_info(devpath)
82
            info = udev.udevadm_info(devpath)
25
84
        if 'DM_PART' in udev.udevadm_info(devpath):
83
        if 'DM_PART' in info and 'DM_MPATH' in info:
26
85
            result = True
84
            result = True
27
86
85
28
87
    LOG.debug("%s is multipath device partition? %s", devpath, result)
86
    LOG.debug("%s is multipath device partition? %s", devpath, result)
29
diff --git a/curtin/storage_config.py b/curtin/storage_config.py
30
index e6c33cc..81b7385 100644
31
--- a/curtin/storage_config.py
32
+++ b/curtin/storage_config.py
33
@@ -7,7 +7,7 @@ import re
34
7
import yaml
7
import yaml
35
8
8
36
9
from curtin.log import LOG
9
from curtin.log import LOG
38
10
from curtin.block import schemas
10
from curtin.block import multipath, schemas
39
11
from curtin import config as curtin_config
11
from curtin import config as curtin_config
40
12
from curtin import util
12
from curtin import util
41
13
13
42
@@ -453,72 +453,15 @@ class ProbertParser(object):
43
453
453
44
454
        return None
454
        return None
45
455
455
49
456
    def is_mpath(self, blockdev):
456
    def is_mpath_member(self, blockdev):
50
457
        if blockdev.get('DM_MULTIPATH_DEVICE_PATH') == "1":
457
        return multipath.is_mpath_member(blockdev.get('DEVNAME', ''), blockdev)
48
458
            return True
51
459
458
53
460
        return bool('mpath-' in blockdev.get('DM_UUID', ''))
459
    def is_mpath_device(self, blockdev):
54
460
        return multipath.is_mpath_device(blockdev.get('DEVNAME', ''), blockdev)
55
461
461
116
462
    def get_mpath_name(self, blockdev):
462
    def is_mpath_partition(self, blockdev):
117
463
        mpath_data = self.probe_data.get('multipath')
463
        return multipath.is_mpath_partition(
118
464
        if not mpath_data:
464
            blockdev.get('DEVNAME', ''), blockdev)
59
465
            return None
60
466
61
467
        bd_name = blockdev['DEVNAME']
62
468
        if blockdev['DEVTYPE'] == 'partition':
63
469
            bd_name = self.partition_parent_devname(blockdev)
64
470
        bd_name = os.path.basename(bd_name)
65
471
        for path in mpath_data.get('paths', []):
66
472
            if bd_name == path.get('device'):
67
473
                rv = path.get('multipath')
68
474
                return rv
69
475
70
476
    def find_mpath_member(self, blockdev):
71
477
        if blockdev.get('DM_MULTIPATH_DEVICE_PATH') == "1":
72
478
            # find all other DM_MULTIPATH_DEVICE_PATH devs with same serial
73
479
            serial = blockdev.get('ID_SERIAL')
74
480
            members = sorted([os.path.basename(dev['DEVNAME'])
75
481
                              for dev in self.blockdev_data.values()
76
482
                              if dev.get("ID_SERIAL", "") == serial and
77
483
                              dev['DEVTYPE'] == blockdev['DEVTYPE']])
78
484
            # [/dev/sda, /dev/sdb]
79
485
            # [/dev/sda1, /dev/sda2, /dev/sdb1, /dev/sdb2]
80
486
81
487
        else:
82
488
            dm_mpath = blockdev.get('DM_MPATH')
83
489
            dm_uuid = blockdev.get('DM_UUID')
84
490
            dm_part = blockdev.get('DM_PART')
85
491
            dm_name = blockdev.get('DM_NAME')
86
492
87
493
            if dm_mpath:
88
494
                multipath = dm_mpath
89
495
            elif dm_name:
90
496
                multipath = dm_name
91
497
            else:
92
498
                # part1-mpath-30000000000000064
93
499
                # mpath-30000000000000064
94
500
                # mpath-36005076306ffd6b60000000000002406
95
501
                match = re.search(r'mpath\-([a-zA-Z]*|\d*)+$', dm_uuid)
96
502
                if not match:
97
503
                    LOG.debug('Failed to extract multipath ID pattern from '
98
504
                              'DM_UUID value: "%s"', dm_uuid)
99
505
                    return None
100
506
                # remove leading 'mpath-'
101
507
                multipath = match.group(0)[6:]
102
508
            mpath_data = self.probe_data.get('multipath')
103
509
            if not mpath_data:
104
510
                return None
105
511
            members = sorted([path['device'] for path in mpath_data['paths']
106
512
                              if path['multipath'] == multipath])
107
513
108
514
            # append partition number if present
109
515
            if dm_part:
110
516
                members = [member + dm_part for member in members]
111
517
112
518
        if len(members):
113
519
            return members[0]
114
520
115
521
        return None
119
522
465
120
523
    def blockdev_to_id(self, blockdev):
466
    def blockdev_to_id(self, blockdev):
121
524
        """ Examine a blockdev dictionary and return a tuple of curtin
467
        """ Examine a blockdev dictionary and return a tuple of curtin
122
@@ -539,15 +482,13 @@ class ProbertParser(object):
123
539
            if 'DM_LV_NAME' in blockdev:
482
            if 'DM_LV_NAME' in blockdev:
124
540
                devtype = 'lvm-partition'
483
                devtype = 'lvm-partition'
125
541
                name = blockdev['DM_LV_NAME']
484
                name = blockdev['DM_LV_NAME']
135
542
            elif self.is_mpath(blockdev):
485
            elif self.is_mpath_device(blockdev):
136
543
                # extract a multipath member device
486
                devtype = 'mpath-disk'
137
544
                member = self.find_mpath_member(blockdev)
487
                name = blockdev['DM_NAME']
138
545
                if member:
488
            elif self.is_mpath_partition(blockdev):
139
546
                    name = member
489
                devtype = 'mpath-partition'
140
547
                else:
490
                name = '{}-part{}'.format(
141
548
                    name = blockdev['DM_UUID']
491
                    blockdev['DM_MPATH'], blockdev['DM_PART'])
133
549
                if 'DM_PART' in blockdev:
134
550
                    devtype = 'partition'
142
551
            elif is_dmcrypt(blockdev):
492
            elif is_dmcrypt(blockdev):
143
552
                devtype = 'dmcrypt'
493
                devtype = 'dmcrypt'
144
553
                name = blockdev['DM_NAME']
494
                name = blockdev['DM_NAME']
145
@@ -681,10 +622,15 @@ class BlockdevParser(ProbertParser):
146
681
        errors = []
622
        errors = []
147
682
623
148
683
        for devname, data in self.blockdev_data.items():
624
        for devname, data in self.blockdev_data.items():
150
684
            # skip composed devices here, except partitions
625
            # skip composed devices here, except partitions and multipath
151
685
            if data.get('DEVPATH', '').startswith('/devices/virtual/block'):
626
            if data.get('DEVPATH', '').startswith('/devices/virtual/block'):
154
686
                if data.get('DEVTYPE', '') != "partition":
627
                if not self.is_mpath_device(data):
155
687
                    continue
628
                    if not self.is_mpath_partition(data):
156
629
                        if data.get('DEVTYPE', '') != "partition":
157
630
                            continue
158
631
            # skip disks that are members of multipath devices
159
632
            if self.is_mpath_member(data):
160
633
                continue
161
688
            entry = self.asdict(data)
634
            entry = self.asdict(data)
162
689
            if entry:
635
            if entry:
163
690
                try:
636
                try:
164
@@ -698,7 +644,10 @@ class BlockdevParser(ProbertParser):
165
698
    def valid_id(self, id_value):
644
    def valid_id(self, id_value):
166
699
        # reject wwn=0x0+
645
        # reject wwn=0x0+
167
700
        if id_value.lower().startswith('0x'):
646
        if id_value.lower().startswith('0x'):
169
701
            return int(id_value, 16) > 0
647
            try:
170
648
                return int(id_value, 16) > 0
171
649
            except ValueError:
172
650
                return True
173
702
        # accept non-empty (removing whitspace) strings
651
        # accept non-empty (removing whitspace) strings
174
703
        return len(''.join(id_value.split())) > 0
652
        return len(''.join(id_value.split())) > 0
175
704
653
176
@@ -710,10 +659,16 @@ class BlockdevParser(ProbertParser):
177
710
            blockdev attribute.
659
            blockdev attribute.
178
711
        """
660
        """
179
712
        uniq = {}
661
        uniq = {}
184
713
        source_keys = {
662
        if self.is_mpath_device(blockdev):
185
714
            'wwn': ['ID_WWN_WITH_EXTENSION', 'ID_WWN'],
663
            source_keys = {
186
715
            'serial': ['ID_SERIAL', 'ID_SERIAL_SHORT'],
664
                'wwn': ['DM_WWN'],
187
716
        }
665
                'serial': ['DM_SERIAL'],  # only present with focal+
188
666
            }
189
667
        else:
190
668
            source_keys = {
191
669
                'wwn': ['ID_WWN_WITH_EXTENSION', 'ID_WWN'],
192
670
                'serial': ['ID_SERIAL', 'ID_SERIAL_SHORT'],
193
671
            }
194
717
        for skey, id_keys in source_keys.items():
672
        for skey, id_keys in source_keys.items():
195
718
            for id_key in id_keys:
673
            for id_key in id_keys:
196
719
                if id_key in blockdev and skey not in uniq:
674
                if id_key in blockdev and skey not in uniq:
197
@@ -740,6 +695,10 @@ class BlockdevParser(ProbertParser):
198
740
            storage config dictionary.  This method
695
            storage config dictionary.  This method
199
741
            will return curtin storage types: disk, partition.
696
            will return curtin storage types: disk, partition.
200
742
        """
697
        """
201
698
        dev_type = blockdev_data['DEVTYPE']
202
699
        if self.is_mpath_partition(blockdev_data):
203
700
            dev_type = 'partition'
204
701
205
743
        # just disks and partitions
702
        # just disks and partitions
206
744
        if blockdev_data['DEVTYPE'] not in ["disk", "partition"]:
703
        if blockdev_data['DEVTYPE'] not in ["disk", "partition"]:
207
745
            return None
704
            return None
208
@@ -752,13 +711,13 @@ class BlockdevParser(ProbertParser):
209
752
711
210
753
        devname = blockdev_data.get('DEVNAME')
712
        devname = blockdev_data.get('DEVNAME')
211
754
        entry = {
713
        entry = {
213
755
            'type': blockdev_data['DEVTYPE'],
714
            'type': dev_type,
214
756
            'id': self.blockdev_to_id(blockdev_data),
715
            'id': self.blockdev_to_id(blockdev_data),
215
757
        }
716
        }
220
758
        if blockdev_data.get('DM_MULTIPATH_DEVICE_PATH') == "1":
717
        if self.is_mpath_device(blockdev_data):
221
759
            mpath_name = self.get_mpath_name(blockdev_data)
718
            entry['multipath'] = blockdev_data['DM_NAME']
222
760
            if mpath_name:
719
        elif self.is_mpath_partition(blockdev_data):
223
761
                entry['multipath'] = mpath_name
720
            entry['multipath'] = blockdev_data['DM_MPATH']
224
762
721
225
763
        # default disks to gpt
722
        # default disks to gpt
226
764
        if entry['type'] == 'disk':
723
        if entry['type'] == 'disk':
227
@@ -796,8 +755,17 @@ class BlockdevParser(ProbertParser):
228
796
755
229
797
        if entry['type'] == 'partition':
756
        if entry['type'] == 'partition':
230
798
            attrs = blockdev_data['attrs']
757
            attrs = blockdev_data['attrs']
233
799
            entry['number'] = int(attrs['partition'])
758
            if self.is_mpath_partition(blockdev_data):
234
800
            parent_devname = self.partition_parent_devname(blockdev_data)
759
                entry['number'] = int(blockdev_data['DM_PART'])
235
760
                parent_devname = self.lookup_devname(
236
761
                    '/dev/mapper/' + blockdev_data['DM_MPATH'])
237
762
                if parent_devname is None:
238
763
                    raise ValueError(
239
764
                        "Cannot find parent mpath device %s for %s" % (
240
765
                            blockdev_data['DM_MPATH'], devname))
241
766
            else:
242
767
                entry['number'] = int(attrs['partition'])
243
768
                parent_devname = self.partition_parent_devname(blockdev_data)
244
801
            parent_blockdev = self.blockdev_data[parent_devname]
769
            parent_blockdev = self.blockdev_data[parent_devname]
245
802
            if 'ID_PART_TABLE_TYPE' not in parent_blockdev:
770
            if 'ID_PART_TABLE_TYPE' not in parent_blockdev:
246
803
                # Exclude the fake partition that the kernel creates
771
                # Exclude the fake partition that the kernel creates
247
@@ -810,9 +778,7 @@ class BlockdevParser(ProbertParser):
248
810
            if ptable:
778
            if ptable:
249
811
                part = None
779
                part = None
250
812
                for pentry in ptable['partitions']:
780
                for pentry in ptable['partitions']:
254
813
                    node = pentry['node']
781
                    if self.lookup_devname(pentry['node']) == devname:
252
814
                    node_p = node.replace(parent_devname, '')
253
815
                    if node_p.replace('p', '') == attrs['partition']:
255
816
                        part = pentry
782
                        part = pentry
256
817
                        break
783
                        break
257
818
784
258
@@ -880,6 +846,9 @@ class FilesystemParser(ProbertParser):
259
880
                errors.append(err)
846
                errors.append(err)
260
881
                continue
847
                continue
261
882
848
262
849
            if self.is_mpath_member(blockdev_data):
263
850
                continue
264
851
265
883
            # no floppy, no cdrom
852
            # no floppy, no cdrom
266
884
            if blockdev_data['MAJOR'] in ["11", "2"]:
853
            if blockdev_data['MAJOR'] in ["11", "2"]:
267
885
                continue
854
                continue
268
diff --git a/examples/tests/multipath-reuse.yaml b/examples/tests/multipath-reuse.yaml
269
886
new file mode 100644
855
new file mode 100644
270
index 0000000..24e193e
271
--- /dev/null
272
+++ b/examples/tests/multipath-reuse.yaml
273
@@ -0,0 +1,61 @@
274
1
275
2
# The point of this test is to test installing to a existing
276
3
# partitions of a multipathed disk
277
4
278
5
bucket:
279
6
  - &setup |
280
7
    parted /dev/disk/by-id/dm-name-mpatha --script -- \
281
8
        mklabel msdos                   \
282
9
        mkpart primary ext4 1GiB 4GiB   \
283
10
        mkpart primary ext4 4GiB 5GiB   \
284
11
        set 1 boot on
285
12
    udevadm settle
286
13
287
14
early_commands:
288
15
  00-setup-msdos-ptable: [sh, -exuc, *setup]
289
16
290
17
install:
291
18
  unmount: disabled
292
19
showtrace: true
293
20
storage:
294
21
    version: 1
295
22
    config:
296
23
      - id: sda
297
24
        type: disk
298
25
        ptable: msdos
299
26
        serial: 'IPR-0 1234567890'
300
27
        name: mpath_a
301
28
        grub_device: true
302
29
        multipath: mpatha
303
30
        path: /dev/disk/by-id/dm-name-mpatha
304
31
        preserve: true
305
32
      - id: sda1
306
33
        type: partition
307
34
        number: 1
308
35
        size: 3GB
309
36
        device: sda
310
37
        flag: boot
311
38
        preserve: true
312
39
      - id: sda2
313
40
        type: partition
314
41
        number: 2
315
42
        size: 1GB
316
43
        device: sda
317
44
        preserve: true
318
45
      - id: sda1_root
319
46
        type: format
320
47
        fstype: ext4
321
48
        volume: sda1
322
49
      - id: sda2_home
323
50
        type: format
324
51
        fstype: ext4
325
52
        volume: sda2
326
53
      - id: sda1_mount
327
54
        type: mount
328
55
        path: /
329
56
        device: sda1_root
330
57
      - id: sda2_mount
331
58
        type: mount
332
59
        path: /home
333
60
        device: sda2_home
334
61
        options: 'defaults,nofail'
335
diff --git a/tests/unittests/test_block_multipath.py b/tests/unittests/test_block_multipath.py
336
index 426be56..db767ab 100644
337
--- a/tests/unittests/test_block_multipath.py
338
+++ b/tests/unittests/test_block_multipath.py
339
@@ -1,7 +1,7 @@
340
1
import mock
1
import mock
341
2
2
342
3
from curtin.block import multipath
3
from curtin.block import multipath
344
4
from .helpers import CiTestCase, raise_pexec_error
4
from .helpers import CiTestCase
345
5
5
346
6
6
347
7
# dmsetup uses tabs as separators
7
# dmsetup uses tabs as separators
348
@@ -63,23 +63,40 @@ class TestMultipath(CiTestCase):
349
63
        self.m_udev.udevadm_info.return_value = {'DM_UUID': 'lvm-vg-foo-lv1'}
63
        self.m_udev.udevadm_info.return_value = {'DM_UUID': 'lvm-vg-foo-lv1'}
350
64
        self.assertFalse(multipath.is_mpath_device(self.random_string()))
64
        self.assertFalse(multipath.is_mpath_device(self.random_string()))
351
65
65
352
66
    def test_is_mpath_member_true(self):
353
67
        """is_mpath_device returns false when DM_UUID doesnt start w/ mpath-"""
354
68
        self.assertTrue(multipath.is_mpath_member(self.random_string()))
355
69
356
70
    def test_is_mpath_member_false(self):
66
    def test_is_mpath_member_false(self):
359
71
        """is_mpath_member returns false if 'multipath -c <dev>' exits err."""
67
        """is_mpath_member returns false if DM_MULTIPATH_DEVICE_PATH is not
360
72
        self.m_subp.side_effect = raise_pexec_error
68
        present"""
361
69
        self.m_udev.udevadm_info.return_value = {}
362
70
        self.assertFalse(multipath.is_mpath_member(self.random_string()))
363
71
364
72
    def test_is_mpath_member_false_2(self):
365
73
        """is_mpath_member returns false if DM_MULTIPATH_DEVICE_PATH is not
366
74
        '1'"""
367
75
        self.m_udev.udevadm_info.return_value = {
368
76
            "DM_MULTIPATH_DEVICE_PATH": "2",
369
77
            }
370
73
        self.assertFalse(multipath.is_mpath_member(self.random_string()))
78
        self.assertFalse(multipath.is_mpath_member(self.random_string()))
371
74
79
372
80
    def test_is_mpath_member_true(self):
373
81
        """is_mpath_member returns true if DM_MULTIPATH_DEVICE_PATH is
374
82
        '1'"""
375
83
        self.m_udev.udevadm_info.return_value = {
376
84
            "DM_MULTIPATH_DEVICE_PATH": "1",
377
85
            }
378
86
        self.assertTrue(multipath.is_mpath_member(self.random_string()))
379
87
380
75
    def test_is_mpath_partition_true(self):
88
    def test_is_mpath_partition_true(self):
382
76
        """is_mpath_member returns true if 'multipath -c <dev>' exits 0."""
89
        """is_mpath_partition returns true if udev info contains right keys."""
383
77
        dm_device = "/dev/dm-" + self.random_string()
90
        dm_device = "/dev/dm-" + self.random_string()
385
78
        self.m_udev.udevadm_info.return_value = {'DM_PART': '1'}
91
        self.m_udev.udevadm_info.return_value = {
386
92
            'DM_PART': '1',
387
93
            'DM_MPATH': 'a',
388
94
            }
389
79
        self.assertTrue(multipath.is_mpath_partition(dm_device))
95
        self.assertTrue(multipath.is_mpath_partition(dm_device))
390
80
96
391
81
    def test_is_mpath_partition_false(self):
97
    def test_is_mpath_partition_false(self):
393
82
        """is_mpath_member returns false if DM_PART is not present for dev."""
98
        """is_mpath_partition returns false if DM_PART is not present for dev.
394
99
        """
395
83
        self.assertFalse(multipath.is_mpath_partition(self.random_string()))
100
        self.assertFalse(multipath.is_mpath_partition(self.random_string()))
396
84
101
397
85
    def test_mpath_partition_to_mpath_id_and_partnumber(self):
102
    def test_mpath_partition_to_mpath_id_and_partnumber(self):
398
diff --git a/tests/unittests/test_storage_config.py b/tests/unittests/test_storage_config.py
399
index 2d27d4e..0ed7659 100644
400
--- a/tests/unittests/test_storage_config.py
401
+++ b/tests/unittests/test_storage_config.py
402
@@ -467,149 +467,51 @@ class TestBlockdevParser(CiTestCase):
403
467
            self.assertDictEqual(expected_dict,
467
            self.assertDictEqual(expected_dict,
404
468
                                 self.bdevp.asdict(blockdev))
468
                                 self.bdevp.asdict(blockdev))
405
469
469
407
470
    def test_blockdev_detects_multipath(self):
470
    def test_blockdev_multipath_disk(self):
408
471
        self.probe_data = _get_data('probert_storage_multipath.json')
471
        self.probe_data = _get_data('probert_storage_multipath.json')
409
472
        self.bdevp = BlockdevParser(self.probe_data)
472
        self.bdevp = BlockdevParser(self.probe_data)
411
473
        blockdev = self.bdevp.blockdev_data['/dev/sda2']
473
        blockdev = self.bdevp.blockdev_data['/dev/dm-0']
412
474
        expected_dict = {
474
        expected_dict = {
416
475
            'flag': 'linux',
475
            'id': 'mpath-disk-mpatha',
414
476
            'id': 'partition-sda2',
415
477
            'offset': 2097152,
417
478
            'multipath': 'mpatha',
476
            'multipath': 'mpatha',
422
479
            'size': 10734272512,
477
            'path': '/dev/dm-0',
423
480
            'type': 'partition',
478
            'ptable': 'gpt',
424
481
            'device': 'disk-sda',
479
            'type': 'disk',
425
482
            'number': 2}
480
            'wwn': '0x0000000000000064',
426
481
            }
427
483
        self.assertDictEqual(expected_dict, self.bdevp.asdict(blockdev))
482
        self.assertDictEqual(expected_dict, self.bdevp.asdict(blockdev))
428
484
483
430
485
    def test_blockdev_skips_multipath_entry_if_no_multipath_data(self):
484
    def test_blockdev_multipath_partition(self):
431
486
        self.probe_data = _get_data('probert_storage_multipath.json')
485
        self.probe_data = _get_data('probert_storage_multipath.json')
432
487
        del self.probe_data['multipath']
433
488
        self.bdevp = BlockdevParser(self.probe_data)
486
        self.bdevp = BlockdevParser(self.probe_data)
435
489
        blockdev = self.bdevp.blockdev_data['/dev/sda2']
487
        blockdev = self.bdevp.blockdev_data['/dev/dm-2']
436
490
        expected_dict = {
488
        expected_dict = {
437
489
            'device': 'mpath-disk-mpatha',
438
491
            'flag': 'linux',
490
            'flag': 'linux',
440
492
            'id': 'partition-sda2',
491
            'id': 'mpath-partition-mpatha-part2',
441
492
            'multipath': 'mpatha',
442
493
            'number': 2,
443
493
            'offset': 2097152,
494
            'offset': 2097152,
444
494
            'size': 10734272512,
495
            'size': 10734272512,
445
495
            'type': 'partition',
496
            'type': 'partition',
448
496
            'device': 'disk-sda',
497
            }
447
497
            'number': 2}
449
498
        self.assertDictEqual(expected_dict, self.bdevp.asdict(blockdev))
498
        self.assertDictEqual(expected_dict, self.bdevp.asdict(blockdev))
450
499
499
452
500
    def test_blockdev_skips_multipath_entry_if_bad_multipath_data(self):
500
    @skipUnlessJsonSchema()
453
501
    def test_blockdev_skips_underlying_disks_and_partitions(self):
454
501
        self.probe_data = _get_data('probert_storage_multipath.json')
502
        self.probe_data = _get_data('probert_storage_multipath.json')
455
502
        for path in self.probe_data['multipath']['paths']:
456
503
            path['multipath'] = ''
457
504
        self.bdevp = BlockdevParser(self.probe_data)
503
        self.bdevp = BlockdevParser(self.probe_data)
483
505
        blockdev = self.bdevp.blockdev_data['/dev/sda2']
504
        configs = self.bdevp.parse()[0]
484
506
        expected_dict = {
505
        config_paths = {c.get('path') for c in configs}
485
507
            'flag': 'linux',
506
        self.assertNotIn('/dev/sda', config_paths)
461
508
            'id': 'partition-sda2',
462
509
            'offset': 2097152,
463
510
            'size': 10734272512,
464
511
            'type': 'partition',
465
512
            'device': 'disk-sda',
466
513
            'number': 2}
467
514
        self.assertDictEqual(expected_dict, self.bdevp.asdict(blockdev))
468
515
469
516
    def test_blockdev_skips_multipath_entry_if_no_mp_paths(self):
470
517
        self.probe_data = _get_data('probert_storage_multipath.json')
471
518
        del self.probe_data['multipath']['paths']
472
519
        self.bdevp = BlockdevParser(self.probe_data)
473
520
        blockdev = self.bdevp.blockdev_data['/dev/sda2']
474
521
        expected_dict = {
475
522
            'flag': 'linux',
476
523
            'id': 'partition-sda2',
477
524
            'offset': 2097152,
478
525
            'size': 10734272512,
479
526
            'type': 'partition',
480
527
            'device': 'disk-sda',
481
528
            'number': 2}
482
529
        self.assertDictEqual(expected_dict, self.bdevp.asdict(blockdev))
486
530
507
487
531
    def test_blockdev_finds_multipath_id_from_dm_uuid(self):
508
    def test_blockdev_finds_multipath_id_from_dm_uuid(self):
488
532
        self.probe_data = _get_data('probert_storage_zlp6.json')
509
        self.probe_data = _get_data('probert_storage_zlp6.json')
489
533
        self.bdevp = BlockdevParser(self.probe_data)
510
        self.bdevp = BlockdevParser(self.probe_data)
490
534
        blockdev = self.bdevp.blockdev_data['/dev/dm-2']
511
        blockdev = self.bdevp.blockdev_data['/dev/dm-2']
491
535
        result = self.bdevp.blockdev_to_id(blockdev)
512
        result = self.bdevp.blockdev_to_id(blockdev)
569
536
        self.assertEqual('disk-sda', result)
513
        self.assertEqual(
570
537
514
            'mpath-disk-36005076306ffd6b60000000000002406', result)
494
538
    def test_blockdev_find_mpath_members_checks_dm_name(self):
495
539
        """ BlockdevParser find_mpath_members uses dm_name if present."""
496
540
        dm14 = {
497
541
            "DEVTYPE": "disk",
498
542
            "DEVLINKS": "/dev/disk/by-id/dm-name-mpathb",
499
543
            "DEVNAME": "/dev/dm-14",
500
544
            "DEVTYPE": "disk",
501
545
            "DM_NAME": "mpathb",
502
546
            "DM_UUID": "mpath-360050768028211d8b000000000000062",
503
547
            "DM_WWN": "0x60050768028211d8b000000000000062",
504
548
            "MPATH_DEVICE_READY": "1",
505
549
            "MPATH_SBIN_PATH": "/sbin",
506
550
        }
507
551
        multipath = {
508
552
            "maps": [
509
553
                {
510
554
                    "multipath": "360050768028211d8b000000000000061",
511
555
                    "sysfs": "dm-11",
512
556
                    "paths": "4"
513
557
                },
514
558
                {
515
559
                    "multipath": "360050768028211d8b000000000000062",
516
560
                    "sysfs": "dm-14",
517
561
                    "paths": "4"
518
562
                },
519
563
                {
520
564
                    "multipath": "360050768028211d8b000000000000063",
521
565
                    "sysfs": "dm-15",
522
566
                    "paths": "4"
523
567
                }],
524
568
            "paths": [
525
569
                {
526
570
                    "device": "sdej",
527
571
                    "serial": "0200a084762cXX00",
528
572
                    "multipath": "mpatha",
529
573
                    "host_wwnn": "0x20000024ff9127de",
530
574
                    "target_wwnn": "0x5005076802065e38",
531
575
                    "host_wwpn": "0x21000024ff9127de",
532
576
                    "target_wwpn": "0x5005076802165e38",
533
577
                    "host_adapter": "[undef]"
534
578
                },
535
579
                {
536
580
                    "device": "sdel",
537
581
                    "serial": "0200a084762cXX00",
538
582
                    "multipath": "mpathb",
539
583
                    "host_wwnn": "0x20000024ff9127de",
540
584
                    "target_wwnn": "0x5005076802065e38",
541
585
                    "host_wwpn": "0x21000024ff9127de",
542
586
                    "target_wwpn": "0x5005076802165e38",
543
587
                    "host_adapter": "[undef]"
544
588
                },
545
589
                {
546
590
                    "device": "sdet",
547
591
                    "serial": "0200a084762cXX00",
548
592
                    "multipath": "mpatha",
549
593
                    "host_wwnn": "0x20000024ff9127de",
550
594
                    "target_wwnn": "0x5005076802065e37",
551
595
                    "host_wwpn": "0x21000024ff9127de",
552
596
                    "target_wwpn": "0x5005076802165e37",
553
597
                    "host_adapter": "[undef]"
554
598
                },
555
599
                {
556
600
                    "device": "sdev",
557
601
                    "serial": "0200a084762cXX00",
558
602
                    "multipath": "mpathb",
559
603
                    "host_wwnn": "0x20000024ff9127de",
560
604
                    "target_wwnn": "0x5005076802065e37",
561
605
                    "host_wwpn": "0x21000024ff9127de",
562
606
                    "target_wwpn": "0x5005076802165e37",
563
607
                    "host_adapter": "[undef]"
564
608
                }],
565
609
        }
566
610
        self.bdevp.blockdev_data['/dev/dm-14'] = dm14
567
611
        self.probe_data['multipath'] = multipath
568
612
        self.assertEqual('disk-sdel', self.bdevp.blockdev_to_id(dm14))
571
613
515
572
614
    def test_blockdev_detects_dasd_device_id_and_vtoc_ptable(self):
516
    def test_blockdev_detects_dasd_device_id_and_vtoc_ptable(self):
573
615
        self.probe_data = _get_data('probert_storage_dasd.json')
517
        self.probe_data = _get_data('probert_storage_dasd.json')
574
@@ -1017,22 +919,6 @@ class TestExtractStorageConfig(CiTestCase):
575
1017
                                 extracted)
919
                                 extracted)
576
1018
920
577
1019
    @skipUnlessJsonSchema()
921
    @skipUnlessJsonSchema()
578
1020
    def test_find_all_multipath(self):
579
1021
        """ verify probed multipath paths are included in config. """
580
1022
        self.probe_data = _get_data('probert_storage_multipath.json')
581
1023
        extracted = storage_config.extract_storage_config(self.probe_data)
582
1024
        config = extracted['storage']['config']
583
1025
        blockdev = self.probe_data['blockdev']
584
1026
585
1027
        for mpmap in self.probe_data['multipath']['maps']:
586
1028
            nr_disks = int(mpmap['paths'])
587
1029
            mp_name = blockdev['/dev/%s' % mpmap['sysfs']]['DM_NAME']
588
1030
            matched_disks = [cfg for cfg in config
589
1031
                             if cfg['type'] == 'disk' and
590
1032
                             cfg.get('multipath', '') == mp_name]
591
1033
            self.assertEqual(nr_disks, len(matched_disks))
592
1034
593
1035
    @skipUnlessJsonSchema()
594
1036
    def test_find_raid_partition(self):
922
    def test_find_raid_partition(self):
595
1037
        """ verify probed raid partitions are found. """
923
        """ verify probed raid partitions are found. """
596
1038
        self.probe_data = _get_data('probert_storage_raid1_partitions.json')
924
        self.probe_data = _get_data('probert_storage_raid1_partitions.json')
597
@@ -1081,6 +967,19 @@ class TestExtractStorageConfig(CiTestCase):
598
1081
        self.assertEqual(expected_dict, disks[0])
967
        self.assertEqual(expected_dict, disks[0])
599
1082
968
600
1083
    @skipUnlessJsonSchema()
969
    @skipUnlessJsonSchema()
601
970
    def test_blockdev_multipath(self):
602
971
        self.probe_data = _get_data('probert_storage_zlp6.json')
603
972
        extracted = storage_config.extract_storage_config(self.probe_data)
604
973
        config = extracted['storage']['config']
605
974
        disks = [cfg for cfg in config if cfg['type'] == 'disk']
606
975
        expected_count = len([
607
976
            1 for bd_name, bd_data in self.probe_data['blockdev'].items()
608
977
            if bd_data.get('DM_UUID', '').startswith('mpath-')
609
978
            or bd_name.startswith('/dev/dasd') and bd_data['DEVTYPE'] == 'disk'
610
979
            ])
611
980
        self.assertEqual(expected_count, len(disks))
612
981
613
982
    @skipUnlessJsonSchema()
614
1084
    def test_blockdev_skips_invalid_wwn(self):
983
    def test_blockdev_skips_invalid_wwn(self):
615
1085
        self.probe_data = _get_data('probert_storage_bogus_wwn.json')
984
        self.probe_data = _get_data('probert_storage_bogus_wwn.json')
616
1086
        extracted = storage_config.extract_storage_config(self.probe_data)
985
        extracted = storage_config.extract_storage_config(self.probe_data)
617
diff --git a/tests/vmtests/test_multipath.py b/tests/vmtests/test_multipath.py
618
index f924d25..163b73a 100644
619
--- a/tests/vmtests/test_multipath.py
620
+++ b/tests/vmtests/test_multipath.py
621
@@ -170,4 +170,20 @@ class GroovyTestMultipathBasic(relbase.groovy, TestMultipathBasicAbs):
622
170
    __test__ = True
170
    __test__ = True
623
171
171
624
172
172
625
173
class TestMultipathReuseAbs(TestMultipathBasicAbs):
626
174
    conf_file = "examples/tests/multipath-reuse.yaml"
627
175
628
176
629
177
class FocalTestMultipathReuse(relbase.focal, TestMultipathReuseAbs):
630
178
    __test__ = True
631
179
632
180
633
181
class HirsuteTestMultipathReuse(relbase.hirsute, TestMultipathReuseAbs):
634
182
    __test__ = True
635
183
636
184
637
185
class GroovyTestMultipathReuse(relbase.groovy, TestMultipathReuseAbs):
638
186
    __test__ = True
639
187
640
188
641
173
# vi: ts=4 expandtab syntax=python
189
# vi: ts=4 expandtab syntax=python
Reviewer	Review Type	Date Requested	Status
Server Team CI bot	continuous-integration		Approve on 2021-03-03
Paride Legovini		2020-10-16	Needs Fixing on 2020-10-16
Review via email: mp+392353@code.launchpad.net