ec2_amitools 1.0.2

data/lib/ec2/amitools/version.rb

@@ -0,0 +1,33 @@
+# 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/manifestv20071010'
+
+module EC2Version
+  MANIFEST_CLASS = ManifestV20071010
+  MANIFEST_VERSION = MANIFEST_CLASS.version
+  PKG_NAME = 'ec2-ami-tools'
+  PKG_VERSION = '1.5'
+  PKG_RELEASE = '7'
+
+  COPYRIGHT_NOTICE = <<CNOTICE
+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.
+CNOTICE
+  
+  def self.version_copyright_string()
+    "#{PKG_VERSION}.#{PKG_RELEASE} #{MANIFEST_VERSION}\n\n" + COPYRIGHT_NOTICE + "\n"
+  end
+end

data/lib/ec2/amitools/xmlbuilder.rb

@@ -0,0 +1,237 @@
+# 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.
+
+# This class makes it easy to build up xml docs, xpath style.
+# Usage:
+#
+# # Create an XMLBuilder:
+# doc = REXML::Document.new(some_xml)
+# builder = XMLBuilder.new(doc)
+# # Add some text elements
+# builder[/book/title] = 'Atlas Shrugged'
+# builder[/book/author] = 'Ann Raynd'
+# # Add an attribute
+# builder[/book/author@salutation] = 'Mrs.'
+#
+# Results in the following xml:
+# <book>
+#   <title>Atlas Shrugged</title>
+#   <author salutation="Mrs.">Ann Raynd</author>
+# </book>
+#
+# Notes on Usage:
+# - If the path starts with a '/' the path is absolute.
+# - If the path does not start with a '/' the path is relative.
+# - When adding an element the return value is an xml builder object anchored at that path
+# - When adding an attrubte the return value is ... ??? dunno what is should be. nil?
+# - To set the element value use XMLBuilder[]=(string) or XMLBuilder[]=(XMLBuilder) or XMLBuilder[]=(node)
+# - To add an element do builder[path] << string or builder[path] << element or builder[path] << node 
+# - If you assign a nil value the value will not be set and the path elements not created.
+
+require 'rexml/document'
+
+class XMLBuilder
+
+  attr_reader :root
+  
+  # Create a new XMLBuilder rooted at the given element, or at a new document if no root is given
+  def initialize(root = nil)
+    @root = root || REXML::Document.new()
+  end
+
+  # Retrieve a builder for the element at the given path
+  def [](path)
+    nodes = PathParser.parse(path)
+    rexml_node = nodes.inject(@root) do |rexml_node, parser_node|
+      parser_node.walk_visit(rexml_node)
+    end
+    XMLBuilder.new(nodes.last.retrieve_visit(rexml_node))
+  end
+
+  # Set the value of the element or attribute at the given path
+  def []=(path, value)
+    # Don't create elements or make assignments for nil values
+    return if value.nil?
+    nodes = PathParser.parse(path)
+    rexml_node = nodes.inject(@root) do |rexml_node, parser_node|
+      parser_node.walk_visit(rexml_node)
+    end
+    nodes.last.assign_visit(rexml_node, value)
+  end
+
+  # Parses an xpath like expression
+  class PathParser
+    def PathParser.parse(path)
+      nodes = path.split('/')
+      @nodes = []
+      first = true
+
+      while (nodes.length > 0)
+        node = Node.new(first, nodes)
+        first = false
+        @nodes << Document.new() if node.document
+        @nodes << Element.new(node.element, node.index) if node.element
+        @nodes << Attribute.new(node.attribute) if node.attribute
+      end
+      @nodes
+    end
+
+    # Helper class used by PathParser
+    class Node
+      attr_reader :document
+      attr_reader :element
+      attr_reader :index
+      attr_reader :attribute
+
+      # Regex for parsing path if the form element[index]@attribute
+      # where [index] and @attribute are optional
+      @@attribute_regex = /^@(\w+)$/
+      @@node_regex = /^(\w+)(?:\[(\d+)\])?(?:@(\w+))?$/
+
+      # Nodes is path.split('/')
+      def initialize(allow_document, nodes)
+        if allow_document && nodes[0] == ''
+          @document = true
+          nodes.shift
+          return
+        end
+        nodes.shift while nodes[0] == ''
+        node = nodes.shift
+        if (match = @@node_regex.match(node))
+          @element = match[1]
+          @index = match[2].to_i || 0
+        elsif (match = @@attribute_regex.match(node))
+          @attribute = match[1]
+        else
+          raise 'Invalid path: Node must be of the form element[index] or @attribute' if document
+        end
+      end
+    end
+
+    # Node classes
+    # Each class represents a node type. An array of these classes is built up when
+    # the path is parsed. Each node is then visited by the current rexml node and 
+    # (depending on which visit function is called) the action taken.
+    #
+    # The visit function are:
+    #  - walk: Walks down the xml dom
+    #  - assign: Assigns the value to rexml node
+    #  - retrieve: Retrives the value of the rexml node
+    #
+    #  Different node types implement different behaviour types. For example retrieve is 
+    #  illegal on Attribute nodes, but on Document and Attribute nodes the given node is returned.
+
+    class Document
+      def initialize()
+      end
+
+      # Move to the document node (top of the xml dom)
+      def walk_visit(rexml_node)
+        return rexml_node if rexml_node.is_a?(REXML::Document)
+        raise "No document set on node. #{rexml_node.name}" if rexml_node.document == nil
+        rexml_node.document
+      end
+
+      def assign_visit(document_node, value)
+        raise 'Can only assign REXML::Elements to document nodes' if !value.is_a?(REXML::Element)
+        raise 'Expected a document node' if !document_node.is_a?(REXML::Element)
+        if doc.root
+          doc.replace_child(doc.root, value)
+        else
+          doc.add_element(element)
+        end
+      end
+
+      def retrieve_visit(document_node)
+        document_node
+      end
+    end
+
+    class Element
+      attr_reader :name
+      attr_reader :index
+
+      def initialize(name, index)
+        @name = name
+        @index = index
+      end
+
+      # Move one element down in the dom
+      def walk_visit(rexml_node)
+        elements = rexml_node.get_elements(name)
+        raise "Invalid index #{index} for element #{@name}" if @index > elements.length
+        # Create a node if it doesn't exist
+        if @index == elements.length
+          new_element = REXML::Element.new(@name)
+          rexml_node.add_element(new_element)
+          new_element
+        else
+          elements[@index]
+        end
+      end
+
+      def assign_visit(rexml_node, value)
+        if value.is_a?(String)
+          rexml_node.text = value
+        elsif value.is_a?(REXML::Element)
+          value.name = rexml_node.name
+          raise "Node #{rexml_node.name} does not have a parent node" if rexml_node.parent.nil?
+          rexml_node.parent.replace_child(rexml_node, value)
+        else
+          raise 'Can only assign a String or a REXML::Element to an element'
+        end
+      end
+
+      def retrieve_visit(rexml_node)
+        rexml_node
+      end
+    end
+
+    class Attribute
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      # Stays on the same node in the dom
+      def walk_visit(rexml_node)
+        rexml_node
+      end
+
+      def assign_visit(rexml_node, value)
+        raise 'Can only assign an attribute to an element.' if !rexml_node.is_a?(REXML::Element)
+        rexml_node.attributes[@name] = value.to_s
+      end
+      
+      def retrieve_visit(rexml_node)
+        raise 'Accessor not valid for paths with an attribute'
+      end
+    end
+  end
+
+end
+
+# Test code
+if $0 == __FILE__
+  
+  def assert_true(expr)
+    raise 'expected true' if !expr
+  end
+  
+  doc = REXML::Document.new()
+  builder = XMLBuilder.new(doc)
+  root_builder = builder['/root']
+  root_builder['nested'] = 'more text'
+  root_builder['/root/bnode'] = 'name'
+  root_builder['/root/bnode/@attr'] = 'attr'
+  puts doc
+end
+

