Merge lp:~sil2100/ubuntu-system-image/server_script_testability into lp:ubuntu-system-image/server

[Łukasz Zemczak]

Make scripts implemented as part of a Script class, making them more easily testable. Add some basic tests for the first two migrated - copy-image and tag-image.

The general script-testability branch. It's something I'm working on part-time between all other things - so far only two scripts are being migrated. Submitting for early review.

[Łukasz Zemczak (sil2100)]

I wouldn't land this right now even without writing more tests, but I'd like to gather some feedback in the meantime when I'm busy with other duties.

[Barry Warsaw (barry)]

In general I really like the direction you're going in with this. More tests == better!

review: Approve

[lp:~sil2100/ubuntu-system-image/server_script_testability]

287. By Łukasz Zemczak on 2016-02-16

Add test for the script execute for tag-image. Fix a bug in setting the phased percentage after tagging (detected thanks to the unit test).

288. By Łukasz Zemczak on 2016-04-14

Add more tests for scripts.

289. By Łukasz Zemczak on 2016-04-14

Move the script classes to a separate script directory. Update copyright.

290. By Łukasz Zemczak on 2016-04-19

Fix script tests. Port the phased percentage script to the new framework, add tests.

291. By Łukasz Zemczak on 2016-04-19

Actually use the new script in the bin/ script of phased percentage.

292. By Łukasz Zemczak on 2016-07-20

Merge trunk.

293. By Łukasz Zemczak on 2016-07-20

Backport the new per-device redirect checks to scripts, add tests for those cases. Fix a few existing test failures.

294. By Łukasz Zemczak on 2016-07-20

pep8 fixes.

Unmerged revisions

294. By Łukasz Zemczak on 2016-07-20

pep8 fixes.

293. By Łukasz Zemczak on 2016-07-20

Backport the new per-device redirect checks to scripts, add tests for those cases. Fix a few existing test failures.

292. By Łukasz Zemczak on 2016-07-20

Merge trunk.

291. By Łukasz Zemczak on 2016-04-19

Actually use the new script in the bin/ script of phased percentage.

290. By Łukasz Zemczak on 2016-04-19

Fix script tests. Port the phased percentage script to the new framework, add tests.

289. By Łukasz Zemczak on 2016-04-14

Move the script classes to a separate script directory. Update copyright.

288. By Łukasz Zemczak on 2016-04-14

Add more tests for scripts.

287. By Łukasz Zemczak on 2016-02-16

Add test for the script execute for tag-image. Fix a bug in setting the phased percentage after tagging (detected thanks to the unit test).

286. By Łukasz Zemczak on 2016-01-21

PEP8 fixes to scripts.py.

285. By Łukasz Zemczak on 2016-01-21

Add arg parsing tests for the tag script as well. Do some PEP8 syntax fixes.

=== modified file 'bin/copy-image' (properties changed: +x to -x)
--- bin/copy-image	2016-06-24 21:02:18 +0000
+++ bin/copy-image	2016-07-20 12:34:06 +0000
@@ -1,8 +1,8 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2013 Canonical Ltd.
-# Author: Stéphane Graber <[e-mail]>
+# Copyright (C) 2015-2016 Canonical Ltd.
+# Author: Łukasz 'sil2100' Zemczak <[e-mail]>
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -16,284 +16,18 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import json
 import os
 import sys
+
 sys.path.insert(0, os.path.join(sys.path[0], os.pardir, "lib"))
 
-from systemimage import config, generators, tools, tree
-
-import argparse
-import fcntl
-import logging
+from systemimage.scripts import script_copy_image
+
+
+def main():
+    script = script_copy_image.CopyImageScript()
+    script.run(sys.argv)
+
 
 if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description="image copier")
-    parser.add_argument("source_channel", metavar="SOURCE-CHANNEL")
-    parser.add_argument("destination_channel", metavar="DESTINATION-CHANNEL")
-    parser.add_argument("device", metavar="DEVICE")
-    parser.add_argument("version", metavar="VERSION", type=int)
-    parser.add_argument("-k", "--keep-version", action="store_true",
-                        help="Keep the original version number")
-    parser.add_argument("-p", "--phased-percentage", type=int,
-                        help="Set the phased percentage for the copied image",
-                        default=100)
-    parser.add_argument("-t", "--tag", type=str,
-                        help="Set a version tag on the new image")
-    parser.add_argument("--verbose", "-v", action="count", default=0)
-
-    args = parser.parse_args()
-
-    # Setup logging
-    formatter = logging.Formatter(
-        "%(asctime)s %(levelname)s %(message)s")
-
-    levels = {1: logging.ERROR,
-              2: logging.WARNING,
-              3: logging.INFO,
-              4: logging.DEBUG}
-
-    if args.verbose > 0:
-        stdoutlogger = logging.StreamHandler(sys.stdout)
-        stdoutlogger.setFormatter(formatter)
-        logging.root.setLevel(levels[min(4, args.verbose)])
-        logging.root.addHandler(stdoutlogger)
-    else:
-        logging.root.addHandler(logging.NullHandler())
-
-    # Load the configuration
-    conf = config.Config()
-
-    # Try to acquire a global lock
-    lock_file = os.path.join(conf.state_path, "global.lock")
-    lock_fd = open(lock_file, 'w')
-
-    try:
-        fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-    except IOError:
-        print("Something else holds the global lock. exiting.")
-        sys.exit(0)
-
-    # Load the tree
-    pub = tree.Tree(conf)
-
-    # Do some checks
-    channels = pub.list_channels()
-    if args.source_channel not in channels:
-        parser.error("Invalid source channel: %s" % args.source_channel)
-
-    if args.destination_channel not in channels:
-        parser.error("Invalid destination channel: %s" %
-                     args.destination_channel)
-
-    if args.device not in channels[args.source_channel]['devices']:
-        parser.error("Invalid device for source channel: %s" %
-                     args.device)
-
-    if args.device not in \
-            channels[args.destination_channel]['devices']:
-        parser.error("Invalid device for destination channel: %s" %
-                     args.device)
-
-    if "alias" in channels[args.source_channel] and \
-            channels[args.source_channel]['alias'] \
-            != args.source_channel:
-        parser.error("Source channel is an alias.")
-
-    if "alias" in channels[args.destination_channel] and \
-            channels[args.destination_channel]['alias'] \
-            != args.destination_channel:
-        parser.error("Destination channel is an alias.")
-
-    if "redirect" in channels[args.source_channel]:
-        parser.error("Source channel is a redirect.")
-
-    if "redirect" in channels[args.destination_channel]:
-        parser.error("Destination channel is a redirect.")
-
-    src_device = channels[args.source_channel]['devices'][args.device]
-    if "redirect" in src_device:
-        parser.error("Source device is a redirect. Use original channel "
-                     "%s instead." % src_device['redirect'])
-
-    dest_device = channels[args.destination_channel]['devices'][args.device]
-    if "redirect" in dest_device:
-        parser.error("Destination device is a redirect. Use original channel "
-                     "%s instead." % dest_device['redirect'])
-
-    if args.tag and "," in args.tag:
-        parser.error("Image tag cannot include the character ','.")
-
-    source_device = pub.get_device(args.source_channel, args.device)
-    destination_device = pub.get_device(args.destination_channel, args.device)
-
-    if args.keep_version:
-        images = [image for image in destination_device.list_images()
-                  if image['version'] == args.version]
-        if images:
-            parser.error("Version number is already used: %s" % args.version)
-
-    # Assign a new version number
-    new_version = args.version
-    if not args.keep_version:
-        # Find the next available version
-        new_version = 1
-        for image in destination_device.list_images():
-            if image['version'] >= new_version:
-                new_version = image['version'] + 1
-    logging.debug("Version for next image: %s" % new_version)
-
-    # Extract the build we want to copy
-    images = [image for image in source_device.list_images()
-              if image['type'] == "full" and image['version'] == args.version]
-    if not images:
-        parser.error("Can't find version: %s" % args.version)
-    source_image = images[0]
-
-    # Extract the list of existing full images
-    full_images = {image['version']: image
-                   for image in destination_device.list_images()
-                   if image['type'] == "full"}
-
-    # Check that the last full and the new image aren't one and the same
-    source_files = [entry['path'].split("/")[-1]
-                    for entry in source_image['files']
-                    if not entry['path'].split("/")[-1].startswith("version-")]
-    destination_files = []
-    if full_images:
-        latest_full = sorted(full_images.values(),
-                             key=lambda image: image['version'])[-1]
-        destination_files = [entry['path'].split("/")[-1]
-                             for entry in latest_full['files']
-                             if not entry['path'].split(
-                                 "/")[-1].startswith("version-")]
-    if source_files == destination_files:
-        parser.error("Source image is already latest full in "
-                     "destination channel.")
-
-    # Generate a list of required deltas
-    delta_base = tools.get_required_deltas(
-        conf, pub, args.destination_channel, args.device)
-
-    # Create new empty entries
-    new_images = {'full': {'files': []}}
-    for delta in delta_base:
-        new_images['delta_%s' % delta['version']] = {'files': []}
-
-    # Extract current version_detail and files
-    version_detail = tools.extract_files_and_version(
-        conf, source_image['files'], args.version, new_images['full']['files'])
-
-    # Generate new version tarball
-    environment = {}
-    environment['channel_name'] = args.destination_channel
-    environment['device'] = destination_device
-    environment['device_name'] = args.device
-    environment['version'] = new_version
-    environment['version_detail'] = [entry
-                                     for entry in version_detail.split(",")
-                                     if not entry.startswith("version=")]
-    environment['new_files'] = new_images['full']['files']
-
-    # Add new tag if requested
-    if args.tag:
-        tools.set_tag_on_version_detail(
-            environment['version_detail'], args.tag)
-        logging.info("Setting tag for image to '%s'" % args.tag)
-
-    logging.info("Generating new version tarball for '%s' (%s)"
-                 % (new_version, ",".join(environment['version_detail'])))
-    version_path = generators.generate_file(conf, "version", [], environment)
-    if version_path:
-        new_images['full']['files'].append(version_path)
-
-    # Generate deltas
-    for abspath in new_images['full']['files']:
-        prefix = abspath.split("/")[-1].rsplit("-", 1)[0]
-        for delta in delta_base:
-            # Extract the source
-            src_path = None
-            for file_dict in delta['files']:
-                if (file_dict['path'].split("/")[-1]
-                        .startswith(prefix)):
-                    src_path = "%s/%s" % (conf.publish_path,
-                                          file_dict['path'])
-                    break
-
-            # Check that it's not the current file
-            if src_path:
-                src_path = os.path.realpath(src_path)
-
-                # FIXME: the keyring- is a big hack...
-                if src_path == abspath and "keyring-" not in src_path:
-                    continue
-
-                # Generators are allowed to return None when no delta
-                # exists at all.
-                logging.info("Generating delta from '%s' for '%s'" %
-                             (delta['version'],
-                              prefix))
-                delta_path = generators.generate_delta(conf, src_path,
-                                                       abspath)
-            else:
-                delta_path = abspath
-
-            if not delta_path:
-                continue
-
-            # Get the full and relative paths
-            delta_abspath, delta_relpath = tools.expand_path(
-                delta_path, conf.publish_path)
-
-            new_images['delta_%s' % delta['version']]['files'] \
-                .append(delta_abspath)
-
-    # Add full image
-    logging.info("Publishing new image '%s' (%s) with %s files."
-                 % (new_version, ",".join(environment['version_detail']),
-                    len(new_images['full']['files'])))
-    destination_device.create_image(
-        "full", new_version, ",".join(environment['version_detail']),
-        new_images['full']['files'],
-        version_detail=",".join(environment['version_detail']))
-
-    # Add delta images
-    for delta in delta_base:
-        files = new_images['delta_%s' % delta['version']]['files']
-        logging.info("Publishing new delta from '%s' (%s)"
-                     " to '%s' (%s) with %s files" %
-                     (delta['version'], delta.get("description", ""),
-                      new_version, ",".join(environment['version_detail']),
-                      len(files)))
-
-        destination_device.create_image(
-            "delta", new_version,
-            ",".join(environment['version_detail']),
-            files,
-            base=delta['version'],
-            version_detail=",".join(environment['version_detail']))
-
-    # Set the phased percentage value for the new image
-    logging.info("Setting phased percentage of the new image to %s%%" %
-                 args.phased_percentage)
-    destination_device.set_phased_percentage(
-        new_version, args.phased_percentage)
-
-    # Expire images
-    if args.destination_channel in conf.channels:
-        if conf.channels[args.destination_channel].fullcount > 0:
-            logging.info("Expiring old images")
-            destination_device.expire_images(
-                conf.channels[args.destination_channel].fullcount)
-
-    # Sync all channel aliases
-    logging.info("Syncing any existing alias")
-    pub.sync_aliases(args.destination_channel)
-
-    # Remove any orphaned file
-    logging.info("Removing orphaned files from the pool")
-    pub.cleanup_tree()
-
-    # Sync the mirrors
-    logging.info("Triggering a mirror sync")
-    tools.sync_mirrors(conf)
+    main()
 
