Merge lp:~salgado/linaro-image-tools/bug-789093 into lp:~salgado/linaro-image-tools/trunk

[Guilherme Salgado]

Make sure rootfs.move_contents() doesn't skip files that are not
world-readable

[lp:~salgado/linaro-image-tools/bug-789093]

377. By Guilherme Salgado on 2011-07-18

Make sure rootfs.move_contents() doesn't skip files that are not world-readable

Unmerged revisions

377. By Guilherme Salgado on 2011-07-18

Make sure rootfs.move_contents() doesn't skip files that are not world-readable

=== added file 'fetch_image.py'
--- fetch_image.py	1970-01-01 00:00:00 +0000
+++ fetch_image.py	2011-07-18 14:39:34 +0000
@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# Copyright (C) 2010, 2011 Linaro
+#
+# Author: James Tunnicliffe <[e-mail]>
+#
+# This file is part of Linaro Image Tools.
+#
+# Linaro Image Tools 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; either version 2
+# of the License, or (at your option) any later version.
+#
+# Linaro Image Tools 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 Linaro Image Tools; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
+# USA.
+
+import sys
+import os
+import linaro_image_tools.FetchImage as FetchImage
+import logging
+
+
+def main():
+    file_handler = FetchImage.FileHandler()
+    config = FetchImage.FetchImageConfig()
+
+    # Unfortunately we need to do a bit of a hack here and look for some
+    # options before performing a full options parse.
+    clean_cache = ("--clean-cache" in sys.argv[1:]
+                   or "-x" in sys.argv[1:])
+
+    force_download = ("--force-download" in sys.argv[1:]
+                      or "-d" in sys.argv[1:])
+
+    if clean_cache:
+        file_handler.clean_cache()
+
+    # If the settings file and server index need updating, grab them
+    file_handler.update_files_from_server(force_download)
+
+    # Load settings YAML, which defines the parameters we ask for and
+    # acceptable responses from the user
+    config.read_config(file_handler.settings_file)
+
+    # Using the settings that the YAML defines as what we need for a build,
+    # generate a command line parser and parse the command line
+    config.parse_args(sys.argv[1:])
+
+    if config.args['platform'] == "snapshot":
+        config.args['release_or_snapshot'] = "snapshot"
+    else:
+        config.args['release_or_snapshot'] = "release"
+
+    # Using the config we have, look up URLs to download data from in the
+    # server index
+    db = FetchImage.DB(file_handler.index_file)
+
+    image_url, hwpack_url = db.get_image_and_hwpack_urls(config.args)
+
+    if(image_url and hwpack_url):
+
+        tools_dir = os.path.dirname(__file__)
+        if tools_dir == '':
+            tools_dir = None
+
+        file_handler.create_media(image_url, hwpack_url,
+                                  config.args, tools_dir)
+    else:
+        logging.error(
+            "Unable to find files that match the parameters specified")
+
+if __name__ == '__main__':
+    main()
 
