ec2_amitools 1.0.2

data/lib/ec2/amitools/downloadbundleparameters.rb

@@ -0,0 +1,84 @@
+# 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/s3toolparameters'
+
+#------------------------------------------------------------------------------#
+
+class DownloadBundleParameters < S3ToolParameters
+
+  PREFIX_DESCRIPTION      = "The filename prefix for bundled AMI files. Defaults to 'image'."
+  DIRECTORY_DESCRIPTION   = ['The directory into which to download the bundled AMI parts.',
+                             "Defaults to the current working directory."]
+  MANIFEST_DESCRIPTION    = ["The local manifest filename. Required only for manifests that",
+                             "pre-date the version 3 manifest file format."]
+  RETRY_DESCRIPTION       = "Automatically retry failed downloads."
+  
+  attr_accessor :manifest,
+                :prefix,
+                :privatekey,
+                :directory,
+                :retry
+    
+  #----------------------------------------------------------------------------#
+
+  def mandatory_params()
+    super()
+    
+    on('-k', '--privatekey KEY', String, USER_PK_PATH_DESCRIPTION) do |privatekey|
+      assert_file_exists(privatekey, '--privatekey')
+      @privatekey = privatekey
+    end
+  end
+
+  #----------------------------------------------------------------------------#
+
+  def optional_params()
+    super()
+    
+    on('-m', '--manifest FILE', String, *MANIFEST_DESCRIPTION) do |manifest|
+      assert_good_key(manifest, '--manifest')
+      @manifest = manifest
+    end
+    
+    on('-p', '--prefix PREFIX', String, PREFIX_DESCRIPTION) do |prefix|
+      assert_good_key(prefix, '--prefix')
+      @prefix = prefix
+    end
+    
+    on('-d', '--directory DIRECTORY', String, *DIRECTORY_DESCRIPTION) do |directory|
+      assert_directory_exists(directory, '--directory')
+      @directory = directory
+    end
+    
+    on('--retry', RETRY_DESCRIPTION) do
+      @retry = true
+    end
+  end
+  
+  #----------------------------------------------------------------------------#
+
+  def validate_params()
+    super()
+    raise MissingMandatory.new('--privatekey') unless @privatekey
+    raise InvalidCombination.new('--prefix', '--manifest') if (@prefix and @manifest)
+  end
+
+  #----------------------------------------------------------------------------#
+
+  def set_defaults()
+    super()
+    @directory = Dir::pwd() unless @directory
+    @prefix = @manifest.split('.')[0..-2].join('.') if (@manifest)
+    @prefix = 'image' unless @prefix
+    @manifest = "#{@prefix}.manifest.xml" unless @manifest
+  end
+  
+end

data/lib/ec2/amitools/exception.rb

@@ -0,0 +1,86 @@
+# 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.
+
+##
+# An exception thrown to indicate an unrecoverable error has been encountered.
+# The process should be terminated and the exception's message should be
+# displayed to the user.
+#
+class FatalError < Exception
+  ##
+  # ((|message|)) The message that should be displayed to the user.
+  # ((|cause|))  The exception that caused the fatal error.
+  #
+  def initialize(message, cause = nil)
+    super(message)
+    @cause = cause
+  end
+end
+
+#------------------------------------------------------------------------------#
+
+##
+# File access error.
+#
+class FileError < FatalError
+  def initialize(filename, error_description, sys_call_err = nil)
+      message = "File Error: #{error_description} \n" +
+                "File name: #{filename}\n"
+      super(message, sys_call_err)
+  end
+end
+
+#------------------------------------------------------------------------------#
+
+##
+# Directory access exception.
+#
+class DirectoryError < FatalError
+  def initialize(dirname, error_description, sys_call_err = nil)
+    message =	"Directory Error: #{error_description} \n" +
+                "Directory name: #{dirname} \n"
+    super(message, sys_call_error)
+  end
+end
+
+#----------------------------------------------------------------------------#
+
+class DownloadError < FatalError
+  def initialize(resource, addr, port, path, error=nil)
+    super("could not download #{resource} from #{addr}/#{path} on #{port}", error)
+  end
+end
+
+#----------------------------------------------------------------------------#
+
+class UploadError < FatalError
+  def initialize(resource, addr, port, path, error=nil)
+    super("could not upload #{resource} to #{addr}/#{path} on #{port}", error)
+  end
+end
+
+#------------------------------------------------------------------------------#
+
+##
+# Parameter error.
+#
+class ParameterError < FatalError
+  def initialize(message)
+    super(message)
+  end
+end
+
+#------------------------------------------------------------------------------#
+
+class AMIInvalid < FatalError
+  def initialize(message)
+    super(message)
+  end
+end

data/lib/ec2/amitools/fileutil.rb

