ec2_amitools 1.0.2

data/lib/ec2/amitools/showversion.rb

@@ -0,0 +1,12 @@
+# Copyright 2008-2014 Amazon.com, Inc. or its affiliates.  All Rights
+# Reserved.  Licensed under the Amazon Software License (the
+# "License").  You may not use this file except in compliance with the
+# License. A copy of the License is located at
+# http://aws.amazon.com/asl or in the "license" file accompanying this
+# file.  This file is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+# the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'ec2/amitools/version'
+puts EC2Version::version_copyright_string()

data/lib/ec2/amitools/syschecks.rb

@@ -0,0 +1,27 @@
+# Copyright 2008-2014 Amazon.com, Inc. or its affiliates.  All Rights
+# Reserved.  Licensed under the Amazon Software License (the
+# "License").  You may not use this file except in compliance with the
+# License. A copy of the License is located at
+# http://aws.amazon.com/asl or in the "license" file accompanying this
+# file.  This file is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+# the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'ec2/amitools/fileutil'
+require 'ec2/platform/current'
+
+module SysChecks
+  def self.rsync_usable?()
+    EC2::Platform::Current::Rsync.usable?
+  end
+  def self.good_tar_version?()
+    EC2::Platform::Current::Tar::Version.current.usable?
+  end
+  def self.get_system_arch()
+    EC2::Platform::Current::System::BUNDLING_ARCHITECTURE
+  end
+  def self.root_user?()
+    EC2::Platform::Current::System.superuser?
+  end
+end

data/lib/ec2/amitools/tool_base.rb

