Merge lp:~wesley-wiedenmeier/curtin/enum-storage-config into lp:~curtin-dev/curtin/trunk

[Wesley Wiedenmeier]

Whenever possible, replace strings in storage config with enums and do enum comparison rather than string comparison for reliability.

This branch isn't quite ready yet, there was a bit more that I wanted to get added in, I'm just using this merge proposal to trigger vmtests.

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:412
https://server-team-jenkins.canonical.com/job/curtin-ci/244/
Executed test runs:
    None: https://server-team-jenkins.canonical.com/job/generic-update-mp/241/console

Click here to trigger a rebuild:
https://server-team-jenkins.canonical.com/job/curtin-ci/244/rebuild

review: Needs Fixing (continuous-integration)

[Ryan Harper (raharper)]

Thanks for starting this conversion. I had put some comments inline below.
As I read through the changes to block_meta, something occurred to me that
I think we should discuss.

AFAICT, while we get stronger "typing" with the enum class, the result in the
code is more verbose and I'd say slightly more opaque since one needs to look
up the enum types and such.

I found it useful to provide sanity checks on the specific strings/keys we use
in the config yaml, specifically the various 'lvm_partition' versus 'lvm_partitions'
sort of error and I'm wondering if it would be simpler to provide a yaml validator
and introspection API that MAAS could use to query curtin's storage config
for the set of types allowed and the keys per type. I think that same api or method
call could be used in the curtin/commands/*.py for enumerating the types without
the enum efforts; just remove the human part of emitting the list of types.

Thoughts?

[Wesley Wiedenmeier (wesley-wiedenmeier)]

I definitely agree that the enum system makes configuration processing more verbose. I also think that even though it does fix some potential errors wrt typos in strings it also introduces quite a few more potential errors, mainly due to the fact that calling str() on either the builtin or fallback enum type is not a useful output. For example, I just figured out that the reason that the ci tests failed was that I had accidentally used 'fstype' instead of 'fstype.name' when generating the fstab.

I do think that the lists of command types and corresponding lists of possible command keys are useful though. With those in place it would be pretty easy to write a simple api for maas to use to get keys to use for configuration. It would also be easy to write a standalone curtin configuration validator, which would be pretty nice on its own.

I think that a good balance between strict typing and having simple code would be to use something similar to the old util.NameSet class but written so that it inserts keys in to its __dict__ rather than implementing __getattr__. I could keep the logic from convert_storage_config_str_to_enum, but instead of using it as a preprocessor for the storage config I could use it for a config validation command. Useing a NameSet instead of the enums would remove the need for conversion everywhere and would make a json dump of storage_config human readable, but it should still provide the same improvements in robustness, as trying to access a member not in the NameSet would cause an AttributeError (i.e. CMD_TYPE.lvm_partitions would be caught by pyflakes)

I'll try making the changes in a different branch, just for comparison. I'll go through the inline comments here first though and address those, thanks for looking through this.

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:415
https://server-team-jenkins.canonical.com/job/curtin-ci/245/
Executed test runs:
    None: https://server-team-jenkins.canonical.com/job/generic-update-mp/242/console

Click here to trigger a rebuild:
https://server-team-jenkins.canonical.com/job/curtin-ci/245/rebuild

review: Needs Fixing (continuous-integration)

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:419
https://server-team-jenkins.canonical.com/job/curtin-ci/246/
Executed test runs:
    None: https://server-team-jenkins.canonical.com/job/generic-update-mp/243/console

Click here to trigger a rebuild:
https://server-team-jenkins.canonical.com/job/curtin-ci/246/rebuild

review: Needs Fixing (continuous-integration)

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:421
https://server-team-jenkins.canonical.com/job/curtin-ci/247/
Executed test runs:
    None: https://server-team-jenkins.canonical.com/job/generic-update-mp/244/console

Click here to trigger a rebuild:
https://server-team-jenkins.canonical.com/job/curtin-ci/247/rebuild

review: Needs Fixing (continuous-integration)

[lp:~wesley-wiedenmeier/curtin/enum-storage-config]

422. By Wesley Wiedenmeier on 2016-06-08

Use (str, bytes) tuple instead of six.string_types as six module not present on
precise ephemeral image

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:422
https://server-team-jenkins.canonical.com/job/curtin-ci/248/
Executed test runs:
    None: https://server-team-jenkins.canonical.com/job/generic-update-mp/245/console

Click here to trigger a rebuild:
https://server-team-jenkins.canonical.com/job/curtin-ci/248/rebuild

review: Needs Fixing (continuous-integration)

[lp:~wesley-wiedenmeier/curtin/enum-storage-config]

423. By Wesley Wiedenmeier on 2016-06-14

In unittests.test_enum, skip the enum test class if tests running in an
environment that does not have the builtin enum module available. Since the
tests validate both the builtin and bakcup enum module it is okay to skip these
tests when the builtin enum is not available, as they will still fully cover
the enum module

In block_meta, make a few style fixes to get tox passing for the trusty version
of pep8, which seems to have different opinions about hanging indents than the
xenial version of pep8

Unmerged revisions

423. By Wesley Wiedenmeier on 2016-06-14

In unittests.test_enum, skip the enum test class if tests running in an
environment that does not have the builtin enum module available. Since the
tests validate both the builtin and bakcup enum module it is okay to skip these
tests when the builtin enum is not available, as they will still fully cover
the enum module

In block_meta, make a few style fixes to get tox passing for the trusty version
of pep8, which seems to have different opinions about hanging indents than the
xenial version of pep8

422. By Wesley Wiedenmeier on 2016-06-08

Use (str, bytes) tuple instead of six.string_types as six module not present on
precise ephemeral image

421. By Wesley Wiedenmeier on 2016-06-08

Use attr_name in enum_t in convert_to_enum as fallback enum class does not work
with isinstance

420. By Wesley Wiedenmeier on 2016-06-08

Clean up fileystem type logic in mount_handler

419. By Wesley Wiedenmeier on 2016-06-08

Use GEN_KEYS.id instead of 'id' in bcache_handler

418. By Wesley Wiedenmeier on 2016-06-08

Use cache_mode.name instead of cache_mode when setting up bcache

417. By Wesley Wiedenmeier on 2016-06-08

Don't attempt to use json.dumps on dict containing enums in raid_handler

416. By Wesley Wiedenmeier on 2016-06-08

Fix enum processing in determine_partition_number and clean up logic

415. By Wesley Wiedenmeier on 2016-06-08

Skip config items missing type instead of aborting installation

414. By Wesley Wiedenmeier on 2016-06-08

Add convert_to_enum function in curtin.enum and use it in functions using enums

=== modified file 'curtin/block/__init__.py'
--- curtin/block/__init__.py	2016-04-22 16:24:00 +0000
+++ curtin/block/__init__.py	2016-06-14 21:02:46 +0000
@@ -22,7 +22,7 @@
 import tempfile
 import itertools
 
-from curtin import util
+from curtin import (util, enum)
 from curtin.udev import udevadm_settle
 from curtin.log import LOG
 
@@ -635,7 +635,12 @@
                     fp.write(buf)
 
 
-def wipe_volume(path, mode="superblock"):
+WIPE_MODES = enum.make_enum('WIPE_MODES',
+                            ("superblock", "zero", "random", "pvremove",
+                             "superblock_recursive"))
+
+
+def wipe_volume(path, mode=WIPE_MODES.superblock):
     """wipe a volume/block device
 
     :param path: a path to a block device
@@ -648,7 +653,9 @@
                     volume and beginning and end of any partitions that are
                     known to be on this device.
     """
-    if mode == "pvremove":
+    mode = enum.convert_to_enum(WIPE_MODES, mode)
+
+    if mode == WIPE_MODES.pvremove:
         # We need to use --force --force in case it's already in a volgroup and
         # pvremove doesn't want to remove it
         cmds = []
@@ -660,14 +667,14 @@
         # wiping something that is already blank
         for cmd in cmds:
             util.subp(cmd, rcs=[0, 5], capture=True)
-    elif mode == "zero":
+    elif mode == WIPE_MODES.zero:
         wipe_file(path)
-    elif mode == "random":
+    elif mode == WIPE_MODES.random:
         with open("/dev/urandom", "rb") as reader:
             wipe_file(path, reader=reader.read)
-    elif mode == "superblock":
+    elif mode == WIPE_MODES.superblock:
         quick_zero(path, partitions=False)
-    elif mode == "superblock-recursive":
+    elif mode == WIPE_MODES.superblock_recursive:
         quick_zero(path, partitions=True)
     else:
         raise ValueError("wipe mode %s not supported" % mode)

=== modified file 'curtin/block/mkfs.py'
--- curtin/block/mkfs.py	2016-04-14 19:24:47 +0000
+++ curtin/block/mkfs.py	2016-06-14 21:02:46 +0000
@@ -18,96 +18,107 @@
 # This module wraps calls to mkfs.<fstype> and determines the appropriate flags
 # for each filesystem type
 
-from curtin import util
-from curtin import block
+from curtin import (util, block, enum)
 
 import string
 import os
 from uuid import uuid1
 
+FMT_KEYS = enum.make_enum('FMT_KEYS', ('volume', 'uuid', 'label', 'fstype'))
+FS_TYPES = enum.make_enum(
+    'FS_TYPES', ('ext', 'ext2', 'ext3', 'ext4',
+                 'fat', 'vfat', 'fat12', 'fat16', 'fat32', 'fat64',
+                 'btrfs', 'jfs', 'ntfs', 'reiserfs', 'swap', 'xfs',))
+FS_FLAGS = enum.make_enum(
+    'FS_FLAGS', ('label', 'uuid', 'force', 'fatsize', 'quiet', 'sectorsize',))
+
 mkfs_commands = {
-    "btrfs": "mkfs.btrfs",
-    "ext2": "mkfs.ext2",
-    "ext3": "mkfs.ext3",
-    "ext4": "mkfs.ext4",
-    "fat": "mkfs.vfat",
-    "fat12": "mkfs.vfat",
-    "fat16": "mkfs.vfat",
-    "fat32": "mkfs.vfat",
-    "vfat": "mkfs.vfat",
-    "jfs": "jfs_mkfs",
-    "ntfs": "mkntfs",
-    "reiserfs": "mkfs.reiserfs",
-    "swap": "mkswap",
-    "xfs": "mkfs.xfs"
+    FS_TYPES.btrfs:     "mkfs.btrfs",
+    FS_TYPES.ext:       "mkfs.ext4",
+    FS_TYPES.ext2:      "mkfs.ext2",
+    FS_TYPES.ext3:      "mkfs.ext3",
+    FS_TYPES.ext4:      "mkfs.ext4",
+    FS_TYPES.fat:       "mkfs.vfat",
+    FS_TYPES.fat12:     "mkfs.vfat",
+    FS_TYPES.fat16:     "mkfs.vfat",
+    FS_TYPES.fat32:     "mkfs.vfat",
+    FS_TYPES.fat64:     "mkfs.vfat",
+    FS_TYPES.vfat:      "mkfs.vfat",
+    FS_TYPES.jfs:       "jfs_mkfs",
+    FS_TYPES.ntfs:      "mkntfs",
+    FS_TYPES.reiserfs:  "mkfs.reiserfs",
+    FS_TYPES.swap:      "mkswap",
+    FS_TYPES.xfs:       "mkfs.xfs"
 }
 
 specific_to_family = {
-    "ext2": "ext",
-    "ext3": "ext",
-    "ext4": "ext",
-    "fat12": "fat",
-    "fat16": "fat",
-    "fat32": "fat",
-    "vfat": "fat",
+    FS_TYPES.ext2:  FS_TYPES.ext,
+    FS_TYPES.ext3:  FS_TYPES.ext,
+    FS_TYPES.ext4:  FS_TYPES.ext,
+    FS_TYPES.fat12: FS_TYPES.fat,
+    FS_TYPES.fat16: FS_TYPES.fat,
+    FS_TYPES.fat32: FS_TYPES.fat,
+    FS_TYPES.fat64: FS_TYPES.fat,
+    FS_TYPES.vfat:  FS_TYPES.fat,
 }
 
 label_length_limits = {
-    "btrfs": 256,
-    "ext": 16,
-    "fat": 11,
-    "jfs": 16,  # see jfs_tune manpage
-    "ntfs": 32,
-    "reiserfs": 16,
-    "swap": 15,  # not in manpages, found experimentally
-    "xfs": 12
+    FS_TYPES.btrfs:     256,
+    FS_TYPES.ext:       16,
+    FS_TYPES.fat:       11,
+    FS_TYPES.jfs:       16,     # see jfs_tune manpage
+    FS_TYPES.ntfs:      32,
+    FS_TYPES.reiserfs:  16,
+    FS_TYPES.swap:      15,     # not in manpages, found experimentally
+    FS_TYPES.xfs:       12,
 }
 
 family_flag_mappings = {
-    "label": {"btrfs": "--label",
-              "ext": "-L",
-              "fat": "-n",
-              "jfs": "-L",
-              "ntfs": "--label",
-              "reiserfs": "--label",
-              "swap": "--label",
-              "xfs": "-L"},
-    "uuid": {"btrfs": "--uuid",
-             "ext": "-U",
-             "reiserfs": "--uuid",
-             "swap": "--uuid"},
-    "force": {"btrfs": "--force",
-              "ext": "-F",
-              "ntfs": "--force",
-              "reiserfs": "-f",
-              "swap": "--force",
-              "xfs": "-f"},
-    "fatsize": {"fat": "-F"},
-    "quiet": {"ext": "-q",
-              "ntfs": "-q",
-              "reiserfs": "-q",
-              "xfs": "--quiet"},
-    "sectorsize": {
-        "btrfs": "--sectorsize",
-        "ext": "-b",
-        "fat": "-S",
-        "ntfs": "--sector-size",
-        "reiserfs": "--block-size"}
+    FS_FLAGS.label: {
+        FS_TYPES.btrfs:     "--label",
+        FS_TYPES.ext:       "-L",
+        FS_TYPES.fat:       "-n",
+        FS_TYPES.jfs:       "-L",
+        FS_TYPES.ntfs:      "--label",
+        FS_TYPES.reiserfs:  "--label",
+        FS_TYPES.swap:      "--label",
+        FS_TYPES.xfs:       "-L"},
+    FS_FLAGS.uuid: {
+        FS_TYPES.btrfs:     "--uuid",
+        FS_TYPES.ext:       "-U",
+        FS_TYPES.reiserfs:  "--uuid",
+        FS_TYPES.swap:      "--uuid"},
+    FS_FLAGS.force: {
+        FS_TYPES.btrfs:     "--force",
+        FS_TYPES.ext:       "-F",
+        FS_TYPES.ntfs:      "--force",
+        FS_TYPES.reiserfs:  "-f",
+        FS_TYPES.swap:      "--force",
+        FS_TYPES.xfs:       "-f"},
+    FS_FLAGS.fatsize: {
+        FS_TYPES.fat:       "-F"},
+    FS_FLAGS.quiet: {
+        FS_TYPES.ext:       "-q",
+        FS_TYPES.ntfs:      "-q",
+        FS_TYPES.reiserfs:  "-q",
+        FS_TYPES.xfs:       "--quiet"},
+    FS_FLAGS.sectorsize: {
+        FS_TYPES.btrfs:     "--sectorsize",
+        FS_TYPES.ext:       "-b",
+        FS_TYPES.fat:       "-S",
+        FS_TYPES.ntfs:      "--sector-size",
+        FS_TYPES.reiserfs:  "--block-size"}
 }
 
 release_flag_mapping_overrides = {
     "precise": {
-        "force": {"btrfs": None},
-        "uuid": {"btrfs": None}},
+        FS_FLAGS.force: {FS_TYPES.btrfs: None},
+        FS_FLAGS.uuid: {FS_TYPES.btrfs: None}},
     "trusty": {
-        "uuid": {"btrfs": None}},
+        FS_FLAGS.uuid: {FS_TYPES.btrfs: None}},
 }
 
 
-def valid_fstypes():
-    return list(mkfs_commands.keys())
-
-
 def get_flag_mapping(flag_name, fs_family, param=None, strict=False):
     ret = []
     release = util.lsb_release()['codename']
@@ -117,13 +128,13 @@
     else:
         flag_sym_families = family_flag_mappings.get(flag_name)
         if flag_sym_families is None:
-            raise ValueError("unsupported flag '%s'" % flag_name)
+            raise ValueError("unsupported flag '%s'" % flag_name.name)
         flag_sym = flag_sym_families.get(fs_family)
 
     if flag_sym is None:
         if strict:
             raise ValueError("flag '%s' not supported by fs family '%s'" %
-                             flag_name, fs_family)
+                             flag_name.name, fs_family.name)
     else:
         ret = [flag_sym]
         if param is not None:
@@ -132,20 +143,22 @@
 
 
 def mkfs(path, fstype, strict=False, label=None, uuid=None, force=False):
-    """Make filesystem on block device with given path using given fstype and
-       appropriate flags for filesystem family.
-
-       Filesystem uuid and label can be passed in as kwargs. By default no
-       label or uuid will be used. If a filesystem label is too long curtin
-       will raise a ValueError if the strict flag is true or will truncate
-       it to the maximum possible length.
-
-       If a flag is not supported by a filesystem family mkfs will raise a
-       ValueError if the strict flag is true or silently ignore it otherwise.
-
-       Force can be specified to force the mkfs command to continue even if it
-       finds old data or filesystems on the partition.
-       """
+    """
+    Make filesystem on block device with given path using given fstype and
+    appropriate flags for filesystem family.
+
+    Filesystem uuid and label can be passed in as kwargs. By default no
+    label or uuid will be used. If a filesystem label is too long curtin
+    will raise a ValueError if the strict flag is true or will truncate
+    it to the maximum possible length.
+
+    If a flag is not supported by a filesystem family mkfs will raise a
+    ValueError if the strict flag is true or silently ignore it otherwise.
+
+    Force can be specified to force the mkfs command to continue even if it
+    finds old data or filesystems on the partition.
+    """
+    fstype = enum.convert_to_enum(FS_TYPES, fstype)
 
     if path is None:
         raise ValueError("invalid block dev path '%s'" % path)
@@ -155,7 +168,7 @@
     fs_family = specific_to_family.get(fstype, fstype)
     mkfs_cmd = mkfs_commands.get(fstype)
     if not mkfs_cmd:
-        raise ValueError("unsupported fs type '%s'" % fstype)
+        raise ValueError("unsupported fs type '%s'" % fstype.name)
 
     if util.which(mkfs_cmd) is None:
         raise ValueError("need '%s' but it could not be found" % mkfs_cmd)
@@ -165,7 +178,7 @@
     # use device logical block size to ensure properly formated filesystems
     (logical_bsize, physical_bsize) = block.get_blockdev_sector_size(path)
     if logical_bsize > 512:
-        cmd.extend(get_flag_mapping("sectorsize", fs_family,
+        cmd.extend(get_flag_mapping(FS_FLAGS.sectorsize, fs_family,
                                     param=str(logical_bsize),
                                     strict=strict))
         # mkfs.vfat doesn't calculate this right for non-512b sector size
@@ -173,36 +186,37 @@
         cmd.extend(["-s", "1"])
 
     if force:
-        cmd.extend(get_flag_mapping("force", fs_family, strict=strict))
+        cmd.extend(get_flag_mapping(FS_FLAGS.force, fs_family, strict=strict))
     if label is not None:
         limit = label_length_limits.get(fs_family)
         if len(label) > limit:
             if strict:
                 raise ValueError("length of fs label for '%s' exceeds max \
                                  allowed for fstype '%s'. max is '%s'"
-                                 % (path, fstype, limit))
+                                 % (path, fstype.name, limit))
             else:
                 label = label[:limit]
-        cmd.extend(get_flag_mapping("label", fs_family, param=label,
+        cmd.extend(get_flag_mapping(FS_FLAGS.label, fs_family, param=label,
                                     strict=strict))
 
     # If uuid is not specified, generate one and try to use it
     if uuid is None:
         uuid = str(uuid1())
-    cmd.extend(get_flag_mapping("uuid", fs_family, param=uuid, strict=strict))
+    cmd.extend(get_flag_mapping(FS_FLAGS.uuid, fs_family, param=uuid,
+                                strict=strict))
 
-    if fs_family == "fat":
-        fat_size = fstype.strip(string.ascii_letters)
+    if fs_family == FS_TYPES.fat:
+        fat_size = fstype.name.strip(string.ascii_letters)
         if fat_size in ["12", "16", "32"]:
-            cmd.extend(get_flag_mapping("fatsize", fs_family, param=fat_size,
-                                        strict=strict))
+            cmd.extend(get_flag_mapping(FS_FLAGS.fatsize, fs_family,
+                                        param=fat_size, strict=strict))
 
     cmd.append(path)
     util.subp(cmd, capture=True)
 
     # if fs_family does not support specifying uuid then use blkid to find it
     # if blkid is unable to then just return None for uuid
-    if fs_family not in family_flag_mappings['uuid']:
+    if fs_family not in family_flag_mappings[FS_FLAGS.uuid]:
         try:
             uuid = block.blkid()[path]['UUID']
         except:
@@ -216,10 +230,10 @@
 def mkfs_from_config(path, info, strict=False):
     """Make filesystem on block device with given path according to storage
        config given"""
-    fstype = info.get('fstype')
+    fstype = info.get(FMT_KEYS.fstype)
     if fstype is None:
         raise ValueError("fstype must be specified")
     # NOTE: Since old metadata on partitions that have not been wiped can cause
     #       some mkfs commands to refuse to work, it's best to use force=True
-    mkfs(path, fstype, strict=strict, force=True, uuid=info.get('uuid'),
-         label=info.get('label'))
+    mkfs(path, fstype, strict=strict, force=True, uuid=info.get(FMT_KEYS.uuid),
+         label=info.get(FMT_KEYS.label))

=== added file 'curtin/block/storage_config.py'
--- curtin/block/storage_config.py	1970-01-01 00:00:00 +0000
+++ curtin/block/storage_config.py	2016-06-14 21:02:46 +0000
@@ -0,0 +1,218 @@
+#   Copyright (C) 2016 Canonical Ltd.
+#
+#   Author: Wesley Wiedenmeier <[e-mail]>
+#
+#   Curtin is free software: you can redistribute it and/or modify it under
+#   the terms of the GNU Affero General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   Curtin is distributed in the hope that it will be useful, but WITHOUT ANY
+#   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for
+#   more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with Curtin.  If not, see <http://www.gnu.org/licenses/>.
+
+# This module provides constants and data processing functions for curtin
+# storage config
+
+from collections import OrderedDict
+
+from curtin import enum
+from curtin.block.mkfs import (FS_TYPES, FMT_KEYS)
+from curtin.block import WIPE_MODES
+
+CMD_TYPES = enum.make_enum(
+    'CMD_TYPES', ('disk', 'partition', 'format', 'mount', 'lvm_volgroup',
+                  'lvm_partition', 'dm_crypt', 'raid', 'bcache'))
+
+# command keys
+GEN_KEYS = enum.make_enum('GEN_KEYS', ('id', 'type', 'name', 'preserve'))
+MOUNT_KEYS = enum.make_enum('MOUNT_KEYS', ('path', 'device'))
+LVM_VG_KEYS = enum.make_enum('LVM_VG_KEYS', ('devices',))
+PART_KEYS = enum.make_enum(
+    'PART_KEYS', ('device', 'size', 'flag', 'number', 'wipe'))
+LVM_PART_KEYS = enum.make_enum('LVM_PART_KEYS', ('name', 'volgroup', 'size'))
+DM_CRYPT_KEYS = enum.make_enum(
+    'DM_CRYPT_KEYS', ('volume', 'key', 'keysize', 'cipher'))
+BCACHE_KEYS = enum.make_enum(
+    'BCACHE_KEYS', ('backing_device', 'cache_device', 'cache_mode'))
+DISK_KEYS = enum.make_enum(
+    'DISK_KEYS', ('ptable', 'wipe', 'serial', 'path', 'grub_device'))
+RAID_KEYS = enum.make_enum(
+    'RAID_KEYS', ('devices', 'raidlevel', 'spare_devices', 'mdname', 'ptable'))
+
+# what item specific keys apply to each command type key
+SC_KEY_MAP = {
+    CMD_TYPES.disk:         DISK_KEYS,
+    CMD_TYPES.partition:    PART_KEYS,
+    CMD_TYPES.format:       FMT_KEYS,
+    CMD_TYPES.mount:        MOUNT_KEYS,
+    CMD_TYPES.lvm_volgroup: LVM_VG_KEYS,
+    CMD_TYPES.lvm_partition: LVM_PART_KEYS,
+    CMD_TYPES.dm_crypt:     DM_CRYPT_KEYS,
+    CMD_TYPES.raid:         RAID_KEYS,
+    CMD_TYPES.bcache:       BCACHE_KEYS,
+}
+
+# command specific enums, (FS_TYPE and WIPE_MODES effectively here as well)
+PT_TYPES = enum.make_enum('PT_TYPES', ('msdos', 'gpt'))
+# NOTE: This covers both dos and gpt flags, but some (like boot) are shared, so
+#       it make sense to keep them together, and it makes storage config
+#       processing simpler
+PART_FLAGS = enum.make_enum(
+    'PART_FLAGS',
+    ('extended', 'logical', 'primary',
+     'boot', 'lvm', 'raid', 'bios_grub', 'prep', 'swap', 'home', 'linux'))
+# NOTE: I think that bcache also accepts 'none' in bcache/cache_mode, and this
+#       disables the cache, but since 'none' is a special value in yaml there
+#       was no way to specify cache mode none before, so leaving it out here
+#       preserves behavior
+BCACHE_MODES = enum.make_enum(
+    'BCACHE_MODES', ('writethrough', 'writeback', 'writearound'))
+
+# mapping of config item attributes with matching cmd specific enum
+# FIXME: DM_CRYPT_KEYS.keysize and DM_CRYPT_KEYS.cipher should be in here too,
+#        but i don't think that the handler function works properly atm, so I
+#        left them out
+# FIXME: I have RAID_KEYS.ptable set here, but I am not sure if disk handler
+#        will be able to partition md devices anymore, it may be good to
+#        disable that functionality with a warning until I can get it working
+# FIXME: RAID_LEVELS needs to be created in block.mdadm, raid information is
+#        still being processed as strings right now
+SC_CFG_TO_ENUM = {
+    GEN_KEYS.type:          CMD_TYPES,
+    DISK_KEYS.ptable:       PT_TYPES,
+    DISK_KEYS.wipe:         WIPE_MODES,
+    PART_KEYS.wipe:         WIPE_MODES,
+    PART_KEYS.flag:         PART_FLAGS,
+    FMT_KEYS.fstype:        FS_TYPES,
+    BCACHE_KEYS.cache_mode: BCACHE_MODES,
+    # RAID_KEYS.raidlevel:  RAID_LEVELS,
+    RAID_KEYS.ptable:       PT_TYPES,
+}
+
+
+def extract_storage_ordered_dict(config):
+    """
+    Extract storage configuration from curtin configuration as an ordered
+    dictionary. This data structure will allow efficient lookups of storage
+    config entries by their id, and will preserve storage config order
+    """
+    storage_config = config.get('storage', {})
+    if not storage_config:
+        raise ValueError("no 'storage' entry in config")
+    scfg = storage_config.get('config')
+    if not scfg:
+        raise ValueError("invalid storage config data")
+    return OrderedDict((d['id'], d) for (i, d) in enumerate(scfg))
+
+
+def convert_storage_config_str_to_enum(config):
+    """
+    Items in storage config are mostly strings. Since string comparison is
+    prone to errors, convert strings in storage config to enums
+    """
+    # non type specific storage config keys
+    general_keys = set(GEN_KEYS)
+
+    res = OrderedDict()
+    for (item_id, old_item) in config.items():
+
+        # all config entries must have a type defined
+        # if a config entry is missing a type just ignore it to preserve old
+        # behavior
+        type_str = old_item.get('type')
+        if not type_str:
+            continue
+
+        # str in enum does not work, so have to try to retrieve enum val and
+        # catch key error if thrown
+        try:
+            item_type = CMD_TYPES[type_str]
+            item_keys = set(SC_KEY_MAP[item_type])
+        except KeyError:
+            raise ValueError("invalid storage config type: '{}'"
+                             .format(type_str))
+
+        # determine what keys are represented in the storage config entry
+        represented_keys = set(k for k in item_keys.union(general_keys)
+                               if k.name in old_item)
+
+        # keys for new_item should be from one of the KEYS enums, to avoid
+        # accessing key attributes by string comparison
+        new_item = dict().fromkeys(represented_keys)
+
+        # copy values over from old to new, preforming enum lookup for config
+        # entries with an associated enum type
+        for key in represented_keys:
+            str_val = old_item.get(key.name)
+            if str_val in (None, 'none', 'None', 'null', 'Null'):
+                new_item[key] = None
+            elif key in SC_CFG_TO_ENUM:
+                enum_t = SC_CFG_TO_ENUM.get(key)
+                assert enum_t is not None
+                try:
+                    new_item[key] = enum_t[str_val]
+                except KeyError:
+                    raise ValueError(
+                        "{} is not a valid value for attr {} in conf entry {}"
+                        .format(str_val, key, item_id))
+            else:
+                new_item[key] = str_val
+
+        # udpate res odict, odict goes by insert order, so this will preserve
+        # original storage config order
+        res.update({item_id: new_item})
+
+    return res
+
+
+def number_storage_config_partitions(config):
+    """
+    Ensure that all partitions in storage config have 'number' specified to
+    save processing during block_meta
+    """
+    return config
+
+
+class StorageConfig(object):
+    """
+    A class to wrap storage config processing.
+
+    Implements many of the standard dictionary methods so it can be treated
+    just like the old ordered dictionary most of the time.
+    """
+
+    def __init__(self, config):
+        """
+        Extract storage configuration from global curtin config and run
+        preprocessing stages
+        """
+        for preprocessor in [extract_storage_ordered_dict,
+                             convert_storage_config_str_to_enum,
+                             number_storage_config_partitions]:
+            config = preprocessor(config)
+
+        # FIXME: this class should store the result and skip running the
+        #        preprocessor functions after the first time through
+        self.config = config
+
+    def get(self, attr, default=None):
+        """Get attr that behaves just like dict"""
+        return self.config.get(attr, default)
+
+    def __getitem__(self, item):
+        """Allow subscripting to access config"""
+        return self.config[item]
+
+    def __iter__(self):
+        """Allow iter from config items"""
+        for e in self.config:
+            yield e
+
+    def items(self):
+        """Allow items() call to config items"""
+        return self.config.items()

=== modified file 'curtin/commands/block_meta.py'
--- curtin/commands/block_meta.py	2016-04-22 16:24:00 +0000
+++ curtin/commands/block_meta.py	2016-06-14 21:02:46 +0000
@@ -17,11 +17,20 @@
 
 from collections import OrderedDict
 from curtin import (block, config, util)
-from curtin.block import mdadm
+from curtin.block import (mdadm, mkfs)
+from curtin.block import storage_config as sc
 from curtin.log import LOG
-from curtin.block import mkfs
 from curtin.reporter import events
 
+# bring in config name sets
+from curtin.block import WIPE_MODES
+from curtin.block.mkfs import (FS_TYPES, FMT_KEYS)
+from curtin.block.storage_config import (
+    GEN_KEYS, DISK_KEYS, PART_KEYS, MOUNT_KEYS, LVM_VG_KEYS,
+    LVM_PART_KEYS, BCACHE_KEYS, RAID_KEYS, DM_CRYPT_KEYS,
+    CMD_TYPES, PT_TYPES, PART_FLAGS
+)
+
 from . import populate_one_subcmd
 from curtin.udev import compose_udev_equality, udevadm_settle
 
@@ -215,7 +224,7 @@
                     break
         for part_dev in part_devs:
             block.wipe_volume(os.path.join("/dev", part_dev),
-                              mode="superblock")
+                              mode=WIPE_MODES.superblock)
 
     if os.path.exists(os.path.join(sys_block_path, "bcache")):
         # bcache device that isn't running, if it were, we would have found it
@@ -275,32 +284,37 @@
 
 def determine_partition_number(partition_id, storage_config):
     vol = storage_config.get(partition_id)
-    partnumber = vol.get('number')
-    if vol.get('flag') == "logical":
-        if not partnumber:
-            LOG.warn('partition \'number\' key not set in config:\n%s',
-                     util.json_dumps(vol))
-            partnumber = 5
-            for key, item in storage_config.items():
-                if item.get('type') == "partition" and \
-                        item.get('device') == vol.get('device') and\
-                        item.get('flag') == "logical":
-                    if item.get('id') == vol.get('id'):
-                        break
-                    else:
-                        partnumber += 1
+    partnumber = vol.get(PART_KEYS.number)
+    if partnumber is not None:
+        return partnumber
+
+    # previously the warning was generated using util.json_dumps,
+    # but util.json_dumps crashes when given an enum. instead, just
+    # output the volume id
+    LOG.warn("partition 'number' key not set in config: %s",
+             vol.get(GEN_KEYS.id))
+
+    if vol.get(PART_KEYS.flag) == PART_FLAGS.logical:
+        partnumber = 5
+        for key, item in storage_config.items():
+            if (item.get(GEN_KEYS.type) == CMD_TYPES.partition and
+                    item.get(PART_KEYS.device) == vol.get(PART_KEYS.device) and
+                    item.get(PART_KEYS.flag) == PART_FLAGS.logical):
+                if item.get(GEN_KEYS.id) == vol.get(GEN_KEYS.id):
+                    break
+                else:
+                    partnumber += 1
     else:
-        if not partnumber:
-            LOG.warn('partition \'number\' key not set in config:\n%s',
-                     util.json_dumps(vol))
-            partnumber = 1
-            for key, item in storage_config.items():
-                if item.get('type') == "partition" and \
-                        item.get('device') == vol.get('device'):
-                    if item.get('id') == vol.get('id'):
-                        break
-                    else:
-                        partnumber += 1
+        partnumber = 1
+        for key, item in storage_config.items():
+            if (item.get(GEN_KEYS.type) == CMD_TYPES.partition and
+                    item.get(PART_KEYS.device) ==
+                    vol.get(PART_KEYS.device)):
+                if item.get(GEN_KEYS.id) == vol.get(GEN_KEYS.id):
+                    break
+                else:
+                    partnumber += 1
+
     return partnumber
 
 
@@ -310,8 +324,8 @@
     vol = storage_config.get(volume)
     path = get_path_to_storage_volume(volume, storage_config)
     ptuuid = None
-    dname = vol.get('name')
-    if vol.get('type') in ["partition", "disk"]:
+    dname = vol.get(GEN_KEYS.name)
+    if vol.get(GEN_KEYS.type) in [CMD_TYPES.disk, CMD_TYPES.partition]:
         (out, _err) = util.subp(["blkid", "-o", "export", path], capture=True,
                                 rcs=[0, 2], retries=[1, 1, 1])
         for line in out.splitlines():
@@ -319,7 +333,8 @@
                 ptuuid = line.split('=')[-1]
                 break
     # we may not always be able to find a uniq identifier on devices with names
-    if not ptuuid and vol.get('type') in ["disk", "partition"]:
+    if (not ptuuid and
+            vol.get(GEN_KEYS.type) in [CMD_TYPES.disk, CMD_TYPES.partition]):
         LOG.warning("Can't find a uuid for volume: {}. Skipping dname.".format(
             dname))
         return
@@ -328,22 +343,24 @@
         compose_udev_equality("SUBSYSTEM", "block"),
         compose_udev_equality("ACTION", "add|change"),
         ]
-    if vol.get('type') == "disk":
+    if vol.get(GEN_KEYS.type) == CMD_TYPES.disk:
         rule.append(compose_udev_equality('ENV{DEVTYPE}', "disk"))
         rule.append(compose_udev_equality('ENV{ID_PART_TABLE_UUID}', ptuuid))
-    elif vol.get('type') == "partition":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.partition:
         rule.append(compose_udev_equality('ENV{DEVTYPE}', "partition"))
-        dname = storage_config.get(vol.get('device')).get('name') + \
-            "-part%s" % determine_partition_number(volume, storage_config)
+        parent_dev = storage_config.get(vol.get(PART_KEYS.device))
+        dname = parent_dev.get(GEN_KEYS.name) + "-part{}".format(
+            determine_partition_number(volume, storage_config))
         rule.append(compose_udev_equality('ENV{ID_PART_ENTRY_UUID}', ptuuid))
-    elif vol.get('type') == "raid":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.raid:
         md_data = mdadm.mdadm_query_detail(path)
         md_uuid = md_data.get('MD_UUID')
         rule.append(compose_udev_equality("ENV{MD_UUID}", md_uuid))
-    elif vol.get('type') == "bcache":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.bcache:
         rule.append(compose_udev_equality("ENV{DEVNAME}", path))
-    elif vol.get('type') == "lvm_partition":
-        volgroup_name = storage_config.get(vol.get('volgroup')).get('name')
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.lvm_partition:
+        parent_vg = storage_config.get(vol.get(LVM_PART_KEYS.volgroup))
+        volgroup_name = parent_vg.get(GEN_KEYS.name)
         dname = "%s-%s" % (volgroup_name, dname)
         rule.append(compose_udev_equality("ENV{DM_NAME}", dname))
     rule.append("SYMLINK+=\"disk/by-dname/%s\"" % dname)
@@ -364,58 +381,59 @@
         raise ValueError("volume with id '%s' not found" % volume)
 
     # Find path to block device
-    if vol.get('type') == "partition":
-        partnumber = determine_partition_number(vol.get('id'), storage_config)
-        disk_block_path = get_path_to_storage_volume(vol.get('device'),
-                                                     storage_config)
+    if vol.get(GEN_KEYS.type) == CMD_TYPES.partition:
+        partnumber = determine_partition_number(
+            vol.get(GEN_KEYS.id), storage_config)
+        disk_block_path = get_path_to_storage_volume(
+            vol.get(PART_KEYS.device), storage_config)
         (base_path, disk_kname) = os.path.split(disk_block_path)
         partition_kname = determine_partition_kname(disk_kname, partnumber)
         volume_path = os.path.join(base_path, partition_kname)
         devsync_vol = os.path.join(disk_block_path)
 
-    elif vol.get('type') == "disk":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.disk:
         # Get path to block device for disk. Device_id param should refer
         # to id of device in storage config
-        if vol.get('serial'):
-            volume_path = block.lookup_disk(vol.get('serial'))
-        elif vol.get('path'):
-            volume_path = vol.get('path')
+        if vol.get(DISK_KEYS.serial):
+            volume_path = block.lookup_disk(vol.get(DISK_KEYS.serial))
+        elif vol.get(DISK_KEYS.path):
+            volume_path = vol.get(DISK_KEYS.path)
         else:
             raise ValueError("serial number or path to block dev must be \
                 specified to identify disk")
 
-    elif vol.get('type') == "lvm_partition":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.lvm_partition:
         # For lvm partitions, a directory in /dev/ should be present with the
         # name of the volgroup the partition belongs to. We can simply append
         # the id of the lvm partition to the path of that directory
-        volgroup = storage_config.get(vol.get('volgroup'))
+        volgroup = storage_config.get(vol.get(LVM_PART_KEYS.volgroup))
         if not volgroup:
             raise ValueError("lvm volume group '%s' could not be found"
-                             % vol.get('volgroup'))
-        volume_path = os.path.join("/dev/", volgroup.get('name'),
-                                   vol.get('name'))
+                             % vol.get(LVM_PART_KEYS.volgroup))
+        volume_path = os.path.join("/dev/", volgroup.get(GEN_KEYS.name),
+                                   vol.get(GEN_KEYS.name))
 
-    elif vol.get('type') == "dm_crypt":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.dm_crypt:
         # For dm_crypted partitions, unencrypted block device is at
         # /dev/mapper/<dm_name>
-        dm_name = vol.get('dm_name')
+        dm_name = vol.get(GEN_KEYS.name)
         if not dm_name:
-            dm_name = vol.get('id')
+            dm_name = vol.get(GEN_KEYS.name)
         volume_path = os.path.join("/dev", "mapper", dm_name)
 
-    elif vol.get('type') == "raid":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.raid:
         # For raid partitions, block device is at /dev/mdX
-        name = vol.get('name')
+        name = vol.get(GEN_KEYS.name)
         volume_path = os.path.join("/dev", name)
 
-    elif vol.get('type') == "bcache":
+    elif vol.get(GEN_KEYS.type) == CMD_TYPES.bcache:
         # For bcache setups, the only reliable way to determine the name of the
         # block device is to look in all /sys/block/bcacheX/ dirs and see what
         # block devs are in the slaves dir there. Then, those blockdevs can be
         # checked against the kname of the devs in the config for the desired
         # bcache device. This is not very elegant though
         backing_device_kname = os.path.split(get_path_to_storage_volume(
-            vol.get('backing_device'), storage_config))[-1]
+            vol.get(BCACHE_KEYS.backing_device), storage_config))[-1]
         sys_path = list(filter(lambda x: backing_device_kname in x,
                                glob.glob("/sys/block/bcache*/slaves/*")))[0]
         while "bcache" not in os.path.split(sys_path)[-1]:
@@ -425,7 +443,7 @@
 
     else:
         raise NotImplementedError("cannot determine the path to storage \
-            volume '%s' with type '%s'" % (volume, vol.get('type')))
+            volume '%s' with type '%s'" % (volume, vol.get(GEN_KEYS.type)))
 
     # sync devices
     if not devsync_vol:
@@ -437,37 +455,47 @@
 
 
 def disk_handler(info, storage_config):
-    ptable = info.get('ptable')
+    ptable = info.get(DISK_KEYS.ptable)
 
-    disk = get_path_to_storage_volume(info.get('id'), storage_config)
+    disk = get_path_to_storage_volume(info.get(GEN_KEYS.id), storage_config)
 
     # Handle preserve flag
-    if info.get('preserve'):
+    if info.get(GEN_KEYS.preserve):
         if not ptable:
             # Don't need to check state, return
             return
 
-        # Check state of current ptable
+        # Check state of current ptable, try to do this using blkid, but if
+        # blkid fails then try to fall back to using parted.
+        _possible_errors = (util.ProcessExecutionError, StopIteration,
+                            IndexError, AttributeError)
         try:
             (out, _err) = util.subp(["blkid", "-o", "export", disk],
                                     capture=True)
-        except util.ProcessExecutionError:
-            raise ValueError("disk '%s' has no readable partition table or \
-                cannot be accessed, but preserve is set to true, so cannot \
-                continue")
-        current_ptable = list(filter(lambda x: "PTTYPE" in x,
-                                     out.splitlines()))[0].split("=")[-1]
-        if current_ptable == "dos" and ptable != "msdos" or \
-                current_ptable == "gpt" and ptable != "gpt":
-            raise ValueError("disk '%s' does not have correct \
+            current_ptable = next(l.split('=')[1] for l in out.splitlines()
+                                  if 'TYPE' in l)
+        except _possible_errors:
+            try:
+                (out, _err) = util.subp(["parted", disk, "--script", "print"],
+                                        capture=True)
+                current_ptable = next(l.split()[-1] for l in out.splitlines()
+                                      if "Partition Table" in l)
+            except _possible_errors:
+                raise ValueError("disk '{}' has no readable partition table or\
+                    cannot be accessed, but preserve is set to true, so cannot\
+                    continue".format(info.get(GEN_KEYS.id)))
+        if not (current_ptable == ptable.name or
+                (current_ptable == "dos" and ptable.name == "msdos")):
+            raise ValueError("disk '{}' does not have correct \
                 partition table, but preserve is set to true, so not \
-                creating table, so not creating table." % info.get('id'))
+                creating table, so not creating table.".format(
+                info.get(GEN_KEYS.id)))
         LOG.info("disk '%s' marked to be preserved, so keeping partition \
                  table")
         return
 
     # Wipe the disk
-    if info.get('wipe') and info.get('wipe') != "none":
+    if info.get(DISK_KEYS.wipe) is not None:
         # The disk has a lable, clear all partitions
         mdadm.mdadm_assemble(scan=True)
         disk_kname = os.path.split(disk)[-1]
@@ -480,29 +508,30 @@
                 block_no = fp.read().rstrip()
             partition_path = os.path.realpath(
                 os.path.join("/dev/block", block_no))
-            block.wipe_volume(partition_path, mode=info.get('wipe'))
+            block.wipe_volume(partition_path, mode=info.get(DISK_KEYS.wipe))
 
         clear_holders("/sys/block/%s" % disk_kname)
-        block.wipe_volume(disk, mode=info.get('wipe'))
+        block.wipe_volume(disk, mode=info.get(DISK_KEYS.wipe))
 
     # Create partition table on disk
-    if info.get('ptable'):
+    if info.get(DISK_KEYS.ptable):
         LOG.info("labeling device: '%s' with '%s' partition table", disk,
                  ptable)
-        if ptable == "gpt":
+        if ptable == PT_TYPES.gpt:
             util.subp(["sgdisk", "--clear", disk])
-        elif ptable == "msdos":
+        elif ptable == PT_TYPES.msdos:
             util.subp(["parted", disk, "--script", "mklabel", "msdos"])
 
     # Make the name if needed
-    if info.get('name'):
-        make_dname(info.get('id'), storage_config)
+    if info.get(GEN_KEYS.name):
+        make_dname(info.get(GEN_KEYS.id), storage_config)
 
 
 def getnumberoflogicaldisks(device, storage_config):
     logicaldisks = 0
     for key, item in storage_config.items():
-        if item.get('device') == device and item.get('flag') == "logical":
+        if (item.get(PART_KEYS.device) == device and
+                item.get(PART_KEYS.flag) == PART_FLAGS.logical):
             logicaldisks = logicaldisks + 1
     return logicaldisks
 
@@ -514,9 +543,9 @@
             break
 
         # skip anything not on this disk, not a 'partition' or 'extended'
-        if command['type'] != 'partition' or command['device'] != disk_id:
-            continue
-        if command.get('flag') == "extended":
+        if (command[GEN_KEYS.type] != CMD_TYPES.partition or
+                command.get(PART_KEYS.device) != disk_id or
+                command.get(PART_KEYS.flag) == PART_FLAGS.extended):
             continue
 
         last_partnum = determine_partition_number(item_id, storage_config)
@@ -525,10 +554,10 @@
 
 
 def partition_handler(info, storage_config):
-    device = info.get('device')
-    size = info.get('size')
-    flag = info.get('flag')
-    disk_ptable = storage_config.get(device).get('ptable')
+    device = info.get(PART_KEYS.device)
+    size = info.get(PART_KEYS.size)
+    flag = info.get(PART_KEYS.flag)
+    disk_ptable = storage_config.get(device).get(DISK_KEYS.ptable)
     partition_type = None
     if not device:
         raise ValueError("device must be set for partition to be created")
@@ -536,7 +565,8 @@
         raise ValueError("size must be specified for partition to be created")
 
     disk = get_path_to_storage_volume(device, storage_config)
-    partnumber = determine_partition_number(info.get('id'), storage_config)
+    partnumber = determine_partition_number(
+        info.get(GEN_KEYS.id), storage_config)
 
     disk_kname = os.path.split(
         get_path_to_storage_volume(device, storage_config))[-1]
@@ -553,11 +583,11 @@
                                                  logical_block_size_bytes))
 
     if partnumber > 1:
-        if partnumber == 5 and disk_ptable == "msdos":
+        if partnumber == 5 and disk_ptable == PT_TYPES.msdos:
             for key, item in storage_config.items():
-                if item.get('type') == "partition" and \
-                        item.get('device') == device and \
-                        item.get('flag') == "extended":
+                if (item.get(GEN_KEYS.type) == CMD_TYPES.partition and
+                        item.get(PART_KEYS.device) == device and
+                        item.get(PART_KEYS.flag) == PART_FLAGS.extended):
                     extended_part_no = determine_partition_number(
                         key, storage_config)
                     break
@@ -566,9 +596,10 @@
             previous_partition = "/sys/block/%s/%s/" % \
                 (disk_kname, partition_kname)
         else:
-            pnum = find_previous_partition(device, info['id'], storage_config)
+            pnum = find_previous_partition(device, info.get(GEN_KEYS.id),
+                                           storage_config)
             LOG.debug("previous partition number for '%s' found to be '%s'",
-                      info.get('id'), pnum)
+                      info.get(GEN_KEYS.id), pnum)
             partition_kname = determine_partition_kname(disk_kname, pnum)
             previous_partition = "/sys/block/%s/%s/" % \
                 (disk_kname, partition_kname)
@@ -594,12 +625,12 @@
         offset_sectors = alignment_offset
     else:
         # further partitions
-        if disk_ptable == "gpt" or flag != "logical":
+        if disk_ptable == PT_TYPES.gpt or flag != PART_FLAGS.logical:
             # msdos primary and any gpt part start after former partition end
             offset_sectors = previous_start_sectors + previous_size_sectors
         else:
             # msdos extended/logical partitions
-            if flag == "logical":
+            if flag == PART_FLAGS.logical:
                 if partnumber == 5:
                     # First logical partition
                     # start at extended partition start + alignment_offset
@@ -619,49 +650,52 @@
     # logical partitions can't share their start sector with the extended
     # partition and logical partitions can't go head-to-head, so we have to
     # realign and for that increase size as required
-    if info.get('flag') == "extended":
+    if info.get(PART_KEYS.flag) == PART_FLAGS.extended:
         logdisks = getnumberoflogicaldisks(device, storage_config)
         length_sectors = length_sectors + (logdisks * alignment_offset)
 
     # Handle preserve flag
-    if info.get('preserve'):
+    if info.get(GEN_KEYS.preserve):
         return
-    elif storage_config.get(device).get('preserve'):
+    elif storage_config.get(device).get(GEN_KEYS.preserve):
         raise NotImplementedError("Partition '%s' is not marked to be \
             preserved, but device '%s' is. At this time, preserving devices \
             but not also the partitions on the devices is not supported, \
             because of the possibility of damaging partitions intended to be \
-            preserved." % (info.get('id'), device))
+            preserved." % (info.get(GEN_KEYS.id), device))
 
     # Set flag
     # 'sgdisk --list-types'
-    sgdisk_flags = {"boot": 'ef00',
-                    "lvm": '8e00',
-                    "raid": 'fd00',
-                    "bios_grub": 'ef02',
-                    "prep": '4100',
-                    "swap": '8200',
-                    "home": '8302',
-                    "linux": '8300'}
+    sgdisk_flags = {
+        PART_FLAGS.boot:    'ef00',
+        PART_FLAGS.lvm:     '8e00',
+        PART_FLAGS.raid:    'fd00',
+        PART_FLAGS.bios_grub: 'ef02',
+        PART_FLAGS.prep:    '4100',
+        PART_FLAGS.swap:    '8200',
+        PART_FLAGS.home:    '8302',
+        PART_FLAGS.linux:   '8300',
+    }
 
     LOG.info("adding partition '%s' to disk '%s' (ptable: '%s')",
-             info.get('id'), device, disk_ptable)
+             info.get(GEN_KEYS.id), device, disk_ptable)
     LOG.debug("partnum: %s offset_sectors: %s length_sectors: %s",
               partnumber, offset_sectors, length_sectors)
-    if disk_ptable == "msdos":
-        if flag in ["extended", "logical", "primary"]:
+    if disk_ptable == PT_TYPES.msdos:
+        if flag in [PART_FLAGS.extended, PART_FLAGS.logical,
+                    PART_FLAGS.primary]:
             partition_type = flag
         else:
-            partition_type = "primary"
-        cmd = ["parted", disk, "--script", "mkpart", partition_type,
+            partition_type = PART_FLAGS.primary
+        cmd = ["parted", disk, "--script", "mkpart", partition_type.name,
                "%ss" % offset_sectors, "%ss" % str(offset_sectors +
                                                    length_sectors)]
         util.subp(cmd, capture=True)
-    elif disk_ptable == "gpt":
+    elif disk_ptable == PT_TYPES.gpt:
         if flag and flag in sgdisk_flags:
             typecode = sgdisk_flags[flag]
         else:
-            typecode = sgdisk_flags['linux']
+            typecode = sgdisk_flags[PART_FLAGS.linux]
         cmd = ["sgdisk", "--new", "%s:%s:%s" % (partnumber, offset_sectors,
                length_sectors + offset_sectors),
                "--typecode=%s:%s" % (partnumber, typecode), disk]
@@ -670,26 +704,27 @@
         raise ValueError("parent partition has invalid partition table")
 
     # Wipe the partition if told to do so
-    if info.get('wipe') and info.get('wipe') != "none":
+    if info.get(PART_KEYS.wipe) is not None:
         block.wipe_volume(
-            get_path_to_storage_volume(info.get('id'), storage_config),
-            mode=info.get('wipe'))
+            get_path_to_storage_volume(info.get(GEN_KEYS.id), storage_config),
+            mode=info.get(PART_KEYS.wipe))
     # Make the name if needed
-    if storage_config.get(device).get('name') and partition_type != 'extended':
-        make_dname(info.get('id'), storage_config)
+    if (storage_config.get(device).get(GEN_KEYS.name) and
+            partition_type != PART_FLAGS.extended):
+        make_dname(info.get(GEN_KEYS.id), storage_config)
 
 
 def format_handler(info, storage_config):
-    volume = info.get('volume')
+    volume = info.get(FMT_KEYS.volume)
     if not volume:
         raise ValueError("volume must be specified for partition '%s'" %
-                         info.get('id'))
+                         info.get(GEN_KEYS.id))
 
     # Get path to volume
     volume_path = get_path_to_storage_volume(volume, storage_config)
 
     # Handle preserve flag
-    if info.get('preserve'):
+    if info.get(GEN_KEYS.preserve):
         # Volume marked to be preserved, not formatting
         return
 
@@ -700,17 +735,17 @@
 
 def mount_handler(info, storage_config):
     state = util.load_command_environment()
-    path = info.get('path')
-    filesystem = storage_config.get(info.get('device'))
-    if not path and filesystem.get('fstype') != "swap":
+    path = info.get(MOUNT_KEYS.path)
+    filesystem = storage_config.get(info.get(MOUNT_KEYS.device))
+    if not path and filesystem.get(FMT_KEYS.fstype) != FS_TYPES.swap:
         raise ValueError("path to mountpoint must be specified")
-    volume = storage_config.get(filesystem.get('volume'))
+    volume = storage_config.get(filesystem.get(FMT_KEYS.volume))
 
     # Get path to volume
-    volume_path = get_path_to_storage_volume(filesystem.get('volume'),
+    volume_path = get_path_to_storage_volume(filesystem.get(FMT_KEYS.volume),
                                              storage_config)
 
-    if filesystem.get('fstype') != "swap":
+    if filesystem.get(FMT_KEYS.fstype) != FS_TYPES.swap:
         # Figure out what point should be
         while len(path) > 0 and path[0] == "/":
             path = path[1:]
@@ -725,40 +760,41 @@
     # Add volume to fstab
     if state['fstab']:
         with open(state['fstab'], "a") as fp:
-            if volume.get('type') in ["raid", "bcache",
-                                      "disk", "lvm_partition"]:
-                location = get_path_to_storage_volume(volume.get('id'),
+            if volume.get(GEN_KEYS.type) in [CMD_TYPES.disk,
+                                             CMD_TYPES.lvm_partition,
+                                             CMD_TYPES.bcache, CMD_TYPES.raid]:
+                location = get_path_to_storage_volume(volume.get(GEN_KEYS.id),
                                                       storage_config)
-            elif volume.get('type') in ["partition", "dm_crypt"]:
+            elif volume.get(GEN_KEYS.type) in [CMD_TYPES.partition,
+                                               CMD_TYPES.dm_crypt]:
                 location = "UUID=%s" % block.get_volume_uuid(volume_path)
             else:
                 raise ValueError("cannot write fstab for volume type '%s'" %
-                                 volume.get("type"))
+                                 volume.get(GEN_KEYS.type))
 
-            if filesystem.get('fstype') == "swap":
+            if filesystem.get(FMT_KEYS.fstype) == FS_TYPES.swap:
                 path = "none"
                 options = "sw"
             else:
                 path = "/%s" % path
                 options = "defaults"
 
-            if filesystem.get('fstype') in ["fat", "fat12", "fat16", "fat32",
-                                            "fat64"]:
-                fstype = "vfat"
-            else:
-                fstype = filesystem.get('fstype')
-            fp.write("%s %s %s %s 0 0\n" % (location, path, fstype, options))
+            fstype = filesystem.get(FMT_KEYS.fstype)
+            if mkfs.specific_to_family.get(fstype) == FS_TYPES.fat:
+                fstype = FS_TYPES.vfat
+            fp.write("%s %s %s %s 0 0\n" % (location, path, fstype.name,
+                                            options))
     else:
         LOG.info("fstab not in environment, so not writing")
 
 
 def lvm_volgroup_handler(info, storage_config):
-    devices = info.get('devices')
+    devices = info.get(LVM_VG_KEYS.devices)
     device_paths = []
-    name = info.get('name')
+    name = info.get(GEN_KEYS.name)
     if not devices:
         raise ValueError("devices for volgroup '%s' must be specified" %
-                         info.get('id'))
+                         info.get(GEN_KEYS.id))
     if not name:
         raise ValueError("name for volgroups needs to be specified")
 
@@ -771,7 +807,7 @@
                             storage_config))
 
     # Handle preserve flag
-    if info.get('preserve'):
+    if info.get(GEN_KEYS.preserve):
         # LVM will probably be offline, so start it
         util.subp(["vgchange", "-a", "y"])
         # Verify that volgroup exists and contains all specified devices
@@ -785,7 +821,7 @@
         if set(current_paths) != set(device_paths):
             raise ValueError("volgroup '%s' marked to be preserved, but does \
                              not exist or does not contain the right physical \
-                             volumes" % info.get('id'))
+                             volumes" % info.get(GEN_KEYS.id))
     else:
         # Create vgrcreate command and run
         cmd = ["vgcreate", name]
@@ -794,15 +830,16 @@
 
 
 def lvm_partition_handler(info, storage_config):
-    volgroup = storage_config.get(info.get('volgroup')).get('name')
-    name = info.get('name')
+    lvm_vg_info = storage_config.get(info.get(LVM_PART_KEYS.volgroup))
+    volgroup = lvm_vg_info.get(GEN_KEYS.name)
+    name = info.get(GEN_KEYS.name)
     if not volgroup:
         raise ValueError("lvm volgroup for lvm partition must be specified")
     if not name:
         raise ValueError("lvm partition name must be specified")
 
     # Handle preserve flag
-    if info.get('preserve'):
+    if info.get(GEN_KEYS.preserve):
         (out, _err) = util.subp(["lvdisplay", "-C", "--separator", "=", "-o",
                                 "lv_name,vg_name", "--noheadings"],
                                 capture=True)
@@ -815,43 +852,40 @@
         if not found:
             raise ValueError("lvm partition '%s' marked to be preserved, but \
                              does not exist or does not mach storage \
-                             configuration" % info.get('id'))
-    elif storage_config.get(info.get('volgroup')).get('preserve'):
+                             configuration" % info.get(GEN_KEYS.id))
+    elif lvm_vg_info.get(GEN_KEYS.preserve):
         raise NotImplementedError("Lvm Partition '%s' is not marked to be \
             preserved, but volgroup '%s' is. At this time, preserving \
             volgroups but not also the lvm partitions on the volgroup is \
             not supported, because of the possibility of damaging lvm \
-            partitions intended to be preserved." % (info.get('id'), volgroup))
+            partitions intended to be preserved." % (info.get(GEN_KEYS.id),
+                                                     volgroup))
     else:
         cmd = ["lvcreate", volgroup, "-n", name]
-        if info.get('size'):
-            cmd.extend(["-L", info.get('size')])
+        if info.get(LVM_PART_KEYS.size):
+            cmd.extend(["-L", info.get(LVM_PART_KEYS.size)])
         else:
             cmd.extend(["-l", "100%FREE"])
 
         util.subp(cmd)
 
-    if info.get('ptable'):
-        raise ValueError("Partition tables on top of lvm logical volumes is \
-                         not supported")
-
-    make_dname(info.get('id'), storage_config)
+    make_dname(info.get(GEN_KEYS.id), storage_config)
 
 
 def dm_crypt_handler(info, storage_config):
     state = util.load_command_environment()
-    volume = info.get('volume')
-    key = info.get('key')
-    keysize = info.get('keysize')
-    cipher = info.get('cipher')
-    dm_name = info.get('dm_name')
+    volume = info.get(DM_CRYPT_KEYS.volume)
+    key = info.get(DM_CRYPT_KEYS.key)
+    keysize = info.get(DM_CRYPT_KEYS.keysize)
+    cipher = info.get(DM_CRYPT_KEYS.cipher)
+    dm_name = info.get(GEN_KEYS.name)
     if not volume:
         raise ValueError("volume for cryptsetup to operate on must be \
             specified")
     if not key:
         raise ValueError("encryption key must be specified")
     if not dm_name:
-        dm_name = info.get('id')
+        dm_name = info.get(GEN_KEYS.id)
 
     volume_path = get_path_to_storage_volume(volume, storage_config)
 
@@ -893,10 +927,10 @@
 
 def raid_handler(info, storage_config):
     state = util.load_command_environment()
-    devices = info.get('devices')
-    raidlevel = info.get('raidlevel')
-    spare_devices = info.get('spare_devices')
-    md_devname = block.dev_path(info.get('name'))
+    devices = info.get(RAID_KEYS.devices)
+    raidlevel = info.get(RAID_KEYS.raidlevel)
+    spare_devices = info.get(RAID_KEYS.spare_devices)
+    md_devname = block.dev_path(info.get(GEN_KEYS.name))
     if not devices:
         raise ValueError("devices for raid must be specified")
     if raidlevel not in ['linear', 'raid0', 0, 'stripe', 'raid1', 1, 'mirror',
@@ -906,7 +940,9 @@
         if spare_devices:
             raise ValueError("spareunsupported in raidlevel '%s'" % raidlevel)
 
-    LOG.debug('raid: cfg: {}'.format(util.json_dumps(info)))
+    # this log message previously used util.json_dumps, but enums cause json to
+    # crash, so just output md name and devices instead
+    LOG.debug('raid: name: {}, devices:{}'.format(md_devname, devices))
     device_paths = list(get_path_to_storage_volume(dev, storage_config) for
                         dev in devices)
     LOG.debug('raid: device path mapping: {}'.format(
@@ -920,7 +956,7 @@
                   zip(spare_devices, spare_device_paths)))
 
     # Handle preserve flag
-    if info.get('preserve'):
+    if info.get(GEN_KEYS.preserve):
         # check if the array is already up, if not try to assemble
         if not mdadm.md_check(md_devname, raidlevel,
                               device_paths, spare_device_paths):
@@ -939,10 +975,10 @@
 
     mdadm.mdadm_create(md_devname, raidlevel,
                        device_paths, spare_device_paths,
-                       info.get('mdname', ''))
+                       info.get(RAID_KEYS.mdname, ''))
 
     # Make dname rule for this dev
-    make_dname(info.get('id'), storage_config)
+    make_dname(info.get(GEN_KEYS.id), storage_config)
 
     # A mdadm.conf will be created in the same directory as the fstab in the
     # configuration. This will then be copied onto the installed system later.
@@ -961,16 +997,16 @@
 
     # If ptable is specified, call disk_handler on this mdadm device to create
     # the table
-    if info.get('ptable'):
+    if info.get(RAID_KEYS.ptable):
         disk_handler(info, storage_config)
 
 
 def bcache_handler(info, storage_config):
-    backing_device = get_path_to_storage_volume(info.get('backing_device'),
-                                                storage_config)
-    cache_device = get_path_to_storage_volume(info.get('cache_device'),
-                                              storage_config)
-    cache_mode = info.get('cache_mode', None)
+    backing_device = get_path_to_storage_volume(
+        info.get(BCACHE_KEYS.backing_device), storage_config)
+    cache_device = get_path_to_storage_volume(
+        info.get(BCACHE_KEYS.cache_device), storage_config)
+    cache_mode = info.get(BCACHE_KEYS.cache_mode)
 
     if not backing_device or not cache_device:
         raise ValueError("backing device and cache device for bcache"
@@ -1093,74 +1129,58 @@
             cache_mode_file = \
                 '/sys/block/{}/bcache/cache_mode'.format(bcache_dev)
             with open(cache_mode_file, "w") as fp:
-                fp.write(cache_mode)
+                fp.write(cache_mode.name)
     else:
         # no backing device
         if cache_mode:
             raise ValueError("cache mode specified which can only be set per \
                               backing devices, but none was specified")
 
-    if info.get('name'):
+    if info.get(GEN_KEYS.name):
         # Make dname rule for this dev
-        make_dname(info.get('id'), storage_config)
+        make_dname(info.get(GEN_KEYS.id), storage_config)
 
-    if info.get('ptable'):
-        raise ValueError("Partition tables on top of lvm logical volumes is \
-                         not supported")
     LOG.debug('Finished bcache creation for backing {} or caching {}'
               .format(backing_device, cache_device))
 
 
-def extract_storage_ordered_dict(config):
-    storage_config = config.get('storage', {})
-    if not storage_config:
-        raise ValueError("no 'storage' entry in config")
-    scfg = storage_config.get('config')
-    if not scfg:
-        raise ValueError("invalid storage config data")
-
-    # Since storage config will often have to be searched for a value by its
-    # id, and this can become very inefficient as storage_config grows, a dict
-    # will be generated with the id of each component of the storage_config as
-    # its index and the component of storage_config as its value
-    return OrderedDict((d["id"], d) for (i, d) in enumerate(scfg))
-
-
 def meta_custom(args):
-    """Does custom partitioning based on the layout provided in the config
+    """
+    Does custom partitioning based on the layout provided in the config
     file. Section with the name storage contains information on which
     partitions on which disks to create. It also contains information about
     overlays (raid, lvm, bcache) which need to be setup.
     """
 
     command_handlers = {
-        'disk': disk_handler,
-        'partition': partition_handler,
-        'format': format_handler,
-        'mount': mount_handler,
-        'lvm_volgroup': lvm_volgroup_handler,
-        'lvm_partition': lvm_partition_handler,
-        'dm_crypt': dm_crypt_handler,
-        'raid': raid_handler,
-        'bcache': bcache_handler
+        CMD_TYPES.disk:             disk_handler,
+        CMD_TYPES.partition:        partition_handler,
+        CMD_TYPES.format:           format_handler,
+        CMD_TYPES.mount:            mount_handler,
+        CMD_TYPES.lvm_volgroup:     lvm_volgroup_handler,
+        CMD_TYPES.lvm_partition:    lvm_partition_handler,
+        CMD_TYPES.dm_crypt:         dm_crypt_handler,
+        CMD_TYPES.raid:             raid_handler,
+        CMD_TYPES.bcache:           bcache_handler
     }
 
     state = util.load_command_environment()
     cfg = config.load_command_config(args, state)
 
-    storage_config_dict = extract_storage_ordered_dict(cfg)
+    storage_config_dict = sc.StorageConfig(cfg)
 
     # set up reportstack
     stack_prefix = state.get('report_stack_prefix', '')
 
     for item_id, command in storage_config_dict.items():
-        handler = command_handlers.get(command['type'])
+        handler = command_handlers.get(command.get(GEN_KEYS.type))
         if not handler:
-            raise ValueError("unknown command type '%s'" % command['type'])
+            raise ValueError("unknown command type '%s'" %
+                             command.get(GEN_KEYS.type))
         with events.ReportEventStack(
                 name=stack_prefix, reporting_enabled=True, level="INFO",
-                description="configuring %s: %s" % (command['type'],
-                                                    command['id'])):
+                description="configuring %s: %s" % (command.get(GEN_KEYS.type),
+                                                    command.get(GEN_KEYS.id))):
             try:
                 handler(command, storage_config_dict)
             except Exception as error:

=== modified file 'curtin/commands/block_wipe.py'
--- curtin/commands/block_wipe.py	2016-04-04 20:12:01 +0000
+++ curtin/commands/block_wipe.py	2016-06-14 21:02:46 +0000
@@ -17,14 +17,17 @@
 
 import sys
 import curtin.block as block
+from curtin.block import WIPE_MODES
+from curtin import enum
 from . import populate_one_subcmd
 
 
 def wipe_main(args):
     #  curtin clear-holders device [device2 [device3]]
+    wipe_mode = enum.convert_to_enum(WIPE_MODES, args.wipe_mode)
     for blockdev in args.devices:
         try:
-            block.wipe_volume(blockdev, mode=args.mode)
+            block.wipe_volume(blockdev, mode=wipe_mode)
         except Exception as e:
             sys.stderr.write(
                 "Failed to wipe volume %s in mode %s: %s" %
@@ -36,8 +39,8 @@
 CMD_ARGUMENTS = (
     ((('-m', '--mode'),
       {'help': 'mode for wipe.', 'action': 'store',
-       'default': 'superblocks',
-       'choices': ['zero', 'superblock', 'superblock-recursive', 'random']}),
+       'default': WIPE_MODES.superblock.name,
+       'choices': sorted(enum.enum_names(WIPE_MODES))}),
      ('devices',
       {'help': 'devices to wipe', 'default': [], 'nargs': '+'}),
      )

=== modified file 'curtin/commands/curthooks.py'
--- curtin/commands/curthooks.py	2016-05-17 21:14:36 +0000
+++ curtin/commands/curthooks.py	2016-06-14 21:02:46 +0000
@@ -377,8 +377,8 @@
 
     # FIXME: these methods need moving to curtin.block
     # and using them from there rather than commands.block_meta
-    from curtin.commands.block_meta import (extract_storage_ordered_dict,
-                                            get_path_to_storage_volume)
+    from curtin.commands.block_meta import get_path_to_storage_volume
+    from curtin.block import storage_config
 
     grubcfg = cfg.get('grub', {})
 
@@ -390,14 +390,14 @@
     # if there is storage config, look for devices tagged with 'grub_device'
     storage_cfg_odict = None
     try:
-        storage_cfg_odict = extract_storage_ordered_dict(cfg)
+        storage_cfg_odict = storage_config.StorageConfig(cfg)
     except ValueError as e:
         pass
 
     if storage_cfg_odict:
         storage_grub_devices = []
         for item_id, item in storage_cfg_odict.items():
-            if not item.get('grub_device'):
+            if not item.get(storage_config.DISK_KEYS.grub_device):
                 continue
             LOG.debug("checking: %s", item)
             storage_grub_devices.append(

=== modified file 'curtin/commands/mkfs.py'
--- curtin/commands/mkfs.py	2016-01-19 00:51:51 +0000
+++ curtin/commands/mkfs.py	2016-06-14 21:02:46 +0000
@@ -17,7 +17,8 @@
 
 from . import populate_one_subcmd
 from curtin.block.mkfs import mkfs as run_mkfs
-from curtin.block.mkfs import valid_fstypes
+from curtin.block.mkfs import FS_TYPES
+from curtin import enum
 
 import sys
 
@@ -28,7 +29,7 @@
        'metavar': 'DEVICE', 'action': 'store', 'nargs': '+'}),
      (('-f', '--fstype'),
       {'help': 'filesystem type to use. default is ext4',
-       'choices': sorted(valid_fstypes()),
+       'choices': sorted(enum.enum_names(FS_TYPES)),
        'default': 'ext4', 'action': 'store'}),
      (('-l', '--label'),
       {'help': 'label to use for filesystem', 'action': 'store'}),
@@ -45,13 +46,14 @@
 
 
 def mkfs(args):
+    fstype = enum.convert_to_enum(FS_TYPES, args.fstype)
     for device in args.devices:
-        uuid = run_mkfs(device, args.fstype, strict=args.strict,
+        uuid = run_mkfs(device, fstype, strict=args.strict,
                         uuid=args.uuid, label=args.label,
                         force=args.force)
 
         print("Created '%s' filesystem in '%s' with uuid '%s' and label '%s'" %
-              (args.fstype, device, uuid, args.label))
+              (fstype.name, device, uuid, args.label))
 
     sys.exit(0)
 

=== added file 'curtin/enum.py'
--- curtin/enum.py	1970-01-01 00:00:00 +0000
+++ curtin/enum.py	2016-06-14 21:02:46 +0000
@@ -0,0 +1,90 @@
+#   Copyright (C) 2016 Canonical Ltd.
+#
+#   Author: Wesley Wiedenmeier <[e-mail]>
+#
+#   Curtin is free software: you can redistribute it and/or modify it under
+#   the terms of the GNU Affero General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   Curtin is distributed in the hope that it will be useful, but WITHOUT ANY
+#   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for
+#   more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with Curtin.  If not, see <http://www.gnu.org/licenses/>.
+
+# this provides a python2 and python3 compatible enum class
+# it was written by harlowja at:
+# https://gist.github.com/harlowja/f60d91128a1fcd99d30d27715d5a9a30
+
+from __future__ import absolute_import
+
+try:
+    import enum
+except ImportError:
+    enum = None
+
+
+def enum_names(enum):
+    return [i.name for i in enum]
+
+
+def convert_to_enum(enum_t, attr_name):
+    """convert attr_name to instance of enum_t"""
+    # the fallback enum method will not work with isinstance, use comparison
+    if (isinstance(attr_name, enum_t) or attr_name in enum_t):
+        return attr_name
+    elif isinstance(attr_name, str):
+        try:
+            return enum_t[attr_name]
+        except KeyError:
+            raise ValueError("'{}' not a valid value for '{}'"
+                             .format(attr_name, enum_t))
+    raise ValueError("invalid input type for enum {}".format(attr_name))
+
+
+def make_enum(cls_name, enums):
+    # Basic validations.
+    if not enums:
+        raise ValueError("At least one enum name must be provided")
+    if not cls_name:
+        raise ValueError("A class name must be provided")
+    for e in enums:
+        # cannot use six.string_types as six module is not present in precise
+        # ephemeral image
+        if not isinstance(e, (str, bytes)):
+            raise TypeError("Enum name '%s' must be a string type" % e)
+    # Just use the built-in one (if we can).
+    if enum is not None:
+        return enum.Enum(cls_name, enums)
+    else:
+        # Otherwise make a good enough equivalent.
+
+        class EnumValue(object):
+            __slots__ = ('name', 'value')
+
+            def __init__(self, name, value):
+                self.name = name
+                self.value = value
+
+            def __repr__(self):
+                return "<%s.%s: %s>" % (cls_name, self.name, self.value)
+
+        enums_vals = [EnumValue(e, i + 1) for i, e in enumerate(enums)]
+        enum_dict = dict(zip(enums, enums_vals))
+
+        class EnumMeta(type):
+
+            def __new__(cls, name, parents, dct):
+                return super(EnumMeta, cls).__new__(cls, name, parents, dct)
+
+            def __iter__(self):
+                for e in enums_vals:
+                    yield e
+
+            def __getitem__(self, item):
+                return enum_dict[item]
+
+        return EnumMeta(cls_name, (object,), enum_dict)

=== modified file 'curtin/reporter/events.py'
--- curtin/reporter/events.py	2016-05-06 17:21:33 +0000
+++ curtin/reporter/events.py	2016-06-14 21:02:46 +0000
@@ -25,6 +25,7 @@
 import time
 
 from . import instantiated_handler_registry
+from curtin import enum
 
 FINISH_EVENT_TYPE = 'finish'
 START_EVENT_TYPE = 'start'
@@ -32,15 +33,7 @@
 
 DEFAULT_EVENT_ORIGIN = 'curtin'
 
-
-class _nameset(set):
-    def __getattr__(self, name):
-        if name in self:
-            return name
-        raise AttributeError("%s not a valid value" % name)
-
-
-status = _nameset(("SUCCESS", "WARN", "FAIL"))
+status = enum.make_enum('status', ('SUCCESS', 'WARN', 'FAIL'))
 
 
 class ReportingEvent(object):
@@ -87,12 +80,12 @@
 
     def as_string(self):
         return '{0}: {1}: {2}: {3}'.format(
-            self.event_type, self.name, self.result, self.description)
+            self.event_type, self.name, self.result.name, self.description)
 
     def as_dict(self):
         """The event represented as json friendly."""
         data = super(FinishReportingEvent, self).as_dict()
-        data['result'] = self.result
+        data['result'] = self.result.name
         if self.post_files:
             data['files'] = _collect_file_info(self.post_files)
         if self.result == status.WARN:

=== modified file 'tests/unittests/test_block_mkfs.py'
--- tests/unittests/test_block_mkfs.py	2016-04-07 20:47:33 +0000
+++ tests/unittests/test_block_mkfs.py	2016-06-14 21:02:46 +0000
@@ -1,4 +1,6 @@
 from curtin.block import mkfs
+from curtin.block.mkfs import (FMT_KEYS, FS_TYPES)
+from curtin.block.storage_config import (GEN_KEYS, CMD_TYPES)
 
 from unittest import TestCase
 import mock
@@ -8,9 +10,16 @@
     test_uuid = "fb26cc6c-ae73-11e5-9e38-2fb63f0c3155"
 
     def _get_config(self, fstype):
-        return {"fstype": fstype, "type": "format", "id": "testfmt",
-                "volume": "null", "label": "format1",
-                "uuid": self.test_uuid}
+        try:
+            fs_type_enum = FS_TYPES[fstype]
+        except KeyError:
+            fs_type_enum = None
+        return {FMT_KEYS.fstype: fs_type_enum,
+                GEN_KEYS.type: CMD_TYPES.format,
+                GEN_KEYS.id: "testfmt",
+                FMT_KEYS.volume: "null",
+                FMT_KEYS.label: "format1",
+                FMT_KEYS.uuid: self.test_uuid}
 
     def _assert_same_flags(self, call, expected):
         print("call:\n{}".format(call))
@@ -104,13 +113,16 @@
         """Do not proceed if filesystem label is too long"""
         with self.assertRaises(ValueError):
             conf = self._get_config("ext4")
-            conf['label'] = "thislabelislongerthan16chars"
-            self._run_mkfs_with_config(conf, "mkfs.ext4", [], strict=True)
+            conf[FMT_KEYS.label] = "thislabelislongerthan16chars"
+            expected_flags = ["-F", ["-L", conf[FMT_KEYS.label]],
+                              ["-U", self.test_uuid]]
+            self._run_mkfs_with_config(conf, "mkfs.ext4", expected_flags,
+                                       strict=True)
 
         conf = self._get_config("swap")
         expected_flags = ["--force", ["--label", "abcdefghijklmno"],
-                          ["--uuid", conf['uuid']]]
-        conf['label'] = "abcdefghijklmnop"  # 16 chars, 15 is max
+                          ["--uuid", self.test_uuid]]
+        conf[FMT_KEYS.label] = "abcdefghijklmnop"  # 16 chars, 15 is max
 
         # Raise error, do not truncate with strict = True
         with self.assertRaises(ValueError):

=== added file 'tests/unittests/test_enum.py'
--- tests/unittests/test_enum.py	1970-01-01 00:00:00 +0000
+++ tests/unittests/test_enum.py	2016-06-14 21:02:46 +0000
@@ -0,0 +1,88 @@
+from unittest import (TestCase, skipIf)
+from curtin import enum as curtin_enum
+
+try:
+    import enum as builtin_enum
+except:
+    builtin_enum = None
+
+
+class _disable_builtin_enum(object):
+    def __init__(self, curtin_enum_instance):
+        self.curtin_enum_instance = curtin_enum_instance
+
+    def __enter__(self):
+        self.curtin_enum_instance_old_enum = self.curtin_enum_instance.enum
+        self.curtin_enum_instance.enum = None
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.curtin_enum_instance.enum = self.curtin_enum_instance_old_enum
+
+
+@skipIf(builtin_enum is None,
+        'TestEnum disabled when enum module is not available')
+class TestEnum(TestCase):
+    def _get_colors_enum(self):
+        return curtin_enum.make_enum('colors', ['red', 'green', 'blue'])
+
+    def test_enum_selection(self):
+        """Ensure that curtin.enum uses py3 enum when available"""
+        self.assertEqual(builtin_enum, curtin_enum.enum)
+        if builtin_enum is not None:
+            self.assertTrue(isinstance(self._get_colors_enum(),
+                                       builtin_enum.EnumMeta))
+        with _disable_builtin_enum(curtin_enum):
+            self.assertFalse(isinstance(self._get_colors_enum(),
+                                        builtin_enum.EnumMeta))
+
+    def test_fallback_enum_comparisons(self):
+        """Ensure that the fallback curtin.enum handles comparisons"""
+        with _disable_builtin_enum(curtin_enum):
+            colors = self._get_colors_enum()
+            self.assertEqual(colors.red, colors.red)
+            self.assertIs(colors.red, colors.red)
+            self.assertNotEqual(colors.blue, colors.red)
+            self.assertIsNot(colors.blue, colors.red)
+            self.assertNotEqual(colors.blue, 'blue')
+            self.assertNotEqual(colors.blue, 3)
+            self.assertEqual(colors.blue.value, 3)
+            self.assertEqual(colors.blue.name, 'blue')
+
+    def test_fallback_enum_meta(self):
+        """Ensure that the fallback enum meta works"""
+        with _disable_builtin_enum(curtin_enum):
+            colors = self._get_colors_enum()
+            for color, expected in zip(colors, ('red', 'green', 'blue')):
+                self.assertEqual(color.name, expected)
+            self.assertEqual(colors['red'].name, 'red')
+            with self.assertRaises(KeyError):
+                colors['purple']
+
+    def test_enum_names(self):
+        """Ensure that enum names works with both builtin and fallback enum"""
+        self.assertEqual(curtin_enum.enum_names(self._get_colors_enum()),
+                         ['red', 'green', 'blue'])
+        with _disable_builtin_enum(curtin_enum):
+            self.assertEqual(curtin_enum.enum_names(self._get_colors_enum()),
+                             ['red', 'green', 'blue'])
+
+    def test_convert_to_enum(self):
+        """Ensure that enum.convert_to_enum() works"""
+        colors = self._get_colors_enum()
+        self.assertEqual(curtin_enum.convert_to_enum(colors, colors.red),
+                         colors.red)
+        self.assertEqual(curtin_enum.convert_to_enum(colors, 'green'),
+                         colors.green)
+        with self.assertRaises(ValueError):
+            curtin_enum.convert_to_enum(colors, 'purple')
+        with self.assertRaises(ValueError):
+            curtin_enum.convert_to_enum(colors, dict())
+
+    def test_convert_to_enum_use_fallback(self):
+        """Ensure that enum.convert_to_enum() works with fallback enum"""
+        with _disable_builtin_enum(curtin_enum):
+            colors = self._get_colors_enum()
+            self.assertEqual(curtin_enum.convert_to_enum(colors, colors.red),
+                             colors.red)
+            self.assertEqual(curtin_enum.convert_to_enum(colors, 'green'),
+                             colors.green)