@@ -0,0 +1,219 @@
+# 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.
+
+# Utility class and methods.
+
+require 'ec2/amitools/exception'
+require 'tmpdir'
+require 'fileutils'
+require 'pathname'
+require 'tempfile'
+require 'zlib'
+
+##
+# Module containing file utility methods.
+#
+module FileUtil
+  include Zlib
+  BUFFER_SIZE = 1024 * 1024	# Buffer size in bytes.
+  PART_SUFFIX = '.part.'
+
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Assert the specified file exists.
+  # An exception is raised if it does not.
+  #
+  def FileUtil.assert_exists(filename)
+    raise FileError(filename, 'a required file could not be found') unless exists?(filename)
+  end
+
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Compress the specified file and return the path to the temporary compressed
+  # file that will be deleted upon termination of the process.
+  #
+  def FileUtil.compress(filename)
+    outfilename = filename+'.gz'    
+    GzipWriter.open(outfilename) do |outfile|
+      begin
+        File.open(filename, 'r') do |infile|
+          while not (infile.eof)
+             outfile.write(infile.read(BUFFER_SIZE))
+          end
+        end
+      ensure
+
+      end
+    end
+    outfilename
+  end
+
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Expand ((|src_filename|)) to ((|dst_filename|)).
+  #
+  def FileUtil.expand(src_filename, dst_filename)
+    GzipReader.open(src_filename) do |gzfile|
+      File.open(dst_filename, 'w') do |file|
+        while not (gzfile.eof?)
+          file.write(gzfile.read(BUFFER_SIZE))
+        end
+      end
+    end
+  end
+
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Split the specified file into chunks of the specified size.
+  # yields the <file,chunk,chunk size> to a block which writes the actual chunks
+  # The chunks are output to the local directory.
+  # Typical invocation looks like:
+  # FileUtil.split('file',5){|sf,cf,cs| ChunkWriter.write_chunk(sf,cf,cs)}
+  #
+  # ((|filename|)) The file to split.
+  # ((|part_name_prefix|)) The prefix for the parts filenames.
+  # ((|cb_size|)) The chunk size in bytes.
+  # ((|dst_dir|)) The destination to create the file parts in.
+  #
+  # Returns a list of the created filenames.
+  #
+  def FileUtil.split(filename, part_name_prefix, cb_size, dst_dir)
+    begin
+      # Check file exists and is accessible.
+      begin
+        file = File.new(filename, File::RDONLY)
+      rescue SystemCallError => e
+        raise FileError.new(filename, "could not open file to split", e)
+      end
+      
+      # Create the part file upfront to catch any creation/access errors
+      # before writing out data.
+      nr_parts = (Float(File.size(filename)) / Float(cb_size)).ceil
+      part_names = []
+      nr_parts.times do |i|
+        begin
+          nr_parts_digits = nr_parts.to_s.length
+          part_name_suffix = PART_SUFFIX + i.to_s.rjust(nr_parts_digits).gsub(' ', '0')
+          part_names[i] = part_name = part_name_prefix + part_name_suffix
+          FileUtils.touch File.join(dst_dir, part_name)
+        rescue SystemCallError => e
+          raise FileError.new(filename, "could not create part file", e)
+        end
+      end
+      
+      # Write parts to files.
+      part_names.each do |part_file_name|
+        File.open(File.join(dst_dir, part_file_name), 'w+') do |pf|
+          write_chunk(file, pf, cb_size)
+        end
+      end
+
+      part_names
+    ensure
+      file.close if not file.nil?
+    end
+  end
+
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Concatenate the specified files into a single file.
+  # If the specified output file already exists it will be overwritten.
+  # ((|filenames|)) An ordered collection of the names of split files.
+  # ((|out_filename|)) The output filename.
+  #
+  def FileUtil.cat(filenames, out_filename)
+    File.open(out_filename, 'w') do |of|
+      filenames.each do |filename|
+        File.open(filename) do |file|
+          while not (file.eof?)
+            of.write(file.read(BUFFER_SIZE))
+            of.flush
+          end
+        end
+      end
+    end
+  end 
+
+  #----------------------------------------------------------------------------#
+  
+  def FileUtil.exists?(fullname)
+    FileTest.exists?(fullname)
+  end
+  
+  #----------------------------------------------------------------------------#
+  
+  def FileUtil.directory?(fullname)
+    File::Stat.new(fullname).directory?
+  end
+  
+  #----------------------------------------------------------------------------#
+  
+  def FileUtil.symlink?(fullname)
+    File::Stat.new(fullname).symlink?
+  end
+
+  #----------------------------------------------------------------------------#
+
+  def FileUtil.tempdir(basename, tmpdir=Dir::tmpdir, tries=10)
+    tmpdir = '/tmp' if $SAFE > 0 and tmpdir.tainted?
+    fail = 0
+    tmpname = nil
+    begin
+      begin
+        tmpname = File.join(tmpdir, sprintf('%s%d.%s', basename, $$, Time.now.to_f.to_s))
+      end until !File.exist? tmpname
+    rescue
+      fail += 1
+      retry if fail < tries
+      raise "failed to generate a temporary directory name '%s'" % tmpname
+    end
+    tmpname
+  end
+
+
+  #----------------------------------------------------------------------------#
+
+  def FileUtil.size(f)
+    total =  `du -s #{f}`.split[0].to_i rescue nil
+    if total.nil? or $?.exitstatus != 0
+      total = 0
+      Find.find(f) do |s| 
+        total += File.directory?(s) ? 0 : File.size(s)
+      end
+    end
+    total
+  end
+  
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Write chunk to file.
+  # ((|sf|)) Source file.
+  # ((|cf|)) Chunk file.
+  # ((|cs|)) Chunk size in bytes.
+  # Returns true if eof was encountered.
+  #  
+  def FileUtil.write_chunk(sf, cf, cs)
+    cb_written = 0  # Bytes written.
+    cb_left = cs    # Bytes left to write in this chunk.
+    while (!sf.eof? && cb_left > 0) do
+      buf = sf.read(BUFFER_SIZE < cb_left ? BUFFER_SIZE : cb_left)
+      cf.write(buf)
+      cb_written += buf.length
+      cb_left = cs - cb_written
+    end
+    sf.eof
+  end 
+end