@@ -0,0 +1,224 @@
+# Copyright 2008-2014 Amazon.com, Inc. or its affiliates.  All Rights
+# Reserved.  Licensed under the Amazon Software License (the
+# "License").  You may not use this file except in compliance with the
+# License. A copy of the License is located at
+# http://aws.amazon.com/asl or in the "license" file accompanying this
+# file.  This file is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+# the License for the specific language governing permissions and
+# limitations under the License.
+
+module AMIToolExceptions
+  # All fatal errors should inherit from this.
+  class EC2FatalError < RuntimeError
+    attr_accessor :code
+    def initialize(code, msg)
+      super(msg)
+      @code = code
+    end
+  end
+
+  class FileNotFound < EC2FatalError
+    def initialize(path)
+      super(2, "File not found: #{path}")
+    end
+  end
+
+  class S3Error < EC2FatalError
+    def initialize(msg)
+      super(3, "Error talking to S3: #{msg}")
+    end
+  end
+
+  class PromptTimeout < EC2FatalError
+    def initialize(msg=nil)
+      message = "Timed out waiting for user input"
+      message += ": #{msg}" unless msg.nil?
+      super(5, message)
+    end
+  end
+
+  # This is more for flow control than anything else.
+  # Raising it should terminate execution, but not print an error.
+  class EC2StopExecution < RuntimeError
+    attr_accessor :code
+    def initialize(code=0)
+      super()
+      @code = code
+    end
+  end
+
+  class TryFailed < RuntimeError
+  end
+
+end
+
+class AMITool
+
+  include AMIToolExceptions
+
+  PROMPT_TIMEOUT = 30
+  MAX_TRIES = 5
+  BACKOFF_PERIOD = 5
+
+  #------------------------------------------------------------------------------#
+  # Methods to override in subclasses
+  #------------------------------------------------------------------------------#
+
+  def get_manual()
+    # We have to get the manual text into here.
+    raise "NotImplemented: get_manual()"
+  end
+
+  def get_name()
+    # We have to get the tool name into here.
+    raise "NotImplemented: get_name()"
+  end
+
+  def main(params)
+    # Main entry point.
+    raise "NotImplemented: main()"
+  end
+
+  #------------------------------------------------------------------------------#
+  # Utility methods
+  #------------------------------------------------------------------------------#
+
+  # Display a message (without appending a newline) and ask for a response.
+  # Returns user response or nil if interactivity is not desired.
+  # Raises exception on timeout.
+  def interactive_prompt(message, name=nil)
+    return nil unless interactive?
+    begin
+      $stdout.print(message)
+      $stdout.flush
+      Timeout::timeout(PROMPT_TIMEOUT) do
+        return gets
+      end
+    rescue Timeout::Error
+      raise PromptTimeout.new(name)
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+
+  # Display a message on stderr.
+  # If interactive, asks for confirmation (yes/no).
+  # Returns true if in batch mode or user agrees, false if user disagrees.
+  # Raises exception on timeout.
+  def warn_confirm(message)
+    $stderr.puts(message)
+    $stderr.flush
+    return true unless interactive?
+    response = interactive_prompt("Are you sure you want to continue? [y/N]")
+    if response =~ /^[Yy]/
+      return true
+    end
+    return false
+  end
+
+  #----------------------------------------------------------------------------#
+
+  def retry_s3(retrying=true)
+    tries = 0
+    while true
+      tries += 1
+      begin
+        result = yield
+        return result
+      rescue TryFailed => e
+        $stderr.puts e.message
+        if retrying and tries < MAX_TRIES
+          $stdout.puts "Retrying in #{BACKOFF_PERIOD}s ..."
+        else
+          raise EC2FatalError.new(3, e.message)
+        end
+      end
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+  # Standard behaviour
+  #------------------------------------------------------------------------------#
+
+  def handle_early_exit_parameters(params)
+    if params.version
+      puts get_name() + " " + params.version_copyright_string()
+      return
+    end
+    
+    if params.show_help
+      puts params.help
+      return
+    end
+    
+    if params.manual
+      puts get_manual()
+      return
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+
+  def interactive?
+    @interactive
+  end
+
+  #------------------------------------------------------------------------------#
+
+  def get_parameters(params_class)
+    # Parse the parameters and die on errors.
+    # Assume that if we're parsing parameters, it's safe to exit.
+    begin
+      params = params_class.new(ARGV)
+    rescue StandardError => e
+      $stderr.puts e.message
+      $stderr.puts "Try '#{get_name} --help'"
+      exit 1
+    end
+    
+    # Deal with help, verion, etc.
+    if params.early_exit?
+      handle_early_exit_parameters(params)
+      exit 0
+    end
+    
+    # Some general flags that we want to set
+    @debug = params.debug
+    @interactive = params.interactive?
+    
+    # Finally, return the leftovers.
+    params
+  end
+
+  #------------------------------------------------------------------------------#
+
+  def run(params_class)
+    # We want to be able to reuse bits without having to parse
+    # parameters, so run() is not called from the constructor.
+    begin
+      params = get_parameters(params_class)
+      main(params)
+    rescue AMIToolExceptions::EC2StopExecution => e
+      # We've been asked to stop.
+      exit e.code
+    rescue AMIToolExceptions::PromptTimeout => e
+      $stderr.puts e.message
+      exit e.code
+    rescue AMIToolExceptions::EC2FatalError => e
+      $stderr.puts "ERROR: #{e.message}"
+      puts e.backtrace if @debug
+      exit e.code
+    rescue Interrupt => e
+      $stderr.puts "\n#{get_name} interrupted."
+      puts e.backtrace if @debug
+      exit 255
+    rescue => e
+      $stderr.puts "ERROR: #{e.message}"
+      puts e.inspect if @debug
+      puts e.backtrace if @debug
+      exit 254
+    end
+  end
+
+end

data/lib/ec2/amitools/unbundle.rb

