Merge lp:~darkmuggle-deactivatedaccount/cloud-init/lp-1233698 into lp:~cloud-init-dev/cloud-init/trunk

[Ben Howard]

Fix for bug #1233698 and Windows Azure's default NTFS ephemeral device.

[Scott Moser (smoser)]

There is really no reason for:
 dd_cmd = util.which("dd")
 subp(dd_cmd)

That is identical to:
 subp(dd_cmd)

purge_disk doesn't seem that it should be something that is partition table specific.
The end result is that you have an unpartitioned disk.

A "wipe the disk" method might look like this:
 def wipe_disk(devname):
   for f in $devname[0-9]*:
      [ -b "$f" ] && wipefs $f || :

   dd if=/dev/zero of=$devname
   out=$(dd if=/dev/zero of="$target" bs=1024 \
          seek=$(($size-1024)) count=1024 2>&1)
   blockdev --rereadpt $devname
   udevadm settle

Interestingly, as you've found, an attempt to "wipe" a disk and then partition it, and then mkfs might end up in there being an existing filesystem at any of the new partitions (ie, if the old disk format had partitions there).
So really what you'd need to do is:
 erase partition tables (gpt is at end and beginning, so zero the first MB and last MB)
 format disk
 rereadpt && udevadm settle
 'wipefs' all partitions
 mkfs

Doing that would actually mean we do not have to pass '-F' to mkfs.extX (note, that -F is not common to all'mkfs' programs so 'mkfs.$FSTYPE -F' wont necessarily work).

Probably could also get away with just calling 'wipefs --all $dev' before formatting.

I'm not sure really what i htink about changing the builtin defaults to overwrite filesystems on azure. that seems dangerous. better if we coudl identify this one scenario and wipe it.

[Scott Moser (smoser)]

for reference:
 $ sudo lsblk /dev/sdb
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sdb 8:16 0 20G 0 disk
└─sdb1 8:17 0 20G 0 part

$ sudo blkid /dev/sdb1
/dev/sdb1: LABEL="Temporary Storage" UUID="E4227FB4227F89F6" TYPE="ntfs"

[Ben Howard (darkmuggle-deactivatedaccount)]

Okay, so there are a couple issues....

First, the use of the device mapping is screwy. The argument against mapping ephemeral0 to /dev/vdb1 (i.e. partition) was that a device should be a device, not a parition. The problem is tha the usage of cloud.get_device_name() in cc_mounts assumes that the device contains a file system and not a partition. That means that the meaning of ephemeral0 and swap are constrained to be on a raw devices only....

But that creates a bigger problem. Previously you stated that you don't want to force the creation of a filesystem. On 12.10 and later, mkfs.ext{2,3,4} refuse to build a file system on a block device (only partitions and special block devices are allowed) with out forcing it.

So this latest merge proposal contains a few work arounds:
1. For SmartOS, the creation is forced because it should be the raw device
2. For Windows Azure, ephemeral0 is defined as /dev/sdb1.
3. For Windows Azure, I added the 'replace_fs' as a means to replace a matching filesystem. This leaves the partition table and the other bits intact, while simply replacing the NTFS filesystem with a ext4 filesystem
4. There is code for the removal of a partition table and all dependant filesystems. It works, but is not used right now.

[lp:~darkmuggle-deactivatedaccount/cloud-init/lp-1233698]

881. By Scott Moser on 2013-10-02

examples/cloud-config-user-groups.txt doc fix, fix pep8

fix documentation of mkpasswd usage in
doc/examples/cloud-config-user-groups.txt

Also, Precise's version of pep8 insists on ordering of imports, but saucy's
has not. So we had some incorrect ordering. This fixes './tools/run-pep8'
on precise.

882. By Ben Howard on 2013-10-02

Added ability to define disks via 'ephemeralX.Y'.
Modified cc_mounts to identify whether ephermalX is partitioned.
Changed datasources for Azure and SmartOS to use 'ephemeralX.Y' format.
Added disk remove functionally

883. By Scott Moser on 2013-10-03

merge from trunk

884. By Scott Moser on 2013-10-03

fix pep8

885. By Scott Moser on 2013-10-03

use native python code for wiping partition table

I'm pretty sure the previous code wasn't seeking correctly
and probably writing near the end, but not to the end.

This is simpler and probably faster.

886. By Scott Moser on 2013-10-03

