Accept new parameters for prepare_image

jimrollenhagen · jimrollenhagen · commit 620f05eb33bc · 2014-04-24T13:00:24.000-07:00
The parameters sent to `prepare_image` changed in https://review.openstack.org/#/c/86490/ This patch brings `prepare_image` up to date with that change. It also changes the way configdrive is written to disk, to match that Ironic is now allowing Nova to build an ISO partition and send the raw image to the agent. This patch also swaps out subprocess.call for processutils.execute in the standby module, since the commands were being changed anyway. Lastly, this patch changes the expected `hashes` dict to be a string parameter called `checksum`, to match what glance returns. Change-Id: Id8af9be920ba51e7e1ce60f4ffd1477e413582c9
diff --git a/ironic_python_agent/cmd/agent.py b/ironic_python_agent/cmd/agent.py
@@ -18,7 +18,8 @@
 from ironic_python_agent.openstack.common import log
 
 
-LOG = log.getLogger()
+log.setup('ironic-python-agent')
+LOG = log.getLogger(__name__)
 
 
 def _get_kernel_params():
diff --git a/ironic_python_agent/extensions/standby.py b/ironic_python_agent/extensions/standby.py
@@ -12,17 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import base64
+import gzip
 import hashlib
 import os
 import requests
-import subprocess
+import six
+import StringIO
 import time
 
-from ironic_python_agent import configdrive
 from ironic_python_agent import errors
 from ironic_python_agent.extensions import base
 from ironic_python_agent import hardware
 from ironic_python_agent.openstack.common import log
+from ironic_python_agent import utils
 
 LOG = log.getLogger(__name__)
 
@@ -47,28 +50,41 @@ def _write_image(image_info, device):
     script = _path_to_script('shell/write_image.sh')
     command = ['/bin/bash', script, image, device]
     LOG.info('Writing image with command: {0}'.format(' '.join(command)))
-    exit_code = subprocess.call(command)
+    exit_code = utils.execute(*command)
     if exit_code != 0:
         raise errors.ImageWriteError(exit_code, device)
     totaltime = time.time() - starttime
     LOG.info('Image {0} written to device {1} in {2} seconds'.format(
              image, device, totaltime))
 
 
-def _copy_configdrive_to_disk(configdrive_dir, device):
+def _write_configdrive_to_file(configdrive, filename):
+    LOG.debug('Writing configdrive to {0}'.format(filename))
+    # configdrive data is base64'd, decode it first
+    data = StringIO.StringIO(base64.b64decode(configdrive))
+    gunzipped = gzip.GzipFile('configdrive', 'rb', 9, data)
+    with open(filename, 'wb') as f:
+        f.write(gunzipped.read())
+    gunzipped.close()
+
+
+def _write_configdrive_to_partition(configdrive, device):
+    filename = _configdrive_location()
+    _write_configdrive_to_file(configdrive, filename)
+
     starttime = time.time()
     script = _path_to_script('shell/copy_configdrive_to_disk.sh')
-    command = ['/bin/bash', script, configdrive_dir, device]
+    command = ['/bin/bash', script, filename, device]
     LOG.info('copying configdrive to disk with command {0}'.format(
              ' '.join(command)))
-    exit_code = subprocess.call(command)
+    exit_code = utils.execute(*command)
 
     if exit_code != 0:
         raise errors.ConfigDriveWriteError(exit_code, device)
 
     totaltime = time.time() - starttime
     LOG.info('configdrive copied from {0} to {1} in {2} seconds'.format(
-             configdrive_dir,
+             configdrive,
              device,
              totaltime))
 
@@ -114,28 +130,22 @@ def _download_image(image_info):
 
 
 def _verify_image(image_info, image_location):
-    hashes = image_info['hashes']
-    for k, v in hashes.items():
-        algo = getattr(hashlib, k, None)
-        if algo is None:
-            continue
-        log_msg = 'Verifying image at {0} with algorithm {1} against hash {2}'
-        LOG.debug(log_msg.format(image_location, k, v))
-        hash_ = algo(open(image_location).read()).hexdigest()
-        if hash_ == v:
-            return True
-        else:
-            log_msg = ('Image verification failed. Location: {0};'
-                       'algorithm: {1}; image hash: {2};'
-                       'verification hash: {3}')
-            LOG.warning(log_msg.format(image_location, k, hash_, v))
+    checksum = image_info['checksum']
+    log_msg = 'Verifying image at {0} against MD5 checksum {1}'
+    LOG.debug(log_msg.format(image_location, checksum))
+    hash_ = hashlib.md5(open(image_location).read()).hexdigest()
+    if hash_ == checksum:
+        return True
+    log_msg = ('Image verification failed. Location: {0};'
+               'image hash: {1}; verification hash: {2}')
+    LOG.warning(log_msg.format(image_location, checksum, hash_))
     return False
 
 
 def _validate_image_info(ext, image_info=None, **kwargs):
     image_info = image_info or {}
 