@@ -0,0 +1,107 @@
+# Copyright 2008-2014 Amazon.com, Inc. or its affiliates.  All Rights
+# Reserved.  Licensed under the Amazon Software License (the
+# "License").  You may not use this file except in compliance with the
+# License. A copy of the License is located at
+# http://aws.amazon.com/asl or in the "license" file accompanying this
+# file.  This file is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+# the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'ec2/amitools/format'
+require 'ec2/amitools/manifestv3'
+require 'ec2/amitools/unbundleparameters'
+require 'ec2/platform/current'
+require 'ec2/amitools/tool_base'
+
+UNBUNDLE_NAME = 'ec2-unbundle'
+
+UNBUNDLE_MANUAL =<<TEXT
+#{UNBUNDLE_NAME} extracts a filesystem image from a bundle AMI.
+
+#{UNBUNDLE_NAME} will:
+- read relevant information from the manifest file
+- concatenate all the parts
+- decrypt and uncompress the image
+TEXT
+
+class Unbundler < AMITool
+
+  def unbundle(p)
+    begin
+      manifest_path = p.manifest_path
+      src_dir = p.source
+      dst_dir = p.destination
+      
+      digest_pipe = File::join( '/tmp', "ec2-unbundle-image-digest-pipe" )
+      File::delete( digest_pipe ) if File::exist?( digest_pipe )
+      unless system( "mkfifo #{digest_pipe}" )
+        raise "error creating named pipe #{digest_pipe}"
+      end
+      
+      # Load manifest and the user's private key.
+      manifest = ManifestV3.new(File.open( manifest_path ) { |f| f.read() })
+      pk = Crypto::loadprivkey( p.user_pk_path )
+      
+      # Extract key and IV from XML manifest.
+      key = pk.private_decrypt(Format::hex2bin( manifest.user_encrypted_key))
+      iv = pk.private_decrypt(Format::hex2bin( manifest.user_encrypted_iv))
+      
+      # Create a string of space separated part paths.
+      part_files = manifest.parts.collect do |part| 
+        File::join( src_dir, part.filename ) 
+      end.join( ' ' )
+      
+      # Join, decrypt, decompress and untar.
+      untar = EC2::Platform::Current::Tar::Command.new.extract.chdir(dst_dir)
+      pipeline = EC2::Platform::Current::Pipeline.new('image-unbundle-pipeline', @debug)
+      pipeline.concat([
+                       ['cat', "openssl sha1 < #{digest_pipe} & cat #{part_files}"],
+                       ['decrypt', "openssl enc -d -aes-128-cbc -K #{key} -iv #{iv}"],
+                       ['gunzip', "gunzip"],
+                       ['tee', "tee #{digest_pipe}"],
+                       ['untar', untar.expand]
+                      ])
+      digest = nil
+      begin
+        digest = pipeline.execute.split(/\s+/).last.strip
+      rescue EC2::Platform::Current::Pipeline::ExecutionError => e
+        $stderr.puts e.message
+      end
+      
+      # Verify digest.
+      unless manifest.digest == digest
+        raise "invalid digest, expected #{manifest.digest} received #{digest}"
+      end
+      
+      puts "Unbundle complete."
+      return 0
+    ensure
+      File::delete( digest_pipe ) if (digest_pipe && File::exist?( digest_pipe ))
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+  # Overrides
+  #------------------------------------------------------------------------------#
+
+  def get_manual()
+    UNBUNDLE_MANUAL
+  end
+
+  def get_name()
+    UNBUNDLE_NAME
+  end
+
+  def main(p)
+    unbundle(p)
+  end
+
+end
+
+#------------------------------------------------------------------------------#
+# Script entry point. Execute only if this file is being executed.
+
+if __FILE__ == $0 || $0.match(/bin\/ec2-unbundle/)
+  Unbundler.new().run(UnbundleParameters)
+end

data/lib/ec2/amitools/unbundleparameters.rb

@@ -0,0 +1,65 @@
+# Copyright 2008-2014 Amazon.com, Inc. or its affiliates.  All Rights
+# Reserved.  Licensed under the Amazon Software License (the
+# "License").  You may not use this file except in compliance with the
+# License. A copy of the License is located at
+# http://aws.amazon.com/asl or in the "license" file accompanying this
+# file.  This file is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+# the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'ec2/amitools/parameters_base'
+
+class UnbundleParameters < ParametersBase
+  
+  MANIFEST_DESCRIPTION    = "The path to the AMI manifest file."
+  SOURCE_DESCRIPTION      = 'The directory containing bundled AMI parts to unbundle. Defaults to ".".'
+  DESTINATION_DESCRIPTION = 'The directory to unbundle the AMI into. Defaults to the ".".'
+  
+  attr_accessor :manifest_path,
+                :user_pk_path,
+                :source,
+                :destination
+  
+  #----------------------------------------------------------------------------#
+
+  def mandatory_params()
+    on('-k', '--privatekey PATH', String, USER_PK_PATH_DESCRIPTION) do |path|
+      assert_file_exists(path, '--privatekey')
+      @user_pk_path = path
+    end
+
+    on('-m', '--manifest PATH', String, MANIFEST_DESCRIPTION) do |manifest|
+      assert_file_exists(manifest, '--manifest')
+      @manifest_path = manifest
+    end
+  end
+
+  #----------------------------------------------------------------------------#
+
+  def optional_params()
+    on('-s', '--source DIRECTORY', String, SOURCE_DESCRIPTION) do |directory|
+      assert_directory_exists(directory, '--source')
+      @source = directory
+    end  
+    
+    on('-d', '--destination DIRECTORY', String, DESTINATION_DESCRIPTION) do |directory|
+      assert_directory_exists(directory, '--destination')
+      @destination = directory
+    end
+  end    
+
+  #----------------------------------------------------------------------------#
+
+  def validate_params()
+    raise MissingMandatory.new('--manifest') unless @manifest_path
+    raise MissingMandatory.new('--privatekey') unless @user_pk_path
+  end
+
+  #----------------------------------------------------------------------------#
+
+  def set_defaults()
+    @source ||= Dir::pwd()
+    @destination ||= Dir::pwd()
+  end
+end