remove verbosity of log.info

887. By Ben Howard on 2013-10-03

Moved ephemeralX.Y handling from Datasource into the cc_disk_setup, which makes it cloud agnostic.

888. By Ben Howard on 2013-10-03

Configure SmartOS Datasource to be region aware

889. By Ben Howard on 2013-10-03

Wrapped use of 'lsblk' to a generator function; removed other fcalls to 'lsblk'

890. By Ben Howard on 2013-10-03

Make {pep8,pylint,test} pass commit.

891. By Ben Howard on 2013-10-03

Added support for 'ephmeral0.<auto|any|0>' for device mappings in disk
formating support.

=== modified file 'cloudinit/config/cc_disk_setup.py'
--- cloudinit/config/cc_disk_setup.py	2013-10-02 13:25:36 +0000
+++ cloudinit/config/cc_disk_setup.py	2013-10-03 23:32:32 +0000
@@ -19,6 +19,7 @@
 from cloudinit.settings import PER_INSTANCE
 from cloudinit import util
 import logging
+import os
 import shlex
 
 frequency = PER_INSTANCE
@@ -29,13 +30,13 @@
 LSBLK_CMD = util.which("lsblk")
 BLKID_CMD = util.which("blkid")
 BLKDEV_CMD = util.which("blockdev")
+WIPEFS_CMD = util.which("wipefs")
 
 LOG = logging.getLogger(__name__)
 
 
 def handle(_name, cfg, cloud, log, _args):
     """
-    Call util.prep_disk for disk_setup cloud-config.
     See doc/examples/cloud-config_disk-setup.txt for documentation on the
     format.
     """
@@ -93,6 +94,15 @@
         LOG.debug("updated disk_setup device entry '%s' to '%s'",
                   origname, transformed)
 
+def reset_part_definition(definition, value):
+    if not value and 'partition' in definition:
+        definition['opartition'] = definition['partition']
+        del definition['partition']
+
+    else:
+        definition['partition'] = value
+
+    return definition
 
 def update_fs_setup_devices(disk_setup, tformer):
     # update 'fs_setup' dictionary anywhere were a device may occur
@@ -103,13 +113,40 @@
             continue
 
         origname = definition.get('device')
+
         if origname is None:
             continue
 
-        transformed = tformer(origname)
+        transformed = None
+        if len(origname.split('.')) == 2:
+            # this maps ephemeralX.Y to a proper disk name. For example,
+            # if the origname is 'ephemeral0.1' and transformed is /dev/sdb
+            # then the returned device will be /dev/sdb1 _if_ /dev/sdb1 exists
+            # otherwise NONE
+            base_name, partition = origname.split('.')
+            tformed = tformer(base_name)
+            LOG.info("base device for %s is %s" % (origname, tformed))
+
+            if partition == "0":
+                transformed = tformed
+                definition = reset_part_definition(definition, None)
+
+            elif partition in ("auto", "any"):
+                definition = reset_part_definition(definition, partition)
+                transformed = tformed
+
+            else:
+                definition = reset_part_definition(definition, None)
+                transformed = util.map_device_alias(tformed, alias=origname)
+                LOG.info("%s is mapped to %s" % (origname, transformed))
+
+        else:
+            transformed = tformer(origname)
+
         if transformed is None or transformed == origname:
             continue
 
+        LOG.info("Mapped %s to physical device %s" % (origname, transformed))
         definition['_origname'] = origname
         definition['device'] = transformed
 
@@ -127,23 +164,56 @@
         yield key, value
 
 
+def enumerate_disk(device, nodeps=False):
+    """
+    Enumerate the elements of a child device.
+
+    Parameters:
+        device: the kernel device name
+        nodeps <BOOL>: don't enumerate children devices
+
+    Return a dict describing the disk:
+        type: the entry type, i.e disk or part
+        fstype: the filesystem type, if it exists
+        label: file system label, if it exists
+        name: the device name, i.e. sda
+    """
+
+    lsblk_cmd = [LSBLK_CMD, '--pairs', '--out', 'NAME,TYPE,FSTYPE,LABEL',
+                 device]
+
+    if nodeps:
+        lsblk_cmd.append('--nodeps')
+
+    info = None
+    try:
+        info, _err = util.subp(lsblk_cmd)
+    except Exception as e:
+        raise Exception("Failed during disk check for %s\n%s" % (device, e))
+
+    parts = [x for x in (info.strip()).splitlines() if len(x.split()) > 0]
+
+    for part in parts:
+        d = {'name': None,
+             'type': None,
+             'fstype': None,
+             'label': None,
+            }
+
+        for key, value in value_splitter(part):
+            d[key.lower()] = value
+
+        yield d
+
+
 def device_type(device):
     """
     Return the device type of the device by calling lsblk.
     """
 
