Merge lp:~raharper/curtin/trunk.nvme_bcache into lp:~curtin-dev/curtin/trunk
- trunk.nvme_bcache
- Merge into trunk
Proposed by
Ryan Harper
| Status: | Merged |
|---|---|
| Merged at revision: | 492 |
| Proposed branch: | lp:~raharper/curtin/trunk.nvme_bcache |
| Merge into: | lp:~curtin-dev/curtin/trunk |
| Diff against target: |
684 lines (+559/-22) 6 files modified
curtin/block/clear_holders.py (+81/-14) curtin/util.py (+21/-0) examples/tests/nvme_bcache.yaml (+114/-0) tests/unittests/test_clear_holders.py (+197/-8) tests/unittests/test_util.py (+69/-0) tests/vmtests/test_nvme.py (+77/-0) |
| To merge this branch: | bzr merge lp:~raharper/curtin/trunk.nvme_bcache |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Server Team CI bot | continuous-integration | Approve | |
| Scott Moser (community) | Approve | ||
|
Review via email:
|
|||
Commit message
Description of the change
clear-holders: ensure that bcache handler waits bcache devices to shutdown
Clear-holder's bcache shutdown handler does not wait for devices owned by bcache driver to be released before returning. On sufficiently fast systems (and with multiple cpus) the time for bcache to release the backing devices may occur slower than the time it takes for curtin to
start attempting to wipe partition data on a backing device. This results
in an IO error due to curtin asserting exclusive access to a device for
wiping.
This series introduces some additional logic in the bcache shutdown
handler by testing that the bcache devices are removed before returning
from the handler.
If the underlying devices are not released, the handler raises an
exception.
Fixes: LP:#1680409
To post a comment you must log in.
Revision history for this message
| Server Team CI bot (server-team-bot) wrote : | # |
review:
Approve
(continuous-integration)
Revision history for this message
| Scott Moser (smoser) wrote : | # |
Some comments inline.
The unit tests seem really tied to the implementation (mocking os.path.exists which is called by 2 different callers).
I realize this is tricky, but maybe some re-work could make the tests more clear.
A test for get_bcache_sys_path would be good.
Revision history for this message
| Ryan Harper (raharper) wrote : | # |
Download full text (7.5 KiB)
On Tue, Apr 11, 2017 at 9:17 AM, Scott Moser <email address hidden> wrote:
> Some comments inline.
> The unit tests seem really tied to the implementation (mocking
> os.path.exists which is called by 2 different callers).
>
> I realize this is tricky, but maybe some re-work could make the tests more
> clear.
>
I'm open to reworking them. Not 100% happy with the current coverage.
>
>
> A test for get_bcache_sys_path would be good.
>
Pretty sure I have that.
>
>
> Diff comments:
>
> > === modified file 'curtin/
> > --- curtin/
> > +++ curtin/
> > @@ -56,32 +56,75 @@
> >
> > def get_bcache_
> > """
> > - Get the /sys/fs/bcache/ path of the bcache volume using specified
> device
> > + Get the /sys/fs/bcache/ path of the bcache cache device bound to
> > + specified device
> > """
> > # FIXME: when block.bcache is written this should be moved there
> > sysfs_path = block.sys_
> > return os.path.
> 'cache'))
> >
> >
> > +def get_bcache_
> > + """
> > + Get the /sys/class/
> > + """
> > + sysfs_path = block.sys_
> > + return os.path.
>
> The comment says "if present", but its not clear what the return would be.
> If the *device* does not exist (get_bcache_
> you'll
> raise an OSError, but if the device exists and the 'bcache' entry does not
> you'll just return it either way.
>
> >>> os.path.
> '/bogus/path/here'
>
Ack, the comment was really from the caller;
I'll rework as I'd like it validate the path before the realpath call as
well.
>
> > +
> > +
> > def shutdown_
> > """
> > Shut down bcache for specified bcache device
> > +
> > + 1. Stop the cacheset that `device` is connected to
> > + 2. Stop the 'device'
> > """
> > + if not device.
>
> we use the string '/sys/class/block' other places, we really should
> SYS_CLASS_BLOCK = '/sys/block'
> not "your fault", but i think having that constant would be good.
>
ACK, though I'd like to punt on the general cleanup into a separate MP.
>
> > + raise ValueError('Invalid Device (%s): '
> > + 'Device path must start with
> /sys/class/block/',
> > + device)
> > +
> > bcache_
> determined '
> > 'that the device has already been shut
> down '
> > 'during handling of another bcache dev. '
> > 'skipping'
> > - if not os.path.
> > - LOG.info(
> > - return
> > -
> > - bcache_sysfs = get_bcache_
> > - if not os.path.
> > - LOG.info(
> > - return
> > -
> ...
- 493. By Ryan Harper
-
Add strict mode for bcache sysfs paths and longer, frequent retries
Feedback from MP suggested we should apply some path checking
when handling sysfs bcache entries; add the strict mode used in
other block methods.When waiting for file removal, we want to avoid blocking for long
periods and also ensure we've waited long enough. A bcache device
may need to flush a cache to the backing device which could take
some time. We also don't want to add latency if it isn't needed by
incurring long sleep intervals. Now we will wait 30 seconds in total
and check every 0.2 seconds if the device has been removed.
Revision history for this message
| Scott Moser (smoser) : | # |
review:
Approve
Revision history for this message
| Server Team CI bot (server-team-bot) wrote : | # |
PASSED: Continuous integration, rev:493
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
Click here to trigger a rebuild:
https:/
review:
Approve
(continuous-integration)
- 494. By Ryan Harper
-
merge from trunk
Revision history for this message
| Server Team CI bot (server-team-bot) wrote : | # |
PASSED: Continuous integration, rev:494
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
Click here to trigger a rebuild:
https:/
review:
Approve
(continuous-integration)
- 495. By Ryan Harper
-
merge from trunk
Revision history for this message
| Server Team CI bot (server-team-bot) wrote : | # |
PASSED: Continuous integration, rev:495
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
Click here to trigger a rebuild:
https:/
review:
Approve
(continuous-integration)
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'curtin/block/clear_holders.py' | |||
| 2 | --- curtin/block/clear_holders.py 2017-01-31 22:03:02 +0000 | |||
| 3 | +++ curtin/block/clear_holders.py 2017-04-24 17:53:29 +0000 | |||
| 4 | @@ -21,6 +21,7 @@ | |||
| 5 | 21 | having to reboot the system | 21 | having to reboot the system |
| 6 | 22 | """ | 22 | """ |
| 7 | 23 | 23 | ||
| 8 | 24 | import errno | ||
| 9 | 24 | import os | 25 | import os |
| 10 | 25 | 26 | ||
| 11 | 26 | from curtin import (block, udev, util) | 27 | from curtin import (block, udev, util) |
| 12 | @@ -54,34 +55,100 @@ | |||
| 13 | 54 | return out.strip() | 55 | return out.strip() |
| 14 | 55 | 56 | ||
| 15 | 56 | 57 | ||
| 17 | 57 | def get_bcache_using_dev(device): | 58 | def get_bcache_using_dev(device, strict=True): |
| 18 | 58 | """ | 59 | """ |
| 20 | 59 | Get the /sys/fs/bcache/ path of the bcache volume using specified device | 60 | Get the /sys/fs/bcache/ path of the bcache cache device bound to |
| 21 | 61 | specified device | ||
| 22 | 60 | """ | 62 | """ |
| 23 | 61 | # FIXME: when block.bcache is written this should be moved there | 63 | # FIXME: when block.bcache is written this should be moved there |
| 24 | 62 | sysfs_path = block.sys_block_path(device) | 64 | sysfs_path = block.sys_block_path(device) |
| 26 | 63 | return os.path.realpath(os.path.join(sysfs_path, 'bcache', 'cache')) | 65 | path = os.path.realpath(os.path.join(sysfs_path, 'bcache', 'cache')) |
| 27 | 66 | if strict and not os.path.exists(path): | ||
| 28 | 67 | err = OSError( | ||
| 29 | 68 | "device '{}' did not have existing syspath '{}'".format( | ||
| 30 | 69 | device, path)) | ||
| 31 | 70 | err.errno = errno.ENOENT | ||
| 32 | 71 | raise err | ||
| 33 | 72 | |||
| 34 | 73 | return path | ||
| 35 | 74 | |||
| 36 | 75 | |||
| 37 | 76 | def get_bcache_sys_path(device, strict=True): | ||
| 38 | 77 | """ | ||
| 39 | 78 | Get the /sys/class/block/<device>/bcache path | ||
| 40 | 79 | """ | ||
| 41 | 80 | sysfs_path = block.sys_block_path(device) | ||
| 42 | 81 | path = os.path.join(sysfs_path, 'bcache') | ||
| 43 | 82 | if strict and not os.path.exists(path): | ||
| 44 | 83 | err = OSError( | ||
| 45 | 84 | "device '{}' did not have existing syspath '{}'".format( | ||
| 46 | 85 | device, path)) | ||
| 47 | 86 | err.errno = errno.ENOENT | ||
| 48 | 87 | raise err | ||
| 49 | 88 | |||
| 50 | 89 | return path | ||
| 51 | 64 | 90 | ||
| 52 | 65 | 91 | ||
| 53 | 66 | def shutdown_bcache(device): | 92 | def shutdown_bcache(device): |
| 54 | 67 | """ | 93 | """ |
| 55 | 68 | Shut down bcache for specified bcache device | 94 | Shut down bcache for specified bcache device |
| 56 | 95 | |||
| 57 | 96 | 1. Stop the cacheset that `device` is connected to | ||
| 58 | 97 | 2. Stop the 'device' | ||
| 59 | 69 | """ | 98 | """ |
| 60 | 99 | if not device.startswith('/sys/class/block'): | ||
| 61 | 100 | raise ValueError('Invalid Device (%s): ' | ||
| 62 | 101 | 'Device path must start with /sys/class/block/', | ||
| 63 | 102 | device) | ||
| 64 | 103 | |||
| 65 | 104 | # bcache device removal should be fast but in an extreme | ||
| 66 | 105 | # case, might require the cache device to flush large | ||
| 67 | 106 | # amounts of data to a backing device. The strategy here | ||
| 68 | 107 | # is to wait for approximately 30 seconds but to check | ||
| 69 | 108 | # frequently since curtin cannot proceed until devices | ||
| 70 | 109 | # cleared. | ||
| 71 | 110 | removal_retries = [0.2] * 150 # 30 seconds total | ||
| 72 | 70 | bcache_shutdown_message = ('shutdown_bcache running on {} has determined ' | 111 | bcache_shutdown_message = ('shutdown_bcache running on {} has determined ' |
| 73 | 71 | 'that the device has already been shut down ' | 112 | 'that the device has already been shut down ' |
| 74 | 72 | 'during handling of another bcache dev. ' | 113 | 'during handling of another bcache dev. ' |
| 75 | 73 | 'skipping'.format(device)) | 114 | 'skipping'.format(device)) |
| 87 | 74 | if not os.path.exists(device): | 115 | |
| 88 | 75 | LOG.info(bcache_shutdown_message) | 116 | if not os.path.exists(device): |
| 89 | 76 | return | 117 | LOG.info(bcache_shutdown_message) |
| 90 | 77 | 118 | return | |
| 91 | 78 | bcache_sysfs = get_bcache_using_dev(device) | 119 | |
| 92 | 79 | if not os.path.exists(bcache_sysfs): | 120 | # stop cacheset if it exists |
| 93 | 80 | LOG.info(bcache_shutdown_message) | 121 | bcache_cache_sysfs = get_bcache_using_dev(device) |
| 94 | 81 | return | 122 | if not os.path.exists(bcache_cache_sysfs): |
| 95 | 82 | 123 | LOG.info('bcache cacheset already removed: %s', | |
| 96 | 83 | LOG.debug('stopping bcache at: %s', bcache_sysfs) | 124 | os.path.basename(bcache_cache_sysfs)) |
| 97 | 84 | util.write_file(os.path.join(bcache_sysfs, 'stop'), '1', mode=None) | 125 | else: |
| 98 | 126 | LOG.info('stopping bcache cacheset at: %s', bcache_cache_sysfs) | ||
| 99 | 127 | util.write_file(os.path.join(bcache_cache_sysfs, 'stop'), | ||
| 100 | 128 | '1', mode=None) | ||
| 101 | 129 | try: | ||
| 102 | 130 | util.wait_for_removal(bcache_cache_sysfs, retries=removal_retries) | ||
| 103 | 131 | except OSError: | ||
| 104 | 132 | LOG.info('Failed to stop bcache cacheset %s', bcache_cache_sysfs) | ||
| 105 | 133 | raise | ||
| 106 | 134 | |||
| 107 | 135 | # after stopping cache set, we may need to stop the device | ||
| 108 | 136 | if not os.path.exists(device): | ||
| 109 | 137 | LOG.info('bcache backing device already removed: %s', device) | ||
| 110 | 138 | return | ||
| 111 | 139 | else: | ||
| 112 | 140 | bcache_block_sysfs = get_bcache_sys_path(device) | ||
| 113 | 141 | LOG.info('stopping bcache backing device at: %s', bcache_block_sysfs) | ||
| 114 | 142 | util.write_file(os.path.join(bcache_block_sysfs, 'stop'), | ||
| 115 | 143 | '1', mode=None) | ||
| 116 | 144 | try: | ||
| 117 | 145 | util.wait_for_removal(device, retries=removal_retries) | ||
| 118 | 146 | except OSError: | ||
| 119 | 147 | LOG.info('Failed to stop bcache backing device %s', | ||
| 120 | 148 | bcache_block_sysfs) | ||
| 121 | 149 | raise | ||
| 122 | 150 | |||
| 123 | 151 | return | ||
| 124 | 85 | 152 | ||
| 125 | 86 | 153 | ||
| 126 | 87 | def shutdown_lvm(device): | 154 | def shutdown_lvm(device): |
| 127 | 88 | 155 | ||
| 128 | === modified file 'curtin/util.py' | |||
| 129 | --- curtin/util.py 2017-04-12 01:38:04 +0000 | |||
| 130 | +++ curtin/util.py 2017-04-24 17:53:29 +0000 | |||
| 131 | @@ -194,6 +194,27 @@ | |||
| 132 | 194 | return _subp(*args, **kwargs) | 194 | return _subp(*args, **kwargs) |
| 133 | 195 | 195 | ||
| 134 | 196 | 196 | ||
| 135 | 197 | def wait_for_removal(path, retries=[1, 3, 5, 7]): | ||
| 136 | 198 | if not path: | ||
| 137 | 199 | raise ValueError('wait_for_removal: missing path parameter') | ||
| 138 | 200 | |||
| 139 | 201 | # Retry with waits between checking for existence | ||
| 140 | 202 | LOG.debug('waiting for %s to be removed', path) | ||
| 141 | 203 | for num, wait in enumerate(retries): | ||
| 142 | 204 | if not os.path.exists(path): | ||
| 143 | 205 | LOG.debug('%s has been removed', path) | ||
| 144 | 206 | return | ||
| 145 | 207 | LOG.debug('sleeping %s', wait) | ||
| 146 | 208 | time.sleep(wait) | ||
| 147 | 209 | |||
| 148 | 210 | # final check | ||
| 149 | 211 | if not os.path.exists(path): | ||
| 150 | 212 | LOG.debug('%s has been removed', path) | ||
| 151 | 213 | return | ||
| 152 | 214 | |||
| 153 | 215 | raise OSError('Timeout exceeded for removal of %s', path) | ||
| 154 | 216 | |||
| 155 | 217 | |||
| 156 | 197 | def load_command_environment(env=os.environ, strict=False): | 218 | def load_command_environment(env=os.environ, strict=False): |
| 157 | 198 | 219 | ||
| 158 | 199 | mapping = {'scratch': 'WORKING_DIR', 'fstab': 'OUTPUT_FSTAB', | 220 | mapping = {'scratch': 'WORKING_DIR', 'fstab': 'OUTPUT_FSTAB', |
| 159 | 200 | 221 | ||
| 160 | === added file 'examples/tests/nvme_bcache.yaml' | |||
| 161 | --- examples/tests/nvme_bcache.yaml 1970-01-01 00:00:00 +0000 | |||
| 162 | +++ examples/tests/nvme_bcache.yaml 2017-04-24 17:53:29 +0000 | |||
| 163 | @@ -0,0 +1,114 @@ | |||
| 164 | 1 | showtrace: true | ||
| 165 | 2 | storage: | ||
| 166 | 3 | config: | ||
| 167 | 4 | - grub_device: true | ||
| 168 | 5 | id: sda | ||
| 169 | 6 | model: LOGICAL VOLUME | ||
| 170 | 7 | name: sda | ||
| 171 | 8 | ptable: gpt | ||
| 172 | 9 | path: /dev/vdb | ||
| 173 | 10 | type: disk | ||
| 174 | 11 | wipe: superblock | ||
| 175 | 12 | - id: sdb | ||
| 176 | 13 | model: LOGICAL VOLUME | ||
| 177 | 14 | name: sdb | ||
| 178 | 15 | path: /dev/vdc | ||
| 179 | 16 | type: disk | ||
| 180 | 17 | wipe: superblock | ||
| 181 | 18 | - id: nvme0n1 | ||
| 182 | 19 | model: INTEL SSDPEDME400G4 | ||
| 183 | 20 | name: nvme0n1 | ||
| 184 | 21 | ptable: gpt | ||
| 185 | 22 | path: /dev/nvme0n1 | ||
| 186 | 23 | type: disk | ||
| 187 | 24 | wipe: superblock | ||
| 188 | 25 | - device: sda | ||
| 189 | 26 | flag: boot | ||
| 190 | 27 | id: sda-part1 | ||
| 191 | 28 | name: sda-part1 | ||
| 192 | 29 | number: 1 | ||
| 193 | 30 | offset: 4194304B | ||
| 194 | 31 | size: 536870912B | ||
| 195 | 32 | type: partition | ||
| 196 | 33 | uuid: 9f0fda16-c096-4cee-82ac-4f5f294253a2 | ||
| 197 | 34 | wipe: superblock | ||
| 198 | 35 | - device: sda | ||
| 199 | 36 | flag: boot | ||
| 200 | 37 | id: sda-part2 | ||
| 201 | 38 | name: sda-part2 | ||
| 202 | 39 | number: 2 | ||
| 203 | 40 | size: 1G | ||
| 204 | 41 | type: partition | ||
| 205 | 42 | uuid: 7dbb079c-60e5-4900-b3ca-4a92c5cbd6d3 | ||
| 206 | 43 | wipe: superblock | ||
| 207 | 44 | - device: sda | ||
| 208 | 45 | id: sda-part3 | ||
| 209 | 46 | name: sda-part3 | ||
| 210 | 47 | number: 3 | ||
| 211 | 48 | size: 5G | ||
| 212 | 49 | type: partition | ||
| 213 | 50 | uuid: 560de16e-6dc1-4e85-8e66-aaf1062dabcd | ||
| 214 | 51 | wipe: superblock | ||
| 215 | 52 | - device: nvme0n1 | ||
| 216 | 53 | id: nvme0n1-part1 | ||
| 217 | 54 | name: nvme0n1-part1 | ||
| 218 | 55 | number: 1 | ||
| 219 | 56 | offset: 4194304B | ||
| 220 | 57 | size: 5G | ||
| 221 | 58 | type: partition | ||
| 222 | 59 | uuid: 9692359a-8a6d-4fa2-bbe6-48b97c4c8832 | ||
| 223 | 60 | wipe: superblock | ||
| 224 | 61 | - backing_device: sda-part3 | ||
| 225 | 62 | cache_device: nvme0n1-part1 | ||
| 226 | 63 | cache_mode: writeback | ||
| 227 | 64 | id: bcache1 | ||
| 228 | 65 | name: bcache1 | ||
| 229 | 66 | type: bcache | ||
| 230 | 67 | - backing_device: sdb | ||
| 231 | 68 | cache_device: nvme0n1-part1 | ||
| 232 | 69 | cache_mode: writeback | ||
| 233 | 70 | id: bcache2 | ||
| 234 | 71 | name: bcache2 | ||
| 235 | 72 | type: bcache | ||
| 236 | 73 | - fstype: fat32 | ||
| 237 | 74 | id: sda-part1_format | ||
| 238 | 75 | label: efi | ||
| 239 | 76 | type: format | ||
| 240 | 77 | uuid: e23b3115-228d-410c-a2b0-5bffeaf1c1d0 | ||
| 241 | 78 | volume: sda-part1 | ||
| 242 | 79 | - fstype: ext4 | ||
| 243 | 80 | id: sda-part2_format | ||
| 244 | 81 | label: boot | ||
| 245 | 82 | type: format | ||
| 246 | 83 | uuid: 8940edad-7882-4978-91a6-5f80f95ea4e8 | ||
| 247 | 84 | volume: sda-part2 | ||
| 248 | 85 | - fstype: ext4 | ||
| 249 | 86 | id: bcache1_format | ||
| 250 | 87 | label: root | ||
| 251 | 88 | type: format | ||
| 252 | 89 | uuid: 627296af-d976-4baf-8abc-b388143d4dd3 | ||
| 253 | 90 | volume: bcache1 | ||
| 254 | 91 | - fstype: xfs | ||
| 255 | 92 | id: bcache2_format | ||
| 256 | 93 | label: '' | ||
| 257 | 94 | type: format | ||
| 258 | 95 | uuid: ada2cfb1-cfad-4d66-99ff-ea3e79790233 | ||
| 259 | 96 | volume: bcache2 | ||
| 260 | 97 | - device: bcache1_format | ||
| 261 | 98 | id: bcache1_mount | ||
| 262 | 99 | path: / | ||
| 263 | 100 | type: mount | ||
| 264 | 101 | - device: sda-part2_format | ||
| 265 | 102 | id: sda-part2_mount | ||
| 266 | 103 | path: /boot | ||
| 267 | 104 | type: mount | ||
| 268 | 105 | - device: sda-part1_format | ||
| 269 | 106 | id: sda-part1_mount | ||
| 270 | 107 | path: /boot/efi | ||
| 271 | 108 | type: mount | ||
| 272 | 109 | - device: bcache2_format | ||
| 273 | 110 | id: bcache2_mount | ||
| 274 | 111 | options: '' | ||
| 275 | 112 | path: /srv | ||
| 276 | 113 | type: mount | ||
| 277 | 114 | version: 1 | ||
| 278 | 0 | 115 | ||
| 279 | === modified file 'tests/unittests/test_clear_holders.py' | |||
| 280 | --- tests/unittests/test_clear_holders.py 2017-01-27 01:00:39 +0000 | |||
| 281 | +++ tests/unittests/test_clear_holders.py 2017-04-24 17:53:29 +0000 | |||
| 282 | @@ -9,6 +9,7 @@ | |||
| 283 | 9 | class TestClearHolders(TestCase): | 9 | class TestClearHolders(TestCase): |
| 284 | 10 | test_blockdev = '/dev/null' | 10 | test_blockdev = '/dev/null' |
| 285 | 11 | test_syspath = '/sys/class/block/null' | 11 | test_syspath = '/sys/class/block/null' |
| 286 | 12 | remove_retries = [0.2] * 150 # clear_holders defaults to 30 seconds | ||
| 287 | 12 | example_holders_trees = [ | 13 | example_holders_trees = [ |
| 288 | 13 | [{'device': '/sys/class/block/sda', 'name': 'sda', 'holders': | 14 | [{'device': '/sys/class/block/sda', 'name': 'sda', 'holders': |
| 289 | 14 | [{'device': '/sys/class/block/sda/sda1', 'name': 'sda1', | 15 | [{'device': '/sys/class/block/sda/sda1', 'name': 'sda1', |
| 290 | @@ -89,12 +90,25 @@ | |||
| 291 | 89 | def test_get_bcache_using_dev(self, mock_os, mock_block): | 90 | def test_get_bcache_using_dev(self, mock_os, mock_block): |
| 292 | 90 | """Ensure that get_bcache_using_dev works""" | 91 | """Ensure that get_bcache_using_dev works""" |
| 293 | 91 | fake_bcache = '/sys/fs/bcache/fake' | 92 | fake_bcache = '/sys/fs/bcache/fake' |
| 294 | 93 | mock_os.path.join.side_effect = os.path.join | ||
| 295 | 94 | mock_block.sys_block_path.return_value = self.test_syspath | ||
| 296 | 92 | mock_os.path.realpath.return_value = fake_bcache | 95 | mock_os.path.realpath.return_value = fake_bcache |
| 299 | 93 | mock_os.path.exists.side_effect = lambda x: x == fake_bcache | 96 | |
| 298 | 94 | mock_block.sys_block_path.return_value = self.test_blockdev | ||
| 300 | 95 | bcache_dir = clear_holders.get_bcache_using_dev(self.test_blockdev) | 97 | bcache_dir = clear_holders.get_bcache_using_dev(self.test_blockdev) |
| 301 | 98 | mock_os.path.realpath.assert_called_with(self.test_syspath + | ||
| 302 | 99 | '/bcache/cache') | ||
| 303 | 96 | self.assertEqual(bcache_dir, fake_bcache) | 100 | self.assertEqual(bcache_dir, fake_bcache) |
| 304 | 97 | 101 | ||
| 305 | 102 | @mock.patch('curtin.block.clear_holders.os') | ||
| 306 | 103 | @mock.patch('curtin.block.clear_holders.block') | ||
| 307 | 104 | def test_get_bcache_sys_path(self, mock_block, mock_os): | ||
| 308 | 105 | fake_backing = '/sys/class/block/fake' | ||
| 309 | 106 | mock_block.sys_block_path.return_value = fake_backing | ||
| 310 | 107 | mock_os.path.join.side_effect = os.path.join | ||
| 311 | 108 | mock_os.path.exists.return_value = True | ||
| 312 | 109 | bcache_dir = clear_holders.get_bcache_sys_path("/dev/fake") | ||
| 313 | 110 | self.assertEqual(bcache_dir, fake_backing + "/bcache") | ||
| 314 | 111 | |||
| 315 | 98 | @mock.patch('curtin.block.clear_holders.get_dmsetup_uuid') | 112 | @mock.patch('curtin.block.clear_holders.get_dmsetup_uuid') |
| 316 | 99 | @mock.patch('curtin.block.clear_holders.block') | 113 | @mock.patch('curtin.block.clear_holders.block') |
| 317 | 100 | def test_differentiate_lvm_and_crypt( | 114 | def test_differentiate_lvm_and_crypt( |
| 318 | @@ -115,22 +129,197 @@ | |||
| 319 | 115 | mock_block.path_to_kname.assert_called_with(self.test_syspath) | 129 | mock_block.path_to_kname.assert_called_with(self.test_syspath) |
| 320 | 116 | mock_get_dmsetup_uuid.assert_called_with(self.test_syspath) | 130 | mock_get_dmsetup_uuid.assert_called_with(self.test_syspath) |
| 321 | 117 | 131 | ||
| 322 | 132 | @mock.patch('curtin.block.clear_holders.get_bcache_sys_path') | ||
| 323 | 118 | @mock.patch('curtin.block.clear_holders.util') | 133 | @mock.patch('curtin.block.clear_holders.util') |
| 324 | 119 | @mock.patch('curtin.block.clear_holders.os') | 134 | @mock.patch('curtin.block.clear_holders.os') |
| 325 | 120 | @mock.patch('curtin.block.clear_holders.LOG') | 135 | @mock.patch('curtin.block.clear_holders.LOG') |
| 326 | 121 | @mock.patch('curtin.block.clear_holders.get_bcache_using_dev') | 136 | @mock.patch('curtin.block.clear_holders.get_bcache_using_dev') |
| 327 | 122 | def test_shutdown_bcache(self, mock_get_bcache, mock_log, mock_os, | 137 | def test_shutdown_bcache(self, mock_get_bcache, mock_log, mock_os, |
| 329 | 123 | mock_util): | 138 | mock_util, mock_get_bcache_block): |
| 330 | 124 | """test clear_holders.shutdown_bcache""" | 139 | """test clear_holders.shutdown_bcache""" |
| 331 | 140 | # | ||
| 332 | 141 | # pass in a sysfs path to a bcache block device, | ||
| 333 | 142 | # determine the bcache cset it is part of (or not) | ||
| 334 | 143 | # 1) stop the cset device (if it's enabled) | ||
| 335 | 144 | # 2) wait on cset to be removed if it was present | ||
| 336 | 145 | # 3) stop the block device (if it's still present after stopping cset) | ||
| 337 | 146 | # 4) wait on bcache block device to be removed | ||
| 338 | 147 | # | ||
| 339 | 148 | |||
| 340 | 149 | device = self.test_syspath | ||
| 341 | 150 | bcache_cset_uuid = 'c08ae789-a964-46fb-a66e-650f0ae78f94' | ||
| 342 | 151 | |||
| 343 | 125 | mock_os.path.exists.return_value = True | 152 | mock_os.path.exists.return_value = True |
| 344 | 126 | mock_os.path.join.side_effect = os.path.join | 153 | mock_os.path.join.side_effect = os.path.join |
| 349 | 127 | mock_get_bcache.return_value = self.test_blockdev | 154 | # os.path.realpath on symlink of /sys/class/block/null/bcache/cache -> |
| 350 | 128 | clear_holders.shutdown_bcache(self.test_syspath) | 155 | # to /sys/fs/bcache/cset_UUID |
| 351 | 129 | mock_get_bcache.assert_called_with(self.test_syspath) | 156 | mock_get_bcache.return_value = '/sys/fs/bcache/' + bcache_cset_uuid |
| 352 | 130 | self.assertTrue(mock_log.debug.called) | 157 | mock_get_bcache_block.return_value = device + '/bcache' |
| 353 | 158 | |||
| 354 | 159 | clear_holders.shutdown_bcache(device) | ||
| 355 | 160 | |||
| 356 | 161 | mock_get_bcache.assert_called_with(device) | ||
| 357 | 162 | mock_get_bcache_block.assert_called_with(device) | ||
| 358 | 163 | |||
| 359 | 164 | self.assertTrue(mock_log.info.called) | ||
| 360 | 131 | self.assertFalse(mock_log.warn.called) | 165 | self.assertFalse(mock_log.warn.called) |
| 362 | 132 | mock_util.write_file.assert_called_with(self.test_blockdev + '/stop', | 166 | mock_util.wait_for_removal.assert_has_calls([ |
| 363 | 167 | mock.call('/sys/fs/bcache/' + bcache_cset_uuid, | ||
| 364 | 168 | retries=self.remove_retries), | ||
| 365 | 169 | mock.call(device, retries=self.remove_retries)]) | ||
| 366 | 170 | |||
| 367 | 171 | mock_util.write_file.assert_has_calls([ | ||
| 368 | 172 | mock.call('/sys/fs/bcache/%s/stop' % bcache_cset_uuid, | ||
| 369 | 173 | '1', mode=None), | ||
| 370 | 174 | mock.call(device + '/bcache/stop', | ||
| 371 | 175 | '1', mode=None)]) | ||
| 372 | 176 | |||
| 373 | 177 | @mock.patch('curtin.block.clear_holders.get_bcache_sys_path') | ||
| 374 | 178 | @mock.patch('curtin.block.clear_holders.util') | ||
| 375 | 179 | @mock.patch('curtin.block.clear_holders.os') | ||
| 376 | 180 | @mock.patch('curtin.block.clear_holders.LOG') | ||
| 377 | 181 | @mock.patch('curtin.block.clear_holders.get_bcache_using_dev') | ||
| 378 | 182 | def test_shutdown_bcache_non_sysfs_device(self, mock_get_bcache, mock_log, | ||
| 379 | 183 | mock_os, mock_util, | ||
| 380 | 184 | mock_get_bcache_block): | ||
| 381 | 185 | device = "/dev/fakenull" | ||
| 382 | 186 | with self.assertRaises(ValueError): | ||
| 383 | 187 | clear_holders.shutdown_bcache(device) | ||
| 384 | 188 | |||
| 385 | 189 | self.assertEqual(0, len(mock_get_bcache.call_args_list)) | ||
| 386 | 190 | self.assertEqual(0, len(mock_log.call_args_list)) | ||
| 387 | 191 | self.assertEqual(0, len(mock_os.call_args_list)) | ||
| 388 | 192 | self.assertEqual(0, len(mock_util.call_args_list)) | ||
| 389 | 193 | self.assertEqual(0, len(mock_get_bcache_block.call_args_list)) | ||
| 390 | 194 | |||
| 391 | 195 | @mock.patch('curtin.block.clear_holders.get_bcache_sys_path') | ||
| 392 | 196 | @mock.patch('curtin.block.clear_holders.util') | ||
| 393 | 197 | @mock.patch('curtin.block.clear_holders.os') | ||
| 394 | 198 | @mock.patch('curtin.block.clear_holders.LOG') | ||
| 395 | 199 | @mock.patch('curtin.block.clear_holders.get_bcache_using_dev') | ||
| 396 | 200 | def test_shutdown_bcache_no_device(self, mock_get_bcache, mock_log, | ||
| 397 | 201 | mock_os, mock_util, | ||
| 398 | 202 | mock_get_bcache_block): | ||
| 399 | 203 | device = "/sys/class/block/null" | ||
| 400 | 204 | mock_os.path.exists.return_value = False | ||
| 401 | 205 | |||
| 402 | 206 | clear_holders.shutdown_bcache(device) | ||
| 403 | 207 | |||
| 404 | 208 | self.assertEqual(1, len(mock_log.info.call_args_list)) | ||
| 405 | 209 | self.assertEqual(1, len(mock_os.path.exists.call_args_list)) | ||
| 406 | 210 | self.assertEqual(0, len(mock_get_bcache.call_args_list)) | ||
| 407 | 211 | self.assertEqual(0, len(mock_util.call_args_list)) | ||
| 408 | 212 | self.assertEqual(0, len(mock_get_bcache_block.call_args_list)) | ||
| 409 | 213 | |||
| 410 | 214 | @mock.patch('curtin.block.clear_holders.get_bcache_sys_path') | ||
| 411 | 215 | @mock.patch('curtin.block.clear_holders.util') | ||
| 412 | 216 | @mock.patch('curtin.block.clear_holders.os') | ||
| 413 | 217 | @mock.patch('curtin.block.clear_holders.LOG') | ||
| 414 | 218 | @mock.patch('curtin.block.clear_holders.get_bcache_using_dev') | ||
| 415 | 219 | def test_shutdown_bcache_no_cset(self, mock_get_bcache, mock_log, | ||
| 416 | 220 | mock_os, mock_util, | ||
| 417 | 221 | mock_get_bcache_block): | ||
| 418 | 222 | device = "/sys/class/block/null" | ||
| 419 | 223 | mock_os.path.exists.side_effect = iter([ | ||
| 420 | 224 | True, # backing device exists | ||
| 421 | 225 | False, # cset device not present (already removed) | ||
| 422 | 226 | True, # backing device (still) exists | ||
| 423 | 227 | ]) | ||
| 424 | 228 | mock_get_bcache.return_value = '/sys/fs/bcache/fake' | ||
| 425 | 229 | mock_get_bcache_block.return_value = device + '/bcache' | ||
| 426 | 230 | mock_os.path.join.side_effect = os.path.join | ||
| 427 | 231 | |||
| 428 | 232 | clear_holders.shutdown_bcache(device) | ||
| 429 | 233 | |||
| 430 | 234 | self.assertEqual(2, len(mock_log.info.call_args_list)) | ||
| 431 | 235 | self.assertEqual(3, len(mock_os.path.exists.call_args_list)) | ||
| 432 | 236 | self.assertEqual(1, len(mock_get_bcache.call_args_list)) | ||
| 433 | 237 | self.assertEqual(1, len(mock_get_bcache_block.call_args_list)) | ||
| 434 | 238 | self.assertEqual(1, len(mock_util.write_file.call_args_list)) | ||
| 435 | 239 | self.assertEqual(1, len(mock_util.wait_for_removal.call_args_list)) | ||
| 436 | 240 | |||
| 437 | 241 | mock_get_bcache.assert_called_with(device) | ||
| 438 | 242 | mock_get_bcache_block.assert_called_with(device) | ||
| 439 | 243 | mock_util.write_file.assert_called_with(device + '/bcache/stop', | ||
| 440 | 133 | '1', mode=None) | 244 | '1', mode=None) |
| 441 | 245 | retries = self.remove_retries | ||
| 442 | 246 | mock_util.wait_for_removal.assert_called_with(device, retries=retries) | ||
| 443 | 247 | |||
| 444 | 248 | @mock.patch('curtin.block.clear_holders.get_bcache_sys_path') | ||
| 445 | 249 | @mock.patch('curtin.block.clear_holders.util') | ||
| 446 | 250 | @mock.patch('curtin.block.clear_holders.os') | ||
| 447 | 251 | @mock.patch('curtin.block.clear_holders.LOG') | ||
| 448 | 252 | @mock.patch('curtin.block.clear_holders.get_bcache_using_dev') | ||
| 449 | 253 | def test_shutdown_bcache_delete_cset_and_backing(self, mock_get_bcache, | ||
| 450 | 254 | mock_log, mock_os, | ||
| 451 | 255 | mock_util, | ||
| 452 | 256 | mock_get_bcache_block): | ||
| 453 | 257 | device = "/sys/class/block/null" | ||
| 454 | 258 | mock_os.path.exists.side_effect = iter([ | ||
| 455 | 259 | True, # backing device exists | ||
| 456 | 260 | True, # cset device not present (already removed) | ||
| 457 | 261 | True, # backing device (still) exists | ||
| 458 | 262 | ]) | ||
| 459 | 263 | cset = '/sys/fs/bcache/fake' | ||
| 460 | 264 | mock_get_bcache.return_value = cset | ||
| 461 | 265 | mock_get_bcache_block.return_value = device + '/bcache' | ||
| 462 | 266 | mock_os.path.join.side_effect = os.path.join | ||
| 463 | 267 | |||
| 464 | 268 | clear_holders.shutdown_bcache(device) | ||
| 465 | 269 | |||
| 466 | 270 | self.assertEqual(2, len(mock_log.info.call_args_list)) | ||
| 467 | 271 | self.assertEqual(3, len(mock_os.path.exists.call_args_list)) | ||
| 468 | 272 | self.assertEqual(1, len(mock_get_bcache.call_args_list)) | ||
| 469 | 273 | self.assertEqual(1, len(mock_get_bcache_block.call_args_list)) | ||
| 470 | 274 | self.assertEqual(2, len(mock_util.write_file.call_args_list)) | ||
| 471 | 275 | self.assertEqual(2, len(mock_util.wait_for_removal.call_args_list)) | ||
| 472 | 276 | |||
| 473 | 277 | mock_get_bcache.assert_called_with(device) | ||
| 474 | 278 | mock_get_bcache_block.assert_called_with(device) | ||
| 475 | 279 | mock_util.write_file.assert_has_calls([ | ||
| 476 | 280 | mock.call(cset + '/stop', '1', mode=None), | ||
| 477 | 281 | mock.call(device + '/bcache/stop', '1', mode=None)]) | ||
| 478 | 282 | mock_util.wait_for_removal.assert_has_calls([ | ||
| 479 | 283 | mock.call(cset, retries=self.remove_retries), | ||
| 480 | 284 | mock.call(device, retries=self.remove_retries) | ||
| 481 | 285 | ]) | ||
| 482 | 286 | |||
| 483 | 287 | @mock.patch('curtin.block.clear_holders.get_bcache_sys_path') | ||
| 484 | 288 | @mock.patch('curtin.block.clear_holders.util') | ||
| 485 | 289 | @mock.patch('curtin.block.clear_holders.os') | ||
| 486 | 290 | @mock.patch('curtin.block.clear_holders.LOG') | ||
| 487 | 291 | @mock.patch('curtin.block.clear_holders.get_bcache_using_dev') | ||
| 488 | 292 | def test_shutdown_bcache_delete_cset_no_backing(self, mock_get_bcache, | ||
| 489 | 293 | mock_log, mock_os, | ||
| 490 | 294 | mock_util, | ||
| 491 | 295 | mock_get_bcache_block): | ||
| 492 | 296 | device = "/sys/class/block/null" | ||
| 493 | 297 | mock_os.path.exists.side_effect = iter([ | ||
| 494 | 298 | True, # backing device exists | ||
| 495 | 299 | True, # cset device not present (already removed) | ||
| 496 | 300 | False, # backing device is removed with cset | ||
| 497 | 301 | ]) | ||
| 498 | 302 | cset = '/sys/fs/bcache/fake' | ||
| 499 | 303 | mock_get_bcache.return_value = cset | ||
| 500 | 304 | mock_get_bcache_block.return_value = device + '/bcache' | ||
| 501 | 305 | mock_os.path.join.side_effect = os.path.join | ||
| 502 | 306 | |||
| 503 | 307 | clear_holders.shutdown_bcache(device) | ||
| 504 | 308 | |||
| 505 | 309 | self.assertEqual(2, len(mock_log.info.call_args_list)) | ||
| 506 | 310 | self.assertEqual(3, len(mock_os.path.exists.call_args_list)) | ||
| 507 | 311 | self.assertEqual(1, len(mock_get_bcache.call_args_list)) | ||
| 508 | 312 | self.assertEqual(0, len(mock_get_bcache_block.call_args_list)) | ||
| 509 | 313 | self.assertEqual(1, len(mock_util.write_file.call_args_list)) | ||
| 510 | 314 | self.assertEqual(1, len(mock_util.wait_for_removal.call_args_list)) | ||
| 511 | 315 | |||
| 512 | 316 | mock_get_bcache.assert_called_with(device) | ||
| 513 | 317 | mock_util.write_file.assert_has_calls([ | ||
| 514 | 318 | mock.call(cset + '/stop', '1', mode=None), | ||
| 515 | 319 | ]) | ||
| 516 | 320 | mock_util.wait_for_removal.assert_has_calls([ | ||
| 517 | 321 | mock.call(cset, retries=self.remove_retries) | ||
| 518 | 322 | ]) | ||
| 519 | 134 | 323 | ||
| 520 | 135 | @mock.patch('curtin.block.clear_holders.LOG') | 324 | @mock.patch('curtin.block.clear_holders.LOG') |
| 521 | 136 | @mock.patch('curtin.block.clear_holders.block.sys_block_path') | 325 | @mock.patch('curtin.block.clear_holders.block.sys_block_path') |
| 522 | 137 | 326 | ||
| 523 | === modified file 'tests/unittests/test_util.py' | |||
| 524 | --- tests/unittests/test_util.py 2017-04-07 20:12:45 +0000 | |||
| 525 | +++ tests/unittests/test_util.py 2017-04-24 17:53:29 +0000 | |||
| 526 | @@ -614,4 +614,73 @@ | |||
| 527 | 614 | except KeyError as e: | 614 | except KeyError as e: |
| 528 | 615 | self.fail("unexpected key error raised: %s" % e) | 615 | self.fail("unexpected key error raised: %s" % e) |
| 529 | 616 | 616 | ||
| 530 | 617 | |||
| 531 | 618 | class TestWaitForRemoval(TestCase): | ||
| 532 | 619 | def test_wait_for_removal_missing_path(self): | ||
| 533 | 620 | with self.assertRaises(ValueError): | ||
| 534 | 621 | util.wait_for_removal(None) | ||
| 535 | 622 | |||
| 536 | 623 | @mock.patch('curtin.util.time') | ||
| 537 | 624 | @mock.patch('curtin.util.os') | ||
| 538 | 625 | def test_wait_for_removal(self, mock_os, mock_time): | ||
| 539 | 626 | path = "/file/to/remove" | ||
| 540 | 627 | mock_os.path.exists.side_effect = iter([ | ||
| 541 | 628 | True, # File is not yet removed | ||
| 542 | 629 | False, # File has been removed | ||
| 543 | 630 | ]) | ||
| 544 | 631 | |||
| 545 | 632 | util.wait_for_removal(path) | ||
| 546 | 633 | |||
| 547 | 634 | self.assertEqual(2, len(mock_os.path.exists.call_args_list)) | ||
| 548 | 635 | self.assertEqual(1, len(mock_time.sleep.call_args_list)) | ||
| 549 | 636 | mock_os.path.exists.assert_has_calls([ | ||
| 550 | 637 | mock.call(path), | ||
| 551 | 638 | mock.call(path), | ||
| 552 | 639 | ]) | ||
| 553 | 640 | mock_time.sleep.assert_has_calls([ | ||
| 554 | 641 | mock.call(1), | ||
| 555 | 642 | ]) | ||
| 556 | 643 | |||
| 557 | 644 | @mock.patch('curtin.util.time') | ||
| 558 | 645 | @mock.patch('curtin.util.os') | ||
| 559 | 646 | def test_wait_for_removal_timesout(self, mock_os, mock_time): | ||
| 560 | 647 | path = "/file/to/remove" | ||
| 561 | 648 | mock_os.path.exists.return_value = True | ||
| 562 | 649 | |||
| 563 | 650 | with self.assertRaises(OSError): | ||
| 564 | 651 | util.wait_for_removal(path) | ||
| 565 | 652 | |||
| 566 | 653 | self.assertEqual(5, len(mock_os.path.exists.call_args_list)) | ||
| 567 | 654 | self.assertEqual(4, len(mock_time.sleep.call_args_list)) | ||
| 568 | 655 | mock_os.path.exists.assert_has_calls(5 * [mock.call(path)]) | ||
| 569 | 656 | mock_time.sleep.assert_has_calls([ | ||
| 570 | 657 | mock.call(1), | ||
| 571 | 658 | mock.call(3), | ||
| 572 | 659 | mock.call(5), | ||
| 573 | 660 | mock.call(7), | ||
| 574 | 661 | ]) | ||
| 575 | 662 | |||
| 576 | 663 | @mock.patch('curtin.util.time') | ||
| 577 | 664 | @mock.patch('curtin.util.os') | ||
| 578 | 665 | def test_wait_for_removal_custom_retry(self, mock_os, mock_time): | ||
| 579 | 666 | path = "/file/to/remove" | ||
| 580 | 667 | timeout = 100 | ||
| 581 | 668 | mock_os.path.exists.side_effect = iter([ | ||
| 582 | 669 | True, # File is not yet removed | ||
| 583 | 670 | False, # File has been removed | ||
| 584 | 671 | ]) | ||
| 585 | 672 | |||
| 586 | 673 | util.wait_for_removal(path, retries=[timeout]) | ||
| 587 | 674 | |||
| 588 | 675 | self.assertEqual(2, len(mock_os.path.exists.call_args_list)) | ||
| 589 | 676 | self.assertEqual(1, len(mock_time.sleep.call_args_list)) | ||
| 590 | 677 | mock_os.path.exists.assert_has_calls([ | ||
| 591 | 678 | mock.call(path), | ||
| 592 | 679 | mock.call(path), | ||
| 593 | 680 | ]) | ||
| 594 | 681 | mock_time.sleep.assert_has_calls([ | ||
| 595 | 682 | mock.call(timeout), | ||
| 596 | 683 | ]) | ||
| 597 | 684 | |||
| 598 | 685 | |||
| 599 | 617 | # vi: ts=4 expandtab syntax=python | 686 | # vi: ts=4 expandtab syntax=python |
| 600 | 618 | 687 | ||
| 601 | === modified file 'tests/vmtests/test_nvme.py' | |||
| 602 | --- tests/vmtests/test_nvme.py 2017-02-22 01:42:16 +0000 | |||
| 603 | +++ tests/vmtests/test_nvme.py 2017-04-24 17:53:29 +0000 | |||
| 604 | @@ -99,3 +99,80 @@ | |||
| 605 | 99 | 99 | ||
| 606 | 100 | class ZestyTestNvme(relbase.zesty, TestNvmeAbs): | 100 | class ZestyTestNvme(relbase.zesty, TestNvmeAbs): |
| 607 | 101 | __test__ = True | 101 | __test__ = True |
| 608 | 102 | |||
| 609 | 103 | |||
| 610 | 104 | class TestNvmeBcacheAbs(VMBaseClass): | ||
| 611 | 105 | arch_skip = [ | ||
| 612 | 106 | "s390x", # nvme is a pci device, no pci on s390x | ||
| 613 | 107 | ] | ||
| 614 | 108 | interactive = False | ||
| 615 | 109 | conf_file = "examples/tests/nvme_bcache.yaml" | ||
| 616 | 110 | extra_disks = ['10G'] | ||
| 617 | 111 | nvme_disks = ['6G'] | ||
| 618 | 112 | uefi = True | ||
| 619 | 113 | disk_to_check = [('sda', 1), ('sda', 2), ('sda', 3)] | ||
| 620 | 114 | |||
| 621 | 115 | collect_scripts = [textwrap.dedent(""" | ||
| 622 | 116 | cd OUTPUT_COLLECT_D | ||
| 623 | 117 | ls /sys/class/ > sys_class | ||
| 624 | 118 | ls /sys/class/nvme/ > ls_nvme | ||
| 625 | 119 | ls /dev/nvme* > ls_dev_nvme | ||
| 626 | 120 | ls /dev/disk/by-dname/ > ls_dname | ||
| 627 | 121 | ls -al /dev/bcache/by-uuid/ > ls_bcache_by_uuid |: | ||
| 628 | 122 | blkid -o export /dev/vda > blkid_output_vda | ||
| 629 | 123 | blkid -o export /dev/vda1 > blkid_output_vda1 | ||
| 630 | 124 | blkid -o export /dev/vda2 > blkid_output_vda2 | ||
| 631 | 125 | bcache-super-show /dev/nvme0n1p1 > bcache_super_nvme0n1p1 | ||
| 632 | 126 | ls /sys/fs/bcache > bcache_ls | ||
| 633 | 127 | cat /sys/block/bcache0/bcache/cache_mode > bcache_cache_mode | ||
| 634 | 128 | cat /proc/partitions > proc_partitions | ||
| 635 | 129 | ls -al /dev/disk/by-uuid/ > ls_uuid | ||
| 636 | 130 | cat /etc/fstab > fstab | ||
| 637 | 131 | mkdir -p /dev/disk/by-dname | ||
| 638 | 132 | ls /dev/disk/by-dname/ > ls_dname | ||
| 639 | 133 | find /etc/network/interfaces.d > find_interfacesd | ||
| 640 | 134 | |||
| 641 | 135 | v="" | ||
| 642 | 136 | out=$(apt-config shell v Acquire::HTTP::Proxy) | ||
| 643 | 137 | eval "$out" | ||
| 644 | 138 | echo "$v" > apt-proxy | ||
| 645 | 139 | """)] | ||
| 646 | 140 | |||
| 647 | 141 | def test_output_files_exist(self): | ||
| 648 | 142 | self.output_files_exist(["ls_nvme", "ls_dname", "ls_dev_nvme"]) | ||
| 649 | 143 | |||
| 650 | 144 | def test_nvme_device_names(self): | ||
| 651 | 145 | ls_nvme = os.path.join(self.td.collect, 'ls_nvme') | ||
| 652 | 146 | # trusty and vivid do not have sys/class/nvme but | ||
| 653 | 147 | # nvme devices do work | ||
| 654 | 148 | if os.path.getsize(ls_nvme) > 0: | ||
| 655 | 149 | self.check_file_strippedline("ls_nvme", "nvme0") | ||
| 656 | 150 | else: | ||
| 657 | 151 | self.check_file_strippedline("ls_dev_nvme", "/dev/nvme0") | ||
| 658 | 152 | self.check_file_strippedline("ls_dev_nvme", "/dev/nvme0n1") | ||
| 659 | 153 | self.check_file_strippedline("ls_dev_nvme", "/dev/nvme0n1p1") | ||
| 660 | 154 | |||
| 661 | 155 | def test_bcache_output_files_exist(self): | ||
| 662 | 156 | self.output_files_exist(["bcache_super_nvme0n1p1", "bcache_ls", | ||
| 663 | 157 | "bcache_cache_mode"]) | ||
| 664 | 158 | |||
| 665 | 159 | def test_bcache_status(self): | ||
| 666 | 160 | bcache_cset_uuid = None | ||
| 667 | 161 | bcache_super = self.load_collect_file("bcache_super_nvme0n1p1") | ||
| 668 | 162 | for line in bcache_super.splitlines(): | ||
| 669 | 163 | if line != "" and line.split()[0] == "cset.uuid": | ||
| 670 | 164 | bcache_cset_uuid = line.split()[-1].rstrip() | ||
| 671 | 165 | self.assertIsNotNone(bcache_cset_uuid) | ||
| 672 | 166 | self.assertTrue(bcache_cset_uuid in | ||
| 673 | 167 | self.load_collect_file("bcache_ls").splitlines()) | ||
| 674 | 168 | |||
| 675 | 169 | def test_bcache_cachemode(self): | ||
| 676 | 170 | self.check_file_regex("bcache_cache_mode", r"\[writeback\]") | ||
| 677 | 171 | |||
| 678 | 172 | |||
| 679 | 173 | class XenialTestNvmeBcache(relbase.xenial, TestNvmeBcacheAbs): | ||
| 680 | 174 | __test__ = True | ||
| 681 | 175 | |||
| 682 | 176 | |||
| 683 | 177 | class ZestyTestNvmeBcache(relbase.zesty, TestNvmeBcacheAbs): | ||
| 684 | 178 | __test__ = True | ||
PASSED: Continuous integration, rev:492
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
Click here to trigger a rebuild:
https:/