data/lib/ec2/amitools/uploadbundle.rb

@@ -0,0 +1,361 @@
+# Copyright 2008-2014 Amazon.com, Inc. or its affiliates.  All Rights
+# Reserved.  Licensed under the Amazon Software License (the
+# "License").  You may not use this file except in compliance with the
+# License. A copy of the License is located at
+# http://aws.amazon.com/asl or in the "license" file accompanying this
+# file.  This file is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+# the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'ec2/common/s3support'
+require 'ec2/amitools/uploadbundleparameters'
+require 'uri'
+require 'ec2/amitools/instance-data'
+require 'ec2/amitools/manifestv20071010'
+require 'rexml/document'
+require 'digest/md5'
+require 'base64'
+require 'ec2/amitools/tool_base'
+require 'ec2/amitools/region'
+
+#------------------------------------------------------------------------------#
+
+UPLOAD_BUNDLE_NAME = 'ec2-upload-bundle'
+
+UPLOAD_BUNDLE_MANUAL =<<TEXT
+#{UPLOAD_BUNDLE_NAME} is a command line tool to upload a bundled Amazon Image to S3 storage 
+for use by EC2. An Amazon Image may be one of the following:
+- Amazon Machine Image (AMI)
+- Amazon Kernel Image (AKI)
+- Amazon Ramdisk Image (ARI)
+
+#{UPLOAD_BUNDLE_NAME} will:
+- create an S3 bucket to store the bundled AMI in if it does not already exist
+- upload the AMI manifest and parts files to S3, granting specified privileges 
+- on them (defaults to EC2 read privileges)
+
+To manually retry an upload that failed, #{UPLOAD_BUNDLE_NAME} can optionally:
+- skip uploading the manifest
+- only upload bundled AMI parts from a specified part onwards
+TEXT
+
+#------------------------------------------------------------------------------#
+
+class BucketLocationError < AMIToolExceptions::EC2FatalError
+  def initialize(bucket, location, bucket_location)
+    location = "US" if location == :unconstrained
+    bucket_location = "US" if bucket_location == :unconstrained
+    super(10, "Bucket \"#{bucket}\" already exists in \"#{bucket_location}\" and \"#{location}\" was specified.")
+  end
+end
+
+#----------------------------------------------------------------------------#
+
+# Upload the specified file.
+
+class BundleUploader < AMITool
+
+  def upload(s3_conn, bucket, key, file, acl, retry_upload)
+    retry_s3(retry_upload) do
+      begin
+        md5 = get_md5(file)
+        s3_conn.put(bucket, key, file, {"x-amz-acl"=>acl, "content-md5"=>md5})
+        return
+      rescue EC2::Common::HTTP::Error::PathInvalid => e
+        raise FileNotFound(file)
+      rescue => e
+        raise TryFailed.new("Failed to upload \"#{file}\": #{e.message}")
+      end
+    end
+  end
+
+  #----------------------------------------------------------------------------#
+
+  def get_md5(file)
+    Base64::encode64(Digest::MD5::digest(File.open(file) { |f| f.read })).strip
+  end
+
+  #----------------------------------------------------------------------------#
+
+  # 
+  # Availability zone names are generally in the format => ${REGION}${ZONENUMBER}.
+  # Examples being us-east-1b, us-east-1c, etc.
+  #
+  def get_availability_zone()
+    instance_data = EC2::InstanceData.new
+    instance_data.availability_zone
+  end
+
+  #----------------------------------------------------------------------------#
+
+  # Return a list of bundle part filename and part number tuples from the manifest.
+  def get_part_info(manifest)
+    parts = manifest.ami_part_info_list.map do |part|
+      [part['filename'], part['index']]
+    end
+    parts.sort
+  end
+
+  #------------------------------------------------------------------------------#
+
+  def uri2string(uri)
+    s = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+    # Remove the trailing '/'.
+    return (s[-1..-1] == "/" ? s[0..-2] : s)
+  end
+
+  #------------------------------------------------------------------------------#
+
+  # Get the bucket's location.
+  def get_bucket_location(s3_conn, bucket)
+    begin
+      response = s3_conn.get_bucket_location(bucket)
+    rescue EC2::Common::HTTP::Error::Retrieve => e
+      if e.code == 404
+        # We have a "Not found" S3 response, which probably means the bucket doesn't exist.
+        return nil
+      end
+      raise e
+    end
+    $stdout.puts "check_bucket_location response: #{response.body}" if @debug and response.text?
+    docroot = REXML::Document.new(response.body).root
+    bucket_location = REXML::XPath.first(docroot, '/LocationConstraint').text
+    bucket_location ||= :unconstrained
+  end
+
+  #------------------------------------------------------------------------------#
+
+  # Check if the bucket exists and is in an appropriate location.
+  def check_bucket_location(bucket, bucket_location, location)
+    if bucket_location.nil?
+      # The bucket does not exist. Safe, but we need to create it.
+      return false
+    end
+    if location.nil?
+      # The bucket exists and we don't care where it is.
+      return true
+    end
+    unless [bucket_location, AwsRegion.guess_region_from_s3_bucket(bucket_location)].include?(location)
+      # The bucket isn't where we want it. This is a problem.
+      raise BucketLocationError.new(bucket, location, bucket_location)
+    end
+    # The bucket exists and is in the right place.
+    return true
+  end
+
+  #------------------------------------------------------------------------------#
+
+  # Create the specified bucket if it does not exist.
+  def create_bucket(s3_conn, bucket, bucket_location, location, retry_create)
+    begin
+      if check_bucket_location(bucket, bucket_location, location)
+        return true
+      end
+      $stdout.puts "Creating bucket..."
+      
+      retry_s3(retry_create) do
+        error = "Could not create or access bucket #{bucket}"
+        begin
+          rsp = s3_conn.create_bucket(bucket, location == :unconstrained ? nil : location)
+        rescue EC2::Common::HTTP::Error::Retrieve => e
+          error += ": server response #{e.message} #{e.code}" 
+          raise TryFailed.new(e.message)
+        rescue RuntimeError => e
+          error += ": error message #{e.message}"
+          raise e
+        end
+      end
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+
+  # If we return true, we have a v2-compliant name.
+  # If we return false, we wish to use a bad name.
+  # Otherwise we quietly wander off to die in peace.
+  def check_bucket_name(bucket)
+    if EC2::Common::S3Support::bucket_name_s3_v2_safe?(bucket)
+      return true
+    end
+    message = "The specified bucket is not S3 v2 safe (see S3 documentation for details):\n#{bucket}"
+    if warn_confirm(message)
+      # Assume the customer knows what he's doing.
+      return false
+    else
+      # We've been asked to stop, so quietly wander off to die in peace.
+      raise EC2StopExecution.new()
+    end
+  end
+
+  # force v1 S3 addressing when using govcloud endpoint
+  def check_govcloud_override(s3_url)
+    if s3_url =~ /s3-us-gov-west-1/
+      false
+    else
+      true
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+
+  def get_region()
+    zone = get_availability_zone()
+    if zone.nil?
+      return nil
+    end
+    # assume region names do not have a common naming scheme. Therefore we manually go through all known region names
+    AwsRegion.regions.each do |region| 
+      match = zone.match(region)
+      if not match.nil?
+        return region
+      end
+    end
+    nil
+  end
+
+  # This is very much a best effort attempt. If in doubt, we don't warn.
+  def cross_region?(location, bucket_location)
+
+    # If the bucket exists, its S3 location is canonical.
+    s3_region = bucket_location
+    s3_region ||= location
+    s3_region ||= :unconstrained
+
+    region = get_region()
+
+    if region.nil?
+      # If we can't get the region, assume we're fine since there's
+      # nothing more we can do.
+      return false
+    end
+
+    return s3_region != AwsRegion.get_s3_location(region)
+  end
+
+  #------------------------------------------------------------------------------#
+
+  def warn_about_migrating()
+    message = ["You are bundling in one region, but uploading to another. If the kernel",
+               "or ramdisk associated with this AMI are not in the target region, AMI",
+               "registration will fail.",
+               "You can use the ec2-migrate-manifest tool to update your manifest file",
+               "with a kernel and ramdisk that exist in the target region.",
+              ].join("\n")
+    unless warn_confirm(message)
+      raise EC2StopExecution.new()
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+
+  def get_s3_conn(s3_url, user, pass, method, sigv, region=nil)
+    EC2::Common::S3Support.new(s3_url, user, pass, method, @debug, sigv, region)
+  end
+
+  #------------------------------------------------------------------------------#
+  
+  #
+  # Get parameters and display help or manual if necessary.
+  #
+  def upload_bundle(url,
+                    bucket,
+                    keyprefix,
+                    user,
+                    pass,
+                    location,
+                    manifest_file,
+                    retry_stuff,
+                    part,
+                    directory,
+                    acl,
+                    skipmanifest,
+                    sigv,
+                    region)
+    begin
+      # Get the S3 URL.
+      s3_uri = URI.parse(url)
+      s3_url = uri2string(s3_uri)
+      v2_bucket = check_bucket_name(bucket) and check_govcloud_override(s3_url)
+      s3_conn = get_s3_conn(s3_url, user, pass, (v2_bucket ? nil : :path), sigv, region)
+
+      # Get current location and bucket location.
+      bucket_location = get_bucket_location(s3_conn, bucket)
+
+      # Load manifest.
+      xml = File.open(manifest_file) { |f| f.read }
+      manifest = ManifestV20071010.new(xml)
+      
+      # If in interactive mode, warn when bundling a kernel into our AMI and we are uploading cross-region
+      if interactive? and manifest.kernel_id and cross_region?(location, bucket_location)
+        warn_about_migrating()
+      end
+
+      # Create storage bucket if required.
+      create_bucket(s3_conn, bucket, bucket_location, location, retry_stuff)
+      
+      # Upload AMI bundle parts.
+      $stdout.puts "Uploading bundled image parts to the S3 bucket #{bucket} ..."
+      get_part_info(manifest).each do |part_info|
+        if part.nil? or (part_info[1] >= part)
+          path = File.join(directory, part_info[0])
+          upload(s3_conn, bucket, keyprefix + part_info[0], path, acl, retry_stuff)
+          $stdout.puts "Uploaded #{part_info[0]}"
+        else
+          $stdout.puts "Skipping #{part_info[0]}"
+        end
+      end
+      
+      # Encrypt and upload manifest.
+      unless skipmanifest
+        $stdout.puts "Uploading manifest ..."
+        upload(s3_conn, bucket, keyprefix + File::basename(manifest_file), manifest_file, acl, retry_stuff)
+        $stdout.puts "Uploaded manifest."
+        $stdout.puts 'Manifest uploaded to: %s/%s' % [bucket, keyprefix + File::basename(manifest_file)]
+      else
+        $stdout.puts "Skipping manifest."
+      end
+
+      $stdout.puts 'Bundle upload completed.'
+    rescue EC2::Common::HTTP::Error => e
+      $stderr.puts e.backtrace if @debug
+      raise S3Error.new(e.message)
+    end
+  end
+
+  #------------------------------------------------------------------------------#
+  # Overrides
+  #------------------------------------------------------------------------------#
+
+  def get_manual()
+    UPLOAD_BUNDLE_MANUAL
+  end
+
+  def get_name()
+    UPLOAD_BUNDLE_NAME
+  end
+
+  def main(p)
+    upload_bundle(p.url,
+                  p.bucket,
+                  p.keyprefix,
+                  p.user,
+                  p.pass,
+                  p.location,
+                  p.manifest,
+                  p.retry,
+                  p.part,
+                  p.directory,
+                  p.acl,
+                  p.skipmanifest,
+                  p.sigv,
+                  p.region)
+  end
+
+end
+
+#------------------------------------------------------------------------------#
+# Script entry point. Execute only if this file is being executed.
+if __FILE__ == $0 || $0.match(/bin\/ec2-upload-bundle/)
+  BundleUploader.new().run(UploadBundleParameters)
+end