data/lib/ec2/amitools/xmlutil.rb

@@ -0,0 +1,55 @@
+# 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 'rexml/document'
+require 'stringio'
+
+# Module containing utility XML manipulation functions.
+module XMLUtil
+  # Extract the string representation of the specified XML element name
+  # _element_name_ from the XML string _xml_data_
+  def XMLUtil.get_xml(xml_data, element_name)
+    start_tag = '<'+element_name+'>'
+    end_tag = '</'+element_name+'>'
+    return nil if (start_idx = xml_data.index(start_tag)).nil?
+    return nil if (end_idx = xml_data.index(end_tag)).nil?
+    end_idx += end_tag.size - 1
+    xml_data[start_idx..end_idx]
+  end
+
+  #----------------------------------------------------------------------------#
+
+  # Trivially escape the XML string _xml_, by making the following substitutions:
+  # * & for &amp;
+  # * < for &lt;
+  # * > for &gt;
+  # Return the escaped XML string.
+  def XMLUtil::escape( xml )
+    escaped_xml = xml.gsub( '&', '&amp;' )
+    escaped_xml.gsub!( '<', '&lt;' )
+    escaped_xml.gsub!( '>', '&gt;' )
+    return escaped_xml
+  end
+  
+  #----------------------------------------------------------------------------#
+  
+  # Trivially unescape the escaped XML string _escaped_xml_, by making the
+  # following substitutions:
+  # * &amp; for &
+  # * &lt; for <
+  # * &gt; for >
+  # Return the XML string.
+  def XMLUtil::unescape( escaped_xml )
+    xml = escaped_xml.gsub( '&lt;', '<' )
+    xml.gsub!( '&gt;', '>' )
+    xml.gsub!( '&amp;', '&' )
+    return xml
+  end
+end