=== modified file 'bin/set-phased-percentage' (properties changed: +x to -x)
--- bin/set-phased-percentage	2016-06-24 21:02:18 +0000
+++ bin/set-phased-percentage	2016-07-20 12:34:06 +0000
@@ -20,77 +20,13 @@
 import sys
 sys.path.insert(0, os.path.join(sys.path[0], os.pardir, "lib"))
 
-from systemimage import config, tools, tree
-
-import argparse
-import logging
+from systemimage.scripts import script_set_phased_percentage
+
+
+def main():
+    script = script_set_phased_percentage.SetPhasedPercentageScript()
+    script.run(sys.argv)
+
 
 if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description="set phased percentage")
-    parser.add_argument("channel", metavar="CHANNEL")
-    parser.add_argument("device", metavar="DEVICE")
-    parser.add_argument("version", metavar="VERSION", type=int)
-    parser.add_argument("percentage", metavar="PERCENTAGE", type=int)
-    parser.add_argument("--verbose", "-v", action="count")
-
-    args = parser.parse_args()
-
-    # Setup logging
-    formatter = logging.Formatter(
-        "%(asctime)s %(levelname)s %(message)s")
-
-    levels = {1: logging.ERROR,
-              2: logging.WARNING,
-              3: logging.INFO,
-              4: logging.DEBUG}
-
-    if args.verbose > 0:
-        stdoutlogger = logging.StreamHandler(sys.stdout)
-        stdoutlogger.setFormatter(formatter)
-        logging.root.setLevel(levels[min(4, args.verbose)])
-        logging.root.addHandler(stdoutlogger)
-    else:
-        logging.root.addHandler(logging.NullHandler())
-
-    # Load the configuration
-    conf = config.Config()
-
-    # Load the tree
-    pub = tree.Tree(conf)
-
-    # Do some checks
-    channels = pub.list_channels()
-    if args.channel not in channels:
-        parser.error("Invalid channel: %s" % args.channel)
-
-    if args.device not in channels[args.channel]['devices']:
-        parser.error("Invalid device for source channel: %s" %
-                     args.device)
-
-    if args.percentage < 0 or args.percentage > 100:
-        parser.error("Invalid value: %s" % args.percentage)
-
-    if "alias" in channels[args.channel] and \
-            channels[args.channel]['alias'] != args.channel:
-        parser.error("Channel is an alias.")
-
-    if "redirect" in channels[args.channel]:
-        parser.error("Channel is a redirect.")
-
-    target_device = channels[args.channel]['devices'][args.device]
-    if "redirect" in target_device:
-        parser.error("Target device is a redirect. Use original channel "
-                     "%s instead." % target_device['redirect'])
-
-    dev = pub.get_device(args.channel, args.device)
-    logging.info("Setting phased-percentage of '%s' to %s%%" %
-                 (args.version, args.percentage))
-    dev.set_phased_percentage(args.version, args.percentage)
-
-    # Sync all channel aliases
-    logging.info("Syncing any existing alias")
-    pub.sync_aliases(args.channel)
-
-    # Sync the mirrors
-    logging.info("Triggering a mirror sync")
-    tools.sync_mirrors(conf)
+    main()
 
=== modified file 'bin/tag-image' (properties changed: +x to -x)
--- bin/tag-image	2016-06-24 21:02:18 +0000
+++ bin/tag-image	2016-07-20 12:34:06 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2015 Canonical Ltd.
+# Copyright (C) 2015-2016 Canonical Ltd.
 # Author: Łukasz 'sil2100' Zemczak <[e-mail]>
 
 # This program is free software: you can redistribute it and/or modify
@@ -16,191 +16,17 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import json
 import os
 import sys
-import argparse
-import fcntl
-import logging
 
 sys.path.insert(0, os.path.join(sys.path[0], os.pardir, "lib"))
 
-from operator import itemgetter
-from systemimage import config, generators, tools, tree
+from systemimage.scripts import script_tag_image
 
 
 def main():