=== added file 'fetch_image_ui.py'
--- fetch_image_ui.py	1970-01-01 00:00:00 +0000
+++ fetch_image_ui.py	2011-07-18 14:39:34 +0000
@@ -0,0 +1,1714 @@
+#!/usr/bin/env python
+# Copyright (C) 2010, 2011 Linaro
+#
+# Author: James Tunnicliffe <[e-mail]>
+#
+# This file is part of Linaro Image Tools.
+#
+# Linaro Image Tools 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; either version 2
+# of the License, or (at your option) any later version.
+#
+# Linaro Image Tools 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 Linaro Image Tools; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
+# USA.
+
+import wx
+import wx.wizard
+import wx.wizard as wiz
+import sys
+import re
+import os
+import linaro_image_tools.FetchImage as FetchImage
+import string
+import unittest
+import operator
+import Queue
+import time
+import datetime
+
+
+def add_button(bind_to,
+               sizer,
+               label,
+               style,
+               select_event,
+               hover_event,
+               unhover_event):
+
+    """Create a radio button with event bindings."""
+    if(style != None):
+        radio_button = wx.RadioButton(bind_to, label=label, style=style)
+    else:
+        radio_button = wx.RadioButton(bind_to, label=label)
+
+    sizer.Add(radio_button, 0, wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP, 5)
+    bind_to.Bind(wx.EVT_RADIOBUTTON, select_event, radio_button)
+    wx.EVT_ENTER_WINDOW(radio_button, hover_event)
+    wx.EVT_LEAVE_WINDOW(radio_button, unhover_event)
+
+    return radio_button
+
+
+class ReleaseOrSnapshotPage(wiz.PyWizardPage):
+    """Ask the user if they want to use a release or a snapshot"""
+
+    def __init__(self, parent, config):
+        wiz.PyWizardPage.__init__(self, parent)
+        self.config = config
+        self.settings = self.config.settings
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.next = None
+        self.prev = None
+
+        self.sizer.Add(wx.StaticText(self, -1,
+"""This Wizard will write an operating system of your choosing to
+either a disk image or to an MMC card. First we need to know if
+your priority is stability or the latest and greatest features."""))
+
+        self.box1 = wx.BoxSizer(wx.VERTICAL)
+
+        self.button_text = {'release':  "I would like to run stable, "
+                                        "tested software.",
+                            'snapshot': "I would like to run untested, but "
+                                        "more up-to-date software."}
+
+        add_button(self, self.box1, self.button_text['release'],
+                   wx.RB_GROUP, self.event_radio_button_select, None, None)
+
+        # Save the setting for the default selected value
+        self.settings['release_or_snapshot'] = "release"
+
+        add_button(self, self.box1, self.button_text['snapshot'], None,
+                   self.event_radio_button_select, None, None)
+
+        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        self.SetSizerAndFit(self.sizer)
+        self.sizer.Fit(self)
+        self.Move((50, 50))
+
+    def event_radio_button_select(self, event):
+        self.radio_selected = event.GetEventObject().GetLabel()
+        # The radio button can be release, snapshot or "latest snapshot"
+        if(self.radio_selected == self.button_text['release']):
+            self.settings['release_or_snapshot'] = "release"
+        else:
+            self.settings['release_or_snapshot'] = "snapshot"
+
+    def SetNext(self, next):
+        self.next = next
+
+    def GetNext(self):
+        return self.next
+
+
+class AboutMyHardwarePage(wiz.WizardPageSimple):
+    """Ask the user about their hardware. This only asks about the board, not
+       any specific hardware packs because there can be multiple names for the
+       same hardware pack or sometimes a hardware pack is only available in the
+       releases or snapshots repository. We whittle down the choice as we go
+       and the user can chose a hardare pack (if they don't like the default)
+       under advanced options in the Linaro Media Create options
+       page"""
+
+    def __init__(self, parent, config, db, width):
+        wiz.WizardPageSimple.__init__(self, parent)
+        self.settings = config.settings
+        self.db = db
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.box1 = wx.BoxSizer(wx.VERTICAL)
+        self.box2 = wx.BoxSizer(wx.VERTICAL)
+
+        header = wx.StaticText(self,
+                               label="Please select the hardware that you "
+                                     "would like to build an image for from "
+                                     "the following list")
+
+        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
+
+        #--- Hardware Combo Box ---
+        # Make sure that the displayed release is the one set in settings if
+        # no selection is made
+        if "panda" in self.settings['choice']['hardware'].keys():
+            default_hardware = "panda"
+        else:
+            default_hardware = self.settings['choice']['hardware'].keys()[-1]
+
+        self.settings['hardware'] = default_hardware
+        self.settings['compatable_hwpacks'] = (
+                self.settings['choice']['hwpack'][self.settings['hardware']])
+
+        self.cb_hardware = wx.ComboBox(self,
+                            value=self.settings['choice']
+                                               ['hardware']
+                                               [default_hardware],
+                            style=wx.CB_DROPDOWN | wx.CB_READONLY)
+
+        self.Bind(wx.EVT_COMBOBOX,
+                  self.event_combo_box_hardware,
+                  self.cb_hardware)
+        self.box1.Add(self.cb_hardware, 0,
+                      wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP, 5)
+
+        self.sizer.Add(header)
+        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+        self.sizer.Add(self.box2, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+        self.SetSizerAndFit(self.sizer)
+        self.sizer.Fit(self)
+        self.Move((50, 50))
+
+    def on_page_changing(self):
+        self.update_hardware_box()
+
+    def update_hardware_box(self):
+        self.cb_hardware.Clear()
+
+        sorted_hardware_names = sorted(self.settings['choice']['hardware']
+                                                                  .iteritems(),
+                                       key=operator.itemgetter(1))
+
+        table = self.settings['release_or_snapshot'] + "_hwpacks"
+
+        for device_name, human_readable_name in sorted_hardware_names:
+            for hwpack in self.settings['choice']['hwpack'][device_name]:
+                if self.db.hardware_is_available_in_table(table, hwpack):
+                    self.cb_hardware.Append(human_readable_name, device_name)
+                    break
+
+    #--- Event(s) ---
+    def event_combo_box_hardware(self, event):
+        self.settings['hardware'] = (event
+                                     .GetEventObject()
+                                      .GetClientData(event.GetSelection())
+                                       .encode('ascii'))
+
+        self.settings['compatable_hwpacks'] = (
+                self.settings['choice']['hwpack'][self.settings['hardware']])
+    #--- END event(s) ---
+
+
+class SelectStableRelease(wiz.WizardPageSimple):
+    """Ask the user which Linaro release they would like to run."""
+    def __init__(self, parent, config, db, width):
+        wiz.WizardPageSimple.__init__(self, parent)
+        self.settings = config.settings
+        self.db = db
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.wizard = parent
+
+        header = wx.StaticText(self, label="Please select the stable Linaro "
+                                           "release you would like to use")
+
+        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
+
+        self.sizer.Add(header)
+        self.box1 = wx.BoxSizer(wx.VERTICAL)
+
+        platforms = []
+        for key, value in self.settings['choice']['platform'].items():
+            platforms.append(key)
+
+        default_release = self.settings['UI']['translate'][platforms[-1]]
+        self.cb_release = wx.ComboBox(self,
+                                      value=default_release,
+                                      style=wx.CB_DROPDOWN | wx.CB_READONLY)
+        self.Bind(wx.EVT_COMBOBOX,
+                  self.event_combo_box_release,
+                  self.cb_release)
+
+        if(default_release in self.settings['UI']['translate']):
+            default_release = self.settings['UI']['translate'][default_release]
+        self.settings['platform'] = (
+                    self.settings['UI']['reverse-translate'][default_release])
+
+        for item in platforms:
+            if(item in self.settings['UI']['translate']):
+                new_item = self.settings['UI']['translate'][item]
+                item = new_item
+
+            self.cb_release.Append(item, item.upper())
+
+        self.cb_build = wx.ComboBox(self,
+                                    style=wx.CB_DROPDOWN | wx.CB_READONLY)
+        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_build, self.cb_build)
+
+        self.box1.Add(self.cb_release, 0,
+                      wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP, 5)
+        self.box1.Add(self.cb_build, 0,
+                      wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP, 5)
+        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+        self.SetSizerAndFit(self.sizer)
+        self.sizer.Fit(self)
+        self.Move((50, 50))
+
+    def update_build_box(self):
+        """Depending on what hardware has been chosen, the OS list may be
+        restricted. Filter out anything that is unavailable."""
+        self.cb_build.Clear()
+
+        builds = self.db.get_builds(self.settings['platform'])
+        self.cb_build.SetValue("No build available")
+
+        for build in builds:
+            if(self.db.hardware_is_available_for_platform_build(
+                                          self.settings['compatable_hwpacks'],
+                                          self.settings['platform'],
+                                          build)
+                and self.db.build_is_available_for_platform_image(
+                                "release_binaries",
+                                self.settings['platform'],
+                                self.settings['image'],
+                                build)):
+
+                self.cb_build.Append(build)
+                self.cb_build.SetValue(build)
+                self.settings['release_build'] = build
+
+        available_hwpacks = (
+            self.db.get_available_hwpacks_for_hardware_build_plaform(
+                                          self.settings['compatable_hwpacks'],
+                                          self.settings['platform'],
+                                          self.settings['release_build']))
+
+        if len(available_hwpacks):
+            self.settings['hwpack'] = available_hwpacks[0]
+            self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
+        else:
+            self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
+
+    def update_release_and_build_boxes(self):
+        """Depending on what hardware has been chosen, some builds may be
+           unavailable..."""
+        self.cb_release.Clear()
+
+        default_release = None
+        for platform, value in self.settings['choice']['platform'].items():
+            if(self.db.hardware_is_available_for_platform(
+                                          self.settings['compatable_hwpacks'],
+                                          platform)
+               and len(self.db.execute_return_list(
+                               'select * from release_binaries '
+                               'where platform == ? and image == ?',
+                                (platform, self.settings['image'])))):
+
+                if(platform in self.settings['UI']['translate']):
+                    platform = self.settings['UI']['translate'][platform]
+
+                self.cb_release.Append(platform, platform.upper())
+                if not default_release or default_release < platform:
+                    default_release = platform
+
+        self.settings['platform'] = (
+                    self.settings['UI']['reverse-translate'][default_release])
+        self.cb_release.SetValue(default_release)
+        self.update_build_box()
+
+    #--- Event(s) ---
+    def event_combo_box_release(self, evt):
+        str = evt.GetString().encode('ascii').lower()
+        if(str in self.settings['UI']['reverse-translate']):
+            str = self.settings['UI']['reverse-translate'][str]
+        self.settings['platform'] = str
+
+        self.update_build_box()
+
+    def event_combo_box_build(self, evt):
+        self.settings['release_build'] = evt.GetString().encode('ascii')
+    #--- END event(s) ---
+
+
+class SelectSnapshot(wiz.WizardPageSimple):
+    """Present the user with a calendar widget and a list of builds available
+    on the selected date so they can chose a snapshot. Filter out days when
+    their chosen hardware does not have an available build."""
+
+    def __init__(self, parent, config, db, width):
+        wiz.WizardPageSimple.__init__(self, parent)
+        self.settings = config.settings
+        self.db = db
+        self.wizard = parent
+        self.width = width
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+
+        header = wx.StaticText(self,
+                               label="Builds are created most days. First "
+                                     "please select the day on which the "
+                                     "build you would like to use was built,"
+                                     " then, if there was more than one "
+                                     "build that day you will be able to "
+                                     "select the build number.")
+        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
+
+        box1 = wx.BoxSizer(wx.VERTICAL)
+        self.sizer.Add(header)
+
+        # Set today as the default build date in settings
+        # (matches the date picker)
+        self.today = wx.DateTime()
+        self.today.SetToCurrent()
+        self.settings['build_date'] = self.today.FormatISODate().encode('ascii')
+
+        dpc = wx.DatePickerCtrl(self, size=(120, -1),
+                                style=wx.DP_DEFAULT)
+        self.Bind(wx.EVT_DATE_CHANGED, self.on_date_changed, dpc)
+
+        #--- Build number Combo Box ---
+        # Make sure that the displayed build is the one set in settings if no
+        # selection is made
+        self.settings['build_number'] = 0
+        self.update_build()
+        self.cb_build = wx.ComboBox(self,
+                                    style=wx.CB_DROPDOWN | wx.CB_READONLY)
+        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_build, self.cb_build)
+
+        #--- Layout ---
+        # -- Combo boxes for hardware and image selection --
+
+        grid2 = wx.FlexGridSizer(0, 2, 0, 0)
+        grid2.Add(dpc, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+        grid2.Add(self.cb_build, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        box1.Add(grid2, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        self.sizer.Add(box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        self.help_text = wx.StaticText(self)
+        self.sizer.Add(self.help_text, 1, wx.EXPAND, 5)
+
+        self.SetSizer(self.sizer)
+        self.sizer.Fit(self)
+        self.Move((50, 50))
+
+    def update_platform(self):
+        build_and_date = self.settings['snapshot_build'].split(":")
+
+        if len(build_and_date) == 2:
+            self.settings['platform'] = (
+                    self.db.execute_return_list(
+                            "select platform from snapshot_binaries "
+                            "where date == ? and build == ?",
+                            (build_and_date[0], build_and_date[1])))
+
+            if len(self.settings['platform']) > 0:
+                self.settings['platform'] = self.settings['platform'][0][0]
+
+    def update_build(self):
+        small_date = re.sub('-', '', self.settings['build_date'])
+        self.settings['snapshot_build'] = (small_date
+                                           + ":"
+                                           + str(self.settings['build_number']))
+
+    def fill_build_combo_box_for_date(self, date):
+        """Every time a date is chosen, this function should be called. It will
+        check to see if a compatible build is available. If there isn't, it
+        will search for one and provide some help text to tell the user when
+        compatable builds were built."""
+        # Re-populate the build combo box
+
+        self.cb_build.Clear()
+
+        builds = self.db.get_binary_builds_on_day_from_db(
+                                      self.settings['image'],
+                                      date,
+                                      self.settings['compatable_hwpacks'])
+
+        if len(builds):
+            max = 0
+            for item in builds:
+                #Always get a tuple, only interested in the first entry
+                item = item[0]
+                self.cb_build.Append(item, item.upper())
+
+                if item > max:
+                    max = item
+
+            self.cb_build.SetValue(max)
+            self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
+            self.help_text.SetLabel("")
+
+        else:
+            self.cb_build.SetValue("No builds available")
+            future_date, past_date = self.db.get_next_prev_day_with_builds(
+                                           self.settings['image'],
+                                           date,
+                                           self.settings['compatable_hwpacks'])
+
+            help_text = None
+
+            if future_date and past_date:
+                help_text = ("There are no builds that match your "
+                             "specifications available on the selected date. "
+                             "The previous build was on " + past_date +
+                             " and the next build was on " + future_date + ".")
+            elif future_date:
+                help_text = ("There are no builds that match your "
+                             "specifications available on the selected date. "
+                             "The next build was on " + future_date +
+                             " and I couldn't find a past build (looked one "
+                             "year back from the selected date).")
+            elif past_date:
+                help_text = ("There are no builds that match your "
+                             "specifications available on the selected date. "
+                             "The previous build was on " + past_date)
+                if date != self.today.FormatISODate().encode('ascii'):
+                    help_text += (" and I couldn't find a future build (I "
+                                  "looked up to one year forward from the "
+                                  "selected date).")
+            else:
+                help_text = ("I could not find any builds that match your "
+                             "specifications close to the selected date (I "
+                             "looked forward and back one year from the "
+                             "selected date).")
+
+            self.help_text.SetLabel(help_text)
+            self.help_text.Wrap(self.width - 10)
+            self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
+
+    #--- Event(s) ---
+    def on_date_changed(self, evt):
+        self.settings['build_date'] = evt.GetDate().FormatISODate().encode('ascii')
+        self.fill_build_combo_box_for_date(self.settings['build_date'])
+        self.update_build()
+
+    def event_combo_box_build(self, evt):
+        self.settings['build_number'] = evt.GetString().encode('ascii').lower()
+        self.update_build()
+    #--- END event(s) ---
+
+
+class SelectOS(wiz.WizardPageSimple):
+    """Ask the user which OS they would like to run. Filter out any choices
+    that are unavailable due to previous choices."""
+    def __init__(self, parent, config, db, width):
+        wiz.WizardPageSimple.__init__(self, parent)
+        self.settings = config.settings
+        self.wizard = parent
+        self.db = db
+        self.width = width
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.settings['image'] = None
+
+        header = wx.StaticText(self, label="Please select the operating "
+                                           "system you would like to run on "
+                                           "your hardware.")
+        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
+
+        self.box1 = wx.BoxSizer(wx.VERTICAL)
+        self.sizer.Add(header)
+
+        self.cb_image = wx.ComboBox(self,
+                                    style=wx.CB_DROPDOWN | wx.CB_READONLY)
+        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_os, self.cb_image)
+
+        #--- Layout ---
+        # -- Combo boxes for hardware and image selection --
+        self.box1.Add(self.cb_image, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        self.help_text = wx.StaticText(self)
+        self.sizer.Add(self.help_text, 1, wx.EXPAND, 5)
+
+        self.SetSizer(self.sizer)
+        self.sizer.Fit(self)
+        self.Move((50, 50))
+
+    def get_human_os_name(self, item):
+        """Given an OS name from the database, return a human name (either
+        translated from the YAML settings, or just prettified) and if it is a
+        LEB OS or not"""
+
+        item = re.sub("linaro-", "", item)  # Remove any linaro- decoration
+
+        human_name = item
+
+        if item in self.settings['UI']['descriptions']:
+            human_name = self.settings['UI']['descriptions'][item]
+        else:
+            # Make human_name look nicer...
+            human_name = string.capwords(item)
+
+        leb_search = re.search("^LEB:\s*(.*)$", human_name)
+
+        if leb_search:
+            return leb_search.group(1), True
+
+        return human_name, False
+
+    def fill_os_list(self):
+        """Filter the list of OS's from the config file based on the users
+        preferences so all choices in the list are valid (i.e. their hardware
+        is supported for the build they have chosen)."""
+
+        # select unique image from snapshot_binaries/release_binaries to
+        # generate list
+        os_list = None
+        if self.settings['release_or_snapshot'] == "release":
+            os_list = self.db.get_os_list_from('release_binaries')
+        else:
+            os_list = self.db.get_os_list_from('snapshot_binaries')
+
+        self.cb_image.Clear()
+
+        printed_tag = None
+        last_name = None
+        current_image_setting_valid = False
+
+        for state in ["LEB", "other"]:
+            for item in os_list:
+                if item == "old":
+                    # Old is a directory that sometimes hangs around,
+                    # but isn't one we want to display
+                    continue
+
+                # Save the original, untouched image name for use later.
+                # We give it a more human name for display
+                original = item
+                item = re.sub("linaro-", "", item)
+
+                os_hardware_combo_available = (
+                            self.db.image_hardware_combo_available(
+                                    self.settings['release_or_snapshot'],
+                                    original,
+                                    self.settings['compatable_hwpacks']))
+
+                if os_hardware_combo_available:
+                    human_name, is_LEB = self.get_human_os_name(item)
+
+                    if item == self.settings['image']:
+                        current_image_setting_valid = True
+
+                    if state == "LEB" and is_LEB:
+
+                        if printed_tag != state:
+                            self.cb_image.Append(
+                                            "- Linaro Supported Releases -")
+                            printed_tag = state
+
+                        self.cb_image.Append(human_name, original)
+
+                        if self.settings['image'] == None:
+                            self.settings['image'] = original
+
+                    elif state != "LEB" and not is_LEB:
+                        if printed_tag != state:
+                            self.cb_image.Append(
+                                            "- Community Supported Releases -")
+                            printed_tag = state
+
+                        self.cb_image.Append(human_name, original)
+
+                    last_name = original
+
+        if(    self.settings['image'] != None
+           and current_image_setting_valid == False):
+            # If we have an image setting, but it doesn't match the OS list, we
+            # have switched OS list. It may be that adding/removing "linaro-"
+            # from the name will get a match.
+
+            if re.search("linaro-", self.settings['image']):
+                test_name = re.sub("linaro-", "", self.settings['image'])
+            else:
+                test_name = "linaro-" + self.settings['image']
+
+            if test_name in os_list:
+                # Success! We have translated the name and can retain the
+                # "old setting"
+                self.settings['image'] = test_name
+                current_image_setting_valid = True
+
+        if(   self.settings['image'] == None
+           or current_image_setting_valid == False):
+            # This should only get hit if there are no LEBs available
+            self.settings['image'] = last_name
+
+        assert self.settings['image']
+
+        # Make sure the visible selected value matches the saved setting
+        self.cb_image.SetValue(
+                            self.get_human_os_name(self.settings['image'])[0])
+
+    #--- Event(s) ---
+    def event_combo_box_os(self, evt):
+        self.settings['image'] = self.cb_image.GetClientData(
+                                                            evt.GetSelection())
+
+        if self.settings['image']:  # Is None for items that aren't an OS
+            self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
+            image = re.sub("linaro-", "", self.settings['image'])
+
+            if image + "::long" in self.settings['UI']['descriptions']:
+                self.help_text.SetLabel(self.settings['UI']
+                                                     ['descriptions']
+                                                     [image + "::long"])
+            else:
+                self.help_text.SetLabel("")
+
+        else:  # Have selected help text
+            self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
+            self.help_text.SetLabel("Please select an operating system to run "
+                                    "on your chosen hardware.")
+
+        self.help_text.Wrap(self.width - 10)
+    #--- END event(s) ---
+
+
+class LMC_settings(wiz.WizardPageSimple):
+    """Present the user with, intially, the choice of writing the file system
+    they are going to have created to a file, or directly to a device. Ask
+    which file/device to write to.
+
+    If writing to a device, the user is asked to tick a box saying that they
+    understand that the device they have chosen will be erased.
+
+    If the user ticks the advanced box, more options are shown."""
+
+    def __init__(self, parent, config, db, width):
+        wiz.WizardPageSimple.__init__(self, parent)
+        self.settings = config.settings
+        self.wizard = parent
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.yes_use_mmc = False
+        self.db = db
+
+        self.settings['path_selected'] = ""
+
+        header = wx.StaticText(self,
+                               label="Media Creation Settings\n\n"
+                               "Please select if you would like to write the "
+                               "file system I am about to create to a memory "
+                               "card, or to a file on the local file system.")
+        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
+
+        #--- Build some widgets ---
+        #-- Target file system --
+        file_systems = ["ext3", "ext4", "btrfs", "ext2"]
+        default_target = file_systems[0]
+        self.settings['rootfs'] = default_target
+        cb_rootfs = wx.ComboBox(self,
+                                value=default_target,
+                                style=wx.CB_DROPDOWN | wx.CB_READONLY)
+
+        for item in file_systems:
+            cb_rootfs.Append(item, item.upper())
+
+        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_rootfs, cb_rootfs)
+
+        #-- Image size spinner
+        self.image_size_spinner = wx.SpinCtrl(self, -1, "")
+        self.Bind(wx.EVT_SPINCTRL,
+                  self.event_image_size,
+                  self.image_size_spinner)
+
+        #-- Swap size spinner
+        self.swap_size_spinner = wx.SpinCtrl(self, -1, "")
+        self.Bind(wx.EVT_SPINCTRL,
+                  self.event_swap_size,
+                  self.swap_size_spinner)
+
+        #--- Layout ---
+        self.sizer.Add(header, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+        box1 = wx.BoxSizer(wx.VERTICAL)
+        file_dev_grid = wx.FlexGridSizer(0, 2, 0, 0)
+        box1.Add(file_dev_grid, 0, wx.EXPAND)
+        grid1 = wx.FlexGridSizer(0, 2, 0, 0)
+
+        # self.settings['write_to_file_or_device'] should match the first
+        # button below...
+        self.settings['write_to_file_or_device'] = "file"
+        add_button(self,
+                   file_dev_grid,
+                   "Write to file",
+                   wx.RB_GROUP,
+                   self.event_radio_button_select,
+                   None, None)
+
+        add_button(self,
+                   file_dev_grid,
+                   "Write to device",
+                   None,
+                   self.event_radio_button_select,
+                   None, None)
+
+        self.help_text_values = {"device": "Please select a device to write "
+                                           "the file system to:",
+
+                                 "file":   "Please select a file to write the "
+                                           "file system to:"}
+
+        self.help_text = wx.StaticText(
+                             self,
+                             label=self.help_text_values[
+                                     self.settings['write_to_file_or_device']])
+        self.help_text.Wrap(width - 10)
+
+        #-- File/dev picker --
+        file_browse_button = wx.Button(self, -1, "Browse")
+        file_browse_grid   = wx.FlexGridSizer(0, 2, 0, 0)
+        self.file_path_and_name = wx.TextCtrl(self, -1, "", size=(300, -1))
+
+        file_browse_grid.Add(self.file_path_and_name, 0, wx.EXPAND)
+        file_browse_grid.Add(file_browse_button, 0, wx.EXPAND)
+
+        self.Bind(wx.EVT_BUTTON,
+                  self.event_open_file_control,
+                  file_browse_button)
+
+        self.Bind(wx.EVT_TEXT,
+                  self.event_file_path_and_name,
+                  self.file_path_and_name)
+
+        box1.Add(self.help_text, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        box1.Add(file_browse_grid, 0, wx.EXPAND)
+
+        cb1 = wx.CheckBox(self, -1, "Show advanced options")
+        self.Bind(wx.EVT_CHECKBOX, self.event_show_advanced_options, cb1)
+        box1.Add(cb1)
+
+        #-- Combo boxes for hardware and image selection --
+        optional_settings_box_title = wx.StaticBox(
+                                                self,
+                                                label=" Optional Settings ")
+
+        self.optional_settings_box = wx.StaticBoxSizer(
+                                                optional_settings_box_title,
+                                                wx.VERTICAL)
+
+        self.box2 = wx.BoxSizer(wx.VERTICAL)
+
+        self.box2.AddWindow(self.optional_settings_box,
+                            0,
+                            border=2,
+                            flag=wx.ALL | wx.EXPAND)
+
+        grid1.Add(cb_rootfs, 0, wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP, 5)
+
+        grid1.Add(wx.StaticText(self,
+                                label="The root file system of the image"),
+                                0,
+                                wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                                5)
+
+        # We want to sub-devide the cell, to add another grid sizer...
+        file_size_grid = wx.FlexGridSizer(0, 2, 0, 0)
+
+        grid1.Add(file_size_grid,
+                  0,
+                  wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP)
+
+        # Add a spinner that allows us to type/click a numerical value (defined above)
+        file_size_grid.Add(self.image_size_spinner,
+                           0,
+                           wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                           5)
+
+        # Add a choice of MB or GB for size input
+        units = ["GB", "MB"]
+        self.size_unit = units[0]  # Set the default unit
+        unit_choice = wx.Choice(self, -1, (100, 50), choices=units)
+        self.Bind(wx.EVT_CHOICE, self.event_chose_unit, unit_choice)
+        file_size_grid.Add(unit_choice, 0, wx.ALIGN_RIGHT | wx.TOP, 5)
+
+        # Back out of the extra grid, add some help text
+        grid1.Add(wx.StaticText(
+                            self,
+                            label="Writing to file only: Image file size"),
+                            0,
+                            wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                            5)
+
+        # The swap size (MB only)
+        grid1.Add(self.swap_size_spinner,
+                  0,
+                  wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                  5)
+
+        grid1.Add(wx.StaticText(self, label="Swap file size in MB"),
+                  0,
+                  wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                  5)
+
+        self.cb_hwpacks = wx.ComboBox(
+                                self,
+                                value=self.settings['compatable_hwpacks'][0],
+                                style=wx.CB_DROPDOWN | wx.CB_READONLY)
+
+        self.Bind(wx.EVT_COMBOBOX,
+                  self.event_combo_box_hwpack,
+                  self.cb_hwpacks)
+
+        grid1.Add(self.cb_hwpacks,
+                  0,
+                  wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                  5)
+
+        grid1.Add(wx.StaticText(self, label="Compatible hardware packs"),
+                  0,
+                  wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                  5)
+
+        self.optional_settings_box.Add(grid1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        confirm_mmc_usage_title = wx.StaticBox(self, label=" Are you sure? ")
+
+        self.confirm_mmc_usage_box = wx.StaticBoxSizer(confirm_mmc_usage_title,
+                                                       wx.VERTICAL)
+        cb2 = wx.CheckBox(
+                        self,
+                        -1,
+                        "Yes, erase and use the device I have selected above.")
+
+        self.Bind(wx.EVT_CHECKBOX, self.event_use_mmc_tickbox, cb2)
+        self.confirm_mmc_usage_box.Add(cb2)
+
+        self.box3 = wx.BoxSizer(wx.VERTICAL)
+        self.box3.AddWindow(self.confirm_mmc_usage_box,
+                            0,
+                            border=2,
+                            flag=wx.ALL | wx.EXPAND)
+
+        self.sizer.Add(box1, 0, wx.ALIGN_LEFT | wx.ALL, 0)
+        self.sizer.Add(self.box2, 0, wx.ALIGN_LEFT | wx.ALL, 0)
+        self.sizer.Add(self.box3, 0, wx.ALIGN_LEFT | wx.ALL, 0)
+        self.SetSizer(self.sizer)
+        self.sizer.Fit(self)
+        self.Move((50, 50))
+
+    def on_activate(self):
+        self.update_forward_active_and_mmc_confirm_box_visible()
+        self.set_hwpacks_for_hardware()
+
+    def set_hwpacks_for_hardware(self):
+        self.cb_hwpacks.Clear()
+
+        if self.settings['release_or_snapshot'] == "snapshot":
+            self.settings['build'] = self.settings['snapshot_build']
+
+            date_and_build = self.settings['build'].split(":")
+
+            compatable_hwpacks = (
+                self.db.get_available_hwpacks_for_hardware_snapshot_build(
+                                        self.settings['compatable_hwpacks'],
+                                        self.settings['platform'],
+                                        date_and_build[0],
+                                        date_and_build[1]))
+        else:
+            self.settings['build'] = self.settings['release_build']
+            compatable_hwpacks = (
+                self.db.get_available_hwpacks_for_hardware_build_plaform(
+                                        self.settings['compatable_hwpacks'],
+                                        self.settings['platform'],
+                                        self.settings['build']))
+
+        for hwpack in compatable_hwpacks:
+            self.cb_hwpacks.Append(hwpack)
+
+        self.cb_hwpacks.SetStringSelection(compatable_hwpacks[0])
+        self.settings['hwpack'] = compatable_hwpacks[0]
+
+    def update_forward_active_and_mmc_confirm_box_visible(self):
+        if(    self.settings['path_selected']
+           and self.settings['path_selected'] != ""):
+
+            if (   self.settings['write_to_file_or_device'] == "file"
+                or self.settings['write_to_file_or_device'] == "device"
+                   and self.yes_use_mmc):
+                self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
+            else:
+                self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
+        else:
+            self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
+
+        if self.settings['write_to_file_or_device'] == "device":
+            self.box3.Show(self.confirm_mmc_usage_box, True)
+        else:
+            self.box3.Hide(self.confirm_mmc_usage_box, True)
+
+    # --- Event Handlers ---
+    def event_open_file_control(self, event):
+        if self.settings['write_to_file_or_device'] == "file":
+
+            dlg = wx.FileDialog(self,
+                                message="Save file as ...",
+                                defaultDir=os.getcwd(),
+                                defaultFile="",
+                                style=wx.SAVE)
+
+        elif self.settings['write_to_file_or_device'] == "device":
+            dlg = wx.FileDialog(self,
+                                message="Choose a device",
+                                defaultDir=os.getcwd(),
+                                defaultFile="",
+                                style=wx.OPEN | wx.CHANGE_DIR)
+
+        if dlg.ShowModal() == wx.ID_OK:
+            self.settings['path_selected'] = dlg.GetPaths()[0]
+            self.file_path_and_name.SetValue(self.settings['path_selected'])
+
+        dlg.Destroy()
+        self.update_forward_active_and_mmc_confirm_box_visible()
+
+    def event_file_path_and_name(self, event):
+        self.settings['path_selected'] = event.GetString()
+        self.update_forward_active_and_mmc_confirm_box_visible()
+
+    def event_combo_box_hwpack(self, event):
+        self.settings['hwpack'] = event.GetString().encode('ascii')
+
+    def event_combo_box_rootfs(self, evt):
+        self.settings['rootfs'] = evt.GetString().encode('ascii').lower()
+
+    def event_radio_button_select(self, event):
+        """Search the label of the button that has been selected to work out
+        what we are writing to."""
+        setting_search = re.search(
+                            "write to (\w+)",
+                            event
+                             .GetEventObject()
+                              .GetLabel()
+                               .encode('ascii')
+                                .lower())
+
+        assert setting_search
+
+        self.settings['write_to_file_or_device'] = setting_search.group(1)
+
+        self.help_text.SetLabel(
+               self.help_text_values[self.settings['write_to_file_or_device']])
+
+        self.update_forward_active_and_mmc_confirm_box_visible()
+
+    def event_show_advanced_options(self, event):
+        if event.IsChecked():
+            self.box2.Show(self.optional_settings_box, True)
+        else:
+            self.box2.Hide(self.optional_settings_box, True)
+
+    def event_pick_file_path(self, evt):
+        self.settings['path_selected'] = os.path.abspath(evt.GetPath())
+        self.update_forward_active_and_mmc_confirm_box_visible()
+
+    def update_image_size_setting(self):
+        if(self.image_size_spinner.GetValue() > 0):
+            self.settings['image_size'] = (str(self.image_size_spinner
+                                                                 .GetValue())
+                                           + self.size_unit[0])
+        else:
+            self.settings['image_size'] = None
+
+    def event_image_size(self, event):
+        self.update_image_size_setting()
+
+    def event_chose_unit(self, event):
+        self.size_unit = event.GetString()
+        self.update_image_size_setting()
+
+    def event_swap_size(self, event):
+        self.settings['swap_file'] = str(self.image_size_spinner.GetValue())
+
+    def event_use_mmc_tickbox(self, event):
+        self.yes_use_mmc = event.IsChecked()
+        self.update_forward_active_and_mmc_confirm_box_visible()
+
+
+class RunLMC(wiz.WizardPageSimple):
+    """Present the user with some information about their choices and a button
+    to start linaro-media-create. The linaro-media-create process is started in
+    a new thread and important events are communicated back to the UI through a
+    queue."""
+
+    def __init__(self, parent, config, db, width):
+        wiz.WizardPageSimple.__init__(self, parent)
+        self.settings = config.settings
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.db = db
+        self.width = width
+        self.wizard = parent
+
+        header = wx.StaticText(self, label="""Installing...""")
+        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
+
+        self.sizer.Add(header)
+        self.box1 = wx.BoxSizer(wx.VERTICAL)
+
+        # We expect to print 4 lines of information, reserve space using blank
+        # lines.
+        self.settings_summary_text = wx.StaticText(self, label="\n\n\n\n")
+        self.settings_summary_text.Wrap(width - 10)
+
+        self.box1.Add(self.settings_summary_text, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        self.start_button = wx.Button(self, 10, "Start", (20, 20))
+        self.Bind(wx.EVT_BUTTON, self.start_lmc, self.start_button)
+
+        self.start_button.SetToolTipString("Start creating an image, using the"
+                                           "above settings.")
+
+        self.start_button.SetSize(self.start_button.GetBestSize())
+        self.box1.Add(self.start_button, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+
+        self.download_guage = wx.Gauge(self,
+                                       -1,
+                                       1000,
+                                       size=(self.width * 2 / 3, 25))
+
+        self.status_grid = wx.FlexGridSizer(0, 2)
+
+        self.status_grid.Add(wx.StaticText(self, label="Downloading files"),
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.downloading_files_status = wx.StaticText(self, label="")
+
+        self.status_grid.Add(self.downloading_files_status,
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.status_grid.Add(self.download_guage,
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.downloading_files_info = wx.StaticText(self, label="")
+
+        self.status_grid.Add(self.downloading_files_info,
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.status_grid.Add(wx.StaticText(self, label="Unpacking downloads"),
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.unpacking_files_status = wx.StaticText(self, label="")
+
+        self.status_grid.Add(self.unpacking_files_status,
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.status_grid.Add(wx.StaticText(self, label="Installing packages"),
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.installing_packages_status = wx.StaticText(self, label="")
+
+        self.status_grid.Add(self.installing_packages_status,
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.status_grid.Add(wx.StaticText(self, label="Create file system"),
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.create_file_system_status = wx.StaticText(self, label="")
+
+        self.status_grid.Add(self.create_file_system_status,
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.status_grid.Add(wx.StaticText(self, label="Populate file system"),
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.populate_file_system_status = wx.StaticText(self, label="")
+
+        self.status_grid.Add(self.populate_file_system_status,
+                             0,
+                             wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP,
+                             5)
+
+        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+        self.sizer.Add(self.status_grid, 0, wx.ALIGN_LEFT | wx.ALL, 5)
+        self.SetSizerAndFit(self.sizer)
+        self.sizer.Fit(self)
+        self.Move((50, 50))
+
+    def on_activate(self):
+        """Called just before the page is displayed to update the text based on
+        the users preferences."""
+
+        # The build is stored in different forms depending on if we are using a
+        # release or snapshot but from here on in it is a common value
+        if self.settings['release_or_snapshot'] == "snapshot":
+            self.settings['build'] = self.settings['snapshot_build']
+        else:
+            self.settings['build'] = self.settings['release_build']
+
+        settings_summary = ("Press start to create an image with the "
+                            "following settings:\n")
+        settings_summary += "Operating System: " + self.settings['image'] + "\n"
+        settings_summary += "Hardware: " + self.settings['hardware'] + "\n"
+
+        # Assumption is that a file may be in a long path, we don't know how
+        # big the font is and we don't want to allow the path to run off the
+        # end of the line, so if a file is chosen, just show the file name.
+        # Devices are (probably) /dev/some_short_name and the user really needs
+        # to check them, so we show the whole thing.
+        path = self.settings['path_selected']
+        if self.settings['write_to_file_or_device'] == "file":
+            path = self.settings['path_selected'].split(os.sep)[-1]
+
+        settings_summary += (  "Writing image to "
+                             + self.settings['write_to_file_or_device']
+                             + " "
+                             + path)
+
+        self.settings_summary_text.SetLabel(settings_summary)
+        self.settings_summary_text.Wrap(self.width - 10)
+
+    def start_lmc(self, event):
+        """Start a thread that runs linaro-media-create and a timer, which
+        checks for UI updates every 100ms"""
+
+        if self.settings['write_to_file_or_device'] == "file":
+            self.settings['image_file'] = self.settings['path_selected']
+        elif self.settings['write_to_file_or_device'] == "device":
+            self.settings['mmc'] = self.settings['path_selected']
+        else:
+            assert False, ("self.config.settings['write_to_file_or_device'] "
+                           "was an unexpected value"
+                           + self.settings['write_to_file_or_device'])
+
+        image_url, hwpack_url = self.db.get_image_and_hwpack_urls(self.settings)
+
+        # Currently the UI is blocked when LMC is running, so grey out the
+        # buttons to indicate to the user that they won't work!
+        self.wizard.FindWindowById(wx.ID_BACKWARD).Disable()
+        self.wizard.FindWindowById(wx.ID_CANCEL).Disable()
+
+        if(image_url and hwpack_url):
+
+            self.file_handler = FetchImage.FileHandler()
+
+            self.timer = wx.Timer(self)
+            self.Bind(wx.EVT_TIMER, self.timer_ping, self.timer)
+            self.timer.Start(milliseconds=100, oneShot=True)
+
+            tools_dir = os.path.dirname(__file__)
+            if tools_dir == '':
+                tools_dir = None
+
+            self.start_button.Disable()
+            self.event_queue = Queue.Queue()
+            self.lmc_thread = self.file_handler.LinaroMediaCreate(
+                                                    image_url,
+                                                    hwpack_url,
+                                                    self.file_handler,
+                                                    self.event_queue,
+                                                    self.settings,
+                                                    tools_dir)
+            self.lmc_thread.start()
+        else:
+            print >> sys.stderr, ("Unable to find files that match the"
+                                  "parameters specified")
+
+    def timer_ping(self, event):
+        """During start_lmc a timer is started to poll for events from
+        linaro-media-create every 100ms. This is the function which is called
+        to do that polling."""
+
+        while not self.event_queue.empty():
+            event = self.event_queue.get()
+
+            if event[0] == "start":
+                self.event_start(event[1])
+
+            elif event[0] == "end":
+                self.event_end(event[1])
+
+            elif event == "terminate":
+                # Process complete. Enable next button.
+                self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
+                self.populate_file_system_status.SetLabel("Done")
+                return  # Even if queue isn't empty, stop processing it
+
+            elif event[0] == "update":
+                self.event_update(event[1], event[2], event[3])
+
+            else:
+                print >> sys.stderr, "timer_ping: Unhandled event", event
+
+        self.timer.Start(milliseconds=50, oneShot=True)
+
+    def unsigned_packages_query(self, package_list):
+        message = ('In order to continue, I need to install some unsigned'
+                   'packages into the image. Is this OK? The packages are:'
+                   '\n\n' + package_list)
+
+        dlg = wx.MessageDialog(self,
+                               message,
+                               'Install Unsigned Packages Into Image?',
+                               wx.YES_NO | wx.NO_DEFAULT)
+
+        choice = dlg.ShowModal()
+        dlg.Destroy()
+
+        return choice == wx.ID_YES
+
+    #--- Event(s) ---
+    def event_start(self, event):
+        if event == "download OS":
+            self.downloading_files_status.SetLabel("Downloading OS")
+        elif event == "download hwpack":
+            self.downloading_files_status.SetLabel("Downloading Hardware Pack")
+        elif event == "unpack":
+            self.unpacking_files_status.SetLabel("Running")
+        elif event == "installing packages":
+            self.installing_packages_status.SetLabel("Running")
+
+        elif re.search('^unverified_packages:', event):
+            # Get rid of event ID and whitespace invariance
+            packages = " ".join(event.split()[1:])
+            install_unsigned_packages = self.unsigned_packages_query(packages)
+
+            if install_unsigned_packages == False:
+                self.file_handler.kill_create_media()
+                sys.exit(1)
+            else:
+                self.lmc_thread.send_to_create_process("y")
+
+        elif event == "create file system":
+            self.create_file_system_status.SetLabel("Running")
+        elif event == "populate file system":
+            self.populate_file_system_status.SetLabel("Running")
+        else:
+            print "Unhandled start event:", event
+
+    def event_end(self, event):
+        if event == "download OS":
+            self.downloading_files_status.SetLabel("Done (1/2)")
+        elif event == "download hwpack":
+            self.downloading_files_status.SetLabel("Done")
+        elif event == "unpack":
+            self.unpacking_files_status.SetLabel("Done")
+        elif event == "installing packages":
+            self.installing_packages_status.SetLabel("Done")
+        elif event == "create file system":
+            self.create_file_system_status.SetLabel("Done")
+        elif event == "populate file system":
+            self.populate_file_system_status.SetLabel("Done")
+        else:
+            print "Unhhandled end event:", event
+
+    def event_update(self, task, update_type, value):
+        if task == "download":
+            if update_type == "name":
+                self.downloading_files_status.SetLabel("Downloading")
+                self.old_time = time.time()
+                self.old_bytes_downloaded = 0
+
+            elif update_type == "progress":
+                self.total_bytes_downloaded += value
+
+                time_difference = time.time() - self.old_time
+
+                if time_difference > 1.0:
+                    self.old_time = time.time()
+
+                    # More than a second has passed since we calculated data
+                    # rate
+                    speed = (  float(  self.total_bytes_downloaded
+                                     - self.old_bytes_downloaded)
+                             / time_difference)
+
+                    self.old_bytes_downloaded = self.total_bytes_downloaded
+
+                    self.speeds.append(speed)
+
+                    average_speed = 0
+                    speeds_accumulated = 0
+                    for speed in reversed(self.speeds):
+                        average_speed += speed
+                        speeds_accumulated += 1
+
+                        if speeds_accumulated == 6:
+                            break  # do rolling average of 6 seconds
+
+                    average_speed /= speeds_accumulated
+
+                    time_remaining = (  (  self.total_bytes_to_download
+                                         - self.total_bytes_downloaded)
+                                      / speed)
+
+                    pretty_time = str(datetime.timedelta(seconds=int(
+                                                              time_remaining)))
+
+                    # Following table assumes we don't get past TBps internet
+                    # connections soon :-)
+                    units = ["Bps", "kBps", "MBps", "GBps", "TBps"]
+                    units_index = 0
+                    while speed > 1024:
+                        speed /= 1024
+                        units_index += 1
+
+                    info = "Downloading at {0:.1f} {1}".format(
+                                                         speed,
+                                                         units[units_index])
+
+                    self.downloading_files_status.SetLabel(info)
+
+                    info = "{0} remaining".format(
+                                                         pretty_time)
+
+                    self.downloading_files_info.SetLabel(info)
+
+                self.download_guage.SetValue(  1000
+                                             * self.total_bytes_downloaded
+                                             / self.total_bytes_to_download)
+
+            elif update_type == "total bytes":
+                self.total_bytes_to_download = value
+                self.total_bytes_downloaded = 0
+                self.speeds = []  # keep an array of speeds used to calculate
+                # the estimated time remaining - by not just using the
+                # current speed we can stop the ETA bouncing around too much.
+
+    def event_combo_box_release(self, evt):
+        pass
+
+    def event_combo_box_build(self, evt):
+        pass
+    #--- END event(s) ---
+
+
+class TestDriveWizard(wx.wizard.Wizard):
+    def __init__(self, title):
+        wx.wizard.Wizard.__init__(self, None, -1, title, wx.NullBitmap)
+        self.Bind(wx.wizard.EVT_WIZARD_PAGE_CHANGING, self.on_page_changing)
+        self.done_startup = False
+
+    def on_page_changing(self, evt):
+        'Executed before the page changes.'
+
+        if self.done_startup == False:
+            self.pages['lmc_settings'].box2.Hide(
+                            self.pages['lmc_settings'].optional_settings_box,
+                            True)
+
+            self.pages['lmc_settings'].box3.Hide(
+                            self.pages['lmc_settings'].confirm_mmc_usage_box,
+                            True)
+
+            self.done_startup = True
+
+        page = evt.GetPage()
+
+        if evt.GetDirection():  # If going forwards...
+            # Always enable back button if going forwards
+            self.wizard.FindWindowById(wx.ID_BACKWARD).Enable()
+
+            # If going from a select snapshot or select release page, record
+            # which we were on so the back button of the next page works
+            if(self.config.settings['release_or_snapshot'] == "release"):
+                self.pages['select_os'].SetNext(self.pages['select_release'])
+                self.pages['select_release'].SetPrev(self.pages['select_os'])
+
+                self.pages['select_release'].SetNext(self.pages['lmc_settings'])
+                self.pages['lmc_settings'].SetPrev(self.pages['select_release'])
+            else:
+                self.pages['select_os'].SetNext(self.pages['select_snapshot'])
+                self.pages['select_snapshot'].SetPrev(self.pages['select_os'])
+
+                if(page == self.pages['select_os']):
+                    self.pages['select_snapshot'].fill_build_combo_box_for_date(
+                                            self.config.settings['build_date'])
+
+                self.pages['select_snapshot'].SetNext(self.pages['lmc_settings'])
+                self.pages['lmc_settings'].SetPrev(self.pages['select_snapshot'])
+
+            if page == self.pages['hardware_details']:
+                self.pages['select_os'].fill_os_list()
+
+            if page == self.pages['release_or_snapshot']:
+                self.pages['hardware_details'].on_page_changing()
+
+            # If about to move into the release selection, make sure the list
+            # is populated only with releases that are valid with our current
+            # selection
+            if(    page == self.pages['select_os']
+               and self.config.settings['release_or_snapshot'] == "release"):
+                self.pages['select_release'].update_release_and_build_boxes()
+
+            if page == self.pages['select_snapshot']:
+                # Execute when exiting page
+                self.pages['select_snapshot'].update_platform()
+
+            if(   page == self.pages['select_snapshot']
+               or page == self.pages['select_release']):
+                self.pages['lmc_settings'].on_activate()
+
+            if page == self.pages['lmc_settings']:
+                # Forward stays disabled until LMC has finished running
+                self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
+                self.pages['run_lmc'].on_activate()
+
+        else:  # Always enable the forward button if reversing into a page
+            self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
+
+    def go(self):
+        file_handler = FetchImage.FileHandler()
+        self.config = FetchImage.FetchImageConfig()
+        self.config.settings["force_download"] = False
+        self.config.settings['compatable_hwpacks'] = ['foo']
+
+        # If the settings file and server index need updating, grab them
+        file_handler.update_files_from_server()
+
+        # Load settings YAML, which defines the parameters we ask for and
+        # acceptable responses from the user
+        self.config.read_config(file_handler.settings_file)
+
+        # Using the config we have, look up URLs to download data from in
+        # the server index
+        db = FetchImage.DB(file_handler.index_file)
+
+        # Create the wizard and the pages
+        self.wizard = wiz.Wizard(self, -1, "Linaro Media Builder")
+
+        self.pages = {}
+        self.pages['release_or_snapshot'] = ReleaseOrSnapshotPage(self.wizard,
+                                                                  self.config)
+        self.wizard.FitToPage(self.pages['release_or_snapshot'])
+        (width, height) = self.wizard.GetSize()
+
+        self.pages['hardware_details']  = AboutMyHardwarePage(self.wizard,
+                                                              self.config,
+                                                              db,
+                                                              width)
+
+        self.pages['select_release']    = SelectStableRelease(self.wizard,
+                                                              self.config,
+                                                              db,
+                                                              width)
+
+        self.pages['select_snapshot']   = SelectSnapshot(self.wizard,
+                                                         self.config,
+                                                         db,
+                                                         width)
+
+        self.pages['select_os']         = SelectOS(self.wizard,
+                                                   self.config,
+                                                   db,
+                                                   width)
+
+        self.pages['lmc_settings']      = LMC_settings(self.wizard,
+                                                       self.config,
+                                                       db,
+                                                       width)
+
+        self.pages['run_lmc']           = RunLMC(self.wizard,
+                                                 self.config,
+                                                 db,
+                                                 width)
+
+        self.pages['release_or_snapshot'].SetNext(
+                                            self.pages['hardware_details'])
+
+        self.pages['hardware_details'].SetPrev(
+                                            self.pages['release_or_snapshot'])
+
+        self.pages['hardware_details'].SetNext(self.pages['select_os'])
+        self.pages['select_os'].SetPrev(self.pages['hardware_details'])
+        # Select OS goes to select build, which is customised for
+        # releases or snapshots
+        self.pages['lmc_settings'].SetNext(self.pages['run_lmc'])
+        self.pages['run_lmc'].SetPrev(self.pages['lmc_settings'])
+
+        for (name, page) in self.pages.items():
+            self.wizard.GetPageAreaSizer().Add(page)
+
+        self.wizard.RunWizard(self.pages['release_or_snapshot'])
+
+
+def run():
+    """Wrapper around the full wizard. Is encapsulated in its own function to
+       allow a restart to be performed, as described in __main___, easily"""
+    app = wx.PySimpleApp()  # Start the application
+    if app:
+        pass  # We don't use this directly. Stop pyflakes complaining!
+    
+    w = TestDriveWizard('Simple Wizard')
+    return w.go()
+
+
+class TestURLLookupFunctions(unittest.TestCase):
+
+    def setUp(self):
+        self.file_handler   = FetchImage.FileHandler()
+        self.file_handler.update_files_from_server()
+        self.config         = FetchImage.FetchImageConfig()
+        self.config.settings["force_download"] = False
+
+        # Load settings YAML, which defines the parameters we ask for and
+        # acceptable responses from the user
+        self.config.read_config(self.file_handler.settings_file)
+
+        # Using the config we have, look up URLs to download data from in the
+        # server index
+        self.db = FetchImage.DB(self.file_handler.index_file)
+
+    def test_url_lookup(self):
+        self.settings = self.config.settings
+        self.settings['release_or_snapshot'] = "snapshot"
+
+        #--- Test first with a snapshot build lookup ---
+        # -- Fix a build date --
+        # We only need to look up a single snapshot date. Start with today and
+        # go with the day in the DB, build 0
+        today = wx.DateTime()
+        today.SetToCurrent()
+
+        # -- Don't iterate through platforms for snapshot --
+
+        # -- Select hardware --
+        for self.settings['hardware'] in (
+                                   self.settings['choice']['hardware'].keys()):
+
+            compatable_hwpacks = self.settings['choice']['hwpack'][
+                                                    self.settings['hardware']]
+
+            future_date, past_date = self.db.get_next_prev_day_with_builds(
+                                        "linaro-alip",
+                                        today.FormatISODate().encode('ascii'),
+                                        compatable_hwpacks)
+
+            if past_date == None:
+                # Some hardware packs are not available in the snapshot repo,
+                # so just skip if they aren't
+                continue
+
+            builds = self.db.get_binary_builds_on_day_from_db(
+                                                        "linaro-alip",
+                                                        past_date,
+                                                        compatable_hwpacks)
+
+            self.assertTrue(len(builds))
+            # If the above assert fails, either the DB is empty, or
+            # db.get_binary_builds_on_day_from_db failed
+
+            small_date = re.sub('-', '', past_date)
+            self.settings['build'] = small_date + ":" + "0"
+
+            # -- Iterate through hardware packs --
+            for self.settings['hwpack'] in compatable_hwpacks:
+
+                # If hardware pack is available...
+                if(self.settings['hwpack']
+                    in self.db.get_hwpacks('snapshot_hwpacks')):
+
+                    # -- Iterate through images
+                    os_list = self.db.get_os_list_from('snapshot_binaries')
+
+                    for self.settings['image'] in os_list:
+                        if re.search('old', self.settings['image']):
+                            # Directories with old in the name are of no
+                            # interest to us
+                            continue
+
+                        # -- Check build which matches these parameters
+                        #    (builds that don't match are excluded in UI) --
+                        if(    len(self.db.execute_return_list(
+                                    'select * from snapshot_hwpacks '
+                                    'where hardware == ? '
+                                    'and date == ? '
+                                    'and build == ?',
+                                    (self.settings['hwpack'],
+                                     small_date,
+                                     "0")))
+                           and len(self.db.execute_return_list(
+                                    'select * from snapshot_binaries '
+                                    'where image == ? '
+                                    'and date == ? '
+                                    'and build == ?',
+                                    (self.settings['image'],
+                                     small_date,
+                                     "0")))):
+
+                            # - Run the function under test! -
+                            image_url, hwpack_url = (
+                              self.db.get_image_and_hwpack_urls(self.settings))
+
+                            self.assertTrue(image_url)
+                            self.assertTrue(hwpack_url)
+
+        #--- Now test release build lookup ---
+        self.settings['release_or_snapshot'] = "release"
+        # -- Select hardware --
+        for self.settings['hardware'] in (
+                                    self.settings['choice']['hardware'].keys()):
+            compatable_hwpacks = (
+                  self.settings['choice']['hwpack'][self.settings['hardware']])
+
+            # -- Iterate through hardware packs --
+            for self.settings['hwpack'] in compatable_hwpacks:
+
+                # If hardware pack is available...
+                if(self.settings['hwpack']
+                    in self.db.get_hwpacks('release_hwpacks')):
+
+                    # -- Iterate through images
+                    os_list = self.db.get_os_list_from('release_binaries')
+
+                    for self.settings['image'] in os_list:
+                        if re.search('old', self.settings['image']):
+                            # Directories with old in the name are of no
+                            # interest to us
+                            continue
+
+                        for platform, ignore in (
+                                  self.settings['choice']['platform'].items()):
+                            self.settings['platform'] = platform
+
+                            # -- Iterate through available builds --
+                            builds = self.db.get_builds(
+                                                    self.settings['platform'],
+                                                    self.settings['image'])
+
+                            for build in builds:
+                                self.settings['build'] = build
+
+                                # -- Check build which matches these parameters
+                                #(builds that don't match are excluded in UI)--
+                                if(    len(self.db.execute_return_list(
+                                            'select * from release_hwpacks '
+                                            'where platform == ? '
+                                            'and hardware == ? '
+                                            'and build == ?',
+                                            (self.settings['platform'],
+                                             self.settings['hwpack'],
+                                             self.settings['build'])))
+                                   and len(self.db.execute_return_list(
+                                            'select * from release_binaries '
+                                            'where platform == ? '
+                                            'and image == ? '
+                                            'and build == ?',
+                                            (self.settings['platform'],
+                                             self.settings['image'],
+                                             self.settings['build'])))):
+
+                                    # - Run the function under test! -
+                                    image_url, hwpack_url = (
+                                        self.db.get_image_and_hwpack_urls(self.settings))
+                                    self.assertTrue(image_url)
+                                    self.assertTrue(hwpack_url)
+
+if __name__ == '__main__':
+    run()
 
=== modified file 'linaro-android-media-create'
--- linaro-android-media-create	2011-05-26 09:16:35 +0000
+++ linaro-android-media-create	2011-07-18 14:39:34 +0000
@@ -133,12 +133,13 @@
     unpack_android_binary_tarball(args.system, SYSTEM_DIR)
     unpack_android_binary_tarball(args.userdata, DATA_DIR)
 
-    # Create partitions    
+    # Create partitions
     boot_partition, system_partition, cache_partition, \
         data_partition, sdcard_partition = setup_android_partitions( \
         board_config, media, args.image_size, args.boot_label,
         args.should_create_partitions, args.should_align_boot_part)
 
+    board_config.populate_raw_partition(args.device, BOOT_DIR)
     populate_partition(BOOT_DIR + "/boot", BOOT_DISK, boot_partition)
     board_config.populate_boot_script(boot_partition, BOOT_DISK, args.consoles)
     populate_partition(SYSTEM_DIR + "/system", SYSTEM_DISK, system_partition)
 
=== modified file 'linaro-hwpack-install'
--- linaro-hwpack-install	2011-01-29 16:35:06 +0000
+++ linaro-hwpack-install	2011-07-18 14:39:34 +0000
@@ -36,7 +36,7 @@
 FORCE_YES="no"
 SOURCES_LIST_FILE="${TEMP_DIR}/sources.list"
 APT_GET_OPTIONS="Dir::Etc::SourceList=${SOURCES_LIST_FILE}"
-SUPPORTED_FORMATS="1.0"  # A space-separated list of hwpack formats.
+SUPPORTED_FORMATS="1.0 2.0"  # A space-separated list of hwpack formats.
 
 sudo="sudo"
 if [ $(id -u) -eq 0 ]; then
 
=== renamed file 'linaro_image_tools/index_server.py' => 'linaro-image-indexer'
--- linaro_image_tools/index_server.py	2011-06-17 18:04:47 +0000
+++ linaro-image-indexer	2011-07-18 14:39:34 +0000
@@ -22,10 +22,10 @@
 
 import os
 import re
-import FetchImage
 import urlparse
 import logging
 import bz2
+import linaro_image_tools.FetchImage
 
 RELEASES_WWW_DOCUMENT_ROOT  = "/srv/releases.linaro.org/www/platform/"
 RELEASE_URL                 = "http://releases.linaro.org/platform/"
@@ -41,7 +41,7 @@
     def __init__(self):
         self.reset()
         self.db_file_name = "server_index"
-        self.db = FetchImage.DB(self.db_file_name)
+        self.db = linaro_image_tools.FetchImage.DB(self.db_file_name)
 
     def crawl(self):
         self.db.set_url_parse_info(self.url_parse)
@@ -89,8 +89,6 @@
                                  url_chunks_):
         
         if(not id_ in self.url_parse):
-            
-            print base_dir_
             self.url_parse[id_] = {"base_dir":      base_dir_,
                                    "base_url":      base_url_,
                                    "url_validator": url_validator_,
 
=== modified file 'linaro-media-create'
--- linaro-media-create	2011-06-21 09:16:28 +0000
+++ linaro-media-create	2011-07-18 14:39:34 +0000
@@ -104,6 +104,7 @@
     ROOT_DISK = os.path.join(TMP_DIR, 'root-disc')
 
     board_config = board_configs[args.board]
+    board_config.set_metadata(args.hwpacks)
 
     ensure_required_commands(args)
 
 
=== modified file 'linaro_image_tools/FetchImage.py'
--- linaro_image_tools/FetchImage.py	2011-06-17 18:04:47 +0000
+++ linaro_image_tools/FetchImage.py	2011-07-18 14:39:34 +0000
@@ -52,15 +52,6 @@
                                      "image-tools",
                                      "fetch_image")
 
-    class DummyEventHandler():
-        """Just a sink for events if no event handler is provided to
-        create_media"""
-        def event_start(self, event):
-            pass
-
-        def event_end(self, event):
-            pass
-
     def has_key_and_evaluates_True(self, dictionary, key):
         return bool(key in dictionary and dictionary[key])
 
@@ -72,17 +63,15 @@
             list.append(setting_name)
             list.append(dictionary[key])
 
-    def create_media(self, image_url, hwpack_url, settings, tools_dir,
-                     run_in_gui=False, event_handler=None):
-        """Create a command line for linaro-media-create based on the settings
-        provided then run linaro-media-create, either in a separate thread
-        (GUI mode) or in the current one (CLI mode)."""
+    def build_lmc_command(self,
+                          binary_file,
+                          hwpack_file,
+                          settings,
+                          tools_dir,
+                          run_in_gui=False):
 
         import linaro_image_tools.utils
 
-        if event_handler == None:
-            event_handler = self.DummyEventHandler()
-
         args = []
         args.append("pkexec")
 
@@ -100,41 +89,6 @@
         if run_in_gui:
             args.append("--nocheck-mmc")
 
-        event_handler.event_start("download OS")
-        try:
-            binary_file = self.download(image_url,
-                                        settings["force_download"],
-                                        show_wx_progress=run_in_gui,
-                                        wx_progress_title=
-                                         "Downloading file 1 of 2")
-        except Exception:
-            # Download error. Hardly matters what, we can't continue.
-            print "Unexpected error:", sys.exc_info()[0]
-            logging.error("Unable to download " + image_url + " - aborting.")
-        event_handler.event_end("download OS")
-
-        if binary_file == None:  # User hit cancel when downloading
-            sys.exit(0)
-
-        event_handler.event_start("download hwpack")
-        try:
-            hwpack_file = self.download(hwpack_url,
-                                        settings["force_download"],
-                                        show_wx_progress=run_in_gui,
-                                        wx_progress_title=
-                                         "Downloading file 2 of 2")
-        except Exception:
-            # Download error. Hardly matters what, we can't continue.
-            print "Unexpected error:", sys.exc_info()[0]
-            logging.error("Unable to download " + hwpack_url + " - aborting.")
-        event_handler.event_end("download hwpack")
-
-        if hwpack_file == None:  # User hit cancel when downloading
-            sys.exit(0)
-
-        logging.info("Have downloaded OS binary to", binary_file,
-                     "and hardware pack to", hwpack_file)
-
         if 'rootfs' in settings and settings['rootfs']:
             args.append("--rootfs")
             args.append(settings['rootfs'])
@@ -157,34 +111,74 @@
         args.append("--hwpack")
         args.append(hwpack_file)
 
-        logging.info(args)
-
-        if run_in_gui:
-            self.lmcargs        = args
-            self.event_handler  = event_handler
-            self.started_lmc    = False
-            return
-
-        else:
-            self.create_process = subprocess.Popen(args)
-            self.create_process.wait()
+        logging.info(" ".join(args))
+
+        return args
+
+    def create_media(self, image_url, hwpack_url, settings, tools_dir):
+        """Create a command line for linaro-media-create based on the settings
+        provided then run linaro-media-create, either in a separate thread
+        (GUI mode) or in the current one (CLI mode)."""
+
+        to_download = [(image_url, "OS"),
+                       (hwpack_url, "hwpack")]
+        downloaded_files = self.download_files(to_download,
+                                               settings)
+
+        args = self.build_lmc_command(downloaded_files['OS'],
+                                      downloaded_files['hwpack'],
+                                      settings,
+                                      tools_dir)
+
+        self.create_process = subprocess.Popen(args)
+        self.create_process.wait()
 
     class LinaroMediaCreate(threading.Thread):
         """Thread class for running linaro-media-create"""
-        def __init__(self, event_handler, lmcargs, event_queue):
+        def __init__(self,
+                     image_url,
+                     hwpack_url,
+                     file_handler,
+                     event_queue,
+                     settings,
+                     tools_dir):
+
             threading.Thread.__init__(self)
-            self.event_handler = event_handler
-            self.lmcargs = lmcargs
-            self.event_queue = event_queue
+
+            self.image_url      = image_url
+            self.hwpack_url     = hwpack_url
+            self.file_handler   = file_handler
+            self.event_queue    = event_queue
+            self.settings       = settings
+            self.tools_dir      = tools_dir
 
         def run(self):
-            """Start linaro-media-create and look for lines in the output that:
-            1. Tell us that an event has happened that we can use to update the
-               UI progress.
-            2. Tell us that linaro-media-create is asking a question that needs
-               to be re-directed to the GUI"""
-
-            self.create_process = subprocess.Popen(self.lmcargs,
+            """
+            1. Download required files.
+            2. Build linaro-media-create command
+            3. Start linaro-media-create and look for lines in the output that:
+               1. Tell us that an event has happened that we can use to update
+                  the UI progress.
+               2. Tell us that linaro-media-create is asking a question that
+                  needs to be re-directed to the GUI
+            """
+
+            to_download = [(self.image_url, "OS"),
+                           (self.hwpack_url, "hwpack")]
+
+            downloaded_files = self.file_handler.download_files(
+                                                            to_download,
+                                                            self.settings,
+                                                            self.event_queue)
+
+            lmc_command = self.file_handler.build_lmc_command(
+                                                    downloaded_files['OS'],
+                                                    downloaded_files['hwpack'],
+                                                    self.settings,
+                                                    self.tools_dir,
+                                                    True)
+
+            self.create_process = subprocess.Popen(lmc_command,
                                                    stdin=subprocess.PIPE,
                                                    stdout=subprocess.PIPE,
                                                    stderr=subprocess.STDOUT)
@@ -262,18 +256,6 @@
             print >> self.create_process.stdin, text
             self.waiting_for_event_response = False
 
-    def start_lmc_gui_thread(self, event_queue):
-        self.lmc_thread = self.LinaroMediaCreate(self.event_handler,
-                                                 self.lmcargs, event_queue)
-        self.lmc_thread.start()
-
-    def kill_create_media(self):
-        pass  # TODO: Something!
-              # Need to make sure all child processes are terminated.
-
-    def send_to_create_process(self, text):
-        self.lmc_thread.send_to_create_process(text)
-
     def name_and_path_from_url(self, url):
         """Return the file name and the path at which the file will be stored
         on the local system based on the URL we are downloading from"""
@@ -290,34 +272,94 @@
 
         return file_name, file_path
 
-    def create_wx_progress(self, title, message):
-        """Create a standard WX progrss dialog"""
-        import wx
-        self.dlg = wx.ProgressDialog(title,
-                                     message,
-                                     maximum=1000,
-                                     parent=None,
-                                     style=wx.PD_CAN_ABORT
-                                      | wx.PD_APP_MODAL
-                                      | wx.PD_ELAPSED_TIME
-                                      | wx.PD_AUTO_HIDE
-                                      | wx.PD_REMAINING_TIME)
-
-    def timer_ping(self):
-        self.update_wx_process(self.download_count)
-
-    def update_wx_progress(self, count):
-        self.download_count = count
-        (self.do_download, skip) = self.dlg.Update(count)
-
-    def download(self, url, force_download=False,
-                 show_wx_progress=False, wx_progress_title=None):
+    def urllib2_open(self, url):
+        maxtries = 10
+        for trycount in range(0, maxtries):
+            try:
+                response = urllib2.urlopen(url)
+            except:
+                if trycount < maxtries - 1:
+                    print "Unable to connect to", url, "retrying in 5 seconds..."
+                    time.sleep(5)
+                    continue
+                else:
+                    print "Connect failed:", url
+                    raise
+                    return None
+            else:
+                return response
+
+        return None
+
+    def download_files(self,
+                       downloads_list,
+                       settings,
+                       event_queue=None):
+        """
+        Download files specified in the downloads_list, which is a list of
+        url, name tuples.
+        """
+
+        downloaded_files = {}
+
+        bytes_to_download = 0
+
+        for url, name in downloads_list:
+            file_name, file_path = self.name_and_path_from_url(url)
+
+            file_name = file_path + os.sep + file_name
+            if os.path.exists(file_name):
+                continue  # If file already exists, don't download it
+
+            response = self.urllib2_open(url)
+            if response:
+                bytes_to_download += int(response.info()
+                                          .getheader('Content-Length').strip())
+                response.close()
+
+        if event_queue:
+            event_queue.put(("update",
+                             "download",
+                             "total bytes",
+                             bytes_to_download))
+
+        for url, name in downloads_list:
+            if event_queue:
+                event_queue.put(("start", "download " + name))
+                event_queue.put(("update",
+                                 "download",
+                                 "name",
+                                 name))
+
+            path = None
+            try:
+                path = self.download(url,
+                                     event_queue,
+                                     settings["force_download"])
+            except Exception:
+                # Download error. Hardly matters what, we can't continue.
+                print "Unexpected error:", sys.exc_info()[0]
+                logging.error("Unable to download " + url + " - aborting.")
+
+            if event_queue:
+                event_queue.put(("end", "download " + name))
+
+            if path == None:  # User hit cancel when downloading
+                sys.exit(0)
+
+            downloaded_files[name] = path
+            logging.info("Have downloaded {0} to {1}".format(name, path))
+
+        return downloaded_files
+
+    def download(self,
+                 url,
+                 event_queue,
+                 force_download=False):
         """Downloads the file requested buy URL to the local cache and returns
         the full path to the downloaded file"""
 
         file_name, file_path = self.name_and_path_from_url(url)
-
-        just_file_name = file_name
         file_name = file_path + os.sep + file_name
 
         if not os.path.isdir(file_path):
@@ -328,23 +370,9 @@
                                      "--force-download to override).")
             return file_name
 
-        logging.info("Fetching", url)
+        logging.info("Fetching " + url)
 
-        maxtries = 10
-        for trycount in range(0, maxtries):
-            try:
-                response = urllib2.urlopen(url)
-            except:
-                if trycount < maxtries - 1:
-                    print "Unable to download", url, "retrying in 5 seconds..."
-                    time.sleep(5)
-                    continue
-                else:
-                    print "Download failed for some reason:", url
-                    raise
-                    return
-            else:
-                break
+        response = self.urllib2_open(url)
 
         self.do_download = True
         file_out = open(file_name, 'w')
@@ -356,28 +384,22 @@
 
         if show_progress:
             chunk_size = download_size_in_bytes / 1000
-            if show_wx_progress:
-                if wx_progress_title == None:
-                    wx_progress_title = "Downloading File"
-                self.create_wx_progress(wx_progress_title,
-                                        "Downloading " + just_file_name)
-            else:
+            if not event_queue:
                 print "Fetching", url
         else:
             chunk_size = download_size_in_bytes
 
-        if show_progress and show_wx_progress:
-            # Just update the download box before we get the first %
-            self.update_wx_progress(0)
-
         printed_progress = False
         while self.do_download:
             chunk = response.read(chunk_size)
             if len(chunk):
                 # Print a % download complete so we don't get too bored
                 if show_progress:
-                    if show_wx_progress:
-                        self.update_wx_progress(chunks_downloaded)
+                    if event_queue:
+                        event_queue.put(("update",
+                                         "download",
+                                         "progress",
+                                         len(chunk)))
                     else:
                         # Have 1000 chunks so div by 10 to get %...
                         sys.stdout.write("\r%d%%" % (chunks_downloaded / 10))
@@ -400,7 +422,7 @@
 
         return file_name
 
-    def download_if_old(self, url, force_download, show_wx_progress=False):
+    def download_if_old(self, url, event_queue, force_download):
         file_name, file_path = self.name_and_path_from_url(url)
 
         file_path_and_name = file_path + os.sep + file_name
@@ -411,25 +433,25 @@
             force_download = (force_download == True
                               or (    time.mktime(time.localtime())
                                     - os.path.getmtime(file_path_and_name)
-                                  > 60 * 60 * 24))
+                                  > 60 * 60))
         except OSError:
             force_download = True  # File not found...
 
-        return self.download(url, force_download, show_wx_progress)
+        return self.download(url, event_queue, force_download)
 
     def update_files_from_server(self, force_download=False,
-                                 show_wx_progress=False):
+                                 event_queue=None):
 
-        settings_url     = "http://z.nanosheep.org/fetch_image_settings.yaml"
-        server_index_url = "http://z.nanosheep.org/server_index.bz2"
+        settings_url     = "http://releases.linaro.org/fetch_image/fetch_image_settings.yaml"
+        server_index_url = "http://releases.linaro.org/fetch_image/server_index.bz2"
 
         self.settings_file = self.download_if_old(settings_url,
-                                                  force_download,
-                                                  show_wx_progress)
+                                                  event_queue,
+                                                  force_download)
 
         self.index_file = self.download_if_old(server_index_url,
-                                               force_download,
-                                               show_wx_progress)
+                                               event_queue,
+                                               force_download)
 
         zip_search = re.search(r"^(.*)\.bz2$", self.index_file)
 
@@ -484,9 +506,9 @@
             self.settings['UI']['reverse-translate'][value] = key
 
     def parse_args(self, args):
-        parser = argparse.ArgumentParser(description=
-                                         "Create a board image, first "
-                                         "downloading any required files.")
+        parser = argparse.ArgumentParser(description="Create a board image, "
+                                         "first downloading any required "
+                                         "files.")
 
         for (key, value) in self.settings['choice'].items():
             parser.add_argument(
@@ -983,7 +1005,7 @@
                 loop_date_increment = -one_day
 
             test_date[in_the] = current_date
-            
+
             while test_date[in_the] <= max_search_date:
                 test_date[in_the] += loop_date_increment
 
 
=== modified file 'linaro_image_tools/fetch_image_settings.yaml'
--- linaro_image_tools/fetch_image_settings.yaml	2011-06-17 18:04:47 +0000
+++ linaro_image_tools/fetch_image_settings.yaml	2011-07-18 14:39:34 +0000
@@ -45,6 +45,7 @@
     # u8500: U8500
     overo: Overo
     smdkv310: S5PV310
+    origen: Origen
   
   hwpack:
     beagle:
@@ -88,6 +89,9 @@
      - lt-s5pv310
      - s5pv310
 
+    origen:
+     - lt-origen
+
   image:
   - alip
   - developer
 
=== modified file 'linaro_image_tools/hwpack/config.py'
--- linaro_image_tools/hwpack/config.py	2011-06-20 13:46:16 +0000
+++ linaro_image_tools/hwpack/config.py	2011-07-18 14:39:34 +0000
@@ -22,7 +22,7 @@
 import ConfigParser
 import re
 
-from hardwarepack_format import (
+from linaro_image_tools.hwpack.hardwarepack_format import (
     HardwarePackFormatV1,
     HardwarePackFormatV2,
     )
@@ -42,7 +42,7 @@
     SOURCES_ENTRY_KEY = "sources-entry"
     PACKAGES_KEY = "packages"
     PACKAGE_REGEX = NAME_REGEX
-    PATH_REGEX = r"[a-z0-9][a-z0-9+\-./]+$"
+    PATH_REGEX = r"[a-z0-9][a-z0-9+\-./_]+$"
     ORIGIN_KEY = "origin"
     MAINTAINER_KEY = "maintainer"
     ARCHITECTURES_KEY = "architectures"
@@ -58,6 +58,16 @@
     PARTITION_LAYOUT_KEY = "partition_layout"
     MMC_ID_KEY = "mmc_id"
     FORMAT_KEY = "format"
+    BOOT_MIN_SIZE_KEY = "boot_min_size"
+    ROOT_MIN_SIZE_KEY = "root_min_size"
+    LOADER_MIN_SIZE_KEY = "loader_min_size"
+
+    DEFINED_PARTITION_LAYOUTS = [
+        'bootfs16_rootfs',
+        'bootfs_rootfs',
+        #'reserved_bootfs_rootfs',
+        ]
+
 
     def __init__(self, fp):
         """Create a Config.
@@ -93,6 +103,9 @@
             self._validate_wireless_interfaces()
             self._validate_partition_layout()
             self._validate_mmc_id()
+            self._validate_boot_min_size()
+            self._validate_root_min_size()
+            self._validate_loader_min_size()
 
         self._validate_sections()
 
@@ -217,6 +230,30 @@
         return self._get_option_from_main_section(self.MMC_ID_KEY)
 
     @property
+    def root_min_size(self):
+        """Minimum size of the root partition, in MiB.
+
+        An int.
+        """
+        return self._get_option_from_main_section(self.ROOT_MIN_SIZE_KEY)
+
+    @property
+    def boot_min_size(self):
+        """Minimum size of the boot partition, in MiB.
+
+        An int.
+        """
+        return self._get_option_from_main_section(self.BOOT_MIN_SIZE_KEY)
+
+    @property
+    def loader_min_size(self):
+        """Minimum size of the optional loader partition, in MiB.
+
+        An int.
+        """
+        return self._get_option_from_main_section(self.LOADER_MIN_SIZE_KEY)
+
+    @property
     def origin(self):
         """The origin that should be recorded in the hwpack.
 
@@ -375,17 +412,12 @@
         pass
 
     def _validate_partition_layout(self):
-        defined_partition_layouts = [
-            #'bootfs16_rootfs',
-            'bootfs_rootfs',
-            #'reserved_bootfs_rootfs',
-            ]
-        if self.partition_layout not in defined_partition_layouts:
+        if self.partition_layout not in self.DEFINED_PARTITION_LAYOUTS:
             raise HwpackConfigError(
                 "Undefined partition layout %s in the [%s] section. "
                 "Valid partition layouts are %s."
                 % (self.partition_layout, self.MAIN_SECTION,
-                   ", ".join(defined_partition_layouts)))
+                   ", ".join(self.DEFINED_PARTITION_LAYOUTS)))
 
     def _validate_mmc_id(self):
         mmc_id = self.mmc_id
@@ -396,6 +428,36 @@
         except:
             raise HwpackConfigError("Invalid mmc id %s" % (mmc_id))
 
+    def _validate_root_min_size(self):
+        root_min_size = self.root_min_size
+        if root_min_size is None:
+            return
+        try:
+            assert int(root_min_size) > 0
+        except:
+            raise HwpackConfigError(
+                "Invalid root min size %s" % (root_min_size))
+
+    def _validate_boot_min_size(self):
+        boot_min_size = self.boot_min_size
+        if boot_min_size is None:
+            return
+        try:
+            assert int(boot_min_size) > 0
+        except:
+            raise HwpackConfigError(
+                "Invalid boot min size %s" % (boot_min_size))
+
+    def _validate_loader_min_size(self):
+        loader_min_size = self.loader_min_size
+        if loader_min_size is None:
+            return
+        try:
+            assert int(loader_min_size) > 0
+        except:
+            raise HwpackConfigError(
+                "Invalid loader min size %s" % (loader_min_size))
+
     def _validate_include_debs(self):
         try:
             self.include_debs
 
=== modified file 'linaro_image_tools/hwpack/hardwarepack.py'
--- linaro_image_tools/hwpack/hardwarepack.py	2011-06-20 13:46:16 +0000
+++ linaro_image_tools/hwpack/hardwarepack.py	2011-07-18 14:39:34 +0000
@@ -80,7 +80,8 @@
     def add_v2_config(self, serial_tty=None, kernel_addr=None, initrd_addr=None,
                       load_addr=None, fdt=None, wired_interfaces=[],
                       wireless_interfaces=[], partition_layout=None,
-                      mmc_id=None):
+                      mmc_id=None, boot_min_size=None, root_min_size=None,
+                      loader_min_size=None):
         """Add fields that are specific to the new format.
 
         These fields are not present in earlier config files.
@@ -94,6 +95,9 @@
         self.wireless_interfaces = wireless_interfaces
         self.partition_layout = partition_layout
         self.mmc_id = mmc_id
+        self.boot_min_size = boot_min_size
+        self.root_min_size = root_min_size
+        self.loader_min_size = loader_min_size
 
     @classmethod
     def from_config(cls, config, version, architecture):
@@ -126,7 +130,10 @@
                                    wired_interfaces=config.wired_interfaces,
                                    wireless_interfaces=config.wireless_interfaces,
                                    partition_layout=config.partition_layout,
-                                   mmc_id=config.mmc_id)
+                                   mmc_id=config.mmc_id,
+                                   boot_min_size=config.boot_min_size,
+                                   root_min_size=config.root_min_size,
+                                   loader_min_size=config.loader_min_size)
         return metadata
 
     def __str__(self):
@@ -163,6 +170,13 @@
             metadata += "PARTITION_LAYOUT=%s\n" % self.partition_layout
         if self.mmc_id is not None:
             metadata += "MMC_ID=%s\n" % self.mmc_id
+        if self.boot_min_size is not None:
+            metadata += "BOOT_MIN_SIZE=%s\n" % self.boot_min_size
+        if self.root_min_size is not None:
+            metadata += "ROOT_MIN_SIZE=%s\n" % self.root_min_size
+        if self.loader_min_size is not None:
+            metadata += "LOADER_MIN_SIZE=%s\n" % self.loader_min_size
+
         return metadata
 
 
 
=== modified file 'linaro_image_tools/hwpack/tests/test_config.py'
--- linaro_image_tools/hwpack/tests/test_config.py	2011-06-17 12:28:43 +0000
+++ linaro_image_tools/hwpack/tests/test_config.py	2011-07-18 14:39:34 +0000
@@ -216,13 +216,16 @@
         self.assertValidationError("Invalid path: ~~", config)
 
     def test_validate_partition_layout(self):
-        config = self.get_config(self.valid_start_v2 + 
-                                 "u-boot-package = u-boot-linaro-s5pv310\n" \
-                                     "u-boot-file = u-boot.bin\n" \
-                                     "partition_layout = apafs_bananfs\n")
+        partition_layout = 'apafs_bananfs'
+        config = self.get_config(self.valid_start_v2 + "u-boot-package = " \
+                                     "u-boot-linaro-s5pv310\nu-boot-file = " \
+                                     "u-boot.bin\npartition_layout = %s\n" % \
+                                     partition_layout)
         self.assertValidationError(
-            "Undefined partition layout apafs_bananfs in the [hwpack] " \
-                "section. Valid partition layouts are bootfs_rootfs.", config)
+            "Undefined partition layout %s in the [%s] section. "
+            "Valid partition layouts are %s."
+            % (partition_layout, 'hwpack',
+               ", ".join(config.DEFINED_PARTITION_LAYOUTS)), config)
 
     def test_validate_wired_interfaces(self):
         self.assertTrue("XXX What is an invalid interface name?")
@@ -246,6 +249,21 @@
                                  "mmc_id = x\n")
         self.assertValidationError("Invalid mmc id x", config)
 
+    def test_validate_boot_min_size(self):
+        config = self.get_config(self.valid_complete_v2 + 
+                                 "boot_min_size = x\n")
+        self.assertValidationError("Invalid boot min size x", config)
+
+    def test_validate_root_min_size(self):
+        config = self.get_config(self.valid_complete_v2 + 
+                                 "root_min_size = x\n")
+        self.assertValidationError("Invalid root min size x", config)
+
+    def test_validate_loader_min_size(self):
+        config = self.get_config(self.valid_complete_v2 + 
+                                 "loader_min_size = x\n")
+        self.assertValidationError("Invalid loader min size x", config)
+
     def test_validate_kernel_addr(self):
         config = self.get_config(self.valid_complete_v2 + 
                                  "kernel_addr = 0x8000000\n")
@@ -327,6 +345,27 @@
         config.validate()
         self.assertEqual("1", config.mmc_id)
 
+    def test_boot_min_size(self):
+        config = self.get_config(self.valid_complete_v2 + 
+                                 "boot_min_size = 50\n" + 
+                                 self.valid_end)
+        config.validate()
+        self.assertEqual("50", config.boot_min_size)
+
+    def test_root_min_size(self):
+        config = self.get_config(self.valid_complete_v2 + 
+                                 "root_min_size = 50\n" + 
+                                 self.valid_end)
+        config.validate()
+        self.assertEqual("50", config.root_min_size)
+
+    def test_loader_min_size(self):
+        config = self.get_config(self.valid_complete_v2 + 
+                                 "loader_min_size = 2\n" + 
+                                 self.valid_end)
+        config.validate()
+        self.assertEqual("2", config.loader_min_size)
+
     def test_kernel_addr(self):
         config = self.get_config(self.valid_complete_v2 + 
                                  "kernel_addr = 0x80000000\n" + 
 
=== modified file 'linaro_image_tools/hwpack/tests/test_hardwarepack.py'
--- linaro_image_tools/hwpack/tests/test_hardwarepack.py	2011-06-17 15:10:49 +0000
+++ linaro_image_tools/hwpack/tests/test_hardwarepack.py	2011-07-18 14:39:34 +0000
@@ -183,6 +183,33 @@
             "MMC_ID=1\n",
             str(metadata))
 
+    def test_str_with_boot_min_size(self):
+        metadata = Metadata("ahwpack", "4", "armel",
+                            format=HardwarePackFormatV2())
+        metadata.add_v2_config(boot_min_size='50')
+        self.assertEqual(
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\n"
+            "BOOT_MIN_SIZE=50\n",
+            str(metadata))
+
+    def test_str_with_root_min_size(self):
+        metadata = Metadata("ahwpack", "4", "armel",
+                            format=HardwarePackFormatV2())
+        metadata.add_v2_config(root_min_size='100')
+        self.assertEqual(
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\n"
+            "ROOT_MIN_SIZE=100\n",
+            str(metadata))
+
+    def test_str_with_loader_min_size(self):
+        metadata = Metadata("ahwpack", "4", "armel",
+                            format=HardwarePackFormatV2())
+        metadata.add_v2_config(loader_min_size='1')
+        self.assertEqual(
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\n"
+            "LOADER_MIN_SIZE=1\n",
+            str(metadata))
+
     def test_from_config(self):
         class Config:
             name = "foo"
 
=== modified file 'linaro_image_tools/media_create/android_boards.py'
--- linaro_image_tools/media_create/android_boards.py	2011-04-22 15:09:08 +0000
+++ linaro_image_tools/media_create/android_boards.py	2011-07-18 14:39:34 +0000
@@ -28,6 +28,8 @@
 from linaro_image_tools.media_create.boards import PART_ALIGN_S
 from linaro_image_tools.media_create.boards import BeagleConfig
 from linaro_image_tools.media_create.boards import PandaConfig
+from linaro_image_tools.media_create.boards import SnowballSdConfig
+from linaro_image_tools.media_create.boards import SnowballEmmcConfig
 from linaro_image_tools.media_create.boards import (
     align_up,
     align_partition,
@@ -37,6 +39,7 @@
 from linaro_image_tools import cmd_runner
 import os
 
+
 class AndroidBoardConfig(object):
     @classmethod
     def _get_bootargs(cls, consoles):
@@ -78,7 +81,7 @@
             as_root=True).wait()
 
         boot_env = cls._get_boot_env(consoles)
-        cmdline_filepath = os.path.join(boot_disk, "cmdline") 
+        cmdline_filepath = os.path.join(boot_disk, "cmdline")
         cmdline_file = open(cmdline_filepath, 'r')
         android_kernel_cmdline = cmdline_file.read()
         boot_env['bootargs'] = boot_env['bootargs'] + ' ' + \
@@ -96,7 +99,8 @@
             pass
 
     @classmethod
-    def get_sfdisk_cmd(cls, should_align_boot_part=False):
+    def get_sfdisk_cmd(cls, should_align_boot_part=False,
+                       start_addr=0, extra_part=False):
         if cls.fat_size == 32:
             partition_type = '0x0C'
         else:
@@ -116,7 +120,7 @@
 
         # can only start on sector 1 (sector 0 is MBR / partition table)
         boot_start, boot_end, boot_len = align_partition(
-            1, BOOT_MIN_SIZE_S, boot_align, PART_ALIGN_S)
+            start_addr + 1, BOOT_MIN_SIZE_S, boot_align, PART_ALIGN_S)
         # apparently OMAP3 ROMs require the vfat length to be an even number
         # of sectors (multiple of 1 KiB); decrease the length if it's odd,
         # there should still be enough room
@@ -131,12 +135,28 @@
             _cache_end + 1, USERDATA_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
         sdcard_start, _sdcard_end, _sdcard_len = align_partition(
             _userdata_end + 1, SDCARD_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
- 
+
+        # Snowball board needs a raw partition added to the beginning of image.
+        # If extra_part is True an extra primary partition will be added.
+        # Due to a maximum of 4 primary partitions cache data will be placed in
+        # a extended partition
+        if extra_part == True:
+            assert start_addr > 0, ("Not possible to add extra partition" \
+                                    "when boot partition starts at '0'")
+            return '%s,%s,%s,*\n%s,%s,L\n%s,-,E\n%s,%s,L\n%s,%s,L\n%s,,,-' % (
+            boot_start, boot_len, partition_type, system_start, _system_len,
+            cache_start, cache_start, _cache_len, userdata_start,
+            _userdata_len, sdcard_start)
+
         return '%s,%s,%s,*\n%s,%s,L\n%s,%s,L\n%s,-,E\n%s,%s,L\n%s,,,-' % (
             boot_start, boot_len, partition_type, system_start, _system_len,
             cache_start, _cache_len, userdata_start, userdata_start,
             _userdata_len, sdcard_start)
 
+    @classmethod
+    def populate_raw_partition(cls, media, boot_dir):
+        super(AndroidBoardConfig, cls).populate_raw_partition(boot_dir, media)
+
 
 class AndroidOmapConfig(AndroidBoardConfig):
     pass
@@ -149,10 +169,50 @@
 
 class AndroidPandaConfig(AndroidOmapConfig, PandaConfig):
     _extra_serial_opts = 'console=tty0 console=ttyO2,115200n8'
+    extra_boot_args_options = (
+        'earlyprintk fixrtc nocompcache vram=48M '
+        'omapfb.vram=0:24M,1:24M mem=456M@0x80000000 mem=512M@0xA0000000')
     android_specific_args = 'init=/init androidboot.console=ttyO2'
 
 
+class AndroidSnowballSdConfig(AndroidBoardConfig, SnowballSdConfig):
+    extra_boot_args_options = (
+        'earlyprintk rootdelay=1 fixrtc nocompcache '
+        'mem=128M@0 mali.mali_mem=64M@128M mem=24M@192M hwmem=167M@216M '
+        'mem_issw=1M@383M mem=640M@384M vmalloc=256M')
+    _extra_serial_opts = 'console=tty0 console=ttyO2,115200n8'
+    android_specific_args = 'init=/init androidboot.console=ttyAMA2'
+
+
+class AndroidSnowballEmmcConfig(AndroidBoardConfig, SnowballEmmcConfig):
+    extra_boot_args_options = (
+        'earlyprintk rootdelay=1 fixrtc nocompcache '
+        'mem=128M@0 mali.mali_mem=64M@128M mem=24M@192M hwmem=167M@216M '
+        'mem_issw=1M@383M mem=640M@384M vmalloc=256M')
+    _extra_serial_opts = 'console=tty0 console=ttyAMA2,115200n8'
+    android_specific_args = 'init=/init androidboot.console=ttyAMA2'
+
+    @classmethod
+    def get_sfdisk_cmd(cls, should_align_boot_part=False):
+
+        LOADER_MIN_SIZE_S = align_up(
+            1 * 1024 * 1024, SECTOR_SIZE) / SECTOR_SIZE
+
+        loader_start, loader_end, loader_len = align_partition(
+            SnowballEmmcConfig.SNOWBALL_LOADER_START_S,
+            LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
+
+        command = super(AndroidSnowballEmmcConfig, cls).get_sfdisk_cmd(
+            should_align_boot_part=True, start_addr=loader_end,
+            extra_part=True)
+
+        return '%s,%s,0xDA\n%s' % (
+            loader_start, loader_len, command)
+
+
 android_board_configs = {
     'beagle': AndroidBeagleConfig,
     'panda': AndroidPandaConfig,
+    'snowball_sd': AndroidSnowballSdConfig,
+    'snowball_emmc': AndroidSnowballEmmcConfig,
     }
 
=== modified file 'linaro_image_tools/media_create/boards.py'
--- linaro_image_tools/media_create/boards.py	2011-05-26 20:19:23 +0000
+++ linaro_image_tools/media_create/boards.py	2011-07-18 14:39:34 +0000
@@ -31,11 +31,15 @@
 import tempfile
 import struct
 from binascii import crc32
+import tarfile
+import ConfigParser
+import shutil
 
 from linaro_image_tools import cmd_runner
 
 from linaro_image_tools.media_create.partitions import SECTOR_SIZE
 
+
 KERNEL_GLOB = 'vmlinuz-*-%(kernel_flavor)s'
 INITRD_GLOB = 'initrd.img-*-%(kernel_flavor)s'
 DTB_GLOB = 'dt-*-%(kernel_flavor)s/%(dtb_name)s'
@@ -58,21 +62,11 @@
 # align on 4 MiB
 PART_ALIGN_S = 4 * 1024 * 1024 / SECTOR_SIZE
 
+
 def align_up(value, align):
     """Round value to the next multiple of align."""
     return (value + align - 1) / align * align
 
-# optional bootloader partition; at least 1 MiB; in theory, an i.MX5x
-# bootloader partition could hold RedBoot, FIS table, RedBoot config, kernel,
-# and initrd, but we typically use U-Boot which is about 167 KiB as of
-# 2011/02/11 and currently doesn't even store its environment there, so this
-# should be enough
-LOADER_MIN_SIZE_S = align_up(1 * 1024 * 1024, SECTOR_SIZE) / SECTOR_SIZE
-# boot partition; at least 50 MiB; XXX this shouldn't be hardcoded
-BOOT_MIN_SIZE_S = align_up(50 * 1024 * 1024, SECTOR_SIZE) / SECTOR_SIZE
-# root partition; at least 50 MiB; XXX this shouldn't be hardcoded
-ROOT_MIN_SIZE_S = align_up(50 * 1024 * 1024, SECTOR_SIZE) / SECTOR_SIZE
-
 # Samsung v310 implementation notes and terminology
 #
 # * BL0, BL1 etc. are the various bootloaders in order of execution
@@ -104,6 +98,7 @@
 assert SAMSUNG_V310_BL2_LEN * SECTOR_SIZE == 512 * 1024, (
     "BL1 expects BL2 (u-boot) to be 512 KiB")
 
+
 def align_partition(min_start, min_length, start_alignment, end_alignment):
     """Compute partition start and end offsets based on specified constraints.
 
@@ -125,10 +120,103 @@
     """A descriptor that provides @property behavior on class methods."""
     def __init__(self, getter):
         self.getter = getter
+
     def __get__(self, instance, cls):
         return self.getter(cls)
 
 
+class HardwarepackHandler(object):
+    FORMAT_1 = '1.0'
+    FORMAT_2 = '2.0'
+    FORMAT_MIXED = '1.0and2.0'
+    metadata_filename = 'metadata'
+    format_filename = 'FORMAT'
+    main_section = 'main'
+    hwpack_tarfiles = []
+    tempdir = None
+
+    def __init__(self, hwpacks):
+        self.hwpacks = hwpacks
+        self.hwpack_tarfiles = []
+    
+    class FakeSecHead(object):
+        """ Add a fake section header to the metadata file.
+
+        This is done so we can use ConfigParser to parse the file.
+        """
+        def __init__(self, fp):
+            self.fp = fp
+            self.sechead = '[%s]\n' % HardwarepackHandler.main_section
+
+        def readline(self):
+            if self.sechead:
+                try:
+                    return self.sechead
+                finally:
+                    self.sechead = None
+            else:
+                return self.fp.readline()
+
+    def __enter__(self):
+        self.tempdir = tempfile.mkdtemp()
+        for hwpack in self.hwpacks:
+            hwpack_tarfile = tarfile.open(hwpack, mode='r:gz')
+            self.hwpack_tarfiles.append(hwpack_tarfile)
+        return self
+
+    def __exit__(self, type, value, traceback):
+        for hwpack_tarfile in self.hwpack_tarfiles:
+            if hwpack_tarfile is not None:
+                hwpack_tarfile.close()
+        self.hwpack_tarfiles = []
+        if self.tempdir is not None and os.path.exists(self.tempdir):
+            shutil.rmtree(self.tempdir)
+
+    def get_field(self, section, field):
+        data = None
+        hwpack_with_data = None
+        for hwpack_tarfile in self.hwpack_tarfiles:
+            metadata = hwpack_tarfile.extractfile(self.metadata_filename)
+            # Use RawConfigParser which does not support the magical interpolation
+            # behavior of ConfigParser so we don't mess up metadata accidentally.
+            parser = ConfigParser.RawConfigParser()
+            parser.readfp(self.FakeSecHead(metadata))
+            try:
+                new_data = parser.get(section, field)
+                if new_data is not None:
+                    assert data is None, "The metadata field '%s' is set to " \
+                        "'%s' and new value '%s' is found" % (field, data, new_data)
+                    data = new_data
+                    hwpack_with_data = hwpack_tarfile
+            except ConfigParser.NoOptionError:
+                continue
+        return data, hwpack_with_data
+
+    def get_format(self):
+        format = None
+        supported_formats = [self.FORMAT_1, self.FORMAT_2]
+        for hwpack_tarfile in self.hwpack_tarfiles:
+            format_file = hwpack_tarfile.extractfile(self.format_filename)
+            format_string = format_file.read().strip()
+            if not format_string in supported_formats:
+                raise AssertionError(
+                    "Format version '%s' is not supported." % \
+                        format_string)
+            if format is None:
+                format = format_string
+            elif format != format_string:
+                return self.FORMAT_MIXED
+        return format
+
+    def get_file(self, file_alias):
+        file_name, hwpack_tarfile = self.get_field(self.main_section,
+                                                   file_alias)
+        if file_name is not None:
+            hwpack_tarfile.extract(file_name, self.tempdir)
+            file_name = os.path.join(self.tempdir, file_name)
+        return file_name
+
+
 class BoardConfig(object):
     """The configuration used when building an image for a board."""
     # These attributes may not need to be redefined on some subclasses.
@@ -138,12 +226,17 @@
     mmc_option = '0:1'
     mmc_part_offset = 0
     fat_size = 32
-    extra_serial_opts = ''
-    live_serial_opts = ''
+    _extra_serial_opts = ''
+    _live_serial_opts = ''
     extra_boot_args_options = None
     supports_writing_to_mmc = True
+    LOADER_MIN_SIZE_S = align_up(1 * 1024**2, SECTOR_SIZE) / SECTOR_SIZE
+    BOOT_MIN_SIZE_S = align_up(50 * 1024**2, SECTOR_SIZE) / SECTOR_SIZE
+    ROOT_MIN_SIZE_S = align_up(50 * 1024**2, SECTOR_SIZE) / SECTOR_SIZE
 
-    # These attributes must be defined on all subclasses.
+    # These attributes must be defined on all subclasses for backwards
+    # compatibility with hwpacks v1 format. Hwpacks v2 format allows these to
+    # be specified in the hwpack metadata.
     kernel_addr = None
     initrd_addr = None
     load_addr = None
@@ -152,6 +245,88 @@
     kernel_flavors = None
     boot_script = None
     serial_tty = None
+    wired_interfaces = None
+    wireless_interfaces = None
+    mmc_id = None
+
+    hardwarepack_handler = None
+
+    @classmethod
+    def get_metadata_field(cls, target, field_name):
+        """ Return the metadata value for field_name if it can be found.
+        """
+        data, _ = cls.hardwarepack_handler.get_field(
+            cls.hardwarepack_handler.main_section, field_name)
+        return data
+
+    @classmethod
+    def set_metadata(cls, hwpacks):
+        cls.hardwarepack_handler = HardwarepackHandler(hwpacks)
+        with cls.hardwarepack_handler:
+            if (cls.hardwarepack_handler.get_format() ==
+                cls.hardwarepack_handler.FORMAT_1):
+                return
+
+            if (cls.hardwarepack_handler.get_format() ==
+                cls.hardwarepack_handler.FORMAT_2):
+                # Clear V1 defaults.
+                cls.kernel_addr = None
+                cls.initrd_addr = None
+                cls.load_addr = None
+                cls.serial_tty = None
+                cls.fat_size = None
+                cls.BOOT_MIN_SIZE_S = None
+                cls.ROOT_MIN_SIZE_S = None
+                cls.LOADER_MIN_SIZE_S = None
+
+            # Set new values from metadata.
+            cls.kernel_addr = cls.get_metadata_field(
+                cls.kernel_addr, 'kernel_addr')
+            cls.initrd_addr = cls.get_metadata_field(
+                cls.initrd_addr, 'initrd_addr')
+            cls.load_addr = cls.get_metadata_field(
+                cls.load_addr, 'load_addr')
+            cls.serial_tty = cls.get_metadata_field(
+                cls.serial_tty, 'serial_tty')
+            cls.wired_interfaces = cls.get_metadata_field(
+                cls.wired_interfaces, 'wired_interfaces')
+            cls.wireless_interfaces = cls.get_metadata_field(
+                cls.wireless_interfaces, 'wireless_interfaces')
+            cls.mmc_id = cls.get_metadata_field(
+                cls.mmc_id, 'mmc_id')
+
+            partition_layout = cls.get_metadata_field(cls.fat_size, 'partition_layout')
+            if partition_layout == 'bootfs_rootfs' or partition_layout is None:
+                cls.fat_size = 32
+            elif partition_layout == 'bootfs16_rootfs':
+                cls.fat_size = 16
+            else:
+                raise AssertionError("Unknown partition layout '%s'." % partition_layout)
+
+            boot_min_size = cls.get_metadata_field(
+                cls.BOOT_MIN_SIZE_S, 'boot_min_size')
+            if boot_min_size is not None:
+                cls.BOOT_MIN_SIZE_S = align_up(int(boot_min_size) * 1024**2,
+                                               SECTOR_SIZE) / SECTOR_SIZE
+            root_min_size = cls.get_metadata_field(
+                cls.ROOT_MIN_SIZE_S, 'root_min_size')
+            if root_min_size is not None:
+                cls.ROOT_MIN_SIZE_S = align_up(int(root_min_size) * 1024**2,
+                                               SECTOR_SIZE) / SECTOR_SIZE
+            loader_min_size = cls.get_metadata_field(
+                cls.LOADER_MIN_SIZE_S, 'loader_min_size')
+            if loader_min_size is not None:
+                cls.LOADER_MIN_SIZE_S = align_up(int(loader_min_size) * 1024**2,
+                                               SECTOR_SIZE) / SECTOR_SIZE
+
+
+    @classmethod
+    def get_file(cls, file_alias, default=None):
+        file_in_hwpack = cls.hardwarepack_handler.get_file(file_alias)
+        if file_in_hwpack is not None:
+            return file_in_hwpack
+        else:
+            return default
 
     @classmethod
     def get_sfdisk_cmd(cls, should_align_boot_part=False):
@@ -167,9 +342,6 @@
         else:
             partition_type = '0x0E'
 
-        BOOT_MIN_SIZE_S = align_up(50 * 1024 * 1024, SECTOR_SIZE) / SECTOR_SIZE
-        ROOT_MIN_SIZE_S = align_up(50 * 1024 * 1024, SECTOR_SIZE) / SECTOR_SIZE
-
         # align on sector 63 for compatibility with broken versions of x-loader
         # unless align_boot_part is set
         boot_align = 63
@@ -178,7 +350,7 @@
 
         # can only start on sector 1 (sector 0 is MBR / partition table)
         boot_start, boot_end, boot_len = align_partition(
-            1, BOOT_MIN_SIZE_S, boot_align, PART_ALIGN_S)
+            1, cls.BOOT_MIN_SIZE_S, boot_align, PART_ALIGN_S)
         # apparently OMAP3 ROMs require the vfat length to be an even number
         # of sectors (multiple of 1 KiB); decrease the length if it's odd,
         # there should still be enough room
@@ -189,7 +361,7 @@
         # instruct the use of all remaining space; XXX if we had some root size
         # config, we could do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,%s,*\n%s,,,-' % (
             boot_start, boot_len, partition_type, root_start)
@@ -299,10 +471,12 @@
         if cls.uboot_in_boot_part:
             assert cls.uboot_flavor is not None, (
                 "uboot_in_boot_part is set but not uboot_flavor")
-            uboot_bin = os.path.join(chroot_dir, 'usr', 'lib', 'u-boot',
-                cls.uboot_flavor, 'u-boot.bin')
-            cmd_runner.run(
-                ['cp', '-v', uboot_bin, boot_disk], as_root=True).wait()
+            with cls.hardwarepack_handler:
+                uboot_bin = cls.get_file('u_boot', default=os.path.join(
+                        chroot_dir, 'usr', 'lib', 'u-boot', cls.uboot_flavor,
+                        'u-boot.bin'))
+                cmd_runner.run(
+                    ['cp', '-v', uboot_bin, boot_disk], as_root=True).wait()
 
         cls.make_boot_files(
             uboot_parts_dir, is_live, is_lowmem, consoles, chroot_dir,
@@ -337,9 +511,14 @@
             "No kernel found matching %s for flavors %s" % (
                 KERNEL_GLOB, " ".join(cls.kernel_flavors)))
 
+    @classmethod
+    def populate_raw_partition(cls, media, boot_dir):
+        # Override in subclass if needed
+        pass
+
 
 class OmapConfig(BoardConfig):
-    kernel_flavors = ['linaro-omap4', 'linaro-omap', 'omap4']
+    kernel_flavors = ['linaro-omap4', 'linaro-lt-omap', 'linaro-omap', 'omap4']
     uboot_in_boot_part = True
 
     # XXX: Here we define these things as dynamic properties because our
@@ -471,8 +650,8 @@
 
 class Ux500Config(BoardConfig):
     serial_tty = 'ttyAMA2'
-    extra_serial_opts = 'console=tty0 console=%s,115200n8' % serial_tty
-    live_serial_opts = 'serialtty=%s' % serial_tty
+    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
+    _live_serial_opts = 'serialtty=%s'
     kernel_addr = '0x00100000'
     initrd_addr = '0x08000000'
     load_addr = '0x00008000'
@@ -485,6 +664,14 @@
         'hwmem=48M@302M mem=152M@360M')
     mmc_option = '1:1'
 
+    @classproperty
+    def live_serial_opts(cls):
+        return cls._live_serial_opts % cls.serial_tty
+
+    @classproperty
+    def extra_serial_opts(cls):
+        return cls._extra_serial_opts % cls.serial_tty
+
     @classmethod
     def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
@@ -517,7 +704,7 @@
        and u-boot.'''
     # Boot ROM looks for a boot table of contents (TOC) at 0x20000
     # Actually, it first looks at address 0, but that's where l-m-c
-    # puts the MBR, so the boot loader skips that address. 
+    # puts the MBR, so the boot loader skips that address.
     supports_writing_to_mmc = False
     SNOWBALL_LOADER_START_S = (128 * 1024) / SECTOR_SIZE
     SNOWBALL_STARTUP_FILES_CONFIG = 'startfiles.cfg'
@@ -537,20 +724,20 @@
         This is done since the boot rom always boots off the internal memory;
         there simply is no point to having a loader partition on SD card.
         """
-        # boot ROM expects bootloader at 0x20000, which is sector 0x100 
+        # boot ROM expects bootloader at 0x20000, which is sector 0x100
         # with the usual SECTOR_SIZE of 0x200.
         # (sector 0 is MBR / partition table)
         loader_start, loader_end, loader_len = align_partition(
-            SnowballEmmcConfig.SNOWBALL_LOADER_START_S, 
-            LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
+            SnowballEmmcConfig.SNOWBALL_LOADER_START_S,
+            cls.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
 
         boot_start, boot_end, boot_len = align_partition(
-            loader_end + 1, BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            loader_end + 1, cls.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
         # we ignore _root_end / _root_len and return an sfdisk command to
         # instruct the use of all remaining space; XXX if we had some root size
         # config, we could do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,0xDA\n%s,%s,0x0C,*\n%s,,,-' % (
         loader_start, loader_len, boot_start, boot_len, root_start)
@@ -562,15 +749,22 @@
         make_uImage(cls.load_addr, k_img_data, boot_dir)
         boot_script_path = os.path.join(boot_dir, cls.boot_script)
         make_boot_script(boot_env, boot_script_path)
+        cls.populate_raw_partition(chroot_dir, boot_device_or_file)
+
+    @classmethod
+    def populate_raw_partition(cls, chroot_dir, boot_device_or_file):
+        # Populate created raw partition with TOC and startup files.
+        config_files_path = os.path.join(chroot_dir, 'boot')
         _, toc_filename = tempfile.mkstemp()
-        atexit.register(os.unlink, toc_filename)
-        config_files_path = os.path.join(chroot_dir, 'boot')
         new_files = cls.get_file_info(config_files_path)
         with open(toc_filename, 'wb') as toc:
             cls.create_toc(toc, new_files)
         cls.install_snowball_boot_loader(toc_filename, new_files,
                                      boot_device_or_file,
                                      cls.SNOWBALL_LOADER_START_S)
+        cls.delete_file(toc_filename)
+        cls.delete_file(os.path.join(config_files_path,
+                                     cls.SNOWBALL_STARTUP_FILES_CONFIG))
 
     @classmethod
     def install_snowball_boot_loader(cls, toc_file_name, files,
@@ -584,13 +778,21 @@
         for file in files:
             # XXX We need checks that these files do not overwrite each
             # other. This code assumes that offset and file sizes are ok.
+            filename = file['filename']
             if (file['offset'] % SECTOR_SIZE) != 0:
                 seek_bytes = start_sector * SECTOR_SIZE + file['offset']
-                _dd(file['filename'], boot_device_or_file, block_size=1,
+                _dd(filename, boot_device_or_file, block_size=1,
                     seek=seek_bytes)
             else:
-                seek_sectors = start_sector + file['offset']/SECTOR_SIZE
-                _dd(file['filename'], boot_device_or_file, seek=seek_sectors)
+                seek_sectors = start_sector + file['offset'] / SECTOR_SIZE
+                _dd(filename, boot_device_or_file, seek=seek_sectors)
+            cls.delete_file(filename)
+
+    @classmethod
+    def delete_file(cls, file_path):
+            cmd = ["rm", "%s" % file_path]
+            proc = cmd_runner.run(cmd, as_root=True)
+            proc.wait()
 
     @classmethod
     def create_toc(cls, f, files):
@@ -605,6 +807,8 @@
             # i; int; load_address,
             # 12s; string of char; name
             # http://igloocommunity.org/support/index.php/ConfigPartitionOverview
+            assert len(file['section_name']) < 12, (
+                "Section name %s too large" % file['section_name'])
             flags = 0
             load_adress = file['align']
             data = struct.pack('<IIIii12s', file['offset'], file['size'],
@@ -642,12 +846,20 @@
 
 class Mx5Config(BoardConfig):
     serial_tty = 'ttymxc0'
-    extra_serial_opts = 'console=tty0 console=%s,115200n8' % serial_tty
-    live_serial_opts = 'serialtty=%s' % serial_tty
+    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
+    _live_serial_opts = 'serialtty=%s'
     boot_script = 'boot.scr'
     mmc_part_offset = 1
     mmc_option = '0:2'
 
+    @classproperty
+    def live_serial_opts(cls):
+        return cls._live_serial_opts % cls.serial_tty
+
+    @classproperty
+    def extra_serial_opts(cls):
+        return cls._extra_serial_opts % cls.serial_tty
+
     @classmethod
     def get_sfdisk_cmd(cls, should_align_boot_part=None):
         """Return the sfdisk command to partition the media.
@@ -663,15 +875,15 @@
         # onwards, so it's safer to just start at the first sector, sector 1
         # (sector 0 is MBR / partition table)
         loader_start, loader_end, loader_len = align_partition(
-            1, LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
+            1, cls.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
 
         boot_start, boot_end, boot_len = align_partition(
-            loader_end + 1, BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            loader_end + 1, cls.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
         # we ignore _root_end / _root_len and return a sfdisk command to
         # instruct the use of all remaining space; XXX if we had some root size
         # config, we could do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,0xDA\n%s,%s,0x0C,*\n%s,,,-' % (
             loader_start, loader_len, boot_start, boot_len, root_start)
@@ -680,9 +892,12 @@
     def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
-        uboot_file = os.path.join(
-            chroot_dir, 'usr', 'lib', 'u-boot', cls.uboot_flavor, 'u-boot.imx')
-        install_mx5_boot_loader(uboot_file, boot_device_or_file)
+        with cls.hardwarepack_handler:
+            uboot_file = cls.get_file('u_boot', default=os.path.join(
+                    chroot_dir, 'usr', 'lib', 'u-boot', cls.uboot_flavor,
+                    'u-boot.imx'))
+            install_mx5_boot_loader(uboot_file, boot_device_or_file,
+                                    cls.LOADER_MIN_SIZE_S)
         make_uImage(cls.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
         make_dtb(d_img_data, boot_dir)
@@ -730,8 +945,8 @@
     uboot_flavor = 'ca9x4_ct_vxp'
     uboot_in_boot_part = True
     serial_tty = 'ttyAMA0'
-    extra_serial_opts = 'console=tty0 console=%s,38400n8' % serial_tty
-    live_serial_opts = 'serialtty=%s' % serial_tty
+    _extra_serial_opts = 'console=tty0 console=%s,38400n8'
+    _live_serial_opts = 'serialtty=%s'
     kernel_addr = '0x60008000'
     initrd_addr = '0x81000000'
     load_addr = kernel_addr
@@ -741,6 +956,14 @@
     # only allows for FAT16
     fat_size = 16
 
+    @classproperty
+    def live_serial_opts(cls):
+        return cls._live_serial_opts % cls.serial_tty
+
+    @classproperty
+    def extra_serial_opts(cls):
+        return cls._extra_serial_opts % cls.serial_tty
+
     @classmethod
     def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
@@ -748,17 +971,10 @@
         make_uImage(cls.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
 
-class SMDKV310Config(BoardConfig):
-    uboot_flavor = 'smdkv310'
-    serial_tty = 'ttySAC1'
-    extra_serial_opts = 'console=%s,115200n8' % serial_tty
-    kernel_addr = '0x40007000'
-    initrd_addr = '0x42000000'
-    load_addr = '0x40008000'
-    kernel_flavors = ['s5pv310']
-    boot_script = 'boot.scr'
-    mmc_part_offset = 1
-    mmc_option = '0:2'
+class SamsungConfig(BoardConfig):
+    @classproperty
+    def extra_serial_opts(cls):
+        return cls._extra_serial_opts % cls.serial_tty
 
     @classmethod
     def get_sfdisk_cmd(cls, should_align_boot_part=False):
@@ -773,46 +989,23 @@
 
         # FAT boot partition
         boot_start, boot_end, boot_len = align_partition(
-            loaders_end + 1, BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            loaders_end + 1, cls.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         # root partition
         # we ignore _root_end / _root_len and return a sfdisk command to
         # instruct the use of all remaining space; XXX if we had some root size
         # config, we could do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,0xDA\n%s,%s,0x0C,*\n%s,,,-' % (
             loaders_start, loaders_len, boot_start, boot_len, root_start)
 
     @classmethod
-    def _get_boot_env(cls, is_live, is_lowmem, consoles, rootfs_uuid,
-                      d_img_data):
-        boot_env = super(SMDKV310Config, cls)._get_boot_env(
-            is_live, is_lowmem, consoles, rootfs_uuid, d_img_data)
-
-        boot_env["ethact"] = "smc911x-0"
-        boot_env["ethaddr"] = "00:40:5c:26:0a:5b"
-
-        return boot_env
-
-    @classmethod
     def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
-        spl_file = os.path.join(
-            chroot_dir, 'usr', 'lib', 'u-boot', cls.uboot_flavor,
-            'v310_mmc_spl.bin')
-        # XXX need to check that the length of spl_file is smaller than
-        # SAMSUNG_V310_BL1_LEN
-        _dd(spl_file, boot_device_or_file, seek=SAMSUNG_V310_BL1_START)
-
-        uboot_file = os.path.join(
-            chroot_dir, 'usr', 'lib', 'u-boot', cls.uboot_flavor, 'u-boot.bin')
-        # XXX need to check that the length of uboot_file is smaller than
-        # SAMSUNG_V310_BL2_LEN
-        _dd(uboot_file, boot_device_or_file, seek=SAMSUNG_V310_BL2_START)
-
+        cls.install_samsung_boot_loader(chroot_dir, boot_device_or_file)
         env_size = SAMSUNG_V310_ENV_LEN * SECTOR_SIZE
         env_file = make_flashable_env(boot_env, env_size)
         _dd(env_file, boot_device_or_file, seek=SAMSUNG_V310_ENV_START)
@@ -825,6 +1018,84 @@
         boot_script_path = os.path.join(boot_dir, cls.boot_script)
         make_boot_script(boot_env, boot_script_path)
 
+    @classmethod
+    def _get_samsung_spl(cls, chroot_dir):
+        spl_dir = os.path.join(
+            chroot_dir, 'usr', 'lib', 'u-boot', cls.uboot_flavor)
+        old_spl_path = os.path.join(spl_dir, 'v310_mmc_spl.bin')
+        new_spl_path = os.path.join(spl_dir, 'u-boot-mmc-spl.bin')
+
+        spl_file = old_spl_path
+        # The new upstream u-boot filename has changed
+        if not os.path.exists(spl_file):
+            spl_file = new_spl_path
+
+        if not os.path.exists(spl_file):
+            # missing SPL loader
+            raise AssertionError("Couldn't find the SPL file, tried %s and %s"
+                                 % (old_spl_path, new_spl_path))
+        return spl_file
+
+    @classmethod
+    def _get_samsung_uboot(cls, chroot_dir):
+        uboot_file = os.path.join(
+            chroot_dir, 'usr', 'lib', 'u-boot', cls.uboot_flavor,
+            'u-boot.bin')
+        return uboot_file
+
+    @classmethod
+    def install_samsung_boot_loader(cls, chroot_dir, boot_device_or_file):
+        spl_file = cls._get_samsung_spl(chroot_dir)
+        bl1_max_size = SAMSUNG_V310_BL1_LEN * SECTOR_SIZE
+        assert os.path.getsize(spl_file) <= bl1_max_size, (
+            "%s is larger than %s" % (spl_file, bl1_max_size))
+        _dd(spl_file, boot_device_or_file, seek=SAMSUNG_V310_BL1_START)
+
+        with cls.hardwarepack_handler:
+            uboot_file = cls.get_file(
+                'u_boot', default=cls._get_samsung_uboot(chroot_dir))
+        bl2_max_size = SAMSUNG_V310_BL2_LEN * SECTOR_SIZE
+        assert os.path.getsize(uboot_file) <= bl2_max_size, (
+            "%s is larger than %s" % (uboot_file, bl2_max_size))
+        _dd(uboot_file, boot_device_or_file, seek=SAMSUNG_V310_BL2_START)
+
+
+class SMDKV310Config(SamsungConfig):
+    uboot_flavor = 'smdkv310'
+    serial_tty = 'ttySAC1'
+    _extra_serial_opts = 'console=%s,115200n8'
+    kernel_addr = '0x40007000'
+    initrd_addr = '0x42000000'
+    load_addr = '0x40008000'
+    kernel_flavors = ['s5pv310']
+    boot_script = 'boot.scr'
+    mmc_part_offset = 1
+    mmc_option = '0:2'
+
+    @classmethod
+    def _get_boot_env(cls, is_live, is_lowmem, consoles, rootfs_uuid,
+                      d_img_data):
+        boot_env = super(SamsungConfig, cls)._get_boot_env(
+            is_live, is_lowmem, consoles, rootfs_uuid, d_img_data)
+
+        boot_env["ethact"] = "smc911x-0"
+        boot_env["ethaddr"] = "00:40:5c:26:0a:5b"
+
+        return boot_env
+
+
+class OrigenConfig(SamsungConfig):
+    uboot_flavor = 'origen'
+    serial_tty = 'ttySAC2'
+    _extra_serial_opts = 'console=%s,115200n8'
+    kernel_addr = '0x40007000'
+    initrd_addr = '0x42000000'
+    load_addr = '0x40008000'
+    kernel_flavors = ['origen']
+    boot_script = 'boot.scr'
+    mmc_part_offset = 1
+    mmc_option = '0:2'
+
 
 board_configs = {
     'beagle': BeagleConfig,
@@ -837,9 +1108,10 @@
     'efikamx': EfikamxConfig,
     'efikasb': EfikasbConfig,
     'mx51evk': Mx51evkConfig,
-    'mx53loco' : Mx53LoCoConfig,
+    'mx53loco': Mx53LoCoConfig,
     'overo': OveroConfig,
     'smdkv310': SMDKV310Config,
+    'origen': OrigenConfig,
     }
 
 
@@ -961,13 +1233,13 @@
     return tmpfile
 
 
-def install_mx5_boot_loader(imx_file, boot_device_or_file):
+def install_mx5_boot_loader(imx_file, boot_device_or_file, loader_min_size):
     # bootloader partition starts at +1s but we write the file at +2s, so we
     # need to check that the bootloader partition minus 1s is at least as large
     # as the u-boot binary; note that the real bootloader partition might be
     # larger than LOADER_MIN_SIZE_S, but if u-boot is larger it's a sign we
     # need to bump LOADER_MIN_SIZE_S
-    max_size = (LOADER_MIN_SIZE_S - 1) * SECTOR_SIZE
+    max_size = (loader_min_size - 1) * SECTOR_SIZE
     assert os.path.getsize(imx_file) <= max_size, (
         "%s is larger than guaranteed bootloader partition size" % imx_file)
     _dd(imx_file, boot_device_or_file, seek=2)
@@ -1008,4 +1280,3 @@
         ["cp", "-v", boot_script_path, "%s/boot.ini" % boot_disk],
         as_root=True)
     proc.wait()
-
 
=== modified file 'linaro_image_tools/media_create/partitions.py'
--- linaro_image_tools/media_create/partitions.py	2011-05-31 06:45:22 +0000
+++ linaro_image_tools/media_create/partitions.py	2011-07-18 14:39:34 +0000
@@ -3,7 +3,7 @@
 # Author: Guilherme Salgado <[e-mail]>
 #
 # This file is part of Linaro Image Tools.
-# 
+#
 # Linaro Image Tools 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, either version 3 of the License, or
@@ -28,6 +28,7 @@
     Device,
     Disk,
     PARTITION_NORMAL,
+    PARTITION_EXTENDED,
     )
 
 from linaro_image_tools import cmd_runner
@@ -71,9 +72,8 @@
         bootfs = partitions[0]
         system = partitions[1]
         cache = partitions[2]
-        data = partitions[4]
-        sdcard = partitions[5]
-            
+        data = partitions[3]
+        sdcard = partitions[4]
 
     print "\nFormating boot partition\n"
     proc = cmd_runner.run(
@@ -98,6 +98,7 @@
 
     return bootfs, system, cache, data, sdcard
 
+
 # I wonder if it'd make sense to convert this into a small shim which calls
 # the appropriate function for the given type of device?  I think it's still
 # small enough that there's not much benefit in doing that, but if it grows we
@@ -296,18 +297,28 @@
     # Here we can use parted.Device to read the partitions because we're
     # reading from a regular file rather than a block device.  If it was a
     # block device we'd need root rights.
+    vfat_partition = None
     disk = Disk(Device(image_file))
     partition_info = []
     for partition in disk.partitions:
-        geometry = partition.geometry
-        partition_info.append((geometry.start * SECTOR_SIZE,
-                               geometry.length * SECTOR_SIZE))
+        # Will ignore any partitions before boot and of type EXTENDED
+        if 'boot' in partition.getFlagsAsString():
+            vfat_partition = partition
+            geometry = partition.geometry
+            partition_info.append((geometry.start * SECTOR_SIZE,
+                                   geometry.length * SECTOR_SIZE))
+        elif (vfat_partition is not None and
+              partition.type != PARTITION_EXTENDED):
+            geometry = partition.geometry
+            partition_info.append((geometry.start * SECTOR_SIZE,
+                                   geometry.length * SECTOR_SIZE))
         # NB: don't use vfat_partition.nextPartition() as that might return
         # a partition of type PARTITION_FREESPACE; it's much easier to
         # iterate disk.partitions which only returns
         # parted.PARTITION_NORMAL partitions
-
-    assert len(partition_info) == 6
+    assert vfat_partition is not None, (
+        "Couldn't find boot partition on %s" % image_file)
+    assert len(partition_info) == 5
     return partition_info
 
 
@@ -347,6 +358,7 @@
     return boot_partition, system_partition, cache_partition, \
         data_partition, sdcard_partition
 
+
 def get_boot_and_root_partitions_for_media(media, board_config):
     """Return the device files for the boot and root partitions of media.
 
 
=== modified file 'linaro_image_tools/media_create/rootfs.py'
--- linaro_image_tools/media_create/rootfs.py	2011-04-05 09:26:47 +0000
+++ linaro_image_tools/media_create/rootfs.py	2011-07-18 14:39:34 +0000
@@ -19,6 +19,7 @@
 
 import glob
 import os
+import subprocess
 import tempfile
 
 from linaro_image_tools import cmd_runner
@@ -107,13 +108,26 @@
         flash_kernel, "UBOOT_PART=%s" % target_boot_dev)
 
 
+def _list_files(directory):
+    """List the files and dirs under the given directory.
+
+    Runs as root because we want to list everything, including stuff that may
+    not be world-readable.
+    """
+    p = cmd_runner.run(
+        ['find', directory, '-maxdepth', '1', '-mindepth', '1'],
+        stdout=subprocess.PIPE, as_root=True)
+    stdout, _ = p.communicate()
+    return stdout.split()
+
+
 def move_contents(from_, root_disk):
     """Move everything under from_ to the given root disk.
 
     Uses sudo for moving.
     """
     assert os.path.isdir(from_), "%s is not a directory" % from_
-    files = glob.glob(os.path.join(from_, '*'))
+    files = _list_files(from_)
     mv_cmd = ['mv']
     mv_cmd.extend(sorted(files))
     mv_cmd.append(root_disk)
 
=== modified file 'linaro_image_tools/media_create/tests/test_media_create.py'
--- linaro_image_tools/media_create/tests/test_media_create.py	2011-06-14 09:45:13 +0000
+++ linaro_image_tools/media_create/tests/test_media_create.py	2011-07-18 14:39:34 +0000
@@ -28,7 +28,10 @@
 import textwrap
 import time
 import types
+import struct
+import tarfile
 
+from StringIO import StringIO
 from testtools import TestCase
 
 from linaro_image_tools import cmd_runner
@@ -38,9 +41,11 @@
     boards,
     partitions,
     rootfs,
+    android_boards,
     )
 from linaro_image_tools.media_create.boards import (
-    LOADER_MIN_SIZE_S,
+    SAMSUNG_V310_BL1_START,
+    SAMSUNG_V310_BL2_START,
     SECTOR_SIZE,
     align_up,
     align_partition,
@@ -56,6 +61,11 @@
     _get_file_matching,
     _get_mlo_file,
     _run_mkimage,
+    HardwarepackHandler,
+    BoardConfig,
+    )
+from linaro_image_tools.media_create.android_boards import (
+    android_board_configs,
     )
 from linaro_image_tools.media_create.chroot_utils import (
     copy_file,
@@ -113,6 +123,359 @@
 sudo_args = " ".join(cmd_runner.SUDO_ARGS)
 
 
+class TestHardwarepackHandler(TestCaseWithFixtures):
+    def setUp(self):
+        super(TestHardwarepackHandler, self).setUp()
+        self.tar_dir_fixture = CreateTempDirFixture()
+        self.useFixture(self.tar_dir_fixture)
+
+        self.tarball_fixture = CreateTarballFixture(
+            self.tar_dir_fixture.get_temp_dir())
+        self.useFixture(self.tarball_fixture)
+
+        self.metadata = (
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\nORIGIN=linaro\n")
+
+    def add_to_tarball(self, files, tarball=None):
+        if tarball is None:
+            tarball = self.tarball_fixture.get_tarball()
+        tar_file = tarfile.open(tarball, mode='w:gz')
+        for filename, data in files:
+            tarinfo = tarfile.TarInfo(filename)
+            tarinfo.size = len(data)
+            tar_file.addfile(tarinfo, StringIO(data))
+        tar_file.close()
+        return tarball
+
+    def test_get_format_1(self):
+        data = '1.0'
+        format = "%s\n" % data
+        tarball = self.add_to_tarball(
+            [('FORMAT', format), ('metadata', self.metadata)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            self.assertEquals(hp.get_format(), data)
+
+    def test_get_format_2(self):
+        data = '2.0'
+        format = "%s\n" % data
+        tarball = self.add_to_tarball(
+            [('FORMAT', format), ('metadata', self.metadata)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            self.assertEquals(hp.get_format(), data)
+
+    def test_get_unknown_format_raises(self):
+        data = '9.9'
+        format = "%s\n" % data
+        tarball = self.add_to_tarball(
+            [('FORMAT', format), ('metadata', self.metadata)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            self.assertRaises(AssertionError, hp.get_format)
+
+    def test_mixed_formats(self):
+        format1 = "%s\n" % '1.0'
+        format2 = "%s\n" % '2.0'
+        tarball1 = self.add_to_tarball(
+            [('FORMAT', format1), ('metadata', self.metadata)],
+            tarball=self.tarball_fixture.get_tarball())
+        tarball_fixture2 = CreateTarballFixture(
+            self.tar_dir_fixture.get_temp_dir(), reldir='tarfile2',
+            filename='secondtarball.tar.gz')
+        self.useFixture(tarball_fixture2)
+        tarball2 = self.add_to_tarball(
+            [('FORMAT', format2), ('metadata', self.metadata)],
+            tarball=tarball_fixture2.get_tarball())
+        hp = HardwarepackHandler([tarball2, tarball1])
+        with hp:
+            self.assertEquals(hp.get_format(), '1.0and2.0')
+
+    def test_identical_formats_ok(self):
+        format1 = "%s\n" % '2.0'
+        format2 = "%s\n" % '2.0'
+        tarball1 = self.add_to_tarball(
+            [('FORMAT', format1), ('metadata', self.metadata)],
+            tarball=self.tarball_fixture.get_tarball())
+        tarball_fixture2 = CreateTarballFixture(
+            self.tar_dir_fixture.get_temp_dir(), reldir='tarfile2',
+            filename='secondtarball.tar.gz')
+        self.useFixture(tarball_fixture2)
+        tarball2 = self.add_to_tarball(
+            [('FORMAT', format2), ('metadata', self.metadata)],
+            tarball=tarball_fixture2.get_tarball())
+        hp = HardwarepackHandler([tarball1, tarball2])
+        with hp:
+            self.assertEquals(hp.get_format(), '2.0')
+
+    def test_get_metadata(self):
+        data = 'data to test'
+        metadata = self.metadata + "TEST=%s\n" % data
+        tarball = self.add_to_tarball(
+            [('metadata', metadata)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            test_data, _ = hp.get_field(hp.main_section, 'test')
+            self.assertEqual(test_data, data)
+
+    def test_preserves_formatters(self):
+        data = '%s%d'
+        metadata = self.metadata + "TEST=%s\n" % data
+        tarball = self.add_to_tarball(
+            [('metadata', metadata)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            test_data, _ = hp.get_field(hp.main_section, 'test')
+            self.assertEqual(test_data, data)
+
+    def test_creates_tempdir(self):
+        tarball = self.add_to_tarball(
+            [('metadata', self.metadata)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            self.assertTrue(os.path.exists(hp.tempdir))
+
+    def test_tempfiles_are_removed(self):
+        tempdir = None
+        tarball = self.add_to_tarball(
+            [('metadata', self.metadata)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            tempdir = hp.tempdir
+        self.assertFalse(os.path.exists(tempdir))
+
+    def test_get_file(self):
+        data = 'test file contents\n'
+        metadata_file = 'TESTFILE'
+        file_in_archive = 'testfile'
+        metadata = self.metadata + "%s=%s\n" % (metadata_file, file_in_archive)
+        tarball = self.add_to_tarball(
+            [('metadata', metadata),
+             (file_in_archive, data)])
+        hp = HardwarepackHandler([tarball])
+        with hp:
+            test_file = hp.get_file(metadata_file)
+            self.assertEquals(data, open(test_file, 'r').read())
+        
+
+class TestSetMetadata(TestCaseWithFixtures):
+
+    class MockHardwarepackHandler(HardwarepackHandler):
+        metadata_dict = {}
+
+        def __enter__(self):
+            return self
+
+        def get_field(self, section, field):
+            try:
+                return self.metadata_dict[field], None
+            except:
+                return None, None
+
+        def get_format(self):
+            return '2.0'
+
+        def get_file(self, file_alias):
+            return None
+
+    def test_does_not_set_if_old_format(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(None, config.kernel_addr)
+
+    def test_sets_kernel_addr(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'kernel_addr'
+        data_to_set = '0x8123ABCD'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(data_to_set, config.kernel_addr)
+
+    def test_sets_initrd_addr(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'initrd_addr'
+        data_to_set = '0x8123ABCD'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(data_to_set, config.initrd_addr)
+
+    def test_sets_load_addr(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'load_addr'
+        data_to_set = '0x8123ABCD'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(data_to_set, config.load_addr)
+
+    def test_sets_serial_tty(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'serial_tty'
+        data_to_set = 'ttyAA'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(data_to_set, config.serial_tty)
+
+    def test_sets_wired_interfaces(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'wired_interfaces'
+        data_to_set = 'eth0 eth1'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(data_to_set, config.wired_interfaces)
+
+    def test_sets_wireless_interfaces(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'wireless_interfaces'
+        data_to_set = 'wlan0 wl1'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(data_to_set, config.wireless_interfaces)
+
+    def test_sets_mmc_id(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'mmc_id'
+        data_to_set = '1'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(data_to_set, config.mmc_id)
+
+    def test_sets_boot_min_size(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'boot_min_size'
+        data_to_set = '100'
+        expected = align_up(int(data_to_set) * 1024 * 1024,
+                            SECTOR_SIZE) / SECTOR_SIZE
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(expected, config.BOOT_MIN_SIZE_S)
+
+    def test_sets_root_min_size(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'root_min_size'
+        data_to_set = '3'
+        expected = align_up(int(data_to_set) * 1024 * 1024,
+                            SECTOR_SIZE) / SECTOR_SIZE
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(expected, config.ROOT_MIN_SIZE_S)
+
+    def test_sets_loader_min_size(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'loader_min_size'
+        data_to_set = '2'
+        expected = align_up(int(data_to_set) * 1024 * 1024,
+                            SECTOR_SIZE) / SECTOR_SIZE
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(expected, config.LOADER_MIN_SIZE_S)
+
+    def test_sets_partition_layout_32(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'partition_layout'
+        data_to_set = 'bootfs_rootfs'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(32, config.fat_size)
+
+    def test_sets_partition_layout_16(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'partition_layout'
+        data_to_set = 'bootfs16_rootfs'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        config.set_metadata('ahwpack.tar.gz')
+        self.assertEquals(16, config.fat_size)
+
+    def test_sets_partition_layout_raises(self):
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards, 'HardwarepackHandler',
+                self.MockHardwarepackHandler))
+        field_to_test = 'partition_layout'
+        data_to_set = 'bootfs_bogus_rootfs'
+        self.MockHardwarepackHandler.metadata_dict = {
+            field_to_test: data_to_set,
+            }
+        class config(BoardConfig):
+            pass
+        self.assertRaises(AssertionError, config.set_metadata, 'ahwpack.tar.gz')
+
+
 class TestGetMLOFile(TestCaseWithFixtures):
 
     def test_mlo_from_new_xloader(self):
@@ -150,6 +513,325 @@
             AssertionError, _get_mlo_file, tempdir)
 
 
+def _create_uboot_dir(root, flavor):
+    path = os.path.join(root, 'usr', 'lib', 'u-boot', flavor)
+    os.makedirs(path)
+    return path
+
+
+class TestGetSMDKSPL(TestCaseWithFixtures):
+    config = boards.SMDKV310Config
+
+    def test_no_file_present(self):
+        tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        self.assertRaises(
+            AssertionError, self.config._get_samsung_spl, tempdir)
+
+    def test_old_file_present(self):
+        tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        path = _create_uboot_dir(tempdir, self.config.uboot_flavor)
+        spl_path = os.path.join(path, 'v310_mmc_spl.bin')
+        open(spl_path, 'w').close()
+        self.assertEquals(spl_path, self.config._get_samsung_spl(tempdir))
+
+    def test_new_file_present(self):
+        tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        path = _create_uboot_dir(tempdir, self.config.uboot_flavor)
+        spl_path = os.path.join(path, 'u-boot-mmc-spl.bin')
+        open(spl_path, 'w').close()
+        self.assertEquals(spl_path, self.config._get_samsung_spl(tempdir))
+
+    def test_prefers_old_path(self):
+        tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        path = _create_uboot_dir(tempdir, self.config.uboot_flavor)
+        old_spl_path = os.path.join(path, 'v310_mmc_spl.bin')
+        new_spl_path = os.path.join(path, 'u-boot-mmc-spl.bin')
+        open(old_spl_path, 'w').close()
+        open(new_spl_path, 'w').close()
+        self.assertEquals(old_spl_path, self.config._get_samsung_spl(tempdir))
+
+
+class TestGetSMDKUboot(TestCaseWithFixtures):
+    config = boards.SMDKV310Config
+
+    def test_uses_uboot_flavour(self):
+        chroot_dir = "chroot"
+        uboot_file = os.path.join(chroot_dir, 'usr', 'lib', 'u-boot',
+                                  self.config.uboot_flavor, 'u-boot.bin')
+        self.assertEquals(
+            uboot_file, self.config._get_samsung_uboot(chroot_dir))
+
+
+class TestGetOrigenSPL(TestCaseWithFixtures):
+    config = boards.OrigenConfig
+
+    def test_no_file_present(self):
+        tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        self.assertRaises(
+            AssertionError, self.config._get_samsung_spl, tempdir)
+
+    def test_new_file_present(self):
+        tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        path = _create_uboot_dir(tempdir, self.config.uboot_flavor)
+        spl_path = os.path.join(path, 'u-boot-mmc-spl.bin')
+        open(spl_path, 'w').close()
+        self.assertEquals(spl_path, self.config._get_samsung_spl(tempdir))
+
+
+class TestGetOrigenUboot(TestGetSMDKUboot):
+    config = boards.OrigenConfig
+
+
+class TestCreateToc(TestCaseWithFixtures):
+    ''' Tests boards.SnowballEmmcConfig.create_toc()'''
+
+    def setUp(self):
+        ''' Create a temporary directory to work in'''
+        super(TestCreateToc, self).setUp()
+        self.tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        #Create the test's input data structures
+        zero = '\x00\x00\x00\x00'
+        line1 = zero + zero + zero + zero + zero + 'b' + zero + zero + \
+                 '\x00\x00\x00'
+        maxint = '\xFF\xFF\xFF\x7F'
+        minint = '\xFF\xFF\xFF\xFF'
+        line2 = maxint + maxint + zero + minint + minint + \
+                 'hello' + zero + '\x00\x00\x00'
+        line3 = '\x01\x00\x00\x00' '\x64\x00\x00\x00' + zero + \
+                 '\x05\x00\x00\x00' '\x05\x00\x00\x00' \
+                 'hello' + zero + '\x00\x00\x00'
+        self.expected = line1 + line2 + line3
+
+    def create_files_structure(self, src_data):
+        ''' Creates the data structure that the tested function
+            needs as input'''
+        files = []
+        for line in src_data:
+            files.append({'section_name': line[5],
+                  'filename': 'N/A',
+                  'align': line[3],
+                  'offset': line[0],
+                  'size': line[1],
+                  'load_adress': 'N/A'})
+        return files
+
+    def test_create_toc_normal_case(self):
+        ''' Creates a toc file, and then reads the created
+            file and compares it to precomputed data'''
+        correct_data = [(0, 0, 0, 0, 0, 'b'),
+                        (0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, -1, -1, 'hello'),
+                        (1, 100, 1000, 5, 10, 'hello')]
+        files = self.create_files_structure(correct_data)
+        filename = os.path.join(self.tempdir, 'toc')
+        with open(filename, 'w') as f:
+            boards.SnowballEmmcConfig.create_toc(f, files)
+        with open(filename, 'r') as f:
+            actual = f.read()
+        self.assertEquals(96, len(actual))
+        for i in range(len(actual)):
+            self.assertEquals(self.expected[i], actual[i], 'Mismatch at ix' \
+                ' %d, ref=%c, actual=%c' % (i, self.expected[i], actual[i]))
+
+    def test_create_toc_error_too_large_section_name(self):
+        '''Verify that trying to write past the end of the
+           section name field raises an exception'''
+        illegal_name_data = [(0, 0, 0, 0, 0, 'Too_longName')]
+        files = self.create_files_structure(illegal_name_data)
+        with open(os.path.join(self.tempdir, 'toc'), 'w') as f:
+            self.assertRaises(AssertionError,
+                              boards.SnowballEmmcConfig.create_toc,
+                              f, files)
+
+    def test_create_toc_error_negative_unsigned(self):
+        '''Verify that trying to write a negative number to an unsigned
+           field raises an exception'''
+        illegal_unsigned_data = [(-3, 0, 0, 0, 0, 'xxx')]
+        files = self.create_files_structure(illegal_unsigned_data)
+        with open(os.path.join(self.tempdir, 'toc'), 'w') as f:
+            self.assertRaises(struct.error,
+                              boards.SnowballEmmcConfig.create_toc,
+                              f, files)
+
+
+class TestSnowballBootFiles(TestCaseWithFixtures):
+    ''' Tests boards.SnowballEmmcConfig.install_snowball_boot_loader()'''
+    ''' Tests boards.SnowballEmmcConfig._make_boot_files()'''
+    ''' Tests boards.SnowballEmmcConfig.get_file_info()'''
+
+    def setUp(self):
+        ''' Create temporary directory to work in'''
+        super(TestSnowballBootFiles, self).setUp()
+        self.tempdir = self.useFixture(CreateTempDirFixture()).get_temp_dir()
+        self.temp_bootdir_path = os.path.join(self.tempdir, 'boot')
+        if not os.path.exists(self.temp_bootdir_path):
+            os.makedirs(self.temp_bootdir_path)
+
+    def setupFiles(self):
+        ''' Adds some files in the temp dir that the tested function
+            can use as input:
+            * A config file, which the tested function reads to
+              discover which binary files should be written to
+              the loader partition.
+            * Test versions of the binary files themselves,
+              containing dummy data.
+            Returns the expected value that the tested function should
+            return, given these input files.  '''
+        src_data = [('ISSW', 'boot_image_issw.bin', -1, 0, '5'),
+                    ('X-LOADER', 'boot_image_x-loader.bin', -1, 0, '6'),
+                    ('MEM_INIT', 'mem_init.bin', 0, 0x160000, '7'),
+                    ('PWR_MGT', 'power_management.bin', 0, 0x170000, '8'),
+                    ('NORMAL', 'u-boot.bin', 0, 0xBA0000, '9'),
+                    ('UBOOT_ENV', 'u-boot-env.bin', 0, 0x00C1F000, '10')]
+        # Create a config file
+        cfg_file = os.path.join(self.temp_bootdir_path,
+        boards.SnowballEmmcConfig.SNOWBALL_STARTUP_FILES_CONFIG)
+        with open(cfg_file, 'w') as f:
+            for line in src_data:
+                # Write comments, so we test that the parser can read them
+                f.write('#Yet another comment\n')
+                f.write('%s %s %i %#x %s\n' % line)
+        expected = []
+        # Define dummy binary files, containing nothing but their own
+        # section names.
+        for line in src_data:
+            with open(os.path.join(self.temp_bootdir_path, line[1]), 'w') as f:
+                f.write(line[0])
+        #define the expected values read from the config file
+        expected = []
+        ofs = [boards.SnowballEmmcConfig.TOC_SIZE,
+               boards.SnowballEmmcConfig.TOC_SIZE + len('ISSW'), 0x160000,
+               0x170000, 0xBA0000, 0xC1F000]
+        size = [len('ISSW'), len('X-LOADER'), len('MEM_INIT'), \
+                len('PWR_MGT'), len('NORMAL'), len('UBOOT_ENV')]
+        i = 0
+        for line in src_data:
+            filename = os.path.join(self.temp_bootdir_path, line[1])
+            expected.append({'section_name': line[0],
+                             'filename': filename,
+                             'align': int(line[2]),
+                             'offset': ofs[i],
+                             'size': long(size[i]),
+                             'load_adress': line[4]})
+            i += 1
+        return expected
+
+    def test_file_name_size(self):
+        ''' Test using a to large toc file '''
+        _, toc_filename = tempfile.mkstemp()
+        atexit.register(os.unlink, toc_filename)
+        filedata = 'X'
+        bytes = boards.SnowballEmmcConfig.TOC_SIZE + 1
+        tmpfile = open(toc_filename, 'wb')
+        for n in xrange(bytes):
+            tmpfile.write(filedata)
+        tmpfile.close()
+        files = self.setupFiles()
+        self.assertRaises(AssertionError,
+            boards.SnowballEmmcConfig.install_snowball_boot_loader,
+            toc_filename, files, "boot_device_or_file",
+            boards.SnowballEmmcConfig.SNOWBALL_LOADER_START_S)
+
+    def test_install_snowball_boot_loader_toc(self):
+        fixture = self.useFixture(MockCmdRunnerPopenFixture())
+        toc_filename = self.createTempFileAsFixture()
+        files = self.setupFiles()
+        boards.SnowballEmmcConfig.install_snowball_boot_loader(toc_filename,
+            files, "boot_device_or_file",
+            boards.SnowballEmmcConfig.SNOWBALL_LOADER_START_S)
+        expected = [
+            '%s dd if=%s of=boot_device_or_file bs=512 conv=notrunc' \
+            ' seek=%s' % (sudo_args, toc_filename,
+            boards.SnowballEmmcConfig.SNOWBALL_LOADER_START_S),
+            '%s dd if=%s/boot_image_issw.bin of=boot_device_or_file bs=512' \
+            ' conv=notrunc seek=257' % (sudo_args, self.temp_bootdir_path),
+            '%s rm %s/boot_image_issw.bin' % (sudo_args,
+            self.temp_bootdir_path),
+            '%s dd if=%s/boot_image_x-loader.bin of=boot_device_or_file' \
+            ' bs=1 conv=notrunc seek=131588'
+            % (sudo_args, self.temp_bootdir_path),
+            '%s rm %s/boot_image_x-loader.bin' % (sudo_args,
+            self.temp_bootdir_path),
+            '%s dd if=%s/mem_init.bin of=boot_device_or_file bs=512' \
+            ' conv=notrunc seek=3072' % (sudo_args, self.temp_bootdir_path),
+            '%s rm %s/mem_init.bin' % (sudo_args, self.temp_bootdir_path),
+            '%s dd if=%s/power_management.bin of=boot_device_or_file bs=512' \
+            ' conv=notrunc seek=3200' % (sudo_args, self.temp_bootdir_path),
+            '%s rm %s/power_management.bin' % (sudo_args,
+            self.temp_bootdir_path),
+            '%s dd if=%s/u-boot.bin of=boot_device_or_file bs=512' \
+            ' conv=notrunc seek=24064' % (sudo_args, self.temp_bootdir_path),
+            '%s rm %s/u-boot.bin' % (sudo_args, self.temp_bootdir_path),
+            '%s dd if=%s/u-boot-env.bin of=boot_device_or_file bs=512'
+            ' conv=notrunc seek=25080' % (sudo_args, self.temp_bootdir_path),
+            '%s rm %s/u-boot-env.bin' % (sudo_args, self.temp_bootdir_path)]
+
+        self.assertEqual(expected, fixture.mock.commands_executed)
+
+    def test_snowball_make_boot_files(self):
+        fixture = self.useFixture(MockCmdRunnerPopenFixture())
+        self.useFixture(MockSomethingFixture(tempfile, 'mkstemp',
+            lambda: (-1, '/tmp/temp_snowball_make_boot_files')))
+        self.setupFiles()
+        k_img_file = os.path.join(self.tempdir, 'vmlinuz-1-ux500')
+        i_img_file = os.path.join(self.tempdir, 'initrd.img-1-ux500')
+
+        boot_env = board_configs['snowball_emmc']._get_boot_env(
+            is_live=False, is_lowmem=False, consoles=[],
+            rootfs_uuid="test_boot_env_uuid", d_img_data=None)
+        boards.SnowballEmmcConfig._make_boot_files(boot_env, self.tempdir,
+            self.temp_bootdir_path, 'boot_device_or_file', k_img_file,
+            i_img_file, None)
+        expected = [
+            '%s mkimage -A arm -O linux -T kernel -C none -a 0x00008000 -e' \
+            ' 0x00008000 -n Linux -d %s %s/boot/uImage' % (sudo_args,
+            k_img_file, self.tempdir),
+            '%s cp /tmp/temp_snowball_make_boot_files %s/boot/boot.txt'
+            % (sudo_args, self.tempdir),
+            '%s mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n boot' \
+            ' script -d %s/boot/boot.txt %s/boot/flash.scr'
+            % (sudo_args, self.tempdir, self.tempdir),
+            '%s dd if=/tmp/temp_snowball_make_boot_files' \
+            ' of=boot_device_or_file bs=512 conv=notrunc seek=256'
+            % (sudo_args),
+            '%s dd if=%s/boot/boot_image_issw.bin of=boot_device_or_file' \
+            ' bs=512 conv=notrunc seek=257' % (sudo_args, self.tempdir),
+            '%s rm %s/boot_image_issw.bin' % (sudo_args,
+            self.temp_bootdir_path),
+            '%s dd if=%s/boot/boot_image_x-loader.bin of=boot_device_or_file' \
+            ' bs=1 conv=notrunc seek=131588' % (sudo_args, self.tempdir),
+            '%s rm %s/boot_image_x-loader.bin' % (sudo_args,
+            self.temp_bootdir_path),
+            '%s dd if=%s/boot/mem_init.bin of=boot_device_or_file bs=512' \
+            ' conv=notrunc seek=3072' % (sudo_args, self.tempdir),
+            '%s rm %s/mem_init.bin' % (sudo_args, self.temp_bootdir_path),
+            '%s dd if=%s/boot/power_management.bin of=boot_device_or_file' \
+            ' bs=512 conv=notrunc seek=3200' % (sudo_args, self.tempdir),
+            '%s rm %s/power_management.bin' % (sudo_args,
+            self.temp_bootdir_path),
+            '%s dd if=%s/boot/u-boot.bin of=boot_device_or_file bs=512' \
+            ' conv=notrunc seek=24064' % (sudo_args, self.tempdir),
+            '%s rm %s/u-boot.bin' % (sudo_args, self.temp_bootdir_path),
+            '%s dd if=%s/boot/u-boot-env.bin of=boot_device_or_file bs=512' \
+            ' conv=notrunc seek=25080' % (sudo_args, self.tempdir),
+            '%s rm %s/u-boot-env.bin' % (sudo_args, self.temp_bootdir_path),
+            '%s rm /tmp/temp_snowball_make_boot_files' % (sudo_args),
+            '%s rm %s/startfiles.cfg' % (sudo_args, self.temp_bootdir_path)]
+
+        self.assertEqual(expected, fixture.mock.commands_executed)
+
+    def test_missing_files(self):
+        '''When the files cannot be read, an IOError should be raised'''
+        self.assertRaises(IOError,
+                          boards.SnowballEmmcConfig.get_file_info,
+                          self.tempdir)
+
+    def test_normal_case(self):
+        expected = self.setupFiles()
+        actual = boards.SnowballEmmcConfig.get_file_info(
+            self.temp_bootdir_path)
+        self.assertEquals(expected, actual)
+
+
 class TestBootSteps(TestCaseWithFixtures):
 
     def setUp(self):
@@ -199,6 +881,10 @@
     def test_mx5_steps(self):
         class SomeMx5Config(boards.Mx5Config):
             uboot_flavor = 'uboot_flavor'
+        SomeMx5Config.hardwarepack_handler = (
+            TestSetMetadata.MockHardwarepackHandler('ahwpack.tar.gz'))
+        SomeMx5Config.hardwarepack_handler.get_format = (
+            lambda: '1.0')
         self.make_boot_files(SomeMx5Config)
         expected = [
             'install_mx5_boot_loader', 'make_uImage', 'make_uInitrd',
@@ -206,9 +892,40 @@
         self.assertEqual(expected, self.funcs_calls)
 
     def test_smdkv310_steps(self):
+        def mock_func_creator(name):
+            return classmethod(
+                lambda *args, **kwargs: self.funcs_calls.append(name))
+
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards.SMDKV310Config,
+                'install_samsung_boot_loader',
+                mock_func_creator('install_samsung_boot_loader')))
+        boards.SMDKV310Config.hardwarepack_handler = (
+            TestSetMetadata.MockHardwarepackHandler('ahwpack.tar.gz'))
+        boards.SMDKV310Config.hardwarepack_handler.get_format = (
+            lambda: '1.0')
         self.make_boot_files(boards.SMDKV310Config)
         expected = [
-            '_dd', '_dd', 'make_flashable_env', '_dd', 'make_uImage',
+            'install_samsung_boot_loader', 'make_flashable_env', '_dd', 'make_uImage',
+            'make_uInitrd', 'make_boot_script']
+        self.assertEqual(expected, self.funcs_calls)
+
+    def test_origen_steps(self):
+        def mock_func_creator(name):
+            return classmethod(
+                lambda *args, **kwargs: self.funcs_calls.append(name))
+
+        self.useFixture(MockSomethingFixture(
+                linaro_image_tools.media_create.boards.OrigenConfig,
+                'install_samsung_boot_loader',
+                mock_func_creator('install_samsung_boot_loader')))
+        boards.OrigenConfig.hardwarepack_handler = (
+            TestSetMetadata.MockHardwarepackHandler('ahwpack.tar.gz'))
+        boards.OrigenConfig.hardwarepack_handler.get_format = (
+            lambda: '1.0')
+        self.make_boot_files(boards.OrigenConfig)
+        expected = [
+            'install_samsung_boot_loader', 'make_flashable_env', '_dd', 'make_uImage',
             'make_uInitrd', 'make_boot_script']
         self.assertEqual(expected, self.funcs_calls)
 
@@ -354,6 +1071,23 @@
             '1,8191,0xDA\n8192,106496,0x0C,*\n114688,,,-',
             board_configs['smdkv310'].get_sfdisk_cmd())
 
+    def test_origen(self):
+        self.assertEquals(
+            '1,8191,0xDA\n8192,106496,0x0C,*\n114688,,,-',
+            board_configs['origen'].get_sfdisk_cmd())
+
+    def test_panda_android(self):
+        self.assertEqual(
+            '63,270272,0x0C,*\n270336,524288,L\n794624,524288,L\n' \
+                '1318912,-,E\n1318912,1048576,L\n2367488,,,-', 
+                android_boards.AndroidPandaConfig.get_sfdisk_cmd())
+
+    def test_snowball_emmc_android(self):
+        self.assertEqual(
+            '256,7936,0xDA\n8192,262144,0x0C,*\n270336,524288,L\n' \
+                '794624,-,E\n794624,524288,L\n1318912,1048576,L\n2367488,,,-', 
+                android_boards.AndroidSnowballEmmcConfig.get_sfdisk_cmd())
+
 
 class TestGetBootCmd(TestCase):
 
@@ -396,6 +1130,18 @@
              'ethaddr': '00:40:5c:26:0a:5b'}
         self.assertEqual(expected, boot_commands)
 
+    def test_origen(self):
+        boot_commands = board_configs['origen']._get_boot_env(
+            is_live=False, is_lowmem=False, consoles=[],
+            rootfs_uuid="deadbeef", d_img_data=None)
+        expected = {
+            'bootargs': 'console=ttySAC2,115200n8  root=UUID=deadbeef '
+                        'rootwait ro',
+             'bootcmd': 'fatload mmc 0:2 0x40007000 uImage; '
+                        'fatload mmc 0:2 0x42000000 uInitrd; '
+                        'bootm 0x40007000 0x42000000'}
+        self.assertEqual(expected, boot_commands)
+
     def test_ux500(self):
         boot_commands = board_configs['ux500']._get_boot_env(
             is_live=False, is_lowmem=False, consoles=[],
@@ -509,6 +1255,41 @@
         self.assertEqual(expected, boot_commands)
 
 
+class TestGetBootCmdAndroid(TestCase):
+    def test_panda(self):
+        # XXX: To fix bug 697824 we have to change class attributes of our
+        # OMAP board configs, and some tests do that so to make sure they
+        # don't interfere with us we'll reset that before doing anything.
+        config = android_board_configs['panda']
+        config.serial_tty = config._serial_tty
+        boot_commands = config._get_boot_env(consoles=[])
+        expected = {
+            'bootargs': 'console=tty0 console=ttyO2,115200n8 '
+                        'rootwait ro earlyprintk fixrtc '
+                        'nocompcache vram=48M omapfb.vram=0:24M,1:24M '
+                        'mem=456M@0x80000000 mem=512M@0xA0000000 '
+                        'init=/init androidboot.console=ttyO2',
+            'bootcmd': 'fatload mmc 0:1 0x80200000 uImage; '
+                       'fatload mmc 0:1 0x81600000 uInitrd; '
+                       'bootm 0x80200000 0x81600000'}
+        self.assertEqual(expected, boot_commands)
+	
+    def test_android_snowball_emmc(self):
+        boot_commands = (android_boards.AndroidSnowballEmmcConfig.
+                         _get_boot_env(consoles=[]))
+        expected = {
+            'bootargs': 'console=tty0 console=ttyAMA2,115200n8 '
+                        'rootwait ro earlyprintk '
+                        'rootdelay=1 fixrtc nocompcache '
+                        'mem=128M@0 mali.mali_mem=64M@128M mem=24M@192M '
+                        'hwmem=167M@216M mem_issw=1M@383M mem=640M@384M '
+                        'vmalloc=256M init=/init androidboot.console=ttyAMA2',
+            'bootcmd': 'fatload mmc 1:1 0x00100000 uImage; '
+                       'fatload mmc 1:1 0x08000000 uInitrd; '
+                       'bootm 0x00100000 0x08000000'}
+        self.assertEqual(expected, boot_commands)
+
+
 class TestUnpackBinaryTarball(TestCaseWithFixtures):
 
     def setUp(self):
@@ -607,7 +1388,8 @@
     def test_install_mx5_boot_loader(self):
         fixture = self._mock_Popen()
         imx_file = self.createTempFileAsFixture()
-        install_mx5_boot_loader(imx_file, "boot_device_or_file")
+        install_mx5_boot_loader(imx_file, "boot_device_or_file",
+                                BoardConfig.LOADER_MIN_SIZE_S)
         expected = [
             '%s dd if=%s of=boot_device_or_file bs=512 '
             'conv=notrunc seek=2' % (sudo_args, imx_file)]
@@ -616,9 +1398,10 @@
     def test_install_mx5_boot_loader_too_large(self):
         self.useFixture(MockSomethingFixture(
             os.path, "getsize",
-            lambda s: (LOADER_MIN_SIZE_S - 1) * SECTOR_SIZE + 1))
+            lambda s: (BoardConfig.LOADER_MIN_SIZE_S - 1) * SECTOR_SIZE + 1))
         self.assertRaises(AssertionError,
-            install_mx5_boot_loader, "imx_file", "boot_device_or_file")
+            install_mx5_boot_loader, "imx_file", "boot_device_or_file",
+                          BoardConfig.LOADER_MIN_SIZE_S)
 
     def test_install_omap_boot_loader(self):
         fixture = self._mock_Popen()
@@ -630,6 +1413,58 @@
             '%s cp -v chroot_dir/MLO boot_disk' % sudo_args, 'sync']
         self.assertEqual(expected, fixture.mock.commands_executed)
 
+    def test_install_smdk_u_boot(self):
+        fixture = self._mock_Popen()
+        uboot_flavor = boards.SMDKV310Config.uboot_flavor
+        self.useFixture(MockSomethingFixture(
+            boards.SMDKV310Config, '_get_samsung_spl',
+            classmethod(lambda cls, chroot_dir: "%s/%s/SPL" % (
+                chroot_dir, uboot_flavor))))
+        self.useFixture(MockSomethingFixture(
+            boards.SMDKV310Config, '_get_samsung_uboot',
+            classmethod(lambda cls, chroot_dir: "%s/%s/uboot" % (
+                chroot_dir, uboot_flavor))))
+        boards.SMDKV310Config.hardwarepack_handler = (
+            TestSetMetadata.MockHardwarepackHandler('ahwpack.tar.gz'))
+        boards.SMDKV310Config.hardwarepack_handler.get_format = (
+            lambda: '1.0')
+        self.useFixture(MockSomethingFixture(os.path, 'getsize',
+                                             lambda file: 1))
+        boards.SMDKV310Config.install_samsung_boot_loader(
+            "chroot_dir", "boot_disk")
+        expected = [
+            '%s dd if=chroot_dir/%s/SPL of=boot_disk bs=512 conv=notrunc '
+            'seek=%d' % (sudo_args, uboot_flavor, SAMSUNG_V310_BL1_START),
+            '%s dd if=chroot_dir/%s/uboot of=boot_disk bs=512 conv=notrunc '
+            'seek=%d' % (sudo_args, uboot_flavor, SAMSUNG_V310_BL2_START)]
+        self.assertEqual(expected, fixture.mock.commands_executed)
+
+    def test_install_origen_u_boot(self):
+        fixture = self._mock_Popen()
+        uboot_flavor = boards.OrigenConfig.uboot_flavor
+        self.useFixture(MockSomethingFixture(
+            boards.OrigenConfig, '_get_samsung_spl',
+            classmethod(lambda cls, chroot_dir: "%s/%s/SPL" % (
+                chroot_dir, uboot_flavor))))
+        self.useFixture(MockSomethingFixture(
+            boards.OrigenConfig, '_get_samsung_uboot',
+            classmethod(lambda cls, chroot_dir: "%s/%s/uboot" % (
+                chroot_dir, uboot_flavor))))
+        boards.OrigenConfig.hardwarepack_handler = (
+            TestSetMetadata.MockHardwarepackHandler('ahwpack.tar.gz'))
+        boards.OrigenConfig.hardwarepack_handler.get_format = (
+            lambda: '1.0')
+        self.useFixture(MockSomethingFixture(os.path, 'getsize',
+                                             lambda file: 1))
+        boards.OrigenConfig.install_samsung_boot_loader(
+            "chroot_dir", "boot_disk")
+        expected = [
+            '%s dd if=chroot_dir/%s/SPL of=boot_disk bs=512 conv=notrunc '
+            'seek=%d' % (sudo_args, uboot_flavor, SAMSUNG_V310_BL1_START),
+            '%s dd if=chroot_dir/%s/uboot of=boot_disk bs=512 conv=notrunc '
+            'seek=%d' % (sudo_args, uboot_flavor, SAMSUNG_V310_BL2_START)]
+        self.assertEqual(expected, fixture.mock.commands_executed)
+
     def test_get_plain_boot_script_contents(self):
         boot_env = {'bootargs': 'mybootargs', 'bootcmd': 'mybootcmd'}
         boot_script_data = get_plain_boot_script_contents(boot_env)
@@ -820,6 +1655,25 @@
             [('1,8191,0xDA\n8192,106496,0x0C,*\n114688,,,-', HEADS,
               SECTORS, '', self.media.path)], sfdisk_fixture.mock.calls)
 
+    def test_create_partitions_for_origen(self):
+        # For this board we create a one cylinder partition at the beginning.
+        popen_fixture = self.useFixture(MockCmdRunnerPopenFixture())
+        sfdisk_fixture = self.useFixture(MockRunSfdiskCommandsFixture())
+
+        create_partitions(
+            board_configs['origen'], self.media, HEADS, SECTORS, '')
+
+        self.assertEqual(
+            ['%s parted -s %s mklabel msdos' % (sudo_args, self.media.path),
+             'sync'],
+            popen_fixture.mock.commands_executed)
+        # Notice that we create all partitions in a single sfdisk run because
+        # every time we run sfdisk it actually repartitions the device,
+        # erasing any partitions created previously.
+        self.assertEqual(
+            [('1,8191,0xDA\n8192,106496,0x0C,*\n114688,,,-', HEADS,
+              SECTORS, '', self.media.path)], sfdisk_fixture.mock.calls)
+
     def test_create_partitions_for_beagle(self):
         popen_fixture = self.useFixture(MockCmdRunnerPopenFixture())
         sfdisk_fixture = self.useFixture(MockRunSfdiskCommandsFixture())
@@ -893,13 +1747,21 @@
             (63 * SECTOR_SIZE, 32768 * SECTOR_SIZE),
             (32831 * SECTOR_SIZE, 65536 * SECTOR_SIZE),
             (98367 * SECTOR_SIZE, 65536 * SECTOR_SIZE),
-            (294975 * SECTOR_SIZE, (self.android_image_size - 
-                                     294975 * SECTOR_SIZE)),
             ((294975 + ext_part_size) * SECTOR_SIZE,
              (131072 - ext_part_size) * SECTOR_SIZE),
             ((426047 + ext_part_size) * SECTOR_SIZE, 
              self.android_image_size - (426047 + ext_part_size) * SECTOR_SIZE)
             ]
+        
+        self.android_snowball_offsets_and_sizes = [
+            (8192 * SECTOR_SIZE, 24639 * SECTOR_SIZE),
+            (32831 * SECTOR_SIZE, 65536 * SECTOR_SIZE),
+            ((98367  + ext_part_size)* SECTOR_SIZE, 
+             (65536 - ext_part_size) * SECTOR_SIZE),
+            (294975 * SECTOR_SIZE, 131072 * SECTOR_SIZE),
+            ((426047 + ext_part_size) * SECTOR_SIZE, 
+             self.android_image_size - (426047 + ext_part_size) * SECTOR_SIZE)
+            ]
 
     def tearDown(self):
         super(TestPartitionSetup, self).tearDown()
@@ -916,6 +1778,13 @@
             '63,32768,0x0C,*\n32831,65536,L\n98367,65536,L\n294975,-,E\n' \
                 '294975,131072,L\n426047,,,-', '%s' % self.android_image_size)
 
+    def _create_snowball_android_tmpfile(self):
+        # raw, boot, system, cache, (extended), userdata and sdcard partitions
+        return self._create_qemu_img_with_partitions(
+            '256,7936,0xDA\n8192,24639,0x0C,*\n32831,65536,L\n' \
+            '98367,-,E\n98367,65536,L\n294975,131072,L\n' \
+            '426047,,,-', '%s' % self.android_image_size)
+
     def test_convert_size_no_suffix(self):
         self.assertEqual(524288, convert_size_to_bytes('524288'))
 
@@ -945,6 +1814,15 @@
                                               self.android_offsets_and_sizes):
             self.assertEqual(device_pair, expected_pair)
 
+    def test_calculate_snowball_android_partition_size_and_offset(self):
+        tmpfile = self._create_snowball_android_tmpfile()
+        device_info = calculate_android_partition_size_and_offset(tmpfile)
+        # We use map(None, ...) since it would catch if the lists are not of
+        # equal length and zip() would not in all cases.
+        for device_pair, expected_pair in map(None, device_info,
+                                              self.android_snowball_offsets_and_sizes):
+            self.assertEqual(device_pair, expected_pair)
+
     def test_partition_numbering(self):
         # another Linux partition at +24 MiB after the boot/root parts
         tmpfile = self._create_qemu_img_with_partitions(
@@ -1054,7 +1932,7 @@
 
         # get_boot_and_root_loopback_devices will also setup two exit handlers
         # to de-register the loopback devices set up above.
-        self.assertEqual(6, len(atexit_fixture.mock.funcs))
+        self.assertEqual(5, len(atexit_fixture.mock.funcs))
         popen_fixture.mock.calls = []
         atexit_fixture.mock.run_funcs()
         # We did not really run losetup above (as it requires root) so here we
@@ -1065,7 +1943,6 @@
              '%s losetup -d ' % sudo_args,
              '%s losetup -d ' % sudo_args,
              '%s losetup -d ' % sudo_args,
-             '%s losetup -d ' % sudo_args,
              '%s losetup -d ' % sudo_args],
             popen_fixture.mock.commands_executed)
 
@@ -1159,6 +2036,9 @@
 
         self.config = c
         self.config.boot_script = 'boot_script'
+        self.config.hardwarepack_handler = \
+            TestSetMetadata.MockHardwarepackHandler('ahwpack.tar.gz')
+        self.config.hardwarepack_handler.get_format = lambda: '1.0'
         self.popen_fixture = self.useFixture(MockCmdRunnerPopenFixture())
         self.useFixture(MockSomethingFixture(
             self.config, 'make_boot_files', self.save_args))
@@ -1241,6 +2121,14 @@
         os.makedirs(contents_bin)
         os.makedirs(contents_etc)
 
+        # Must mock rootfs._list_files() because populate_rootfs() uses its
+        # return value but since we mock cmd_runner.run() _list_files() would
+        # return an invalid value.
+        def mock_list_files(directory):
+            return [contents_bin, contents_etc]
+        self.useFixture(MockSomethingFixture(
+            rootfs, '_list_files', mock_list_files))
+
         populate_rootfs(
             contents_dir, root_disk, partition='/dev/rootfs',
             rootfs_type='ext3', rootfs_uuid='uuid', should_create_swap=True,
@@ -1282,10 +2170,27 @@
             fixture.mock.commands_executed[0])
         self.assertEqual('UBOOT_PART=/dev/mmcblk0p1', open(tmpfile).read())
 
+    def test_list_files(self):
+        tempdir = self.useFixture(CreateTempDirFixture()).tempdir
+        # We don't want to mock cmd_runner.run() because we're testing the
+        # command that it runs, but we need to monkey-patch SUDO_ARGS because
+        # we don't want to use 'sudo' in tests.
+        orig_sudo_args = cmd_runner.SUDO_ARGS
+        def restore_sudo_args():
+            cmd_runner.SUDO_ARGS = orig_sudo_args
+        self.addCleanup(restore_sudo_args)
+        cmd_runner.SUDO_ARGS = []
+        file1 = self.createTempFileAsFixture(dir=tempdir)
+        self.assertEqual([file1], rootfs._list_files(tempdir))
+
     def test_move_contents(self):
         tempdir = self.useFixture(CreateTempDirFixture()).tempdir
         popen_fixture = self.useFixture(MockCmdRunnerPopenFixture())
         file1 = self.createTempFileAsFixture(dir=tempdir)
+        def mock_list_files(directory):
+            return [file1]
+        self.useFixture(MockSomethingFixture(
+            rootfs, '_list_files', mock_list_files))
 
         move_contents(tempdir, '/tmp/')
 
 
=== modified file 'setup.py'
--- setup.py	2011-05-26 20:32:40 +0000
+++ setup.py	2011-07-18 14:39:34 +0000
@@ -5,7 +5,7 @@
 
 DistUtilsExtra.auto.setup(
         name="linaro-image-tools",
-        version="0.4.8.1",
+        version="2011.06-1.1",
         description="Tools to create and write Linaro images",
         url="https://launchpad.net/linaro-image-tools",
         license="GPL v3 or later",