data/lib/ec2/common/constants.rb

@@ -0,0 +1,16 @@
+# 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 EC2
+  module Common
+    SIGV2 = '2'
+    SIGV4 = '4'
+  end
+end

data/lib/ec2/common/curl.rb

@@ -0,0 +1,110 @@
+# 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.
+
+# -----------------------------------------------------------------------------
+# This is a light ruby wrapper around the curl command-line utility.
+# Unless the run with the -f/--fail flag, the curl utility returns an exit-code 
+# of value 0 for requests that produce responses with HTTP errors codes greater 
+# than or equal to 400; it returns 22 and swallows the response. This wrapper 
+# attempts to emulate the -f/--fail flag while making available response codes
+# with minimal verbosity.
+# -----------------------------------------------------------------------------
+require 'ec2/oem/open4'
+require 'tmpdir'
+
+module EC2
+  module Common
+    module Curl
+      class Error < RuntimeError
+        attr_reader :code
+        def initialize(message, code=22)
+          super message
+          @code = code
+        end
+      end
+      class Response
+        attr_reader :code, :type
+        def initialize(code, type)
+          @code = code.to_i
+          @type = type
+        end
+        def success?
+          (200..299).include? @code
+        end
+        def redirect?
+          (300..399).include? @code
+        end
+        def text?
+          @type =~ /(text|xml)/
+        end
+      end
+      
+      class Result
+        attr_reader :stdout, :stderr, :status, :response
+        def initialize(stdout, stderr, status, response = nil)
+          unless response.nil? or response.is_a? EC2::Common::Curl::Response
+            raise ArgumentError.new('invalid response argument')
+          end
+          @stdout  = stdout
+          @stderr  = stderr
+          @status  = status
+          @response= response
+        end
+        def success?
+          @status == 0
+        end
+      end
+      
+      def self.invoke(command, debug=false)
+        invocation =  "curl -sSL #{command}"
+#         invocation =  "curl -vsSL #{command}" if debug
+        invocation << ' -w "Response-Code: %{http_code}\nContent-Type: %{content_type}"'
+        STDERR.puts invocation if debug
+        pid, stdin, stdout, stderr = Open4::popen4(invocation)
+        pid, status = Process::waitpid2 pid
+        [status, stdout, stderr]
+      end
+
+      def self.print_error(command, status, out, err)
+        puts "----COMMAND------------------"
+        puts command
+        puts "----EXIT-CODE----------------"
+        puts status.exitstatus.inspect
+        puts "----STDOUT-------------------"
+        puts out
+        puts "----STDERR-------------------"
+        puts err
+        puts "-----------------------------"
+      end
+
+      def self.execute(command, debug = false)
+        status, stdout, stderr = self.invoke(command, debug)
+        out = stdout.read
+        err = stderr.read
+        if status.exitstatus == 0
+          code, type = out.chomp.split("\n").zip(['Response-Code', 'Content-Type']).map do |line, name|
+            (m = Regexp.new("^#{name}: (\\S+)$").match(line.chomp)) ? m.captures[0] : nil
+          end
+          if code.nil?
+            self.print_error(command, status, out, err) if debug
+            raise EC2::Common::Curl::Error.new(
+              'Invalid curl output for response-code. Is the server up and reachable?'
+            )
+          end
+          response = EC2::Common::Curl::Response.new(code, type)
+          return EC2::Common::Curl::Result.new(out, err, status.exitstatus, response)
+        else
+          self.print_error(command, status, out, err) if debug
+          return EC2::Common::Curl::Result.new(out, err, status.exitstatus)
+        end
+      end
+    end    
+  end
+end