-    parser = argparse.ArgumentParser(description="image tagger")
-    parser.add_argument("channel", metavar="CHANNEL")
-    parser.add_argument("device", metavar="DEVICE")
-    parser.add_argument("version", metavar="VERSION", type=int)
-    parser.add_argument("tag", metavar="TAG")
-    parser.add_argument("--verbose", "-v", action="count", default=0)
-
-    args = parser.parse_args()
-
-    # Setup logging
-    formatter = logging.Formatter(
-        "%(asctime)s %(levelname)s %(message)s")
-
-    levels = {1: logging.ERROR,
-              2: logging.WARNING,
-              3: logging.INFO,
-              4: logging.DEBUG}
-
-    if args.verbose > 0:
-        stdoutlogger = logging.StreamHandler(sys.stdout)
-        stdoutlogger.setFormatter(formatter)
-        logging.root.setLevel(levels[min(4, args.verbose)])
-        logging.root.addHandler(stdoutlogger)
-    else:
-        logging.root.addHandler(logging.NullHandler())
-
-    # Load the configuration
-    conf = config.Config()
-
-    # Try to acquire a global lock
-    lock_file = os.path.join(conf.state_path, "global.lock")
-    lock_fd = open(lock_file, 'w')
-
-    try:
-        fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-    except IOError:
-        print("Something else holds the global lock. exiting.")
-        sys.exit(0)
-
-    # Load the tree
-    pub = tree.Tree(conf)
-
-    # Do some checks
-    channels = pub.list_channels()
-    if args.channel not in channels:
-        parser.error("Invalid channel: %s" % args.channel)
-
-    if args.device not in channels[args.channel]['devices']:
-        parser.error("Invalid device for channel: %s" % args.device)
-
-    if "alias" in channels[args.channel] and \
-            channels[args.channel]['alias'] \
-            != args.channel:
-        parser.error("Channel is an alias.")
-
-    if "redirect" in channels[args.channel]:
-        parser.error("Channel is a redirect.")
-
-    target_device = channels[args.channel]['devices'][args.device]
-    if "redirect" in target_device:
-        parser.error("Target device is a redirect. Use original channel "
-                     "%s instead." % target_device['redirect'])
-
-    if "," in args.tag:
-        parser.error("Image tag cannot include the character ','.")
-
-    device = pub.get_device(args.channel, args.device)
-
-    device_images = device.list_images()
-    if not device_images:
-        parser.error("No images in selected channel/device.")
-
-    sorted_images = sorted(device_images, key=itemgetter('version'))
-    if args.version != sorted_images[-1]['version']:
-        parser.error("You can only tag the latest image.")
-
-    # Extract the build we want to copy
-    images = [image for image in device_images
-              if image['type'] == "full" and image['version'] == args.version]
-    if not images:
-        parser.error("Can't find version: %s" % args.version)
-    image = images[0]
-
-    # Assign a new version number
-    new_version = args.version + 1
-
-    # Generate a list of required deltas
-    delta_base = tools.get_required_deltas(
-        conf, pub, args.channel, args.device)
-
-    # Create a new empty file list
-    new_files = []
-
-    # Extract current version_detail and image files
-    version_detail = tools.extract_files_and_version(
-        conf, image['files'], args.version, new_files)
-    logging.debug("Original version_detail is: %s" % version_detail)
-
-    # Generate new version tarball environment
-    environment = {}
-    environment['channel_name'] = args.channel
-    environment['device'] = device
-    environment['device_name'] = args.device
-    environment['version'] = new_version
-    environment['version_detail'] = [entry
-                                     for entry in version_detail.split(",")
-                                     if not entry.startswith("version=")]
-    environment['new_files'] = new_files
-
-    # Set the tag for the image
-    tools.set_tag_on_version_detail(environment['version_detail'], args.tag)
-    logging.info("Setting tag for image to '%s'" % args.tag)
-
-    # Generate the new version tarball
-    logging.info("Generating new version tarball for '%s' (%s)"
-                 % (new_version, ",".join(environment['version_detail'])))
-    version_path = generators.generate_file(conf, "version", [], environment)
-    if version_path:
-        new_files.append(version_path)
-
-    # Add full image
-    logging.info("Publishing new image '%s' (%s) with %s files."
-                 % (new_version, ",".join(environment['version_detail']),
-                    len(new_files)))
-    device.create_image(
-        "full", new_version, ",".join(environment['version_detail']),
-        new_files, version_detail=",".join(environment['version_detail']))
-
-    # Add delta images
-    delta_files = []
-    for path in new_files:
-        filename = path.split("/")[-1]
-        if filename.startswith("version-") or filename.startswith("keyring-"):
-            delta_files.append(path)
-
-    for delta in delta_base:
-        logging.info("Publishing new delta from '%s' (%s)"
-                     " to '%s' (%s)" %
-                     (delta['version'], delta.get("description", ""),
-                      new_version, ",".join(environment['version_detail'])))
-
-        device.create_image(
-            "delta", new_version,
-            ",".join(environment['version_detail']),
-            delta_files,
-            base=delta['version'],
-            version_detail=",".join(environment['version_detail']))
-
-    # Set the phased percentage value for the new image
-    percentage = device.get_phased_percentage(args.version)
-    logging.info("Setting phased percentage of the new image to %s%%" %
-                 percentage)
-    device.set_phased_percentage(new_version, percentage)
-
-    # Expire images
-    if args.channel in conf.channels:
-        if conf.channels[args.channel].fullcount > 0:
-            logging.info("Expiring old images")
-            device.expire_images(conf.channels[args.channel].fullcount)
-
-    # Sync all channel aliases
-    logging.info("Syncing any existing alias")
-    pub.sync_aliases(args.channel)
-
-    # Remove any orphaned file
-    logging.info("Removing orphaned files from the pool")
-    pub.cleanup_tree()
-
-    # Sync the mirrors
-    logging.info("Triggering a mirror sync")
-    tools.sync_mirrors(conf)
+    script = script_tag_image.TagImageScript()
+    script.run(sys.argv)
 
 
 if __name__ == '__main__':
 