-    lsblk_cmd = [LSBLK_CMD, '--pairs', '--nodeps', '--out', 'NAME,TYPE',
-                 device]
-    info = None
-    try:
-        info, _err = util.subp(lsblk_cmd)
-    except Exception as e:
-        raise Exception("Failed during disk check for %s\n%s" % (device, e))
-
-    for key, value in value_splitter(info):
-        if key.lower() == "type":
-            return value.lower()
-
+    for d in enumerate_disk(device, nodeps=True):
+        if "type" in d:
+            return d["type"].lower()
     return None
 
 
@@ -204,7 +274,7 @@
 
 
 def find_device_node(device, fs_type=None, label=None, valid_targets=None,
-                     label_match=True):
+                     label_match=True, replace_fs=None):
     """
     Find a device that is either matches the spec, or the first
 
@@ -221,26 +291,12 @@
     if not valid_targets:
         valid_targets = ['disk', 'part']
 
-    lsblk_cmd = [LSBLK_CMD, '--pairs', '--out', 'NAME,TYPE,FSTYPE,LABEL',
-                 device]
-    info = None
-    try:
-        info, _err = util.subp(lsblk_cmd)
-    except Exception as e:
-        raise Exception("Failed during disk check for %s\n%s" % (device, e))
-
     raw_device_used = False
-    parts = [x for x in (info.strip()).splitlines() if len(x.split()) > 0]
-
-    for part in parts:
-        d = {'name': None,
-             'type': None,
-             'fstype': None,
-             'label': None,
-            }
-
-        for key, value in value_splitter(part):
-            d[key.lower()] = value
+    for d in enumerate_disk(device):
+
+        if d['fstype'] == replace_fs and label_match is False:
+            # We found a device where we want to replace the FS
+            return ('/dev/%s' % d['name'], False)
 
         if (d['fstype'] == fs_type and
             ((label_match and d['label'] == label) or not label_match)):
@@ -268,22 +324,20 @@
 
 def is_disk_used(device):
     """
-    Check if the device is currently used. Returns false if there
+    Check if the device is currently used. Returns true if the device
+    has either a file system or a partition entry
     is no filesystem found on the disk.
     """
-    lsblk_cmd = [LSBLK_CMD, '--pairs', '--out', 'NAME,TYPE',
-                 device]
-    info = None
-    try:
-        info, _err = util.subp(lsblk_cmd)
-    except Exception as e:
-        # if we error out, we can't use the device
-        util.logexc(LOG,
-                    "Error checking for filesystem on %s\n%s" % (device, e))
+
+    # If the child count is higher 1, then there are child nodes
+    # such as partition or device mapper nodes
+    use_count = [x for x in enumerate_disk(device)]
+    if len(use_count.splitlines()) > 1:
         return True
 
-    # If there is any output, then the device has something
-    if len(info.splitlines()) > 1:
+    # If we see a file system, then its used
+    _, check_fstype, _ = check_fs(device)
+    if check_fstype:
         return True
 
     return False
@@ -455,6 +509,38 @@
     return sfdisk_definition
 
 
+def purge_disk_ptable(device):
+    # wipe the first and last megabyte of a disk (or file)
+    # gpt stores partition table both at front and at end.
+    start_len = 1024 * 1024
+    end_len = 1024 * 1024
+    with open(device, "rb+") as fp:
+        fp.write('\0' * (start_len))
+        fp.seek(-end_len, os.SEEK_END)
+        fp.write('\0' * end_len)
+        fp.flush()
+
+    read_parttbl(device)
+
+
+def purge_disk(device):
+    """
+    Remove parition table entries
+    """
+
+    # wipe any file systems first
+    for d in enumerate_disk(device):
+        if d['type'] not in ["disk", "crypt"]:
+            wipefs_cmd = [WIPEFS_CMD, "--all", "/dev/%s" % d['name']]
+            try:
+                LOG.info("Purging filesystem on /dev/%s" % d['name'])
+                util.subp(wipefs_cmd)
+            except Exception:
+                raise Exception("Failed FS purge of /dev/%s" % d['name'])
+
+    purge_disk_ptable(device)
+
+
 def get_partition_layout(table_type, size, layout):
     """
     Call the appropriate function for creating the table
