swirl 1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007, 2008, 2009 Blake Mizerany
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+Swirl
+=====
+
+Swirl is an EC2 version agnostic client for EC2 writtin in Ruby. It gets
+out of your way.
+
+The secret is it's simple input extraction and output compacting.  Your
+input parameters and `expand`ed and EC2's (terrible) xml output is
+`compact`ed.
+
+
+Some simple examples:
+
+    # Input
+    { "InstanceId" => ["i-123k2h1", "i-0234d3"] }
+
+is `expand`ed to:
+
+    { "InstanceId.0" => "i-123k2h1", "InstanceId.1" => "i-0234d3" }
+
+and
+
+    # Output
+    {
+      "reservationSet" => {
+        "item" => {
+          "instancesSet" => { "item" => [ ... ] }
+        }
+      }
+    }
+
+and it's varations are now `compact`ed to:
+
+  {
+    "reservationSet" => {
+      "instancesSet" => [ { ... }, { ... } ]
+    }
+  }
+
+
+Some things worth noteing is that compact ignores Symbols.  This
+allows you to pass the params into `call` and use them later
+without affecting the API call (i.e. chain of responsiblity); a
+nifty trick we use in (Rack)[http://github.com/rack/rack]
+
+Use
+---
+
+    ec2 = Swirl::EC2.new
+
+    # Describe all instances
+    ec2.call "DescribeInstances"
+
+    # Describe specific instances
+    ec2.call "DescribeInstances", "InstanceId" => ["i-38hdk2f", "i-93nndch"]
+
+
+Shell
+---
+
+    $ swirl
+    >> c
+    <Swirl::EC2 ... >
+    >> c.call "DescribeInstances"
+    ...
+
+The shell respects your ~/.swirl file for configuration

data/bin/swirl

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require 'irb'
+require 'swirl'
+
+def c
+  @c ||= Swirl::EC2.new
+end
+
+if $0 =~ %r|/swirl|
+  IRB.start(__FILE__)
+end

data/lib/swirl.rb

@@ -0,0 +1 @@
+require 'swirl/ec2'

data/lib/swirl/ec2.rb

@@ -0,0 +1,114 @@
+require 'yaml'
+require 'cgi'
+require 'base64'
+require 'net/https'
+
+require 'crack/xml'
+require 'hmac-sha2'
+
+require 'swirl/helpers'
+
+module Swirl
+
+  ## Errors
+  class InvalidRequest < StandardError ; end
+
+
+  class EC2
+    include Helpers::Compactor
+    include Helpers::Expander
+
+
+    def self.options(name=:default, file="~/.swirl")
+      YAML.load_file(File.expand_path(file))[name]
+    end
+
+    def initialize(options={}, file="~/.swirl")
+      account = options.fetch(:account) { :default }
+      options = self.class.options(account, file).merge(options)
+
+      @aws_access_key_id = options[:aws_access_key_id]
+      @aws_secret_access_key = options[:aws_secret_access_key]
+      @hmac = HMAC::SHA256.new(@aws_secret_access_key)
+      @version = options[:version] || "2009-11-30"
+      @url = URI(options[:url] || "https://ec2.amazonaws.com")
+    end
+
+    def escape(value)
+      CGI.escape(value).gsub(/\+/, "%20")
+    end
+
+    def compile_sorted_form_data(query)
+      valid = query.reject {|_, v| v.nil? }
+      valid.sort.map {|k,v| [k, escape(v)] * "=" } * "&"
+    end
+
+    def compile_signature(method, body)
+      string_to_sign = [method, @url.host, "/", body] * "\n"
+      hmac = @hmac.update(string_to_sign)
+      encoded_sig = Base64.encode64(hmac.digest).chomp
+      escape(encoded_sig)
+    end
+
+    ##
+    # Execute an EC2 command, expand the input,
+    # and compact the output
+    #
+    # Examples:
+    #   ec2.call("DescribeInstances")
+    #   ec2.call("TerminateInstances", "InstanceId" => ["i-1234", "i-993j"]
+    #
+    def call(action, query={})
+      code, data = call!(action, expand(query))
+
+      case code
+      when 200
+        compact(data)
+      when 400...500
+        messages = Array(data["Response"]["Errors"]).map {|_, e| e["Message"] }
+        raise InvalidRequest, messages.join(",")
+      else
+        msg = "unexpected response #{response.code} -> #{data.inspect}"
+        raise InvalidRequest, msg
+      end
+    end
+
+    def call!(action, query={})
+      # Hard coding this here until otherwise needed
+      method = "POST"
+
+      query["Action"] = action
+      query["AWSAccessKeyId"] = @aws_access_key_id
+      query["SignatureMethod"] = "HmacSHA256"
+      query["SignatureVersion"] = "2"
+      query["Timestamp"] = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      query["Version"] = @version
+
+      body = compile_sorted_form_data(query)
+      body += "&" + ["Signature", compile_signature(method, body)].join("=")
+
+      response = post(body)
+      data = Crack::XML.parse(response.body)
+      [response.code.to_i, data]
+    end
+
+    def post(body)
+      headers = { "Content-Type" => "application/x-www-form-urlencoded" }
+
+      http = Net::HTTP.new(@url.host, @url.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      request = Net::HTTP::Post.new(@url.request_uri, headers)
+      request.body = body
+
+      http.request(request)
+    end
+
+    def inspect
+      "<#{self.class.name} version: #{@version} url: #{@url} aws_access_key_id: #{@aws_access_key_id}>"
+    end
+
+  end
+
+end

data/lib/swirl/helpers.rb

@@ -0,0 +1,108 @@
+module Swirl
+
+  module Helpers
+
+    module Compactor
+
+      Lists = [
+        "keySet",
+        "groupSet",
+        "blockDeviceMapping",
+        "instancesSet",
+        "reservationSet",
+        "imagesSet",
+        "ownersSet",
+        "executableBySet",
+        "securityGroupSet",
+        "ipPermissions",
+        "ipRanges",
+        "groups",
+        "securityGroupInfo",
+        "add",
+        "remove",
+        "launchPermission",
+        "productCodes",
+        "availabilityZoneSet",
+        "availabilityZoneInfo",
+        "publicIpsSet",
+        "addressesSet"
+      ]
+
+      def compact(response)
+        root_key = response.keys.first
+        base = response[root_key]
+        compact!(base)
+      end
+      module_function :compact
+
+      def compact!(data)
+        data.inject({}) do |com, (key, value)|
+          if Lists.include?(key)
+            converted = if value && value.has_key?("item")
+              items = value["item"]
+              items ||= []
+              items = items.is_a?(Array) ? items : [items]
+              items.map {|item| compact!(item) }
+            else
+              []
+            end
+            com[key] = converted
+          elsif key == "xmlns"
+            next(com)
+          else
+            com[key] = value
+          end
+          com
+        end
+      end
+      module_function :compact!
+
+    end
+
+    module Expander
+      def expand(request)
+        request.inject({}) do |exp, (key, value)|
+          next(exp) if !key.is_a?(String)
+
+          case value
+          when Array
+            value.each_with_index do |val, n|
+              exp["#{key}.#{n}"] = val
+            end
+          when Range
+            exp["From#{key}"] = value.min
+            exp["To#{key}"] = value.max
+          else
+            exp[key] = value
+          end
+          exp
+        end
+      end
+      module_function :expand
+    end
+
+    module Slop
+      class InvalidKey < StandardError ; end
+
+      def self.new(response)
+        sloppy = Hash.new do |hash, key|
+          camalized = Slop.camalize(key)
+          raise InvalidKey, key if !response.has_key?(camalized)
+          response[camalized]
+        end
+      end
+
+      def self.camalize(stringish)
+        head, tail = stringish.to_s.split("_")
+        rest = Array(tail).map! {|part| part.capitalize }
+        [head, *rest].join
+      end
+
+      def slopify(response)
+        Slop.new(response)
+      end
+    end
+
+  end
+
+end

data/list-types

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'nokogiri'
+rescue LoadError
+  abort <<-MSG
+Unable to load nokogiri.
+  Ensure you have it installed and/or
+  export RUBYOPT=rubygems
+  MSG
+end
+
+require 'open-uri'
+require 'stringio'
+require 'pp'
+
+DefaultWSDL = "http://s3.amazonaws.com/ec2-downloads/2008-02-01.ec2.wsdl"
+
+wsdl_url = ARGV.shift || DefaultWSDL
+Wsdl = Nokogiri::XML.parse(open(wsdl_url))
+
+##__END__
+
+list_keys = []
+item_types = Wsdl.search(%Q|//xs:complexType//xs:element[@name="item"]|)
+item_types.each do |item_type|
+  ns, name = item_type["type"].split(":")
+  next if ns != "tns"
+  complex = item_type.parent.parent
+  uses = Wsdl.search(%Q|//xs:element[@type="#{ns}:#{complex["name"]}"]|)
+  uses.each do |u|
+    list_keys << u["name"]
+  end
+end
+
+pp list_keys.uniq

data/test/compactor_test.rb

@@ -0,0 +1,73 @@
+require 'contest'
+require 'swirl/helpers'
+
+class CompactorTest < Test::Unit::TestCase
+  include Swirl::Helpers
+
+  test "pivots on root" do
+    response = { "Foo" => { "requestId" => "abc123" } }
+    expected = { "requestId" => "abc123" }
+
+    assert_equal expected, Compactor.compact(response)
+  end
+
+  test "ignores xmlns" do
+    response = { "Foo" => { "requestId" => "abc123", "xmlns" => "suckit" } }
+    expected = { "requestId" => "abc123" }
+
+    assert_equal expected, Compactor.compact(response)
+  end
+
+  test "pivots list keys on item" do
+    response = { "Foo" => { "groupSet" => { "item" => [{ "foo" => "bar" }] } } }
+    expected = { "groupSet" =>  [ { "foo" => "bar" } ] }
+
+    assert_equal expected, Compactor.compact(response)
+  end
+
+  test "pivots list keys item and converts to Array not already an Array" do
+    response = { "Foo" => { "groupSet" => { "item" => { "foo" => "bar" } } } }
+    expected = { "groupSet" =>  [ { "foo" => "bar" } ] }
+
+    assert_equal expected, Compactor.compact(response)
+  end
+
+  test "pivots list keys item and makes empty Array if nil" do
+    response = { "Foo" => { "groupSet" => { "item" => nil } } }
+    expected = { "groupSet" =>  [] }
+
+    assert_equal expected, Compactor.compact(response)
+  end
+
+  test "makes value empty Array if nil" do
+    response = { "Foo" => { "groupSet" => nil } }
+    expected = { "groupSet" =>  [] }
+
+    assert_equal expected, Compactor.compact(response)
+  end
+
+  test "traverses list values and compacts" do
+    response = {
+      "Foo" => {
+        "groupSet" => {
+          "item" => {
+            "ipPermissions" => {
+              "item" => {
+                "proto" => "tcp"
+              }
+            }
+          }
+        }
+      }
+    }
+
+    expected = {
+      "groupSet" => [
+        { "ipPermissions" => [ { "proto" => "tcp" } ] }
+      ]
+    }
+
+    assert_equal expected, Compactor.compact(response)
+  end
+
+end

data/test/expander_test.rb

@@ -0,0 +1,46 @@
+require 'contest'
+require 'swirl/helpers'
+
+class ExpanderTest < Test::Unit::TestCase
+  include Swirl::Helpers
+
+  test "leaves params as is by default" do
+    request = { "foo" => "bar" }
+
+    assert_equal request, Expander.expand(request)
+  end
+
+  test "ignores non-String keys" do
+    request = { "foo" => "bar", :ignore => "test" }
+    expected = { "foo" => "bar" }
+
+    assert_equal expected, Expander.expand(request)
+  end
+
+  test "expands Array values to .n key-values" do
+    request = { "group" => ["foo", "bar", "baz"] }
+
+    expected = {
+      "group.0" => "foo",
+      "group.1" => "bar",
+      "group.2" => "baz"
+    }
+
+    assert_equal expected, Expander.expand(request)
+  end
+
+  test "ignores empty Array values" do
+    request = { "group" => [] }
+    expected = {}
+
+    assert_equal expected, Expander.expand(request)
+  end
+
+  test "converts Key of Range to FromKey ToKey" do
+    request = { "Port" => 1..3 }
+    expected = { "FromPort" => 1, "ToPort" => 3 }
+
+    assert_equal expected, Expander.expand(request)
+  end
+
+end

data/test/slop_test.rb

@@ -0,0 +1,29 @@
+require 'contest'
+require 'swirl/helpers'
+
+class SlopTest < Test::Unit::TestCase
+  include Swirl::Helpers
+
+  test "camalize" do
+    assert_equal "foo", Slop.camalize(:foo)
+    assert_equal "fooBar", Slop.camalize(:foo_bar)
+  end
+
+  test "gets sloppy" do
+    slop = Slop.new({"fooBar" => "baz"})
+    assert_equal "baz", slop[:foo_bar]
+  end
+
+  test "honors keys already camalized" do
+    slop = Slop.new({"fooBar" => "baz"})
+    assert_equal "baz", slop["fooBar"]
+  end
+
+  test "raise InvalidKey if key not found" do
+    slop = Slop.new({})
+    assert_raises Slop::InvalidKey do
+      slop[:not_here]
+    end
+  end
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: swirl
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Blake Mizerany
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-26 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: crack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-hmac
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: contest
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.2
+    version: 
+description: A version agnostic EC2 ruby driver
+email: 
+executables: 
+- swirl
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE
+files: 
+- LICENSE
+- README.md
+- list-types
+- lib/swirl/ec2.rb
+- lib/swirl/helpers.rb
+- lib/swirl.rb
+- test/compactor_test.rb
+- test/expander_test.rb
+- test/slop_test.rb
+- bin/swirl
+has_rdoc: true
+homepage: http://github.com/bmizerany/swirl
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Sinatra
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: swirl
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: A version agnostic EC2 ruby driver
+test_files: 
+- test/compactor_test.rb
+- test/expander_test.rb
+- test/slop_test.rb