=== added file 'lib/systemimage/script.py'
--- lib/systemimage/script.py	1970-01-01 00:00:00 +0000
+++ lib/systemimage/script.py	2016-07-20 12:34:06 +0000
@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2015-2016 Canonical Ltd.
+# Authors: Łukasz 'sil2100' Zemczak <[e-mail]>
+#          Stéphane Graber <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import json
+import os
+import sys
+import argparse
+import fcntl
+import logging
+
+sys.path.insert(0, os.path.join(sys.path[0], os.pardir, "lib"))
+
+from operator import itemgetter
+from systemimage import config, generators, tools, tree
+
+
+class ScriptError(Exception):
+    """Exception used to indicate error on any stage of a script."""
+    pass
+
+
+class Script:
+    """Base common class for all system-image scripts."""
+
+    def __init__(self, path=None):
+        # Load the configuration
+        self.conf = config.Config(path) if path else config.Config()
+        self.pub = None  # system-image tree, defined during run()
+
+        # Variables to be defined during setup()/execute()
+        self.channel = None  # Channel name
+        self.device = None  # Device object
+
+        self.lock_fd = None
+
+    def setup_logging(self, verbosity):
+        """Helper function setting up common logging scheme."""
+
+        formatter = logging.Formatter(
+            "%(asctime)s %(levelname)s %(message)s")
+
+        levels = {1: logging.ERROR,
+                  2: logging.WARNING,
+                  3: logging.INFO,
+                  4: logging.DEBUG}
+
+        if verbosity > 0:
+            stdoutlogger = logging.StreamHandler(sys.stdout)
+            stdoutlogger.setFormatter(formatter)
+            logging.root.setLevel(levels[min(4, verbosity)])
+            logging.root.addHandler(stdoutlogger)
+        else:
+            logging.root.addHandler(logging.NullHandler())
+
+    def sync_trees(self):
+        """Helper function for syncing changes to all trees."""
+        # Sync all channel aliases
+        logging.info("Syncing any existing alias")
+        self.pub.sync_aliases(self.channel)
+
+        # Sync the mirrors
+        logging.info("Triggering a mirror sync")
+        tools.sync_mirrors(self.conf)
+
+    def lock(self):
+        """Aquire the global lock, protecting from races."""
+
+        # Try to acquire a global lock
+        lock_file = os.path.join(self.conf.state_path, "global.lock")
+        self.lock_fd = open(lock_file, 'w')
+
+        try:
+            fcntl.lockf(self.lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except IOError:
+            raise ScriptError("Something else holds the global lock. exiting.")
+
+    def presetup(self):
+        """All low-level pre-setup to be done before the script can be run."""
+        # Load the tree
+        self.pub = tree.Tree(self.conf)
+
+    def setup(self, argv):
+        """Implementable in script. Perform script setup, parse cmdline."""
+        pass
+
+    def execute(self):
+        """Implementable in script. All script execution code goes here."""
+        pass
+
+    def cleanup(self):
+        """Called at the end - by default provides image cleanup."""
+
+        # Expire images, if a device was used in the script
+        if self.device and self.channel in self.conf.channels:
+            if self.conf.channels[self.channel].fullcount > 0:
+                logging.info("Expiring old images")
+                self.device.expire_images(
+                    self.conf.channels[
+                        self.channel].fullcount)
+
+        # Remove any orphaned file
+        logging.info("Removing orphaned files from the pool")
+        self.pub.cleanup_tree()
+
+        self.sync_trees()
+
+    def run(self, argv):
+        """Run the script."""
+
+        try:
+            self.lock()
+            self.presetup()
+            self.setup(argv)
+            self.execute()
+            self.cleanup()
+        except ScriptError as err:
+            print(str(err))
+            return False
+
+        return True
+
+
+class CommonImageManipulationScript(Script):
+    """A common base for scripts that manipulate images, providing helpers."""
+
+    def generate_version(self, source_files, version, tag=None):
+        """
+            Generate the version tarball for the version and files.
+            Requires the self.target_version, self.channel and self.device
+            variables: for the new version number, destination channel and
+            device object respectively.
+        """
+
+        # Extract current version_detail and files
+        version_detail = tools.extract_files_and_version(
+            self.conf,
+            source_files,
+            version,
+            self.new_images['full']['files'])
+
+        # Generate new version tarball
+        self.environment = {}
+        self.environment['channel_name'] = self.channel
+        self.environment['device'] = self.device
+        self.environment['device_name'] = self.device.name
+        self.environment['version'] = self.target_version
+        self.environment['version_detail'] = [
+            entry for entry in version_detail.split(",")
+            if not entry.startswith("version=")]
+        self.environment['new_files'] = self.new_images['full']['files']
+
+        # Add new tag if requested
+        if tag:
+            tools.set_tag_on_version_detail(
+                self.environment['version_detail'], tag)
+            logging.info("Setting tag for image to '%s'" % tag)
+
+        logging.info("Generating new version tarball for '%s' (%s)"
+                     % (self.target_version, ",".join(
+                        self.environment['version_detail'])))
+        version_path = generators.generate_file(
+            self.conf, "version", [], self.environment)
+        if version_path:
+            self.new_images['full']['files'].append(version_path)
+
+    def generate_deltas(self):
+        """
+            Generates deltas from the list in self.delta_base.
+            To generate the deltas the self.new_images dictionary is used. All
+            the newly generated delta files are then appended to the new_images
+            structure.
+        """
+
+        for delta in self.delta_base:
+            self.new_images['delta_%s' % delta['version']] = {'files': []}
+
+        # Generate deltas
+        for abspath in self.new_images['full']['files']:
+            prefix = abspath.split("/")[-1].rsplit("-", 1)[0]
+            for delta in self.delta_base:
+                # Extract the source
+                src_path = None
+                for file_dict in delta['files']:
+                    if (file_dict['path'].split("/")[-1]
+                            .startswith(prefix)):
+                        src_path = "%s/%s" % (self.conf.publish_path,
+                                              file_dict['path'])
+                        break
+
+                # Check that it's not the current file
+                if src_path:
+                    src_path = os.path.realpath(src_path)
+
+                    # FIXME: the keyring- is a big hack...
+                    if src_path == abspath and "keyring-" not in src_path:
+                        continue
+
+                    # Generators are allowed to return None when no delta
+                    # exists at all.
+                    logging.info("Generating delta from '%s' for '%s'" %
+                                 (delta['version'],
+                                  prefix))
+                    delta_path = generators.generate_delta(self.conf, src_path,
+                                                           abspath)
+                else:
+                    delta_path = abspath
+
+                if not delta_path:
+                    continue
+
+                # Get the full and relative paths
+                delta_abspath, delta_relpath = tools.expand_path(
+                    delta_path, self.conf.publish_path)
+
+                self.new_images['delta_%s' % delta['version']]['files'] \
+                    .append(delta_abspath)
+
+    def add_images_to_index(self):
+        """
+            Adds all newly created image files to the index.
+            This basically takes all the new entries from the self.new_images
+            dictionary (full and delta entries) and adds them, calling
+            create_image on the device object.
+        """
+
+        # Add full image
+        logging.info("Publishing new image '%s' (%s) with %s files."
+                     % (self.target_version,
+                        ",".join(self.environment['version_detail']),
+                        len(self.new_images['full']['files'])))
+        self.device.create_image(
+            "full",
+            self.target_version,
+            ",".join(self.environment['version_detail']),
+            self.new_images['full']['files'],
+            version_detail=",".join(self.environment['version_detail']))
+
+        # Add delta images
+        for delta in self.delta_base:
+            files = self.new_images['delta_%s' % delta['version']]['files']
+            logging.info("Publishing new delta from '%s' (%s)"
+                         " to '%s' (%s) with %s files" %
+                         (delta['version'],
+                          delta.get("description", ""),
+                          self.target_version,
+                          ",".join(self.environment['version_detail']),
+                          len(files)))
+
+            self.device.create_image(
+                "delta", self.target_version,
+                ",".join(self.environment['version_detail']),
+                files,
+                base=delta['version'],
+                version_detail=",".join(self.environment['version_detail']))
 
=== added directory 'lib/systemimage/scripts'
=== added file 'lib/systemimage/scripts/__init__.py'
=== added file 'lib/systemimage/scripts/script_copy_image.py'
--- lib/systemimage/scripts/script_copy_image.py	1970-01-01 00:00:00 +0000
+++ lib/systemimage/scripts/script_copy_image.py	2016-07-20 12:34:06 +0000
@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016 Canonical Ltd.
+# Authors: Łukasz 'sil2100' Zemczak <[e-mail]>
+#          Stéphane Graber <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import json
+import os
+import sys
+import argparse
+import fcntl
+import logging
+
+from systemimage import config, generators, tools, tree, script
+from systemimage.script import ScriptError
+
+
+class CopyImageScript(script.CommonImageManipulationScript):
+    """Script used to copy images from channel to channel."""
+
+    def setup(self, argv):
+        parser = argparse.ArgumentParser(description="image copier")
+        parser.add_argument("source_channel", metavar="SOURCE-CHANNEL")
+        parser.add_argument("destination_channel",
+                            metavar="DESTINATION-CHANNEL")
+        parser.add_argument("device", metavar="DEVICE")
+        parser.add_argument("version", metavar="VERSION", type=int)
+        parser.add_argument("-k", "--keep-version", action="store_true",
+                            help="Keep the original version number")
+        parser.add_argument("-p", "--phased-percentage", type=int,
+                            help="Set the phased percentage for the copied "
+                                 "image",
+                            default=100)
+        parser.add_argument("-t", "--tag", type=str,
+                            help="Set a version tag on the new image")
+        parser.add_argument("--verbose", "-v", action="count", default=0)
+
+        argv.pop(0)  # To fix issues with parse_args() shifting arguments
+        args = parser.parse_args(argv)
+
+        # Setup logging
+        self.setup_logging(args.verbose)
+
+        # Do some checks
+        channels = self.pub.list_channels()
+        if args.source_channel not in channels:
+            raise ScriptError("Invalid source channel: %s" %
+                              args.source_channel)
+
+        if args.destination_channel not in channels:
+            raise ScriptError("Invalid destination channel: %s" %
+                              args.destination_channel)
+
+        if args.device not in \
+                channels[args.source_channel]['devices']:
+            raise ScriptError("Invalid device for source channel: %s" %
+                              args.device)
+
+        if args.device not in \
+                channels[args.destination_channel]['devices']:
+            raise ScriptError("Invalid device for destination channel: %s" %
+                              args.device)
+
+        if "alias" in channels[args.source_channel] and \
+                channels[args.source_channel]['alias'] \
+                != args.source_channel:
+            raise ScriptError("Source channel is an alias.")
+
+        if "alias" in channels[args.destination_channel] and \
+                channels[args.destination_channel]['alias'] \
+                != args.destination_channel:
+            raise ScriptError("Destination channel is an alias.")
+
+        if "redirect" in channels[args.source_channel]:
+            raise ScriptError("Source channel is a redirect.")
+
+        if "redirect" in channels[args.destination_channel]:
+            raise ScriptError("Destination channel is a redirect.")
+
+        src_device = channels[args.source_channel]['devices'][args.device]
+        if "redirect" in src_device:
+            raise ScriptError("Source device is a redirect. Use original "
+                              "channel %s instead." % src_device['redirect'])
+
+        dest_device = \
+            channels[args.destination_channel]['devices'][args.device]
+        if "redirect" in dest_device:
+            raise ScriptError("Destination device is a redirect. Use original "
+                              "channel %s instead." % dest_device['redirect'])
+
+        if args.tag and "," in args.tag:
+            raise ScriptError("Image tag cannot include the character ','.")
+
+        self.args = args
+        self.channel = args.destination_channel
+
+    def assign_new_version(self, version, keep_version=False):
+        if keep_version:
+            images = [image for image in self.device.list_images()
+                      if image['version'] == version]
+            if images:
+                raise ScriptError(
+                    "Version number is already used: %s" % version)
+
+        # Assign a new version number
+        new_version = version
+        if not keep_version:
+            # Find the next available version
+            new_version = 1
+            for image in self.device.list_images():
+                if image['version'] >= new_version:
+                    new_version = image['version'] + 1
+        logging.debug("Version for next image: %s" % new_version)
+
+        self.target_version = new_version
+
+    def execute(self):
+        source_device = self.pub.get_device(
+            self.args.source_channel, self.args.device)
+        self.device = self.pub.get_device(
+            self.channel, self.args.device)
+
+        # Assign a version number to the new image
+        self.assign_new_version(self.args.version, self.args.keep_version)
+
+        # Extract the build we want to copy
+        source_image = tools.extract_image(
+            source_device.list_images(), self.args.version)
+        if not source_image:
+            raise ScriptError("Can't find version: %s" % version)
+
+        # Extract the list of existing full images
+        full_images = {image['version']: image
+                       for image in self.device.list_images()
+                       if image['type'] == "full"}
+
+        # Check that the last full and the new image aren't one and the same
+        source_files = [entry['path'].split("/")[-1]
+                        for entry in source_image['files']
+                        if not entry['path'].split("/")[-1].startswith(
+                            "version-")]
+        destination_files = []
+        if full_images:
+            latest_full = sorted(full_images.values(),
+                                 key=lambda image: image['version'])[-1]
+            destination_files = [entry['path'].split("/")[-1]
+                                 for entry in latest_full['files']
+                                 if not entry['path'].split(
+                                     "/")[-1].startswith("version-")]
+        if source_files == destination_files:
+            raise ScriptError("Source image is already latest full in "
+                              "destination channel.")
+
+        # Generate a list of required deltas
+        self.delta_base = tools.get_required_deltas(
+            self.conf, self.pub, self.channel, self.args.device)
+
+        # Create new empty entries
+        self.new_images = {'full': {'files': []}}
+
+        # Generate the version tarball
+        self.generate_version(
+            source_image['files'], self.args.version, self.args.tag)
+
+        # Generate all required deltas
+        self.generate_deltas()
+
+        # Add both full and delta images to the index
+        self.add_images_to_index()
+
+        # Set the phased percentage value for the new image
+        logging.info("Setting phased percentage of the new image to %s%%" %
+                     self.args.phased_percentage)
+        self.device.set_phased_percentage(
+            self.target_version, self.args.phased_percentage)
 
=== added file 'lib/systemimage/scripts/script_set_phased_percentage.py'
--- lib/systemimage/scripts/script_set_phased_percentage.py	1970-01-01 00:00:00 +0000
+++ lib/systemimage/scripts/script_set_phased_percentage.py	2016-07-20 12:34:06 +0000
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016 Canonical Ltd.
+# Authors: Łukasz 'sil2100' Zemczak <[e-mail]>
+#          Stéphane Graber <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import json
+import os
+import sys
+import argparse
+import fcntl
+import logging
+
+from systemimage import config, generators, tools, tree, script
+from systemimage.script import ScriptError
+
+
+class SetPhasedPercentageScript(script.CommonImageManipulationScript):
+    """Script used to set phased percentages of images."""
+
+    def setup(self, argv):
+        parser = argparse.ArgumentParser(description="set phased percentage")
+        parser.add_argument("channel", metavar="CHANNEL")
+        parser.add_argument("device", metavar="DEVICE")
+        parser.add_argument("version", metavar="VERSION", type=int)
+        parser.add_argument("percentage", metavar="PERCENTAGE", type=int)
+        parser.add_argument("--verbose", "-v", action="count", default=0)
+
+        argv.pop(0)  # To fix issues with parse_args() shifting arguments
+        args = parser.parse_args(argv)
+
+        # Setup logging
+        self.setup_logging(args.verbose)
+
+        # Do some checks
+        channels = self.pub.list_channels()
+        if args.channel not in channels:
+            raise ScriptError("Invalid channel: %s" % args.channel)
+
+        if args.device not in channels[args.channel]['devices']:
+            raise ScriptError("Invalid device for source channel: %s" %
+                              args.device)
+
+        if args.percentage < 0 or args.percentage > 100:
+            raise ScriptError("Invalid value: %s" % args.percentage)
+
+        if "alias" in channels[args.channel] and \
+                channels[args.channel]['alias'] != args.channel:
+            raise ScriptError("Channel is an alias.")
+
+        if "redirect" in channels[args.channel]:
+            raise ScriptError("Channel is a redirect.")
+
+        target_device = channels[args.channel]['devices'][args.device]
+        if "redirect" in target_device:
+            raise ScriptError(
+                "Target device is a redirect. Use original channel %s "
+                "instead." % target_device['redirect'])
+
+        self.args = args
+
+    def execute(self):
+        dev = self.pub.get_device(self.args.channel, self.args.device)
+        logging.info("Setting phased-percentage of '%s' to %s%%" %
+                     (self.args.version, self.args.percentage))
+        dev.set_phased_percentage(self.args.version, self.args.percentage)
+
+    def cleanup(self):
+        # We're overwriting this method as there's no need to expire images
+        # after running this command
+        self.sync_trees()
 
=== added file 'lib/systemimage/scripts/script_tag_image.py'
--- lib/systemimage/scripts/script_tag_image.py	1970-01-01 00:00:00 +0000
+++ lib/systemimage/scripts/script_tag_image.py	2016-07-20 12:34:06 +0000
@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2016 Canonical Ltd.
+# Authors: Łukasz 'sil2100' Zemczak <[e-mail]>
+#          Stéphane Graber <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import json
+import os
+import sys
+import argparse
+import fcntl
+import logging
+
+from operator import itemgetter
+from systemimage import config, generators, tools, tree, script
+from systemimage.script import ScriptError
+
+
+class TagImageScript(script.CommonImageManipulationScript):
+    """Script used to append/modify tags in images."""
+
+    def setup(self, argv):
+        parser = argparse.ArgumentParser(description="image tagger")
+        parser.add_argument("channel", metavar="CHANNEL")
+        parser.add_argument("device", metavar="DEVICE")
+        parser.add_argument("version", metavar="VERSION", type=int)
+        parser.add_argument("tag", metavar="TAG")
+        parser.add_argument("--verbose", "-v", action="count", default=0)
+
+        argv.pop(0)  # To fix issues with parse_args() shifting arguments
+        args = parser.parse_args(argv)
+
+        # Setup logging
+        self.setup_logging(args.verbose)
+
+        # Do some checks
+        channels = self.pub.list_channels()
+        if args.channel not in channels:
+            raise ScriptError("Invalid channel: %s" % args.channel)
+
+        if args.device not in \
+                channels[args.channel]['devices']:
+            raise ScriptError("Invalid device for channel: %s" % args.device)
+
+        if "alias" in channels[args.channel] and \
+                channels[args.channel]['alias'] \
+                != args.channel:
+            raise ScriptError("Channel is an alias.")
+
+        if "redirect" in channels[args.channel]:
+            raise ScriptError("Channel is a redirect.")
+
+        target_device = channels[args.channel]['devices'][args.device]
+        if "redirect" in target_device:
+            raise ScriptError(
+                "Target device is a redirect. Use original channel %s "
+                "instead." % target_device['redirect'])
+
+        if "," in args.tag:
+            raise ScriptError("Image tag cannot include the character ','.")
+
+        self.args = args
+        self.channel = args.channel
+
+    def execute(self):
+        self.device = self.pub.get_device(self.args.channel, self.args.device)
+
+        device_images = self.device.list_images()
+        if not device_images:
+            raise ScriptError("No images in selected channel/device.")
+
+        sorted_images = sorted(device_images, key=itemgetter('version'))
+        if self.args.version != sorted_images[-1]['version']:
+            raise ScriptError("You can only tag the latest image.")
+
+        # Extract the build we want to copy
+        self.image = tools.extract_image(device_images, self.args.version)
+        if not self.image:
+            raise ScriptError("Can't find version: %s" % version)
+
+        # Remember the current image's phased percentage
+        percentage = self.device.get_phased_percentage(self.args.version)
+
+        # Assign a new version number
+        self.target_version = self.args.version + 1
+
+        # Generate a list of required deltas
+        self.delta_base = tools.get_required_deltas(
+            self.conf, self.pub, self.channel, self.args.device)
+
+        # Create new empty entries
+        self.new_images = {'full': {'files': []}}
+
+        self.generate_version(
+            self.image['files'], self.args.version, self.args.tag)
+
+        # Add delta images
+        delta_files = []
+        for path in self.new_images['full']['files']:
+            filename = path.split("/")[-1]
+            if (filename.startswith("version-") or
+                    filename.startswith("keyring-")):
+                delta_files.append(path)
+
+        for delta in self.delta_base:
+            self.new_images['delta_%s' % delta['version']] = \
+                {'files': delta_files}
+
+        # Add both full and delta images to the index
+        self.add_images_to_index()
+
+        # Set the phased percentage of the image to the previous value
+        logging.info("Setting phased percentage of the new image to %s%%" %
+                     percentage)
+        self.device.set_phased_percentage(self.target_version, percentage)
 
=== added file 'lib/systemimage/tests/test_scripts.py'
--- lib/systemimage/tests/test_scripts.py	1970-01-01 00:00:00 +0000
+++ lib/systemimage/tests/test_scripts.py	2016-07-20 12:34:06 +0000
@@ -0,0 +1,590 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2015-2016 Canonical Ltd.
+# Author: Łukasz 'sil2100' Zemczak <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import shutil
+import stat
+import subprocess
+import tarfile
+import tempfile
+import unittest
+import json
+import six
+import fcntl
+
+from mock import Mock, patch
+from systemimage import config, tools, tree, gpg
+from systemimage import script as script_base
+from systemimage.scripts import (
+    script_copy_image,
+    script_tag_image,
+    script_set_phased_percentage,
+    )
+from systemimage.testing.helpers import HAS_TEST_KEYS, MISSING_KEYS_WARNING
+from systemimage.tools import xz_uncompress
+
+
+class ScriptTests(unittest.TestCase):
+    def setUp(self):
+        temp_directory = tempfile.mkdtemp()
+        self.temp_directory = temp_directory
+        self.old_path = os.environ.get("PATH", None)
+
+        os.mkdir(os.path.join(self.temp_directory, "etc"))
+        state_dir = os.path.join(self.temp_directory, "state")
+        os.mkdir(state_dir)
+        lock_file = os.path.join(state_dir, "global.lock")
+        open(lock_file, 'w+')
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_directory)
+        if self.old_path:
+            os.environ['PATH'] = self.old_path
+
+
+class BaseScriptTests(ScriptTests):
+    def setUp(self):
+        super().setUp()
+        config_path = os.path.join(self.temp_directory, "etc", "config")
+        with open(config_path, "w+") as fd:
+            fd.write("""[global]
+base_path = %s
+gpg_key_path = %s
+public_fqdn = system-image.example.net
+public_http_port = 880
+public_https_port = 8443
+""" % (self.temp_directory, os.path.join(os.getcwd(), "tools", "keys")))
+        self.config_path = config_path
+
+    def test_lock(self):
+        """Make sure locking works."""
+        script = script_base.Script(self.config_path)
+        script.lock()
+        lock_file = os.path.join(script.conf.state_path, "global.lock")
+        lock_fd = open(lock_file, 'r')
+        with self.assertRaises(IOError):
+            fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+    def test_lock_already_locked(self):
+        """Make sure locking twice rises an error."""
+        script = script_base.Script(self.config_path)
+        script2 = script_base.Script(self.config_path)
+        script.lock()
+        with self.assertRaises(script_base.ScriptError):
+            script2.lock()
+
+    @patch('systemimage.tools.sync_mirrors')
+    def test_sync_trees(self, sync_mock):
+        """Check if calling sync_trees synces what we need."""
+        script = script_base.Script(self.config_path)
+        script.pub = Mock()
+        script.sync_trees()
+        self.assertEqual(script.pub.sync_aliases.call_count, 1)
+        self.assertEqual(sync_mock.call_count, 1)
+
+    @patch('systemimage.tools.sync_mirrors')
+    def test_cleanup(self, sync_mock):
+        """Check if cleanup performs proper steps."""
+        script = script_base.Script(self.config_path)
+        script.pub = Mock()
+        script.cleanup()
+        self.assertEqual(script.pub.sync_aliases.call_count, 1)
+        self.assertEqual(script.pub.cleanup_tree.call_count, 1)
+        self.assertEqual(sync_mock.call_count, 1)
+
+    def test_run(self):
+        """Check if all required class methods are called."""
+        script = script_base.Script(self.config_path)
+        script.lock = Mock()
+        script.presetup = Mock()
+        script.setup = Mock()
+        script.execute = Mock()
+        script.cleanup = Mock()
+        script.run([])
+        self.assertEqual(script.lock.call_count, 1)
+        self.assertEqual(script.presetup.call_count, 1)
+        self.assertEqual(script.setup.call_count, 1)
+        self.assertEqual(script.execute.call_count, 1)
+        self.assertEqual(script.cleanup.call_count, 1)
+
+    def test_error_handled(self):
+        """Check if error on any stage causes the script to fail."""
+        script = script_base.Script(self.config_path)
+        script.lock = Mock()
+        script.presetup = Mock()
+        script.setup = Mock()
+        script.execute = Mock()
+        script.cleanup = Mock()
+
+        for name in ["lock", "presetup", "setup", "execute", "cleanup"]:
+            setattr(script, name, Mock(
+                side_effect=script_base.ScriptError('foo')))
+            self.assertFalse(script.run([]))
+            setattr(script, name, Mock())
+
+
+class CommonScriptTests(ScriptTests):
+    def setUp(self):
+        super().setUp()
+        config_path = os.path.join(self.temp_directory, "etc", "config")
+        with open(config_path, "w+") as fd:
+            fd.write("""[global]
+base_path = %s
+gpg_key_path = %s
+public_fqdn = system-image.example.net
+public_http_port = 880
+public_https_port = 8443
+""" % (self.temp_directory, os.path.join(os.getcwd(), "tools", "keys")))
+        self.config_path = config_path
+
+        os.mkdir(os.path.join(self.temp_directory, "www"))
+        script = script_base.CommonImageManipulationScript(self.config_path)
+        script.presetup()
+        script.pub.create_channel("test")
+        script.pub.create_device("test", "test")
+        self.script = script
+        self.device = script.pub.get_device("test", "test")
+
+        # An image helper file that can be used for contents
+        self.image_file = os.path.join(
+            self.script.conf.publish_path, "test_file")
+        open(self.image_file, "w+").close()
+        gpg.sign_file(self.script.conf, "image-signing", self.image_file)
+
+    @unittest.skipUnless(HAS_TEST_KEYS, MISSING_KEYS_WARNING)
+    @patch('systemimage.tools.extract_files_and_version')
+    def test_generate_version(self, extract_mock):
+        """Check if script parts for generating version tarballs work"""
+
+        version = 1
+        tag = "Test-1"
+
+        # Emulate environment of the script run
+        self.script.target_version = version + 1
+        self.script.channel = "ubuntu-test/test"
+        self.script.device = self.device
+        self.script.new_images = {'full': {'files': ["some-file.tar.xz"]}}
+
+        self.script.generate_version([], version, tag)
+
+        self.assertEqual(
+            self.script.new_images['full']['files'],
+            ["some-file.tar.xz",
+                os.path.realpath(os.path.join(
+                    self.device.path,
+                    "version-%s.tar.xz" % self.script.target_version))])
+
+        target_obj = None
+        xz_path = self.script.new_images['full']['files'][-1]
+        unxz_path = os.path.join(self.temp_directory, "temp-unpack.tar")
+        channel_path = "system/etc/system-image/channel.ini"
+        extracted_path = os.path.join(self.temp_directory, channel_path)
+        try:
+            xz_uncompress(xz_path, unxz_path)
+            target_obj = tarfile.open(unxz_path, "r")
+            target_obj.extract(
+                channel_path, self.temp_directory)
+            with open(extracted_path, "r") as f:
+                contents = f.read()
+                self.assertIn(
+                    "tag=%s" % tag, contents)
+                self.assertIn(
+                    "channel: %s" % self.script.channel, contents)
+                self.assertIn(
+                    "build_number: %s" % self.script.target_version, contents)
+        finally:
+            target_obj.close()
+            os.remove(unxz_path)
+            os.remove(extracted_path)
+
+    @unittest.skipUnless(HAS_TEST_KEYS, MISSING_KEYS_WARNING)
+    @patch('systemimage.generators.generate_delta')
+    def test_generate_deltas(self, delta_mock):
+        """Check if we generate proper delta files."""
+
+        # Emulate environment of the script run
+        self.script.version = 2
+        self.script.channel = "ubuntu-test/test"
+        self.script.device = self.device
+        self.script.new_images = {'full': {'files': [
+            os.path.join(self.script.conf.publish_path, "file-source.tar.xz"),
+            os.path.join(self.script.conf.publish_path, "file2-source.tar.xz"),
+            os.path.join(self.script.conf.publish_path,
+                         "keyring-source.tar.xz")]}}
+        self.script.delta_base = [
+            {'version': 1, 'files': [{'path': "file-other.tar.xz"}]},
+            {'version': 2, 'files': [{'path': "file-other2.tar.xz"},
+                                     {'path': "file2-other3.tar.xz"}]},
+            {'version': 3, 'files': [{'path': "file-other4.tar.xz"},
+                                     {'path': "keyring-source.tar.xz"},
+                                     {'path': "file2-other5.tar.xz"}]},
+            {'version': 4, 'files': [{'path': "file-other6.tar.xz"},
+                                     {'path': "keyring-other.tar.xz"},
+                                     {'path': "file-source.tar.xz"}]}, ]
+
+        expected_lengths = {1: 1, 2: 2, 3: 3, 4: 2}
+        delta_mock.return_value = "delta.tar.xz"
+
+        self.script.generate_deltas()
+
+        for delta in self.script.delta_base:
+            version = delta['version']
+            self.assertIn('delta_%s' % version, self.script.new_images)
+            delta_files = self.script.new_images['delta_%s' % version]['files']
+            self.assertEqual(
+                len(delta_files),
+                len(self.script.new_images['full']['files']))
+            self.assertEqual(
+                len([x for x in delta_files if "delta" in x]),
+                expected_lengths[version])
+
+    @unittest.skipUnless(HAS_TEST_KEYS, MISSING_KEYS_WARNING)
+    def test_add_images_to_index(self):
+        """Check if a full image upload is properly added to the index."""
+
+        self.script.target_version = 1
+        self.script.environment = {'version_detail': [
+            "ubuntu=1", "device=1", "tag=Foo"]}
+        self.script.new_images = {'full': {'files': [self.image_file]}}
+        self.script.delta_base = []
+        self.script.device = self.device
+
+        self.script.add_images_to_index()
+        image = tools.extract_image(self.script.device.list_images(), 1)
+
+        self.assertIn('version', image)
+        self.assertEqual(image['version'], 1)
+        self.assertIn('version_detail', image)
+        self.assertEqual(image['version_detail'], "ubuntu=1,device=1,tag=Foo")
+
+    @unittest.skipUnless(HAS_TEST_KEYS, MISSING_KEYS_WARNING)
+    def test_add_images_to_index_with_delta(self):
+        """Check if a full + delta upload is properly added."""
+
+        self.script.target_version = 1
+        self.script.environment = {'version_detail': [
+            "ubuntu=1", "device=1", "tag=Foo"]}
+        self.script.new_images = {
+            'full': {'files': [self.image_file]},
+            'delta_4': {'files': [self.image_file]}}
+        self.script.delta_base = [{
+            'version': 4, 'files': [{'path': "other-file.tar.xz"}]}]
+        self.script.device = self.device
+
+        self.script.add_images_to_index()
+        images = self.script.device.list_images()
+
+        self.assertEqual(len(images), 2)
+
+        has_delta = False
+        has_full = False
+        for image in images:
+            self.assertIn('type', image)
+            if image['type'] == "delta":
+                has_delta = True
+                self.assertIn('base', image)
+                self.assertEqual(image['base'], 4)
+            elif image['type'] == "full":
+                has_full = True
+            self.assertIn('version', image)
+            self.assertEqual(image['version'], 1)
+            self.assertIn('version_detail', image)
+            self.assertEqual(
+                image['version_detail'], "ubuntu=1,device=1,tag=Foo")
+
+        self.assertTrue(has_delta)
+        self.assertTrue(has_full)
+
+
+class ImageScriptBaseTests(ScriptTests):
+    scriptClass = script_base.CommonImageManipulationScript
+
+    def setUp(self):
+        super().setUp()
+        config_path = os.path.join(self.temp_directory, "etc", "config")
+        with open(config_path, "w+") as fd:
+            fd.write("""[global]
+base_path = %s
+gpg_key_path = %s
+public_fqdn = system-image.example.net
+public_http_port = 880
+public_https_port = 8443
+""" % (self.temp_directory, os.path.join(os.getcwd(), "tools", "keys")))
+        self.config_path = config_path
+
+        os.mkdir(os.path.join(self.temp_directory, "www"))
+        script = self.scriptClass(self.config_path)
+        script.presetup()
+        script.pub.create_channel("empty")
+        script.pub.create_channel("from")
+        script.pub.create_channel("to")
+        script.pub.create_device("empty", "test")
+        script.pub.create_device("from", "test")
+        script.pub.create_device("to", "test")
+
+        self.image_file = os.path.join(script.conf.publish_path, "test_file")
+        open(self.image_file, "w+").close()
+        gpg.sign_file(script.conf, "image-signing", self.image_file)
+
+        device = script.pub.get_device("from", "test")
+        device.create_image("full", 1, "abc", [self.image_file])
+        device.create_image("full", 2, "def", [self.image_file])
+        device = script.pub.get_device("to", "test")
+        device.create_image("full", 1, "abc", [self.image_file])
+
+        self.script = script
+
+
+class CopyImageScriptTests(ImageScriptBaseTests):
+    scriptClass = script_copy_image.CopyImageScript
+
+    def test_copy_setup_correct(self):
+        """Check if setup doesn't fail with good arguments."""
+        argv = ["copy-image", "from", "to", "test", "1"]
+        self.script.setup(argv)
+
+    def test_copy_setup_invalid_channel(self):
+        """Check if setup fails on invalid channel arguments."""
+        argv = ["copy-image", "none", "to", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+        argv = ["copy-image", "from", "none", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel_alias("alias1", "from")
+        argv = ["copy-image", "alias1", "to", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+        self.script.pub.create_channel_alias("alias2", "to")
+        argv = ["copy-image", "from", "alias2", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel_redirect("re1", "from")
+        argv = ["copy-image", "re1", "to", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+        self.script.pub.create_channel_alias("re2", "to")
+        argv = ["copy-image", "from", "re2", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel("redirects")
+        self.script.pub.create_per_device_channel_redirect(
+            "test", "redirects", "empty")
+        argv = ["copy-image", "redirects", "to", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        argv = ["copy-image", "from", "redirects", "test", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+    def test_copy_setup_invalid_tag(self):
+        """Check if setup fails on invalid tag arguments."""
+        argv = ["copy-image", "from", "to", "test", "1", "--tag=\"tag,tag\""]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+    def test_copy_setup_invalid_device(self):
+        """Check if setup fails on invalid device selection."""
+        argv = ["copy-image", "from", "to", "none", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_device("to", "to_only")
+        argv = ["copy-image", "from", "to", "to_only", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_device("from", "from_only")
+        device = self.script.pub.get_device("from", "from_only")
+        device.create_image("full", 1, "abc", [self.image_file])
+        argv = ["copy-image", "from", "to", "from_only", "1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+    def test_assign_new_version(self):
+        """Check if new version assignment logic is correct."""
+        self.script.device = self.script.pub.get_device("to", "test")
+
+        self.script.assign_new_version(1, False)
+        self.assertEqual(self.script.target_version, 2)
+        self.script.assign_new_version(4, False)
+        self.assertEqual(self.script.target_version, 2)
+        self.script.assign_new_version(4, True)
+        self.assertEqual(self.script.target_version, 4)
+        with self.assertRaises(script_base.ScriptError):
+            self.script.assign_new_version(1, True)
+
+
+class TagImageScriptTests(ImageScriptBaseTests):
+    scriptClass = script_tag_image.TagImageScript
+
+    def test_tag_setup_correct(self):
+        """Check if setup doesn't fail with good arguments."""
+        argv = ["tag-image", "to", "test", "1", "TAG1"]
+        self.script.setup(argv)
+
+    def test_tag_setup_invalid_channel(self):
+        """Check if setup fails on invalid channel arguments."""
+        argv = ["tag-image", "none", "test", "1", "TAG1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel_alias("alias", "from")
+        argv = ["tag-image", "alias", "test", "1", "TAG1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel_redirect("re", "from")
+        argv = ["tag-image", "re", "test", "1", "TAG1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel("redirects")
+        self.script.pub.create_per_device_channel_redirect(
+            "test", "redirects", "empty")
+        argv = ["tag-image", "redirects", "test", "1", "TAG1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+    def test_tag_setup_invalid_tag(self):
+        """Check if setup fails on invalid tag arguments."""
+        argv = ["tag-image", "to", "test", "1", "TAG1,TAG2"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+    def test_tag_setup_invalid_device(self):
+        """Check if setup fails on invalid device selection."""
+        argv = ["tag-image", "to", "none", "1", "TAG1"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+    def test_tag_execute_invalid_image(self):
+        """Make sure execute fails on invalid image scenarios."""
+        argv = ["tag-image", "empty", "test", "1", "TAG1"]
+        self.script.setup(argv)
+        with self.assertRaises(script_base.ScriptError):
+            self.script.execute()
+
+        argv = ["tag-image", "from", "test", "1", "TAG1"]
+        self.script.setup(argv)
+        with self.assertRaises(script_base.ScriptError):
+            self.script.execute()
+
+        argv = ["tag-image", "from", "test", "3", "TAG1"]
+        self.script.setup(argv)
+        with self.assertRaises(script_base.ScriptError):
+            self.script.execute()
+
+    def test_tag_execute(self):
+        """Check that we can correctly tag an image."""
+        device = self.script.pub.get_device("from", "test")
+        device.set_phased_percentage(2, 60)
+
+        argv = ["tag-image", "from", "test", "2", "TAG1"]
+        self.script.setup(argv)
+        self.script.execute()
+
+        image = tools.extract_image(self.script.device.list_images(), 3)
+        self.assertTrue(image)
+        self.assertIn("version_detail", image)
+        self.assertIn("tag=TAG1", image['version_detail'])
+        self.assertEqual(device.get_phased_percentage(3), 60)
+
+        previous = tools.extract_image(self.script.device.list_images(), 2)
+        self.assertIn("files", image)
+        for f in previous['files']:
+            self.assertIn("path", f)
+            if "version-" not in f['path']:
+                self.assertIn(f, image['files'])
+
+
+class SetPhasedPercentageScriptTests(ImageScriptBaseTests):
+    scriptClass = script_set_phased_percentage.SetPhasedPercentageScript
+
+    def test_phased_setup_correct(self):
+        """Check if setup doesn't fail with good arguments."""
+        argv = ["set-phased-percentage", "to", "test", "1", "50"]
+        self.script.setup(argv)
+
+    def test_phased_setup_invalid_percentage(self):
+        """Check if setup fails with an invalid phase percentage value."""
+        argv = ["set-phased-percentage", "to", "test", "1", "foo"]
+        with self.assertRaises(SystemExit):
+            self.script.setup(argv)
+
+        argv = ["set-phased-percentage", "to", "test", "1", "9000"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        argv = ["set-phased-percentage", "to", "test", "1", "-10"]
+        with self.assertRaises(Exception):
+            self.script.setup(argv)
+
+    def test_phased_setup_invalid_channel(self):
+        """Check if setup fails on invalid channel arguments."""
+        argv = ["set-phased-percentage", "none", "test", "1", "50"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel_alias("alias", "from")
+        argv = ["set-phased-percentage", "alias", "test", "1", "50"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel_redirect("re", "from")
+        argv = ["set-phased-percentage", "re", "test", "1", "50"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+        self.script.pub.create_channel("redirects")
+        self.script.pub.create_per_device_channel_redirect(
+            "test", "redirects", "empty")
+        argv = ["set-phased-percentage", "redirects", "test", "1", "50"]
+        with self.assertRaises(script_base.ScriptError):
+            self.script.setup(argv)
+
+    def test_phased_execute(self):
+        """Check if we can change the percentage forwards and backwards."""
+        device = self.script.pub.get_device("to", "test")
+
+        argv = ["set-phased-percentage", "to", "test", "1", "50"]
+        self.script.setup(argv)
+        self.script.execute()
+        self.assertEqual(device.get_phased_percentage(1), 50)
+
+        argv = ["set-phased-percentage", "to", "test", "1", "60"]
+        self.script.setup(argv)
+        self.script.execute()
+        self.assertEqual(device.get_phased_percentage(1), 60)
+
+        argv = ["set-phased-percentage", "to", "test", "1", "15"]
+        self.script.setup(argv)
+        self.script.execute()
+        self.assertEqual(device.get_phased_percentage(1), 15)
+
+    def test_phased_execute_invalid_image(self):
+        """Check if we fail on trying to phase an older image."""
+        device = self.script.pub.get_device("to", "test")
+
+        argv = ["set-phased-percentage", "from", "test", "1", "50"]
+        with self.assertRaises(Exception):
+            self.script.setup(argv)
+            self.script.execute()
 
=== modified file 'lib/systemimage/tests/test_tools.py'
--- lib/systemimage/tests/test_tools.py	2016-03-16 18:52:39 +0000
+++ lib/systemimage/tests/test_tools.py	2016-07-20 12:34:06 +0000
@@ -432,6 +432,7 @@
 
     def test_set_tag_on_version_detail(self):
         """Set a basic tag."""
+
         version_detail_list = [
             "device=20150821-736d127",
             "custom=20150925-901-35-40-vivid",
@@ -444,6 +445,7 @@
 
     def test_set_tag_on_version_detail_rewrite(self):
         """Make sure tags can be rewritten."""
+
         version_detail_list = [
             "device=20150821-736d127",
             "custom=20150925-901-35-40-vivid",
@@ -458,6 +460,7 @@
 
     def test_set_tag_on_version_detail_clear(self):
         """Clear the tag."""
+
         version_detail_list = [
             "device=20150821-736d127",
             "custom=20150925-901-35-40-vivid",
@@ -470,6 +473,7 @@
 
     def test_extract_files_and_version(self):
         """Check if version_detail is correctly extracted"""
+
         os.mkdir(self.config.publish_path)
 
         version = 12
@@ -501,6 +505,7 @@
     @unittest.skip("Current deltabase handling is broken")
     def test_get_required_deltas(self):
         """Check if a proper list of valid deltabases is found."""
+
         config_path = os.path.join(self.temp_directory, "etc", "config")
         with open(config_path, "w+") as fd:
             fd.write("""[global]
@@ -550,6 +555,42 @@
         six.assertCountEqual(
             self, [base_image1, base_image2], delta_base)
 
+    def test_extract_image(self):
+        """Extracting single images from devices."""
+
+        config_path = os.path.join(self.temp_directory, "etc", "config")
+        with open(config_path, "w+") as fd:
+            fd.write("""[global]
+base_path = %s
+gpg_key_path = %s
+public_fqdn = system-image.example.net
+public_http_port = 880
+public_https_port = 8443
+""" % (self.temp_directory, os.path.join(os.getcwd(), "tools", "keys")))
+        test_config = config.Config(config_path)
+        os.makedirs(test_config.publish_path)
+
+        test_tree = tree.Tree(test_config)
+        test_tree.create_channel("testing")
+        test_tree.create_device("testing", "test")
+
+        image_file = os.path.join(self.config.publish_path, "test_file")
+        open(image_file, "w+").close()
+        gpg.sign_file(test_config, "image-signing", image_file)
+
+        device = test_tree.get_device("testing", "test")
+        device.create_image("full", 1, "abc", [image_file])
+        device.create_image("delta", 2, "abc", [image_file], base=1)
+        device.create_image("full", 4, "abc", [image_file])
+
+        image = tools.extract_image(device.list_images(), 1)
+        self.assertIsNotNone(image)
+        self.assertEqual(image['version'], 1)
+        self.assertIsNone(tools.extract_image(device.list_images(), 2))
+        image = tools.extract_image(device.list_images(), 4)
+        self.assertIsNotNone(image)
+        self.assertEqual(image['version'], 4)
+
     def test_guess_file_compression(self):
         """Check if we can correctly guess compression algorithms."""
         test_string = "test-string"
 
=== modified file 'lib/systemimage/tests/test_tree.py'
--- lib/systemimage/tests/test_tree.py	2016-06-24 19:10:46 +0000
+++ lib/systemimage/tests/test_tree.py	2016-07-20 12:34:06 +0000
@@ -648,7 +648,7 @@
 
     @unittest.skipUnless(HAS_TEST_KEYS, MISSING_KEYS_WARNING)
     def test_index(self):
-        device = tree.Device(self.config, self.temp_directory)
+        device = tree.Device("test", self.config, self.temp_directory)
 
         # Check without files
         self.assertRaises(Exception, device.create_image, "full", 1234,
 
=== modified file 'lib/systemimage/tools.py'
--- lib/systemimage/tools.py	2016-03-16 18:52:39 +0000
+++ lib/systemimage/tools.py	2016-07-20 12:34:06 +0000
@@ -603,6 +603,21 @@
     return version_detail
 
 
+def extract_image(images, version):
+    """
+        Extracts the image file from an device image list for the selected
+        version number.
+    """
+
+    images = [image for image in images
+              if image['type'] == "full" and
+              image['version'] == version]
+    if not images:
+        return None
+
+    return images[0]
+
+
 def set_tag_on_version_detail(version_detail_list, tag):
     """
         Append a tag to the version_detail array.
 
=== modified file 'lib/systemimage/tree.py'
--- lib/systemimage/tree.py	2016-06-24 19:10:46 +0000
+++ lib/systemimage/tree.py	2016-07-20 12:34:06 +0000
@@ -429,8 +429,8 @@
             device_path = os.path.dirname(channels[channel_name]['devices']
                                           [device_name]['index'])
 
-            return Device(self.config, os.path.normpath("%s/%s" % (self.path,
-                          device_path)))
+            return Device(device_name, self.config,
+                          os.path.normpath("%s/%s" % (self.path, device_path)))
 
     def hide_channel(self, channel_name):
         """
@@ -874,7 +874,8 @@
 
 
 class Device:
-    def __init__(self, config, path):
+    def __init__(self, name, config, path):
+        self.name = name
         self.config = config
         self.pub_path = self.config.publish_path
         self.path = path