@@ -542,6 +628,12 @@
     if not is_device_valid(device):
         raise Exception("Device %s is not a disk device!", device)
 
+    # Remove the partition table entries
+    if isinstance(layout, str) and layout.lower() == "remove":
+        LOG.debug("Instructed to remove partition table entries")
+        purge_disk(device)
+        return
+
     LOG.debug("Checking if device layout matches")
     if check_partition_layout(table_type, device, layout):
         LOG.debug("Device partitioning layout matches")
@@ -565,6 +657,26 @@
     LOG.debug("Partition table created for %s", device)
 
 
+def lookup_force_flag(fs):
+    """
+    A force flag might be -F or -F, this look it up
+    """
+    flags = {'ext': '-F',
+             'btrfs': '-f',
+             'xfs': '-f',
+             'reiserfs': '-f',
+            }
+
+    if 'ext' in fs.lower():
+        fs = 'ext'
+
+    if fs.lower() in flags:
+        return flags[fs]
+
+    LOG.warn("Force flag for %s is unknown." % fs)
+    return ''
+
+
 def mkfs(fs_cfg):
     """
     Create a file system on the device.
@@ -592,6 +704,7 @@
     fs_type = fs_cfg.get('filesystem')
     fs_cmd = fs_cfg.get('cmd', [])
     fs_opts = fs_cfg.get('extra_opts', [])
+    fs_replace = fs_cfg.get('replace_fs', False)
     overwrite = fs_cfg.get('overwrite', False)
 
     # This allows you to define the default ephemeral or swap
@@ -632,17 +745,23 @@
             label_match = False
 
         device, reuse = find_device_node(device, fs_type=fs_type, label=label,
-                                         label_match=label_match)
+                                         label_match=label_match,
+                                         replace_fs=fs_replace)
         LOG.debug("Automatic device for %s identified as %s", odevice, device)
 
         if reuse:
             LOG.debug("Found filesystem match, skipping formating.")
             return
 
+        if not reuse and fs_replace and device:
+            LOG.debug("Replacing file system on %s as instructed." % device)
+
         if not device:
             LOG.debug("No device aviable that matches request. "
                       "Skipping fs creation for %s", fs_cfg)
             return
+    elif not partition or str(partition).lower() == 'none':
+        LOG.debug("Using the raw device to place filesystem %s on" % label)
 
     else:
         LOG.debug("Error in device identification handling.")
@@ -682,12 +801,16 @@
         if label:
             fs_cmd.extend(["-L", label])
 
+    # File systems that support the -F flag
+    if not fs_cmd and (overwrite or device_type(device) == "disk"):
+        fs_cmd.append(lookup_force_flag(fs_type))
+
     # Add the extends FS options
     if fs_opts:
         fs_cmd.extend(fs_opts)
 
     LOG.debug("Creating file system %s on %s", label, device)
-    LOG.debug("     Using cmd: %s", "".join(fs_cmd))
+    LOG.debug("     Using cmd: %s", " ".join(fs_cmd))
     try:
         util.subp(fs_cmd)
     except Exception as e:
 
=== modified file 'cloudinit/config/cc_mounts.py'
--- cloudinit/config/cc_mounts.py	2013-03-07 21:27:47 +0000
+++ cloudinit/config/cc_mounts.py	2013-10-03 23:32:32 +0000
@@ -20,6 +20,7 @@
 
 from string import whitespace  # pylint: disable=W0402
 
+import os.path
 import re
 
 from cloudinit import type_utils
@@ -75,7 +76,9 @@
                        "name from ephemeral to ephemeral0"), (i + 1))
 
         if is_mdname(startname):
-            newname = cloud.device_name_to_device(startname)
+            candidate_name = cloud.device_name_to_device(startname)
+            newname = disk_or_part(candidate_name)
+
             if not newname:
                 log.debug("Ignoring nonexistant named mount %s", startname)
                 cfgmnt[i][1] = None
@@ -119,7 +122,8 @@
     # entry has the same device name
     for defmnt in defmnts:
         startname = defmnt[0]
-        devname = cloud.device_name_to_device(startname)
+        candidate_name = cloud.device_name_to_device(startname)
+        devname = disk_or_part(candidate_name)
         if devname is None:
             log.debug("Ignoring nonexistant named default mount %s", startname)
             continue
@@ -198,3 +202,33 @@
         util.subp(("mount", "-a"))
     except:
         util.logexc(log, "Activating mounts via 'mount -a' failed")
+
+
+def disk_or_part(device):
+    """
+    Find where the file system is on the disk, either on
+    the disk itself or on the first partition. We don't go
+    any deeper than partition 1 though.
+    """
+
+    if not device:
+        return None
+
+    short_name = device.split('/')[-1]
+    sys_path = "/sys/block/%s" % short_name
+
+    # if the sys path does not exist but the device exists,
+    # then the device is a partition, no sense looking any further
+    if not os.path.exists(sys_path) and os.path.exists(device):
+        return device
+
+    sys_long_path = sys_path + "/" + short_name + "%s"
+    valid_mappings = [sys_long_path % "1",
+                      sys_long_path % "p1",
+                      sys_path]
+
+    for cdisk in valid_mappings:
+        if not os.path.exists(cdisk):
+            continue
+        return "/dev/%s" % cdisk.split('/')[-1]
+    return None
 
=== modified file 'cloudinit/sources/DataSourceAzure.py'
--- cloudinit/sources/DataSourceAzure.py	2013-09-27 17:00:35 +0000
+++ cloudinit/sources/DataSourceAzure.py	2013-10-03 23:32:32 +0000
@@ -54,8 +54,9 @@
                        'layout': True,
                        'overwrite': False}
          },
-    'fs_setup': [{'filesystem': 'ext4', 'device': 'ephemeral0',
-                  'partition': 'auto'}],
+    'fs_setup': [{'filesystem': 'ext4',
+                  'device': 'ephemeral0.1',
+                  'replace_fs': 'ntfs'}]
 }
 
 DS_CFG_PATH = ['datasource', DS_NAME]
 
=== modified file 'cloudinit/sources/DataSourceSmartOS.py'
--- cloudinit/sources/DataSourceSmartOS.py	2013-09-27 17:35:36 +0000
+++ cloudinit/sources/DataSourceSmartOS.py	2013-10-03 23:32:32 +0000
@@ -46,6 +46,7 @@
     'user-data': ('user-data', False),
     'iptables_disable': ('iptables_disable', True),
     'motd_sys_info': ('motd_sys_info', True),
+    'availability_zone': ('region', True),
 }
 
 DS_NAME = 'SmartOS'
@@ -81,8 +82,9 @@
                        'layout': False,
                        'overwrite': False}
          },
-    'fs_setup': [{'label': 'ephemeral0', 'filesystem': 'ext3',
-                  'device': 'ephemeral0', 'partition': 'auto'}],
+    'fs_setup': [{'label': 'ephemeral0',
+                  'filesystem': 'ext3',
+                  'device': 'ephemeral0'}],
 }
 
 
@@ -174,6 +176,13 @@
                           seed_timeout=self.seed_timeout, default=default,
                           b64=b64)
 
+    @property
+    def availability_zone(self):
+        try:
+            return self.metadata['availability-zone']
+        except KeyError:
+            return None
+
 
 def get_serial(seed_device, seed_timeout):
     """This is replaced in unit testing, allowing us to replace
 