-    for field in ['id', 'urls', 'hashes']:
+    for field in ['id', 'urls', 'checksum']:
         if field not in image_info:
             msg = 'Image is missing \'{0}\' field.'.format(field)
             raise errors.InvalidCommandParamsError(msg)
@@ -144,10 +154,10 @@ def _validate_image_info(ext, image_info=None, **kwargs):
         raise errors.InvalidCommandParamsError(
             'Image \'urls\' must be a list with at least one element.')
 
-    if type(image_info['hashes']) != dict or not image_info['hashes']:
+    if (not isinstance(image_info['checksum'], six.string_types)
+            or not image_info['checksum']):
         raise errors.InvalidCommandParamsError(
-            'Image \'hashes\' must be a dictionary with at least one '
-            'element.')
+            'Image \'checksum\' must be a non-empty string.')
 
 
 class StandbyExtension(base.BaseAgentExtension):
@@ -171,9 +181,7 @@ def cache_image(self, image_info=None, force=False):
     @base.async_command(_validate_image_info)
     def prepare_image(self,
                       image_info=None,
-                      metadata=None,
-                      files=None):
-        location = _configdrive_location()
+                      configdrive=None):
         device = hardware.get_manager().get_os_install_device()
 
         # don't write image again if already cached
@@ -182,16 +190,14 @@ def prepare_image(self,
             _write_image(image_info, device)
             self.cached_image_id = image_info['id']
 
-        LOG.debug('Writing configdrive to {0}'.format(location))
-        configdrive.write_configdrive(location, metadata, files)
-        _copy_configdrive_to_disk(location, device)
+        _write_configdrive_to_partition(configdrive, device)
 
     @base.async_command()
     def run_image(self):
         script = _path_to_script('shell/reboot.sh')
         LOG.info('Rebooting system')
         command = ['/bin/bash', script]
         # this should never return if successful
-        exit_code = subprocess.call(command)
+        exit_code = utils.execute(*command)
         if exit_code != 0:
             raise errors.SystemRebootError(exit_code)
diff --git a/ironic_python_agent/shell/copy_configdrive_to_disk.sh b/ironic_python_agent/shell/copy_configdrive_to_disk.sh
@@ -22,39 +22,28 @@ log() {
 
 usage() {
   [[ -z "$1" ]] || echo -e "USAGE ERROR: $@\n"
-  echo "`basename $0`: CONFIGDRIVE_DIR DEVICE"
-  echo "  - This script injects CONFIGDRIVE_DIR contents as an iso9660"
+  echo "`basename $0`: CONFIGDRIVE DEVICE"
+  echo "  - This script injects CONFIGDRIVE contents as an iso9660"
   echo "    filesystem on a partition at the end of DEVICE."
   exit 1
 }
 
-CONFIGDRIVE_DIR="$1"
+CONFIGDRIVE="$1"
 DEVICE="$2"
 
-[[ -d $CONFIGDRIVE_DIR ]] || usage "$CONFIGDRIVE_DIR (CONFIGDRIVE_DIR) is not a directory"
+[[ -f $CONFIGDRIVE ]] || usage "$CONFIGDRIVE (CONFIGDRIVE) is not a regular file"
 [[ -b $DEVICE ]] || usage "$DEVICE (DEVICE) is not a block device"
 
 # Create small partition at the end of the device
 log "Adding configdrive partition to $DEVICE"
-parted -a optimal -s -- $DEVICE mkpart primary ext2 -16MiB -0
+parted -a optimal -s -- $DEVICE mkpart primary ext2 -64MiB -0
 
 # Find partition we just created
 # Dump all partitions, ignore empty ones, then get the last partition ID
 ISO_PARTITION=`sfdisk --dump $DEVICE | grep -v ' 0,' | tail -n1 | awk '{print $1}'`
 
 # This generates the ISO image of the config drive.
-log "Writing Configdrive contents in $CONFIGDRIVE_DIR to $ISO_PARTITION"
-genisoimage \
- -o ${ISO_PARTITION} \
- -ldots \
- -input-charset 'utf-8' \
- -allow-lowercase \
- -allow-multidot \
- -l \
- -publisher "ironic" \
- -J \
- -r \
- -V 'config-2' \
- ${CONFIGDRIVE_DIR}
+log "Writing Configdrive contents in $CONFIGDRIVE to $ISO_PARTITION"
+dd if=$CONFIGDRIVE of=$ISO_PARTITION bs=64K oflag=direct
 
 log "${DEVICE} imaged successfully!"
diff --git a/ironic_python_agent/tests/extensions/standby.py b/ironic_python_agent/tests/extensions/standby.py
