1
diff --git a/curtin/commands/block_meta.py b/curtin/commands/block_meta.py
2
index ef0a48a..8decab5 100644
3
--- a/curtin/commands/block_meta.py
4
+++ b/curtin/commands/block_meta.py
5
@@ -8,7 +8,8 @@ from curtin.log import LOG, logged_time
6
8
from curtin.reporter import events
8
from curtin.reporter import events
7
9
9
8
10
from . import populate_one_subcmd
10
from . import populate_one_subcmd
10
11
from curtin.udev import compose_udev_equality, udevadm_settle, udevadm_trigger
11
from curtin.udev import (compose_udev_equality, udevadm_settle,
11
12
                         udevadm_trigger, udevadm_info)
12
12
13
13
13
import glob
14
import glob
14
14
import os
15
import os
15
@@ -221,12 +222,43 @@ def sanitize_dname(dname):
16
221
    return ''.join(c if c in valid else '-' for c in dname)
222
    return ''.join(c if c in valid else '-' for c in dname)
17
222
223
18
223
224
19
225
def make_dname_byid(path, error_msg=None, info=None):
20
226
    """ Returns a list of udev equalities for a given disk path
21
227
22
228
    :param path: string of a kernel device path to a block device
23
229
    :param error_msg: more information about path for log/errors
24
230
    :param info: dict of udevadm info key, value pairs of device specified by
25
231
                 path.
26
232
    :returns: list of udev equalities (lists)
27
233
    :raises: ValueError if path is not a disk.
28
234
    :raises: RuntimeError if there is no serial or wwn.
29
235
    """
30
236
    error_msg = str(path) + ("" if not error_msg else " [%s]" % error_msg)
31
237
    if info is None:
32
238
        info = udevadm_info(path=path)
33
239
    devtype = info.get('DEVTYPE')
34
240
    if devtype != "disk":
35
241
        raise ValueError(
36
242
            "Disk tag udev rules are only for disks, %s has devtype=%s" %
37
243
            (error_msg, devtype))
38
244
39
245
    byid_keys = ['ID_SERIAL', 'ID_WWN_WITH_EXTENSION']
40
246
    present = [k for k in byid_keys if info.get(k)]
41
247
    if not present:
42
248
        raise RuntimeError(
43
249
            "Cannot create disk tag udev rule for %s, "
44
250
            "missing 'serial' or 'wwn' value" % error_msg)
45
251
46
252
    return [[compose_udev_equality('ENV{%s}' % k, info[k]) for k in present]]
47
253
48
254
49
224
def make_dname(volume, storage_config):
255
def make_dname(volume, storage_config):
50
225
    state = util.load_command_environment()
256
    state = util.load_command_environment()
51
226
    rules_dir = os.path.join(state['scratch'], "rules.d")
257
    rules_dir = os.path.join(state['scratch'], "rules.d")
52
227
    vol = storage_config.get(volume)
258
    vol = storage_config.get(volume)
53
228
    path = get_path_to_storage_volume(volume, storage_config)
259
    path = get_path_to_storage_volume(volume, storage_config)
54
229
    ptuuid = None
260
    ptuuid = None
55
261
    byid = None
56
230
    dname = vol.get('name')
262
    dname = vol.get('name')
57
231
    if vol.get('type') in ["partition", "disk"]:
263
    if vol.get('type') in ["partition", "disk"]:
58
232
        (out, _err) = util.subp(["blkid", "-o", "export", path], capture=True,
264
        (out, _err) = util.subp(["blkid", "-o", "export", path], capture=True,
59
@@ -235,28 +267,41 @@ def make_dname(volume, storage_config):
60
235
            if "PTUUID" in line or "PARTUUID" in line:
267
            if "PTUUID" in line or "PARTUUID" in line:
61
236
                ptuuid = line.split('=')[-1]
268
                ptuuid = line.split('=')[-1]
62
237
                break
269
                break
63
270
        if vol.get('type') == 'disk':
64
271
            byid = make_dname_byid(path, error_msg="id=%s" % vol.get('id'))
65
238
    # we may not always be able to find a uniq identifier on devices with names
272
    # we may not always be able to find a uniq identifier on devices with names
67
239
    if not ptuuid and vol.get('type') in ["disk", "partition"]:
273
    if (not ptuuid and not byid) and vol.get('type') in ["disk", "partition"]:
68
240
        LOG.warning("Can't find a uuid for volume: {}. Skipping dname.".format(
274
        LOG.warning("Can't find a uuid for volume: {}. Skipping dname.".format(
69
241
            volume))
275
            volume))
70
242
        return
276
        return
71
243
277
73
244
    rule = [
278
    matches = []
74
279
    base_rule = [
75
245
        compose_udev_equality("SUBSYSTEM", "block"),
280
        compose_udev_equality("SUBSYSTEM", "block"),
76
246
        compose_udev_equality("ACTION", "add|change"),
281
        compose_udev_equality("ACTION", "add|change"),
77
247
        ]
282
        ]
78
248
    if vol.get('type') == "disk":
283
    if vol.get('type') == "disk":
81
249
        rule.append(compose_udev_equality('ENV{DEVTYPE}', "disk"))
284
        if ptuuid:
82
250
        rule.append(compose_udev_equality('ENV{ID_PART_TABLE_UUID}', ptuuid))
285
            matches += [[compose_udev_equality('ENV{DEVTYPE}', "disk"),
83
286
                        compose_udev_equality('ENV{ID_PART_TABLE_UUID}',
84
287
                                              ptuuid)]]
85
288
        for rule in byid:
86
289
            matches += [
87
290
                [compose_udev_equality('ENV{DEVTYPE}', "disk")] + rule]
88
251
    elif vol.get('type') == "partition":
291
    elif vol.get('type') == "partition":
93
252
        rule.append(compose_udev_equality('ENV{DEVTYPE}', "partition"))
292
        # if partition has its own name, bind that to the existing PTUUID
94
253
        dname = storage_config.get(vol.get('device')).get('name') + \
293
        if dname:
95
254
            "-part%s" % determine_partition_number(volume, storage_config)
294
            matches += [[compose_udev_equality('ENV{DEVTYPE}', "partition"),
96
255
        rule.append(compose_udev_equality('ENV{ID_PART_ENTRY_UUID}', ptuuid))
295
                        compose_udev_equality('ENV{ID_PART_ENTRY_UUID}',
97
296
                                              ptuuid)]]
98
297
        else:
99
298
            # disks generate dname-part%n rules automatically
100
299
            LOG.debug('No partition-specific dname')
101
300
            return
102
256
    elif vol.get('type') == "raid":
301
    elif vol.get('type') == "raid":
103
257
        md_data = mdadm.mdadm_query_detail(path)
302
        md_data = mdadm.mdadm_query_detail(path)
104
258
        md_uuid = md_data.get('MD_UUID')
303
        md_uuid = md_data.get('MD_UUID')
106
259
        rule.append(compose_udev_equality("ENV{MD_UUID}", md_uuid))
304
        matches += [[compose_udev_equality("ENV{MD_UUID}", md_uuid)]]
107
260
    elif vol.get('type') == "bcache":
305
    elif vol.get('type') == "bcache":
108
261
        # bind dname to bcache backing device's dev.uuid as the bcache minor
306
        # bind dname to bcache backing device's dev.uuid as the bcache minor
109
262
        # device numbers are not stable across reboots.
307
        # device numbers are not stable across reboots.
110
@@ -265,12 +310,12 @@ def make_dname(volume, storage_config):
111
265
        bcache_super = bcache.superblock_asdict(device=backing_dev)
310
        bcache_super = bcache.superblock_asdict(device=backing_dev)
112
266
        if bcache_super and bcache_super['sb.version'].startswith('1'):
311
        if bcache_super and bcache_super['sb.version'].startswith('1'):
113
267
                bdev_uuid = bcache_super['dev.uuid']
312
                bdev_uuid = bcache_super['dev.uuid']
115
268
        rule.append(compose_udev_equality("ENV{CACHED_UUID}", bdev_uuid))
313
        matches += [[compose_udev_equality("ENV{CACHED_UUID}", bdev_uuid)]]
116
269
        bcache.write_label(sanitize_dname(dname), backing_dev)
314
        bcache.write_label(sanitize_dname(dname), backing_dev)
117
270
    elif vol.get('type') == "lvm_partition":
315
    elif vol.get('type') == "lvm_partition":
118
271
        volgroup_name = storage_config.get(vol.get('volgroup')).get('name')
316
        volgroup_name = storage_config.get(vol.get('volgroup')).get('name')
119
272
        dname = "%s-%s" % (volgroup_name, dname)
317
        dname = "%s-%s" % (volgroup_name, dname)
121
273
        rule.append(compose_udev_equality("ENV{DM_NAME}", dname))
318
        matches += [[compose_udev_equality("ENV{DM_NAME}", dname)]]
122
274
    else:
319
    else:
123
275
        raise ValueError('cannot make dname for device with type: {}'
320
        raise ValueError('cannot make dname for device with type: {}'
124
276
                         .format(vol.get('type')))
321
                         .format(vol.get('type')))
125
@@ -283,11 +328,25 @@ def make_dname(volume, storage_config):
126
283
        LOG.warning(
328
        LOG.warning(
127
284
            "dname modified to remove invalid chars. old: '{}' new: '{}'"
329
            "dname modified to remove invalid chars. old: '{}' new: '{}'"
128
285
            .format(dname, sanitized))
330
            .format(dname, sanitized))
131
286
    rule.append("SYMLINK+=\"disk/by-dname/%s\"\n" % sanitized)
331
    content = ['# Written by curtin']
132
287
    LOG.debug("Writing dname udev rule '{}'".format(str(rule)))
332
    for match in matches:
133
333
        rule = (base_rule + match +
134
334
                ["SYMLINK+=\"disk/by-dname/%s\"\n" % sanitized])
135
335
        LOG.debug("Creating dname udev rule '{}'".format(str(rule)))
136
336
        content.append(', '.join(rule))
137
337
138
338
    if vol.get('type') == 'disk':
139
339
        for brule in byid:
140
340
            rule = (base_rule +
141
341
                    [compose_udev_equality('ENV{DEVTYPE}', 'partition')] +
142
342
                    brule +
143
343
                    ['SYMLINK+="disk/by-dname/%s-part%%n"\n' % sanitized])
144
344
            LOG.debug("Creating dname udev rule '{}'".format(str(rule)))
145
345
            content.append(', '.join(rule))
146
346
147
288
    util.ensure_dir(rules_dir)
347
    util.ensure_dir(rules_dir)
148
289
    rule_file = os.path.join(rules_dir, '{}.rules'.format(sanitized))
348
    rule_file = os.path.join(rules_dir, '{}.rules'.format(sanitized))
150
290
    util.write_file(rule_file, ', '.join(rule))
349
    util.write_file(rule_file, '\n'.join(content))
151
291
350
152
292
351
153
293
def get_poolname(info, storage_config):
352
def get_poolname(info, storage_config):
154
diff --git a/curtin/udev.py b/curtin/udev.py
155
index 13d9cc5..106a7e7 100644
156
--- a/curtin/udev.py
157
+++ b/curtin/udev.py
158
@@ -61,4 +61,41 @@ def udevadm_trigger(devices):
159
61
    util.subp(['udevadm', 'trigger'] + list(devices))
61
    util.subp(['udevadm', 'trigger'] + list(devices))
160
62
    udevadm_settle()
62
    udevadm_settle()
161
63
63
162
64
163
65
def udevadm_info(path=None):
164
66
    """ Return a dictionary populated by properties of the device specified
165
67
        in the `path` variable via querying udev 'property' database.
166
68
167
69
    :params: path: path to device, either /dev or /sys
168
70
    :returns: dictionary of key=value pairs as exported from the udev database
169
71
    :raises: ValueError path is None, ProcessExecutionError on exec error.
170
72
    """
171
73
    if not path:
172
74
        raise ValueError('Invalid path: "%s"' % path)
173
75
174
76
    info_cmd = ['udevadm', 'info', '--query=property', path]
175
77
    output, _ = util.subp(info_cmd, capture=True)
176
78
177
79
    # strip for trailing empty line
178
80
    info = {}
179
81
    for line in output.splitlines():
180
82
        if not line:
181
83
            continue
182
84
        # maxsplit=2 gives us key and remaininng part of line is value
183
85
        # py2.7 on Trusty doesn't have keyword, pass as argument
184
86
        key, value = line.split('=', 2)
185
87
        if not value:
186
88
            value = None
187
89
        if value:
188
90
            # devlinks is a list of paths separated by space
189
91
            # convert to a list for easy use
190
92
            if key == 'DEVLINKS':
191
93
                info[key] = value.split()
192
94
            else:
193
95
                # preserve spaces in values, to match udev database
194
96
                info[key] = value
195
97
196
98
    return info
197
99
198
100
199
64
# vi: ts=4 expandtab syntax=python
101
# vi: ts=4 expandtab syntax=python
200
diff --git a/doc/topics/storage.rst b/doc/topics/storage.rst
201
index 92fdbc3..f9a9fe8 100644
202
--- a/doc/topics/storage.rst
203
+++ b/doc/topics/storage.rst
204
@@ -175,7 +175,15 @@ not need to be preserved.
205
175
If the ``name`` key is present, curtin will create a udev rule that makes a
175
If the ``name`` key is present, curtin will create a udev rule that makes a
206
176
symbolic link to the disk with the given name value. This makes it easy to find
176
symbolic link to the disk with the given name value. This makes it easy to find
207
177
disks on an installed system. The links are created in
177
disks on an installed system. The links are created in
209
178
``/dev/disk/by-dname/<name>``.
178
``/dev/disk/by-dname/<name>``.  The udev rules will utilize two types of disk
210
179
metadata to construct the link.  For disks with ``serial`` and/or ``wwn`` values
211
180
these will be used to ensure the name persists even if the contents of the disk
212
181
change.  For legacy purposes, curtin also emits a rule utilizing metadata on
213
182
the disk contents, typically a partition UUID value, this also preserves these
214
183
links for disks which lack persistent attributes such as a ``serial`` or
215
184
``wwn``, typically found on virtualized environments where such values are left
216
185
unset.
217
186
218
179
A link to each partition on the disk will also be created at
187
A link to each partition on the disk will also be created at
219
180
``/dev/disk/by-dname/<name>-part<number>``, so if ``name: maindisk`` is set,
188
``/dev/disk/by-dname/<name>-part<number>``, so if ``name: maindisk`` is set,
220
181
the disk will be at ``/dev/disk/by-dname/maindisk`` and the first partition on
189
the disk will be at ``/dev/disk/by-dname/maindisk`` and the first partition on
221
@@ -276,6 +284,17 @@ filesystem or be mounted anywhere on the system.
222
276
If the preserve flag is set to true, curtin will verify that the partition
284
If the preserve flag is set to true, curtin will verify that the partition
223
277
exists and will not modify the partition.
285
exists and will not modify the partition.
224
278
286
225
287
**name**: *<name>*
226
288
227
289
If the ``name`` key is present, curtin will create a udev rule that makes a
228
290
symbolic link to the partition with the given name value. The links are created
229
291
in ``/dev/disk/by-dname/<name>``.
230
292
231
293
For partitions, the udev rule created relies upon disk contents, in this case
232
294
the partition entry UUID.  This will remain in effect unless the underlying disk
233
295
on which the partition resides has the partition table modified or wiped.
234
296
235
297
236
279
**Config Example**::
298
**Config Example**::
237
280
299
238
281
 - id: disk0-part1
300
 - id: disk0-part1
239
@@ -284,6 +303,7 @@ exists and will not modify the partition.
240
284
   size: 8GB
303
   size: 8GB
241
285
   device: disk0
304
   device: disk0
242
286
   flag: boot
305
   flag: boot
243
306
   name: boot_partition
244
287
307
245
288
.. _format:
308
.. _format:
246
289
309
247
@@ -504,6 +524,12 @@ scheme for Logical Volumes follows the pattern
248
504
with ``name`` *lv1* on a ``lvm_volgroup`` named *vg1* would have the path
524
with ``name`` *lv1* on a ``lvm_volgroup`` named *vg1* would have the path
249
505
``/dev/disk/by-dname/vg1-lv1``.
525
``/dev/disk/by-dname/vg1-lv1``.
250
506
526
251
527
.. note::
252
528
253
529
   dname values for contructed devices (such as lvm) only remain persistent
254
530
   as long as the device metadata does not change.  If users modify the device
255
531
   such that device metadata is changed then the udev rule may no longer apply.
256
532
257
507
**volgroup**: *<volgroup id>*
533
**volgroup**: *<volgroup id>*
258
508
534
259
509
The ``volgroup`` key specifies the ``id`` of the Volume Group in which to
535
The ``volgroup`` key specifies the ``id`` of the Volume Group in which to
260
@@ -600,7 +626,9 @@ The ``name`` key specifies the name of the md device.
261
600
.. note::
626
.. note::
262
601
627
263
602
  Curtin creates a udev rule to create a link to the md device in
628
  Curtin creates a udev rule to create a link to the md device in
265
603
  ``/dev/disk/by-dname/<name>`` using the specified name.
629
  ``/dev/disk/by-dname/<name>`` using the specified name.  The dname
266
630
  symbolic link is only persistent as long as the raid metadata is
267
631
  not modifed or destroyed.
268
604
632
269
605
**raidlevel**: *0, 1, 5, 6, 10*
633
**raidlevel**: *0, 1, 5, 6, 10*
270
606
634
271
@@ -677,6 +705,13 @@ reads/writes from the cache.  None effectively disables bcache.
272
677
If the ``name`` key is present, curtin will create a link to the device at
705
If the ``name`` key is present, curtin will create a link to the device at
273
678
``/dev/disk/by-dname/<name>``.
706
``/dev/disk/by-dname/<name>``.
274
679
707
275
708
.. note::
276
709
277
710
   dname values for contructed devices (such as bcache) only remain persistent
278
711
   as long as the device metadata does not change.  If users modify the device
279
712
   such that device metadata is changed then the udev rule may no longer apply.
280
713
281
714
282
680
**Config Example**::
715
**Config Example**::
283
681
716
284
682
 - id: bcache0
717
 - id: bcache0
285
diff --git a/examples/tests/basic.yaml b/examples/tests/basic.yaml
286
index f0ddc5d..71730c0 100644
287
--- a/examples/tests/basic.yaml
288
+++ b/examples/tests/basic.yaml
289
@@ -26,6 +26,7 @@ storage:
290
26
        number: 3
26
        number: 3
291
27
        size: 1GB
27
        size: 1GB
292
28
        device: sda
28
        device: sda
293
29
        name: swap
294
29
      - id: sda1_root
30
      - id: sda1_root
295
30
        type: format
31
        type: format
296
31
        fstype: ext4
32
        fstype: ext4
297
@@ -88,6 +89,7 @@ storage:
298
88
        device: pnum_disk
89
        device: pnum_disk
299
89
        flag: prep
90
        flag: prep
300
90
        wipe: zero
91
        wipe: zero
301
92
        name: prep
302
91
      - id: pnum_disk_p3
93
      - id: pnum_disk_p3
303
92
        type: partition
94
        type: partition
304
93
        number: 10
95
        number: 10
305
diff --git a/examples/tests/basic_scsi.yaml b/examples/tests/basic_scsi.yaml
306
index 0ea8a51..aa62137 100644
307
--- a/examples/tests/basic_scsi.yaml
308
+++ b/examples/tests/basic_scsi.yaml
309
@@ -25,14 +25,20 @@ storage:
310
25
        number: 3
25
        number: 3
311
26
        size: 1GB
26
        size: 1GB
312
27
        device: sda
27
        device: sda
313
28
        name: swap
314
28
      - id: sda1_root
29
      - id: sda1_root
315
29
        type: format
30
        type: format
316
30
        fstype: ext4
31
        fstype: ext4
317
31
        volume: sda1
32
        volume: sda1
318
33
        label: 'cloudimg-rootfs'
319
32
      - id: sda2_home
34
      - id: sda2_home
320
33
        type: format
35
        type: format
321
34
        fstype: ext4
36
        fstype: ext4
322
35
        volume: sda2
37
        volume: sda2
323
38
      - id: sda3_swap
324
39
        type: format
325
40
        fstype: swap
326
41
        volume: sda3
327
36
      - id: sda1_mount
42
      - id: sda1_mount
328
37
        type: mount
43
        type: mount
329
38
        path: /
44
        path: /
330
@@ -46,6 +52,10 @@ storage:
331
46
        wwn: '0x080258d13ea95ae5'
52
        wwn: '0x080258d13ea95ae5'
332
47
        name: sparedisk
53
        name: sparedisk
333
48
        wipe: superblock
54
        wipe: superblock
334
55
      - id: sparedisk_fat_fmt_id
335
56
        type: format
336
57
        fstype: fat32
337
58
        volume: sparedisk_id
338
49
      - id: btrfs_disk_id
59
      - id: btrfs_disk_id
339
50
        type: disk
60
        type: disk
340
51
        wwn: '0x22dc58dc023c7008'
61
        wwn: '0x22dc58dc023c7008'
341
@@ -78,8 +88,13 @@ storage:
342
78
        device: pnum_disk
88
        device: pnum_disk
343
79
        flag: prep
89
        flag: prep
344
80
        wipe: zero
90
        wipe: zero
345
91
        name: prep
346
81
      - id: pnum_disk_p3
92
      - id: pnum_disk_p3
347
82
        type: partition
93
        type: partition
348
83
        number: 10
94
        number: 10
349
84
        size: 1GB
95
        size: 1GB
350
85
        device: pnum_disk
96
        device: pnum_disk
351
97
      - id: swap_mnt
352
98
        type: mount
353
99
        path: "none"
354
100
        device: sda3_swap
355
diff --git a/examples/tests/nvme.yaml b/examples/tests/nvme.yaml
356
index b2a1276..4cf7735 100644
357
--- a/examples/tests/nvme.yaml
358
+++ b/examples/tests/nvme.yaml
359
@@ -44,7 +44,7 @@ storage:
360
44
        device: main_disk_home
44
        device: main_disk_home
361
45
      - id: nvme_disk
45
      - id: nvme_disk
362
46
        type: disk
46
        type: disk
364
47
        path: /dev/nvme0n1
47
        serial: nvme-a
365
48
        name: nvme_disk
48
        name: nvme_disk
366
49
        wipe: superblock
49
        wipe: superblock
367
50
        ptable: gpt
50
        ptable: gpt
368
@@ -63,7 +63,7 @@ storage:
369
63
        device: nvme_disk
63
        device: nvme_disk
370
64
      - id: nvme_disk2
64
      - id: nvme_disk2
371
65
        type: disk
65
        type: disk
373
66
        path: /dev/nvme1n1
66
        serial: nvme-b
374
67
        wipe: superblock
67
        wipe: superblock
375
68
        ptable: msdos
68
        ptable: msdos
376
69
        name: second_nvme
69
        name: second_nvme
377
diff --git a/examples/tests/nvme_bcache.yaml b/examples/tests/nvme_bcache.yaml
378
index 2ee0ad3..4fefd94 100644
379
--- a/examples/tests/nvme_bcache.yaml
380
+++ b/examples/tests/nvme_bcache.yaml
381
@@ -19,7 +19,7 @@ storage:
382
19
    model: INTEL SSDPEDME400G4
19
    model: INTEL SSDPEDME400G4
383
20
    name: nvme0n1
20
    name: nvme0n1
384
21
    ptable: gpt
21
    ptable: gpt
386
22
    path: /dev/nvme0n1
22
    serial: nvme-a
387
23
    type: disk
23
    type: disk
388
24
    wipe: superblock
24
    wipe: superblock
389
25
  - device: sda
25
  - device: sda
390
diff --git a/tests/unittests/helpers.py b/tests/unittests/helpers.py
391
index 58e068b..1268880 100644
392
--- a/tests/unittests/helpers.py
393
+++ b/tests/unittests/helpers.py
394
@@ -5,7 +5,9 @@ import imp
395
5
import importlib
5
import importlib
396
6
import mock
6
import mock
397
7
import os
7
import os
398
8
import random
399
8
import shutil
9
import shutil
400
10
import string
401
9
import tempfile
11
import tempfile
402
10
from unittest import TestCase
12
from unittest import TestCase
403
11
13
404
@@ -67,6 +69,11 @@ class CiTestCase(TestCase):
405
67
        return os.path.normpath(
69
        return os.path.normpath(
406
68
            os.path.abspath(os.path.sep.join((_dir, path))))
70
            os.path.abspath(os.path.sep.join((_dir, path))))
407
69
71
408
72
    def random_string(self, length=8):
409
73
        """ return a random lowercase string with default length of 8"""
410
74
        return ''.join(
411
75
            random.choice(string.ascii_lowercase) for _ in range(length))
412
76
413
70
77
414
71
def dir2dict(startdir, prefix=None):
78
def dir2dict(startdir, prefix=None):
415
72
    flist = {}
79
    flist = {}
416
diff --git a/tests/unittests/test_make_dname.py b/tests/unittests/test_make_dname.py
417
index 2b92a88..76c7b28 100644
418
--- a/tests/unittests/test_make_dname.py
419
+++ b/tests/unittests/test_make_dname.py
420
@@ -13,10 +13,16 @@ class TestMakeDname(CiTestCase):
421
13
    state = {'scratch': '/tmp/null'}
13
    state = {'scratch': '/tmp/null'}
422
14
    rules_d = '/tmp/null/rules.d'
14
    rules_d = '/tmp/null/rules.d'
423
15
    rule_file = '/tmp/null/rules.d/{}.rules'
15
    rule_file = '/tmp/null/rules.d/{}.rules'
424
16
    disk_serial = 'abcdefg'
425
17
    disk_wwn = '0x1234567890'
426
16
    storage_config = {
18
    storage_config = {
428
17
        'disk1': {'type': 'disk', 'id': 'disk1', 'name': 'main_disk'},
19
        'disk1': {'type': 'disk', 'id': 'disk1', 'name': 'main_disk',
429
20
                  'serial': disk_serial},
430
21
        'disk_noid': {'type': 'disk', 'id': 'disk_noid', 'name': 'main_disk'},
431
18
        'disk1p1': {'type': 'partition', 'id': 'disk1p1', 'device': 'disk1'},
22
        'disk1p1': {'type': 'partition', 'id': 'disk1p1', 'device': 'disk1'},
433
19
        'disk2': {'type': 'disk', 'id': 'disk2',
23
        'disk1p2': {'type': 'partition', 'id': 'disk1p2', 'device': 'disk1',
434
24
                    'name': 'custom-partname'},
435
25
        'disk2': {'type': 'disk', 'id': 'disk2', 'wwn': disk_wwn,
436
20
                  'name': 'in_valid/name!@#$% &*(+disk'},
26
                  'name': 'in_valid/name!@#$% &*(+disk'},
437
21
        'disk2p1': {'type': 'partition', 'id': 'disk2p1', 'device': 'disk2'},
27
        'disk2p1': {'type': 'partition', 'id': 'disk2p1', 'device': 'disk2'},
438
22
        'md_id': {'type': 'raid', 'id': 'md_id', 'name': 'mdadm_name'},
28
        'md_id': {'type': 'raid', 'id': 'md_id', 'name': 'mdadm_name'},
439
@@ -27,7 +33,8 @@ class TestMakeDname(CiTestCase):
440
27
        'lpart2_id': {'type': 'lvm_partition', 'id': 'lpart2_id',
33
        'lpart2_id': {'type': 'lvm_partition', 'id': 'lpart2_id',
441
28
                      'name': 'lvm part/2', 'volgroup': 'lvol_id'},
34
                      'name': 'lvm part/2', 'volgroup': 'lvol_id'},
442
29
        'bcache1_id': {'type': 'bcache', 'id': 'bcache1_id',
35
        'bcache1_id': {'type': 'bcache', 'id': 'bcache1_id',
444
30
                       'name': 'my-cached-data'}
36
                       'name': 'my-cached-data'},
445
37
        'iscsi1': {'type': 'disk', 'id': 'iscsi1', 'name': 'iscsi_disk1'}
446
31
    }
38
    }
447
32
    bcache_super_show = {
39
    bcache_super_show = {
448
33
        'sb.version': '1 [backing device]',
40
        'sb.version': '1 [backing device]',
449
@@ -57,20 +64,37 @@ class TestMakeDname(CiTestCase):
450
57
        rule.append('SYMLINK+="disk/by-dname/{}"\n'.format(target))
64
        rule.append('SYMLINK+="disk/by-dname/{}"\n'.format(target))
451
58
        return ', '.join(rule)
65
        return ', '.join(rule)
452
59
66
453
67
    def _content(self, rules=[]):
454
68
        return "\n".join(['# Written by curtin'] + rules)
455
69
456
70
    @mock.patch('curtin.commands.block_meta.udevadm_info')
457
60
    @mock.patch('curtin.commands.block_meta.LOG')
71
    @mock.patch('curtin.commands.block_meta.LOG')
458
61
    @mock.patch('curtin.commands.block_meta.get_path_to_storage_volume')
72
    @mock.patch('curtin.commands.block_meta.get_path_to_storage_volume')
459
62
    @mock.patch('curtin.commands.block_meta.util')
73
    @mock.patch('curtin.commands.block_meta.util')
461
63
    def test_make_dname_disk(self, mock_util, mock_get_path, mock_log):
74
    def test_make_dname_disk(self, mock_util, mock_get_path, mock_log,
462
75
                             mock_udev):
463
64
        disk_ptuuid = str(uuid.uuid1())
76
        disk_ptuuid = str(uuid.uuid1())
464
65
        mock_util.subp.side_effect = self._make_mock_subp_blkid(
77
        mock_util.subp.side_effect = self._make_mock_subp_blkid(
465
66
            disk_ptuuid, self.disk_blkid)
78
            disk_ptuuid, self.disk_blkid)
466
67
        mock_util.load_command_environment.return_value = self.state
79
        mock_util.load_command_environment.return_value = self.state
471
68
        rule_identifiers = [
80
472
69
            ('DEVTYPE', 'disk'),
81
        rule_identifiers = [('ID_PART_TABLE_UUID', disk_ptuuid)]
473
70
            ('ID_PART_TABLE_UUID', disk_ptuuid)
82
        id_rule_identifiers = [('ID_SERIAL', self.disk_serial)]
474
71
        ]
83
        wwn_rule_identifiers = [('ID_WWN_WITH_EXTENSION', self.disk_wwn)]
475
84
476
85
        def _drule(devtype, match):
477
86
            return [('DEVTYPE', devtype)] + [m for m in match]
478
87
479
88
        def drule(match):
480
89
            return _drule('disk', match)
481
90
482
91
        def prule(match):
483
92
            return _drule('partition', match)
484
72
93
485
73
        # simple run
94
        # simple run
486
95
        mock_udev.side_effect = (
487
96
            [{'DEVTYPE': 'disk', 'ID_SERIAL': self.disk_serial},
488
97
             {'DEVTYPE': 'disk', 'ID_WWN_WITH_EXTENSION': self.disk_wwn}])
489
74
        res_dname = 'main_disk'
98
        res_dname = 'main_disk'
490
75
        block_meta.make_dname('disk1', self.storage_config)
99
        block_meta.make_dname('disk1', self.storage_config)
491
76
        mock_util.ensure_dir.assert_called_with(self.rules_d)
100
        mock_util.ensure_dir.assert_called_with(self.rules_d)
492
@@ -78,7 +102,13 @@ class TestMakeDname(CiTestCase):
493
78
        self.assertFalse(mock_log.warning.called)
102
        self.assertFalse(mock_log.warning.called)
494
79
        mock_util.write_file.assert_called_with(
103
        mock_util.write_file.assert_called_with(
495
80
            self.rule_file.format(res_dname),
104
            self.rule_file.format(res_dname),
497
81
            self._formatted_rule(rule_identifiers, res_dname))
105
            self._content(
498
106
                [self._formatted_rule(drule(rule_identifiers),
499
107
                                      res_dname),
500
108
                 self._formatted_rule(drule(id_rule_identifiers),
501
109
                                      res_dname),
502
110
                 self._formatted_rule(prule(id_rule_identifiers),
503
111
                                      "%s-part%%n" % res_dname)]))
504
82
112
505
83
        # run invalid dname
113
        # run invalid dname
506
84
        res_dname = 'in_valid-name----------disk'
114
        res_dname = 'in_valid-name----------disk'
507
@@ -86,12 +116,39 @@ class TestMakeDname(CiTestCase):
508
86
        self.assertTrue(mock_log.warning.called)
116
        self.assertTrue(mock_log.warning.called)
509
87
        mock_util.write_file.assert_called_with(
117
        mock_util.write_file.assert_called_with(
510
88
            self.rule_file.format(res_dname),
118
            self.rule_file.format(res_dname),
512
89
            self._formatted_rule(rule_identifiers, res_dname))
119
            self._content(
513
120
                [self._formatted_rule(drule(rule_identifiers),
514
121
                                      res_dname),
515
122
                 self._formatted_rule(drule(wwn_rule_identifiers),
516
123
                                      res_dname),
517
124
                 self._formatted_rule(prule(wwn_rule_identifiers),
518
125
                                      "%s-part%%n" % res_dname)]))
519
90
126
520
127
        # iscsi disk with no config, but info returns serial and wwn
521
128
        mock_udev.side_effect = (
522
129
            [{'DEVTYPE': 'disk', 'ID_SERIAL': self.disk_serial,
523
130
              'DEVTYPE': 'disk', 'ID_WWN_WITH_EXTENSION': self.disk_wwn}])
524
131
        res_dname = 'iscsi_disk1'
525
132
        block_meta.make_dname('iscsi1', self.storage_config)
526
133
        mock_util.ensure_dir.assert_called_with(self.rules_d)
527
134
        self.assertTrue(mock_log.debug.called)
528
135
        both_rules = (id_rule_identifiers + wwn_rule_identifiers)
529
136
        mock_util.write_file.assert_called_with(
530
137
            self.rule_file.format(res_dname),
531
138
            self._content(
532
139
                [self._formatted_rule(drule(rule_identifiers), res_dname),
533
140
                 self._formatted_rule(drule(both_rules), res_dname),
534
141
                 self._formatted_rule(prule(both_rules),
535
142
                                      "%s-part%%n" % res_dname)]))
536
143
537
144
    @mock.patch('curtin.commands.block_meta.udevadm_info')
538
91
    @mock.patch('curtin.commands.block_meta.LOG')
145
    @mock.patch('curtin.commands.block_meta.LOG')
539
92
    @mock.patch('curtin.commands.block_meta.get_path_to_storage_volume')
146
    @mock.patch('curtin.commands.block_meta.get_path_to_storage_volume')
540
93
    @mock.patch('curtin.commands.block_meta.util')
147
    @mock.patch('curtin.commands.block_meta.util')
542
94
    def test_make_dname_failures(self, mock_util, mock_get_path, mock_log):
148
    def test_make_dname_failures(self, mock_util, mock_get_path, mock_log,
543
149
                                 mock_udev):
544
150
        mock_udev.side_effect = ([{'DEVTYPE': 'disk'}, {'DEVTYPE': 'disk'}])
545
151
546
95
        mock_util.subp.side_effect = self._make_mock_subp_blkid(
152
        mock_util.subp.side_effect = self._make_mock_subp_blkid(
547
96
            '', self.trusty_blkid)
153
            '', self.trusty_blkid)
548
97
        mock_util.load_command_environment.return_value = self.state
154
        mock_util.load_command_environment.return_value = self.state
549
@@ -99,10 +156,14 @@ class TestMakeDname(CiTestCase):
550
99
        warning_msg = "Can't find a uuid for volume: {}. Skipping dname."
156
        warning_msg = "Can't find a uuid for volume: {}. Skipping dname."
551
100
157
552
101
        # disk with no PT_UUID
158
        # disk with no PT_UUID
556
102
        block_meta.make_dname('disk1', self.storage_config)
159
        disk = 'disk_noid'
557
103
        mock_log.warning.assert_called_with(warning_msg.format('disk1'))
160
        with self.assertRaises(RuntimeError):
558
104
        self.assertFalse(mock_util.write_file.called)
161
            block_meta.make_dname(disk, self.storage_config)
559
162
            mock_log.warning.assert_called_with(warning_msg.format(disk))
560
163
            self.assertFalse(mock_util.write_file.called)
561
105
164
562
165
        mock_util.subp.side_effect = self._make_mock_subp_blkid(
563
166
            '', self.trusty_blkid)
564
106
        # partition with no PART_UUID
167
        # partition with no PART_UUID
565
107
        block_meta.make_dname('disk1p1', self.storage_config)
168
        block_meta.make_dname('disk1p1', self.storage_config)
566
108
        mock_log.warning.assert_called_with(warning_msg.format('disk1p1'))
169
        mock_log.warning.assert_called_with(warning_msg.format('disk1p1'))
567
@@ -123,22 +184,15 @@ class TestMakeDname(CiTestCase):
568
123
        ]
184
        ]
569
124
185
570
125
        # simple run
186
        # simple run
573
126
        res_dname = 'main_disk-part1'
187
        res_dname = 'custom-partname'
574
127
        block_meta.make_dname('disk1p1', self.storage_config)
188
        block_meta.make_dname('disk1p2', self.storage_config)
575
128
        mock_util.ensure_dir.assert_called_with(self.rules_d)
189
        mock_util.ensure_dir.assert_called_with(self.rules_d)
576
129
        self.assertTrue(mock_log.debug.called)
190
        self.assertTrue(mock_log.debug.called)
577
130
        self.assertFalse(mock_log.warning.called)
191
        self.assertFalse(mock_log.warning.called)
578
131
        mock_util.write_file.assert_called_with(
192
        mock_util.write_file.assert_called_with(
579
132
            self.rule_file.format(res_dname),
193
            self.rule_file.format(res_dname),
589
133
            self._formatted_rule(rule_identifiers, res_dname))
194
            self._content(
590
134
195
                [self._formatted_rule(rule_identifiers, res_dname)]))
582
135
        # run invalid dname
583
136
        res_dname = 'in_valid-name----------disk-part1'
584
137
        block_meta.make_dname('disk2p1', self.storage_config)
585
138
        self.assertTrue(mock_log.warning.called)
586
139
        mock_util.write_file.assert_called_with(
587
140
            self.rule_file.format(res_dname),
588
141
            self._formatted_rule(rule_identifiers, res_dname))
591
142
196
592
143
    @mock.patch('curtin.commands.block_meta.mdadm')
197
    @mock.patch('curtin.commands.block_meta.mdadm')
593
144
    @mock.patch('curtin.commands.block_meta.LOG')
198
    @mock.patch('curtin.commands.block_meta.LOG')
594
@@ -158,7 +212,8 @@ class TestMakeDname(CiTestCase):
595
158
        self.assertFalse(mock_log.warning.called)
212
        self.assertFalse(mock_log.warning.called)
596
159
        mock_util.write_file.assert_called_with(
213
        mock_util.write_file.assert_called_with(
597
160
            self.rule_file.format(res_dname),
214
            self.rule_file.format(res_dname),
599
161
            self._formatted_rule(rule_identifiers, res_dname))
215
            self._content(
600
216
                [self._formatted_rule(rule_identifiers, res_dname)]))
601
162
217
602
163
        # invalid name
218
        # invalid name
603
164
        res_dname = 'mdadm-name'
219
        res_dname = 'mdadm-name'
604
@@ -166,7 +221,8 @@ class TestMakeDname(CiTestCase):
605
166
        self.assertTrue(mock_log.warning.called)
221
        self.assertTrue(mock_log.warning.called)
606
167
        mock_util.write_file.assert_called_with(
222
        mock_util.write_file.assert_called_with(
607
168
            self.rule_file.format(res_dname),
223
            self.rule_file.format(res_dname),
609
169
            self._formatted_rule(rule_identifiers, res_dname))
224
            self._content(
610
225
                [self._formatted_rule(rule_identifiers, res_dname)]))
611
170
226
612
171
    @mock.patch('curtin.commands.block_meta.LOG')
227
    @mock.patch('curtin.commands.block_meta.LOG')
613
172
    @mock.patch('curtin.commands.block_meta.get_path_to_storage_volume')
228
    @mock.patch('curtin.commands.block_meta.get_path_to_storage_volume')
614
@@ -183,7 +239,8 @@ class TestMakeDname(CiTestCase):
615
183
        self.assertFalse(mock_log.warning.called)
239
        self.assertFalse(mock_log.warning.called)
616
184
        mock_util.write_file.assert_called_with(
240
        mock_util.write_file.assert_called_with(
617
185
            self.rule_file.format(res_dname),
241
            self.rule_file.format(res_dname),
619
186
            self._formatted_rule(rule_identifiers, res_dname))
242
            self._content(
620
243
                [self._formatted_rule(rule_identifiers, res_dname)]))
621
187
244
622
188
        # with invalid name
245
        # with invalid name
623
189
        res_dname = 'vg1-lvm-part-2'
246
        res_dname = 'vg1-lvm-part-2'
624
@@ -192,7 +249,8 @@ class TestMakeDname(CiTestCase):
625
192
        self.assertTrue(mock_log.warning.called)
249
        self.assertTrue(mock_log.warning.called)
626
193
        mock_util.write_file.assert_called_with(
250
        mock_util.write_file.assert_called_with(
627
194
            self.rule_file.format(res_dname),
251
            self.rule_file.format(res_dname),
629
195
            self._formatted_rule(rule_identifiers, res_dname))
252
            self._content(
630
253
                [self._formatted_rule(rule_identifiers, res_dname)]))
631
196
254
632
197
    @mock.patch('curtin.commands.block_meta.LOG')
255
    @mock.patch('curtin.commands.block_meta.LOG')
633
198
    @mock.patch('curtin.commands.block_meta.bcache')
256
    @mock.patch('curtin.commands.block_meta.bcache')
634
@@ -213,7 +271,8 @@ class TestMakeDname(CiTestCase):
635
213
        self.assertFalse(mock_log.warning.called)
271
        self.assertFalse(mock_log.warning.called)
636
214
        mock_util.write_file.assert_called_with(
272
        mock_util.write_file.assert_called_with(
637
215
            self.rule_file.format(res_dname),
273
            self.rule_file.format(res_dname),
639
216
            self._formatted_rule(rule_identifiers, res_dname))
274
            self._content(
640
275
                [self._formatted_rule(rule_identifiers, res_dname)]))
641
217
276
642
218
    def test_sanitize_dname(self):
277
    def test_sanitize_dname(self):
643
219
        unsanitized_to_sanitized = [
278
        unsanitized_to_sanitized = [
644
@@ -226,4 +285,87 @@ class TestMakeDname(CiTestCase):
645
226
        for (unsanitized, sanitized) in unsanitized_to_sanitized:
285
        for (unsanitized, sanitized) in unsanitized_to_sanitized:
646
227
            self.assertEqual(block_meta.sanitize_dname(unsanitized), sanitized)
286
            self.assertEqual(block_meta.sanitize_dname(unsanitized), sanitized)
647
228
287
648
288
649
289
class TestMakeDnameById(CiTestCase):
650
290
651
291
    @mock.patch('curtin.commands.block_meta.udevadm_info')
652
292
    def test_bad_path(self, m_udev):
653
293
        """test dname_byid raises ValueError on invalid path."""
654
294
        mypath = None
655
295
        with self.assertRaises(ValueError):
656
296
            block_meta.make_dname_byid(mypath)
657
297
658
298
    @mock.patch('curtin.commands.block_meta.udevadm_info')
659
299
    def test_non_disk(self, m_udev):
660
300
        """test dname_byid raises ValueError on DEVTYPE != 'disk'"""
661
301
        mypath = "/dev/" + self.random_string()
662
302
        m_udev.return_value = {'DEVTYPE': 'not_a_disk'}
663
303
        with self.assertRaises(ValueError):
664
304
            block_meta.make_dname_byid(mypath)
665
305
666
306
    @mock.patch('curtin.commands.block_meta.udevadm_info')
667
307
    def test_disk_with_no_id_wwn(self, m_udev):
668
308
        """test dname_byid raises RuntimeError on device without ID or WWN."""
669
309
        mypath = "/dev/" + self.random_string()
670
310
        m_udev.return_value = {'DEVTYPE': 'disk'}
671
311
        with self.assertRaises(RuntimeError):
672
312
            block_meta.make_dname_byid(mypath)
673
313
674
314
    @mock.patch('curtin.commands.block_meta.udevadm_info')
675
315
    def test_udevinfo_not_called_if_info_provided(self, m_udev):
676
316
        """dname_byid does not invoke udevadm_info if using info dict"""
677
317
        myserial = self.random_string()
678
318
        self.assertEqual(
679
319
            [['ENV{ID_SERIAL}=="%s"' % myserial]],
680
320
            block_meta.make_dname_byid(
681
321
                self.random_string(),
682
322
                info={'DEVTYPE': 'disk', 'ID_SERIAL': myserial}))
683
323
        self.assertEqual(0, m_udev.call_count)
684
324
685
325
    @mock.patch('curtin.commands.block_meta.udevadm_info')
686
326
    def test_udevinfo_called_if_info_not_provided(self, m_udev):
687
327
        """dname_byid should call udevadm_info if no data given."""
688
328
        myserial = self.random_string()
689
329
        mypath = "/dev/" + self.random_string()
690
330
        m_udev.return_value = {
691
331
            'DEVTYPE': 'disk', 'ID_SERIAL': myserial, 'DEVNAME': mypath}
692
332
        self.assertEqual(
693
333
            [['ENV{ID_SERIAL}=="%s"' % myserial]],
694
334
            block_meta.make_dname_byid(mypath))
695
335
        self.assertEqual(
696
336
            [mock.call(path=mypath)], m_udev.call_args_list)
697
337
698
338
    def test_disk_with_only_serial(self):
699
339
        """test dname_byid returns rules for ID_SERIAL"""
700
340
        mypath = "/dev/" + self.random_string()
701
341
        myserial = self.random_string()
702
342
        info = {'DEVTYPE': 'disk', 'DEVNAME': mypath, 'ID_SERIAL': myserial}
703
343
        self.assertEqual(
704
344
            [['ENV{ID_SERIAL}=="%s"' % myserial]],
705
345
            block_meta.make_dname_byid(mypath, info=info))
706
346
707
347
    def test_disk_with_only_wwn(self):
708
348
        """test dname_byid returns rules for ID_WWN_WITH_EXTENSION"""
709
349
        mypath = "/dev/" + self.random_string()
710
350
        mywwn = self.random_string()
711
351
        info = {'DEVTYPE': 'disk', 'DEVNAME': mypath,
712
352
                'ID_WWN_WITH_EXTENSION': mywwn}
713
353
        self.assertEqual(
714
354
            [['ENV{ID_WWN_WITH_EXTENSION}=="%s"' % mywwn]],
715
355
            block_meta.make_dname_byid(mypath, info=info))
716
356
717
357
    def test_disk_with_both_id_wwn(self):
718
358
        """test dname_byid returns rules with both ID_SERIAL and ID_WWN"""
719
359
        mypath = "/dev/" + self.random_string()
720
360
        myserial = self.random_string()
721
361
        mywwn = self.random_string()
722
362
        info = {'DEVTYPE': 'disk', 'ID_SERIAL': myserial,
723
363
                'ID_WWN_WITH_EXTENSION': mywwn,
724
364
                'DEVNAME': mypath}
725
365
        self.assertEqual(
726
366
            [['ENV{ID_SERIAL}=="%s"' % myserial,
727
367
              'ENV{ID_WWN_WITH_EXTENSION}=="%s"' % mywwn]],
728
368
            block_meta.make_dname_byid(mypath, info=info))
729
369
730
370
731
229
# vi: ts=4 expandtab syntax=python
371
# vi: ts=4 expandtab syntax=python
732
diff --git a/tests/unittests/test_udev.py b/tests/unittests/test_udev.py
733
230
new file mode 100644
372
new file mode 100644
734
index 0000000..0a070d5
735
--- /dev/null
736
+++ b/tests/unittests/test_udev.py
737
@@ -0,0 +1,68 @@
738
1
# This file is part of curtin. See LICENSE file for copyright and license info.
739
2
740
3
import mock
741
4
742
5
from curtin import udev
743
6
from curtin import util
744
7
from .helpers import CiTestCase
745
8
746
9
747
10
UDEVADM_INFO_QUERY = """\
748
11
DEVLINKS=/dev/disk/by-id/nvme-eui.0025388b710116a1
749
12
DEVNAME=/dev/nvme0n1
750
13
DEVPATH=/devices/pci0000:00/0000:00:1c.4/0000:05:00.0/nvme/nvme0/nvme0n1
751
14
DEVTYPE=disk
752
15
ID_PART_TABLE_TYPE=gpt
753
16
ID_PART_TABLE_UUID=ea0b9ddc-a114-4e01-b257-750d86e3a944
754
17
ID_SERIAL=SAMSUNG MZVLB1T0HALR-000L7_S3TPNY0JB00151
755
18
ID_SERIAL_SHORT=S3TPNY0JB00151
756
19
MAJOR=259
757
20
MINOR=0
758
21
SUBSYSTEM=block
759
22
TAGS=:systemd:
760
23
USEC_INITIALIZED=2026691
761
24
"""
762
25
763
26
INFO_DICT = {
764
27
    'DEVLINKS': ['/dev/disk/by-id/nvme-eui.0025388b710116a1'],
765
28
    'DEVNAME': '/dev/nvme0n1',
766
29
    'DEVPATH':
767
30
        '/devices/pci0000:00/0000:00:1c.4/0000:05:00.0/nvme/nvme0/nvme0n1',
768
31
    'DEVTYPE': 'disk',
769
32
    'ID_PART_TABLE_TYPE': 'gpt',
770
33
    'ID_PART_TABLE_UUID': 'ea0b9ddc-a114-4e01-b257-750d86e3a944',
771
34
    'ID_SERIAL': 'SAMSUNG MZVLB1T0HALR-000L7_S3TPNY0JB00151',
772
35
    'ID_SERIAL_SHORT': 'S3TPNY0JB00151',
773
36
    'MAJOR': '259',
774
37
    'MINOR': '0',
775
38
    'SUBSYSTEM': 'block',
776
39
    'TAGS': ':systemd:',
777
40
    'USEC_INITIALIZED': '2026691'
778
41
}
779
42
780
43
781
44
class TestUdevInfo(CiTestCase):
782
45
783
46
    @mock.patch('curtin.util.subp')
784
47
    def test_udevadm_info(self, m_subp):
785
48
        """ udevadm_info returns dictionary for specified device """
786
49
        mypath = '/dev/nvme0n1'
787
50
        m_subp.return_value = (UDEVADM_INFO_QUERY, "")
788
51
        info = udev.udevadm_info(mypath)
789
52
        m_subp.assert_called_with(
790
53
            ['udevadm', 'info', '--query=property', mypath], capture=True)
791
54
        self.assertEqual(sorted(INFO_DICT), sorted(info))
792
55
793
56
    def test_udevadm_info_no_path(self):
794
57
        """ udevadm_info raises ValueError for invalid path value"""
795
58
        mypath = None
796
59
        with self.assertRaises(ValueError):
797
60
            udev.udevadm_info(mypath)
798
61
799
62
    @mock.patch('curtin.util.subp')
800
63
    def test_udevadm_info_path_not_exists(self, m_subp):
801
64
        """ udevadm_info raises ProcessExecutionError for invalid path value"""
802
65
        mypath = self.random_string()
803
66
        m_subp.side_effect = util.ProcessExecutionError()
804
67
        with self.assertRaises(util.ProcessExecutionError):
805
68
            udev.udevadm_info(mypath)
806
diff --git a/tests/vmtests/__init__.py b/tests/vmtests/__init__.py
807
index 51eda5c..5ffa632 100644
808
--- a/tests/vmtests/__init__.py
809
+++ b/tests/vmtests/__init__.py
810
@@ -21,6 +21,7 @@ from curtin.block import iscsi
811
21
21
812
22
from .report_webhook_logger import CaptureReporting
22
from .report_webhook_logger import CaptureReporting
813
23
from curtin.commands.install import INSTALL_PASS_MSG
23
from curtin.commands.install import INSTALL_PASS_MSG
814
24
from curtin.commands.block_meta import sanitize_dname
815
24
25
816
25
from .image_sync import query as imagesync_query
26
from .image_sync import query as imagesync_query
817
26
from .image_sync import mirror as imagesync_mirror
27
from .image_sync import mirror as imagesync_mirror
818
@@ -955,9 +956,18 @@ class VMBaseClass(TestCase):
819
955
        storage_config = cls.get_class_storage_config()
956
        storage_config = cls.get_class_storage_config()
820
956
        cls.disk_wwns = ["wwn=%s" % x.get('wwn') for x in storage_config
957
        cls.disk_wwns = ["wwn=%s" % x.get('wwn') for x in storage_config
821
957
                         if 'wwn' in x]
958
                         if 'wwn' in x]
824
958
        cls.disk_serials = ["serial=%s" % x.get('serial')
959
        cls.disk_serials = []
825
959
                            for x in storage_config if 'serial' in x]
960
        cls.nvme_serials = []
826
961
        for x in storage_config:
827
962
            if 'serial' in x:
828
963
                serial = x.get('serial')
829
964
                if serial.startswith('nvme'):
830
965
                    cls.nvme_serials.append("serial=%s" % serial)
831
966
                else:
832
967
                    cls.disk_serials.append("serial=%s" % serial)
833
960
968
834
969
        logger.info("disk_serials: %s", cls.disk_serials)
835
970
        logger.info("nvme_serials: %s", cls.nvme_serials)
836
961
        target_disk = "{}:{}:{}:{}:".format(cls.td.target_disk,
971
        target_disk = "{}:{}:{}:{}:".format(cls.td.target_disk,
837
962
                                            "",
972
                                            "",
838
963
                                            cls.disk_driver,
973
                                            cls.disk_driver,
839
@@ -989,11 +999,13 @@ class VMBaseClass(TestCase):
840
989
            disks.extend(['--disk', extra_disk])
999
            disks.extend(['--disk', extra_disk])
841
990
1000
842
991
        # build nvme disk args if needed
1001
        # build nvme disk args if needed
843
1002
        logger.info('nvme disks: %s', cls.nvme_disks)
844
992
        for (disk_no, disk_sz) in enumerate(cls.nvme_disks):
1003
        for (disk_no, disk_sz) in enumerate(cls.nvme_disks):
845
993
            dpath = os.path.join(cls.td.disks, 'nvme_disk_%d.img' % disk_no)
1004
            dpath = os.path.join(cls.td.disks, 'nvme_disk_%d.img' % disk_no)
846
1005
            nvme_serial = cls.nvme_serials[disk_no]
847
994
            nvme_disk = '{}:{}:nvme:{}:{}'.format(dpath, disk_sz,
1006
            nvme_disk = '{}:{}:nvme:{}:{}'.format(dpath, disk_sz,
848
995
                                                  cls.disk_block_size,
1007
                                                  cls.disk_block_size,
850
996
                                                  "serial=nvme-%d" % disk_no)
1008
                                                  "%s" % nvme_serial)
851
997
            disks.extend(['--disk', nvme_disk])
1009
            disks.extend(['--disk', nvme_disk])
852
998
1010
853
999
        # build iscsi disk args if needed
1011
        # build iscsi disk args if needed
854
@@ -1222,6 +1234,8 @@ class VMBaseClass(TestCase):
855
1222
            dpath = os.path.join(cls.td.disks, 'nvme_disk_%d.img' % disk_no)
1234
            dpath = os.path.join(cls.td.disks, 'nvme_disk_%d.img' % disk_no)
856
1223
            disk = '--disk={},driver={},format={},{}'.format(
1235
            disk = '--disk={},driver={},format={},{}'.format(
857
1224
                dpath, disk_driver, TARGET_IMAGE_FORMAT, bsize_args)
1236
                dpath, disk_driver, TARGET_IMAGE_FORMAT, bsize_args)
858
1237
            if len(cls.nvme_serials):
859
1238
                disk += ",%s" % cls.nvme_serials[disk_no]
860
1225
            nvme_disks.extend([disk])
1239
            nvme_disks.extend([disk])
861
1226
1240
862
1227
        # unlike NVMe disks, we do not want to configure the iSCSI disks
1241
        # unlike NVMe disks, we do not want to configure the iSCSI disks
863
@@ -1541,8 +1555,41 @@ class VMBaseClass(TestCase):
864
1541
        for diskname, part in self.disk_to_check:
1555
        for diskname, part in self.disk_to_check:
865
1542
            if part is not 0:
1556
            if part is not 0:
866
1543
                link = diskname + "-part" + str(part)
1557
                link = diskname + "-part" + str(part)
869
1544
                self.assertIn(link, contents)
1558
                self.assertIn(link, contents.splitlines())
870
1545
            self.assertIn(diskname, contents)
1559
            self.assertIn(diskname, contents.splitlines())
871
1560
872
1561
    @skip_if_flag('expected_failure')
873
1562
    def test_dname_rules(self, disk_to_check=None):
874
1563
        if self.target_distro != "ubuntu":
875
1564
            raise SkipTest("dname not present in non-ubuntu releases")
876
1565
877
1566
        if not disk_to_check:
878
1567
            disk_to_check = self.disk_to_check
879
1568
        if disk_to_check is None:
880
1569
            logger.debug('test_dname_rules: no disks to check')
881
1570
            return
882
1571
        logger.debug('test_dname_rules: checking disks: %s', disk_to_check)
883
1572
        self.output_files_exist(["udev_rules.d"])
884
1573
885
1574
        cfg = yaml.load(self.load_collect_file("root/curtin-install-cfg.yaml"))
886
1575
        stgcfg = cfg.get("storage", {}).get("config", [])
887
1576
        disks = [ent for ent in stgcfg if (ent.get('type') == 'disk' and
888
1577
                                           'name' in ent)]
889
1578
        key_to_udev = {
890
1579
            'serial': 'ID_SERIAL',
891
1580
            'wwn': 'ID_WWN_WITH_EXTENSION',
892
1581
        }
893
1582
        for disk in disks:
894
1583
            dname_file = "%s.rules" % sanitize_dname(disk.get('name'))
895
1584
            contents = self.load_collect_file("udev_rules.d/%s" % dname_file)
896
1585
            for key, key_name in key_to_udev.items():
897
1586
                value = disk.get(key)
898
1587
                if value:
899
1588
                    # serials may include spaces, udev replaces them with # _
900
1589
                    if ' ' in value:
901
1590
                        value = value.replace(' ', '_')
902
1591
                    self.assertIn(key_name, contents)
903
1592
                    self.assertIn(value, contents)
904
1546
1593
905
1547
    @skip_if_flag('expected_failure')
1594
    @skip_if_flag('expected_failure')
906
1548
    def test_reporting_data(self):
1595
    def test_reporting_data(self):
907
@@ -1765,6 +1812,9 @@ class PsuedoVMBaseClass(VMBaseClass):
908
1765
    def test_dname(self, disk_to_check=None):
1812
    def test_dname(self, disk_to_check=None):
909
1766
        pass
1813
        pass
910
1767
1814
911
1815
    def test_dname_rules(self, disk_to_check=None):
912
1816
        pass
913
1817
914
1768
    def test_interfacesd_eth0_removed(self):
1818
    def test_interfacesd_eth0_removed(self):
915
1769
        pass
1819
        pass
916
1770
1820
917
diff --git a/tests/vmtests/test_basic.py b/tests/vmtests/test_basic.py
918
index 5cb8c30..48f07d6 100644
919
--- a/tests/vmtests/test_basic.py
920
+++ b/tests/vmtests/test_basic.py
921
@@ -17,9 +17,14 @@ class TestBasicAbs(VMBaseClass):
922
17
    dirty_disks = True
17
    dirty_disks = True
923
18
    conf_file = "examples/tests/basic.yaml"
18
    conf_file = "examples/tests/basic.yaml"
924
19
    extra_disks = ['128G', '128G', '4G']
19
    extra_disks = ['128G', '128G', '4G']
928
20
    nvme_disks = ['4G']
20
    disk_to_check = [('btrfs_volume', 0),
929
21
    disk_to_check = [('main_disk_with_in---valid--dname', 1),
21
                     ('main_disk_with_in---valid--dname', 0),
930
22
                     ('main_disk_with_in---valid--dname', 2)]
22
                     ('main_disk_with_in---valid--dname', 1),
931
23
                     ('main_disk_with_in---valid--dname', 2),
932
24
                     ('pnum_disk', 0),
933
25
                     ('pnum_disk', 1),
934
26
                     ('pnum_disk', 10),
935
27
                     ('sparedisk', 0)]
936
23
    extra_collect_scripts = [textwrap.dedent("""
28
    extra_collect_scripts = [textwrap.dedent("""
937
24
        cd OUTPUT_COLLECT_D
29
        cd OUTPUT_COLLECT_D
938
25
        blkid -o export /dev/vda | cat >blkid_output_vda
30
        blkid -o export /dev/vda | cat >blkid_output_vda
939
@@ -249,7 +254,6 @@ class TestBasicScsiAbs(TestBasicAbs):
940
249
    conf_file = "examples/tests/basic_scsi.yaml"
254
    conf_file = "examples/tests/basic_scsi.yaml"
941
250
    disk_driver = 'scsi-hd'
255
    disk_driver = 'scsi-hd'
942
251
    extra_disks = ['128G', '128G', '4G']
256
    extra_disks = ['128G', '128G', '4G']
943
252
    nvme_disks = ['4G']
944
253
    extra_collect_scripts = [textwrap.dedent("""
257
    extra_collect_scripts = [textwrap.dedent("""
945
254
        cd OUTPUT_COLLECT_D
258
        cd OUTPUT_COLLECT_D
946
255
        blkid -o export /dev/sda | cat >blkid_output_sda
259
        blkid -o export /dev/sda | cat >blkid_output_sda
947
diff --git a/tests/vmtests/test_nvme.py b/tests/vmtests/test_nvme.py
948
index 7755b53..60d9d86 100644
949
--- a/tests/vmtests/test_nvme.py
950
+++ b/tests/vmtests/test_nvme.py
951
@@ -19,9 +19,10 @@ class TestNvmeAbs(VMBaseClass):
952
19
    conf_file = "examples/tests/nvme.yaml"
19
    conf_file = "examples/tests/nvme.yaml"
953
20
    extra_disks = []
20
    extra_disks = []
954
21
    nvme_disks = ['4G', '4G']
21
    nvme_disks = ['4G', '4G']
958
22
    disk_to_check = [('main_disk', 1), ('main_disk', 2), ('main_disk', 15),
22
    disk_to_check = [
959
23
                     ('nvme_disk', 1), ('nvme_disk', 2), ('nvme_disk', 3),
23
        ('main_disk', 1), ('main_disk', 2), ('main_disk', 15),
960
24
                     ('second_nvme', 1)]
24
        ('nvme_disk', 0), ('nvme_disk', 1), ('nvme_disk', 2), ('nvme_disk', 3),
961
25
        ('second_nvme', 0), ('second_nvme', 1)]
962
25
    extra_collect_scripts = [textwrap.dedent("""
26
    extra_collect_scripts = [textwrap.dedent("""
963
26
        cd OUTPUT_COLLECT_D
27
        cd OUTPUT_COLLECT_D
964
27
        ls /sys/class/ > sys_class
28
        ls /sys/class/ > sys_class
965
@@ -97,7 +98,8 @@ class TestNvmeBcacheAbs(TestNvmeAbs):
966
97
    extra_disks = ['10G']
98
    extra_disks = ['10G']
967
98
    nvme_disks = ['6G']
99
    nvme_disks = ['6G']
968
99
    uefi = True
100
    uefi = True
970
100
    disk_to_check = [('sda', 1), ('sda', 2), ('sda', 3)]
101
    disk_to_check = [('sda', 1), ('sda', 2), ('sda', 3),
971
102
                     ('sdb', 0), ('nvme0n1', 0)]
972
101
103
973
102
    extra_collect_scripts = [textwrap.dedent("""
104
    extra_collect_scripts = [textwrap.dedent("""
974
103
        cd OUTPUT_COLLECT_D
105
        cd OUTPUT_COLLECT_D
Reviewer	Review Type	Date Requested	Status
Scott Moser (community)			Approve on 2018-11-29
Server Team CI bot	continuous-integration		Approve on 2018-11-28
Chad Smith		2018-10-31	Pending
Review via email: mp+358116@code.launchpad.net