=== modified file 'cloudinit/util.py'
--- cloudinit/util.py	2013-09-27 23:42:38 +0000
+++ cloudinit/util.py	2013-10-03 23:32:32 +0000
@@ -32,6 +32,7 @@
 import gzip
 import hashlib
 import os
+import os.path
 import platform
 import pwd
 import random
@@ -1826,3 +1827,79 @@
         except:
             pass
     return ret
+
+
+def map_partition(alias):
+    """
+    Return partition number for devices like ephemeral0.0 or ephemeral0.1
+
+    Parameters:
+        alaias: the alias, i.e. ephemeral0 or swap0
+        device: the actual device to markup
+
+    Rules:
+        - anything after a . is a parittion
+        - device.0 is the same as device
+    """
+
+    if len(alias.split('.')) == 1:
+        return None
+
+    suffix = alias.split('.')[-1]
+    try:
+        if int(suffix) == 0:
+            return None
+        return int(suffix)
+    except ValueError:
+        pass
+
+    return None
+
+
+def map_device_alias(device, partition=None, alias=None):
+    """
+    Find the name of the partition. While this might seem rather
+    straight forward, its not since some devices are '<device><partition>'
+    while others are '<device>p<partition>'. For example, /dev/xvda3 on EC2
+    will present as /dev/xvda3p1 for the first partition since /dev/xvda3 is
+    a block device.
+
+    The primary use is to map 'ephemeral0.1' in the datasource to a
+    real device name
+    """
+
+    if not device:
+        raise Exception("Device cannot be undefined!")
+
+    if not partition and not alias:
+        raise Exception("partition or alias is required")
+
+    if alias:
+        partition = map_partition(alias)
+
+    # if the partition doesn't map, return the device
+    if not partition:
+        return device
+
+    short_name = device.split('/')[-1]
+    sys_path = "/sys/block/%s" % short_name
+
+    if not os.path.exists(sys_path):
+        return None
+
+    sys_long_path = sys_path + "/" + short_name
+    valid_mappings = [sys_long_path + "%s" % partition,
+                      sys_long_path + "p%s" % partition]
+
+    for cdisk in valid_mappings:
+        if not os.path.exists(cdisk):
+            continue
+
+        dev_path = "/dev/%s" % cdisk.split('/')[-1]
+        if os.path.exists(dev_path):
+            return dev_path
+        else:
+            LOG.warn("Specificed parition %s does not exist on %s" % (
+                     partition, device))
+
+    return None
 