data/lib/ec2/amitools/format.rb

@@ -0,0 +1,127 @@
+# 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 'stringio'
+
+module Format
+
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Convert the binary data ((|data|)) to an ASCII string of hexadecimal digits
+  # that represents it.
+  #
+  # E.g. if ((|data|)) is the string of bytes 0x1, 0x1A, 0xFF, it is converted
+  # to the string "011AFF".
+  #
+  def Format.bin2hex(data)
+    hex = StringIO.new
+    data.unpack('H*').each {|digit| hex.write(digit)}
+    hex.string
+  end
+
+  #----------------------------------------------------------------------------#
+  
+  ##
+  # Breaks ((|data|)) into blocks of size ((|blocksize|)). The last block maybe
+  # less than ((|blocksize||).
+  #
+  def Format.block(data, blocksize)
+    blocks = Array.new
+    read = 0
+    while read < data.size
+      left = data.size - read
+      blocks << data[read, (left < blocksize) ? left : blocksize]
+      read += (left < blocksize ? left : blocksize)
+    end
+    
+    blocks
+  end
+
+  #----------------------------------------------------------------------------#
+  
+  ##
+  # Convert ASCII string of hexadecimal digits ((|hex|)) into the binary data it
+  # represents. If there are an odd number of hexedecimal digits in ((|hex|)) it
+  # is left padded with a leading '0' character.
+  #
+  # E.g. if ((|hex|)) is "11AFF", it is converted to the string of bytes 0x1,
+  # 0x1A, 0xFF.
+  #
+  def Format.hex2bin(hex)
+    hex = '0' + hex unless (hex.size % 2) == 0
+    data = StringIO.new
+    [[hex].pack('H*')].each {|digit| data.write(digit)}
+    data.string
+  end
+
+  #----------------------------------------------------------------------------#
+
+  ##
+  # Return a single character string containing ((|int|)) converted to a single
+  # byte unsigned integer. The operand must be less than 256.
+  #
+  def Format.int2byte int
+    raise ArgumentError.new('argument greater than 255') unless int < 256
+    int.chr
+  end
+
+  #----------------------------------------------------------------------------#
+
+  # Convert integer _i_ to an unsigned 16 bit int packed into two bytes in big
+  # endian order.
+  def Format::int2int16( i )
+    raise ArgumentError.new( 'argument greater than 65535' ) unless i < 65536
+    hi_byte = ( i >> 8 ).chr
+    lo_byte = ( i & 0xFF).chr
+    return [ hi_byte, lo_byte ]
+  end
+
+  #----------------------------------------------------------------------------#
+  
+  ##
+  # Pad data string ((|data|)) according to the PKCS #7 padding scheme.
+  #
+  def Format.pad_pkcs7(data, blocksize)
+    raise ArgumentError.new("invalid data: #{data.to_s}") unless data and data.kind_of? String
+    raise ArgumentError.new("illegal blocksize: #{blocksize}") unless blocksize > 0x0 and blocksize < 0xFF
+    
+    # Determine the number of padding characters required. If the data size is
+    # divisible by the blocksize, a block of padding is required.
+    nr_padchars = blocksize - (data.size % blocksize)
+    nr_padchars = blocksize unless nr_padchars != 0
+    
+    # Create padding, where the padding byte is the number of padding bytes.
+    padchar = nr_padchars.chr
+    padding = padchar * nr_padchars
+    
+    data + padding
+  end
+  
+  #----------------------------------------------------------------------------#
+  
+  ##
+  # Pad ((|data|)) according to the PKCS #7 padding scheme.
+  #
+  def Format.unpad_pkcs7(data, blocksize)
+    raise ArgumentError.new("illegal blocksize: #{blocksize}") unless blocksize > 0x0 and blocksize < 0xFF
+    raise ArgumentError.new("invalid data: #{data.to_s}") unless data and data.kind_of? String 
+    raise ArgumentError.new("invalid data size: #{data.size}") unless data.size > 0 and (data.size % blocksize) == 0
+    
+    nr_padchars = data[data.size - 1]
+    raise ArgumentError.new("data padding character invalid: #{nr_padchars}") unless (nr_padchars > 0 and nr_padchars <= blocksize)
+    
+    data[0, data.size - nr_padchars]
+  end
+  
+  
+  
+  
+end