=== modified file 'doc/examples/cloud-config-disk-setup.txt'
--- doc/examples/cloud-config-disk-setup.txt	2013-09-27 23:35:20 +0000
+++ doc/examples/cloud-config-disk-setup.txt	2013-10-03 23:32:32 +0000
@@ -30,8 +30,8 @@
 fs_setup:
     - label: ephemeral0
       filesystem: ext4
-      device: ephemeral0
-      partition: auto
+      device: ephemeral0.1
+      replace_fs: ntfs
 
 
 Default disk definitions for SmartOS
@@ -47,8 +47,7 @@
 fs_setup:
     - label: ephemeral0
       filesystem: ext3
-      device: ephemeral0
-      partition: auto
+      device: ephemeral0.0
 
 Cavaut for SmartOS: if ephemeral disk is not defined, then the disk will
     not be automatically added to the mounts.
@@ -171,6 +170,7 @@
           device: <DEVICE>
           partition: <PART_VALUE>
           overwrite: <OVERWRITE>
+          replace_fs: <FS_TYPE>
 
 Where:
     <LABEL>: The file system label to be used. If set to None, no label is
@@ -187,7 +187,13 @@
         label as 'ephemeralX' otherwise there may be issues with the mounting
         of the ephemeral storage layer.
 
-    <PART_VALUE>: The valid options are:
+        If you define the device as 'ephemeralX.Y' then Y will be interpetted
+        as a partition value. However, ephermalX.0 is the _same_ as ephemeralX.
+
+    <PART_VALUE>:
+        Partition definitions are overwriten if you use the '<DEVICE>.Y' notation.
+
+        The valid options are:
         "auto|any": tell cloud-init not to care whether there is a partition
             or not. Auto will use the first partition that does not contain a
             file system already. In the absence of a partition table, it will
@@ -236,5 +242,10 @@
 
         "false": If an existing file system exists, skip the creation.
 
+    <REPLACE_FS>: This is a special directive, used for Windows Azure that
+        instructs cloud-init to replace a file system of <FS_TYPE>. NOTE:
+        unless you define a label, this requires the use of the 'any' partition
+        directive.
+
 Behavior Caveat: The default behavior is to _check_ if the file system exists.
     If a file system matches the specification, then the operation is a no-op.
 
=== modified file 'tests/unittests/test_datasource/test_azure.py'
--- tests/unittests/test_datasource/test_azure.py	2013-10-02 13:25:36 +0000
+++ tests/unittests/test_datasource/test_azure.py	2013-10-03 23:32:32 +0000
@@ -328,8 +328,6 @@
         self.assertTrue(ret)
         cfg = dsrc.get_config_obj()
         self.assertTrue(cfg)
-        self.assertEquals(dsrc.device_name_to_device("ephemeral0"),
-                          "/dev/sdc")
 
     def test_userdata_arrives(self):
         userdata = "This is my user-data"