bguthrie-awsymandias 0.1.1

data/.gitignore

@@ -0,0 +1,2 @@
+coverage/
+.tmtags

data/README.rdoc

@@ -0,0 +1,53 @@
+= Awsymandias
+
+== Description
+
+Awsymandias is a library that helps you set up and tear down complicated AWS environments. In addition to offering a clean, fluent domain model for working with instances and groups of instances it allows you to persist role-to-instance-id mappings to SimpleDB, allowing you to manage your stack from multiple different machines. Eventually it will allow you to add arbitrary instance metadata and help you track instance running costs over time.
+
+== Example
+
+  # Give the stack a name, and describe its members.
+  stack = Awsymandias::EC2::ApplicationStack.new("test") do |s|
+    s.role "db",  :instance_type => "m1.large", ... 
+    s.role "app", :instance_type => "c1.xlarge", ... 
+  end
+
+  # Check if we're running by pulling stack description from SDB; if not, launch asynchronously.
+  stack.launch unless stack.running? 
+  until stack.running?
+    sleep(5)
+  end
+
+  # Capistrano
+  task :test do
+    set :db, stack.db.public_dns
+    set :app, stack.app.public_dns
+  end
+
+This should allow you to re-launch and deploy that AWS stack from any one of several different workstations.
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2009 Brian Guthrie (btguthrie@gmail.com)
+
+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/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+require 'jeweler'
+
+# task :spec
+Spec::Rake::SpecTask.new do |t|
+  t.rcov = true
+  t.rcov_opts = ["--text-summary", "--include-file lib/awsymandias", "--exclude gems,spec"]
+end
+
+task :default => [:spec]
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r awsymandias"
+end
+
+Jeweler::Tasks.new do |s|
+  s.name = "awsymandias"
+  s.summary = "A library for helping you set up, track, and tear down complicated deployment configurations in Amazon EC2."
+  s.email = "btguthrie@gmail.com"
+  s.homepage = "http://github.com/bguthrie/awsymandias"
+  s.description = "A library for helping you set up, track, and tear down complicated deployment configurations in Amazon EC2."
+  s.authors = ["Brian Guthrie"]
+  
+  s.add_dependency 'activesupport', '>= 2.3.0'
+  s.add_dependency 'activeresource', '>= 2.3.0'
+  s.add_dependency 'grempe-amazon-ec2', '>= 0.4.2'
+  s.add_dependency 'money', '>= 2.1.3'
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/awsymandias.rb

@@ -0,0 +1,316 @@
+Dir[File.dirname(__FILE__) + "/../vendor/**/lib"].each { |dir| $: << dir }
+
+require 'EC2'
+require 'aws_sdb'
+require 'money'
+require 'activesupport'
+require 'activeresource'
+
+module Awsymandias
+  class << self
+    attr_writer :access_key_id, :secret_access_key
+    
+    def access_key_id
+      @access_key_id || AMAZON_ACCESS_KEY_ID || ENV['AMAZON_ACCESS_KEY_ID'] 
+    end
+    
+    def secret_access_key
+      @secret_access_key || AMAZON_SECRET_ACCESS_KEY || ENV['AMAZON_SECRET_ACCESS_KEY']
+    end
+  end
+  
+  module EC2
+    class << self
+      # Define the values for AMAZON_ACCESS_KEY_ID and AMAZON_SECRET_ACCESS_KEY_ID to allow for automatic
+      # connection creation.
+      def connection
+        @connection ||= ::EC2::Base.new(
+          :access_key_id     => Awsymandias.access_key_id     || ENV['AMAZON_ACCESS_KEY_ID'],
+          :secret_access_key => Awsymandias.secret_access_key || ENV['AMAZON_SECRET_ACCESS_KEY']
+        )
+      end
+      
+      def instance_types
+        [ 
+          Awsymandias::EC2::InstanceTypes::M1_SMALL, 
+          Awsymandias::EC2::InstanceTypes::M1_LARGE, 
+          Awsymandias::EC2::InstanceTypes::M1_XLARGE, 
+          Awsymandias::EC2::InstanceTypes::C1_MEDIUM, 
+          Awsymandias::EC2::InstanceTypes::C1_XLARGE 
+        ].index_by(&:name)
+      end
+    end
+    
+    InstanceType = Struct.new(:name, :price_per_hour)
+    
+    # All currently available instance types.
+    # TODO Generate dynamically.
+    module InstanceTypes
+      M1_SMALL  = InstanceType.new("m1.small",  Money.new(10))
+      M1_LARGE  = InstanceType.new("m1.large",  Money.new(40))
+      M1_XLARGE = InstanceType.new("m1.xlarge", Money.new(80))
+
+      C1_MEDIUM = InstanceType.new("c1.medium", Money.new(20))
+      C1_XLARGE = InstanceType.new("c1.xlarge", Money.new(80))
+    end
+        
+    # All currently availability zones.
+    # TODO Generate dynamically.
+    module AvailabilityZones
+      US_EAST_1A = "us_east_1a"
+      US_EAST_1B = "us_east_1b"
+      US_EAST_1C = "us_east_1c"
+
+      EU_WEST_1A = "eu_west_1a"
+      EU_WEST_1B = "eu_west_1b"
+    end
+  
+    # An instance represents an AWS instance as derived from a call to EC2's describe-instances methods.
+    # It wraps the simple hash structures returned by the EC2 gem with a domain model.
+    # It inherits from ARes::B in order to provide simple XML <-> domain model mapping.
+    class Instance < ActiveResource::Base
+      include ActiveSupport::CoreExtensions::Hash::Conversions::ClassMethods 
+      extend  ActiveSupport::CoreExtensions::Hash::Conversions::ClassMethods # unrename_keys
+    
+      self.site = "mu"
+    
+      def id;          instance_id;      end
+      def public_dns;  dns_name;         end
+      def private_dns; private_dns_name; end
+    
+      def pending?
+        instance_state.name == "pending"
+      end
+    
+      def running?
+        instance_state.name == "running"
+      end
+    
+      def terminated?
+        instance_state.name == "terminated"
+      end
+    
+      def terminate!
+        Awsymandias::EC2.connection.terminate_instances :instance_id => self.instance_id
+        reload
+      end
+    
+      def reload
+        load(unrename_keys(
+          EC2.connection.describe_instances(:instance_id => [ self.instance_id ])["reservationSet"]["item"].
+            first["instancesSet"]["item"].
+            first # Good lord.
+        ))
+      end
+      
+      def to_params
+        {
+          :image_id => self.image_id,
+          :key_name => self.key_name,
+          :instance_type => self.instance_type,
+          :availability_zone => self.placement.availability_zone
+        }
+      end
+      
+      def instance_type
+        Awsymandias::EC2.instance_types[@attributes['instance_type']]
+      end
+      
+      def launch_time
+        Time.parse(@attributes['launch_time'])
+      end
+      
+      def uptime
+        return 0.seconds if pending?
+        Time.now - self.launch_time
+      end
+      
+      def running_cost
+        return Money.new(0) if pending?
+        instance_type.price_per_hour * (uptime / 1.hour).ceil 
+      end
+        
+      class << self
+        def find(*args)
+          opts = args.extract_options!
+          what = args.first
+          
+          if what == :all
+            find_all(opts[:instance_ids], opts)
+          else
+            find_one(what, opts)
+          end
+        end
+        
+        def find_all(ids, opts={})
+          reservation_set = EC2.connection.describe_instances(:instance_id => ids)["reservationSet"]
+          if reservation_set.nil?
+            []
+          else
+            reservation_set["item"].first["instancesSet"]["item"].map do |item|
+              instantiate_record(unrename_keys(item))
+            end
+          end
+        end
+        
+        def find_one(id, opts={})
+          reservation_set = EC2.connection.describe_instances(:instance_id => [ id ])["reservationSet"]
+          if reservation_set.nil?
+            raise ActiveResource::ResourceNotFound, "not found: #{id}"
+          else
+            reservation_set["item"].first["instancesSet"]["item"].map do |item|
+              instantiate_record(unrename_keys(item))
+            end.first
+          end
+        end
+      
+        def launch(opts={})
+          opts.assert_valid_keys! :image_id, :key_name, :instance_type, :availability_zone, :user_data
+        
+          opts[:instance_type] = opts[:instance_type].name if opts[:instance_type].is_a?(Awsymandias::EC2::InstanceType)
+        
+          response = Awsymandias::EC2.connection.run_instances opts
+          instance_id = response["instancesSet"]["item"].map {|h| h["instanceId"]}.first
+          find(instance_id)
+        end
+      end
+    end
+      
+    # Goal:
+    # stack = EC2::ApplicationStack.new do |stack|
+    #   stack.role "db", :instance_type => EC2::InstanceTypes::C1_XLARGE, :image_id => "ami-3576915c"
+    #   stack.role "app1", "app2", "app3", :instance_type => EC2::InstanceType::M1_XLARGE, :image_id => "ami-dc789fb5"
+    #   stack.role "memcache", :instance_type => EC2::InstanceType::C1_LARGE, :image_id => "ami-dc789fb5"
+    # end
+    # stack.app1.running?
+    class ApplicationStack
+      attr_reader :name, :roles, :sdb_domain
+      
+      DEFAULT_SDB_DOMAIN = "application-stack"
+      
+      class << self
+        def find(name)
+          returning(new(name)) do |stack|
+            return nil unless stack.launched?
+          end
+        end
+        
+        def launch(name, opts={})
+          returning(new(name, opts)) do |stack|
+            stack.launch
+          end
+        end
+      end
+    
+      def initialize(name, opts={})
+        opts.assert_valid_keys! :roles
+        
+        @name       = name
+        @roles      = opts[:roles] || {}
+        @sdb_domain = opts[:sdb_domain] || DEFAULT_SDB_DOMAIN
+        @instances  = {}
+        yield self if block_given?
+      end
+    
+      def role(*names)
+        opts = names.extract_options!
+        names.each do |name|
+          @roles[name] = opts
+          self.metaclass.send(:define_method, name) { @instances[name] }
+        end
+      end
+      
+      def launch
+        @roles.each do |name, params| # TODO Optimize this for a single remote call.
+          @instances[name] = Awsymandias::EC2::Instance.launch(params)
+        end
+        store_role_to_instance_id_mapping!
+        self
+      end
+          
+      def reload
+        raise "Can't reload unless launched" unless launched?
+        @instances.values.each(&:reload) # TODO Optimize this for a single remote call.
+        self
+      end
+          
+      def terminate!
+        @instances.values.each(&:terminate!) # TODO Optimize this for a single remote call.
+        remove_role_to_instance_id_mapping!
+        self
+      end
+      
+      def launched?
+        @instances.any? || restore_from_role_to_instance_id_mapping.any?
+      end
+          
+      def running?
+        launched? && @instances.values.all?(&:running?)
+      end
+      
+      def inspect
+        ( [ "Environment #{@name}, running? #{running?}" ] + roles.map do |role_name, opts|
+          "** #{role_name}: #{opts.inspect}"
+        end ).join("\n")
+      end
+      
+      private
+            
+        def store_role_to_instance_id_mapping!
+          Awsymandias::SimpleDB.put @sdb_domain, @name, ( returning({}) do |h|
+            @instances.each {|role_name, instance| h[role_name] = instance.instance_id}
+          end )
+        end
+        
+        def remove_role_to_instance_id_mapping!
+          Awsymandias::SimpleDB.delete @sdb_domain, @name
+        end
+        
+        def restore_from_role_to_instance_id_mapping
+          @instances = returning(Awsymandias::SimpleDB.get(@sdb_domain, @name)) do |mapping|
+            unless mapping.empty?
+              live_instances = Awsymandias::EC2::Instance.find(:all, :instance_ids => mapping.values.flatten).index_by(&:instance_id)
+              mapping.each do |role_name, instance_id|
+                mapping[role_name] = live_instances[instance_id.first]
+              end
+            end
+          end
+        end
+        
+    end
+  end
+      
+  # TODO Locate a nicer SimpleDB API and get out of the business of maintaining this one.
+  module SimpleDB # :nodoc
+    class << self
+      def connection(opts={})
+        @connection ||= ::AwsSdb::Service.new({
+          :access_key_id     => Awsymandias.access_key_id     || ENV['AMAZON_ACCESS_KEY_ID'],
+          :secret_access_key => Awsymandias.secret_access_key || ENV['AMAZON_SECRET_ACCESS_KEY']
+        }.merge(opts))
+      end
+      
+      def put(domain, name, stuff)
+        connection.put_attributes handle_domain(domain), name, stuff
+      end
+      
+      def get(domain, name)
+        connection.get_attributes(handle_domain(domain), name) || {}
+      end
+      
+      def delete(domain, name)
+        connection.delete_attributes handle_domain(domain), name
+      end
+            
+      private
+      
+        def domain_exists?(domain)
+          Awsymandias::SimpleDB.connection.list_domains[0].include?(domain)
+        end      
+      
+        def handle_domain(domain)
+          returning(domain) { connection.create_domain(domain) unless domain_exists?(domain) }
+        end
+    end
+  end
+end

data/spec/awsymandias_spec.rb

@@ -0,0 +1,678 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + "/../lib/awsymandias"
+
+describe Awsymandias do
+  describe Awsymandias::SimpleDB do
+    describe "connection" do
+      it "configure an instance of AwsSdb::Service" do
+        Awsymandias.access_key_id = "configured key"
+        Awsymandias.secret_access_key = "configured secret"
+      
+        ::AwsSdb::Service.should_receive(:new).
+          with(hash_including(:access_key_id => "configured key", :secret_access_key => "configured secret")).
+          and_return(:a_connection)
+      
+        Awsymandias::SimpleDB.connection.should == :a_connection
+      end
+    end
+  end
+  
+  describe Awsymandias::EC2 do
+    def stub_connection_with(return_value)
+      Awsymandias::EC2.stub!(:connection).and_return stub("a connection", :describe_instances => return_value)
+    end
+    
+    describe "connection" do
+      it "should configure an instance of EC2::Base" do
+        Awsymandias.access_key_id = "configured key"
+        Awsymandias.secret_access_key = "configured secret"
+
+        ::EC2::Base.should_receive(:new).
+          with(hash_including(:access_key_id => "configured key", :secret_access_key => "configured secret")).
+          and_return(:a_connection)
+
+        Awsymandias::EC2.connection.should == :a_connection
+      end    
+    end
+    
+    describe Instance = Awsymandias::EC2::Instance do
+    
+      DESCRIBE_INSTANCES_NO_RESULTS_XML = {
+        "requestId" => "7bca5c7c-1b51-473e-a930-611e55920e39",
+        "xmlns"=>"http://ec2.amazonaws.com/doc/2008-12-01/",
+        "reservationSet" => nil
+      }
+  
+      DESCRIBE_INSTANCES_SINGLE_RESULT_PENDING_XML = {
+        "requestId" => "7bca5c7c-1b51-473e-a930-611e55920e39",
+        "xmlns"=>"http://ec2.amazonaws.com/doc/2008-12-01/",
+        "reservationSet" => {
+          "item" => [ {
+            "reservationId" => "r-db68e3b2", 
+            "requesterId" => "058890971305", 
+            "ownerId" => "358110980006",
+            "groupSet" => { "item" => [ { "groupId" => "default" } ] }, 
+            "instancesSet" => { "item" => [ { 
+              "productCodes" => nil, 
+              "kernelId" => "aki-some-kernel", 
+              "amiLaunchIndex" => "0", 
+              "keyName" => "gsg-keypair", 
+              "ramdiskId" => "ari-b31cf9da", 
+              "launchTime" => "2009-04-20T01:30:35.000Z", 
+              "instanceType" => "m1.large", 
+              "imageId" => "ami-some-image", 
+              "privateDnsName" => nil, 
+              "reason" => nil, 
+              "placement" => { 
+                "availabilityZone" => "us-east-1c" 
+              }, 
+              "dnsName" => nil, 
+              "instanceId" => "i-some-instance", 
+              "instanceState" => {
+                "name" => "pending", 
+                "code"=>"0" 
+              } } ] } } ] } 
+      }
+  
+      DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML = {
+        "requestId" => "7bca5c7c-1b51-473e-a930-611e55920e39",
+        "xmlns"=>"http://ec2.amazonaws.com/doc/2008-12-01/",
+        "reservationSet" => {
+          "item" => [ {
+            "reservationId" => "r-db68e3b2", 
+            "requesterId" => "058890971305", 
+            "ownerId" => "358110980006",
+            "groupSet" => { "item" => [ { "groupId" => "default" } ] }, 
+            "instancesSet" => { "item" => [ { 
+              "productCodes" => nil, 
+              "kernelId" => "aki-some-kernel", 
+              "amiLaunchIndex" => "0", 
+              "keyName" => "gsg-keypair", 
+              "ramdiskId" => "ari-b31cf9da", 
+              "launchTime" => "2009-04-20T01:30:35.000Z", 
+              "instanceType" => "m1.large", 
+              "imageId" => "ami-some-image", 
+              "privateDnsName" => nil, 
+              "reason" => nil, 
+              "placement" => { 
+                "availabilityZone" => "us-east-1c" 
+              }, 
+              "dnsName" => nil, 
+              "instanceId" => "i-some-instance", 
+              "instanceState" => {
+                "name" => "running", 
+                "code"=>"0" 
+              } } ] } } ] } 
+      }
+  
+      DESCRIBE_INSTANCES_MULTIPLE_RESULTS_RUNNING_XML = {
+        "requestId" => "7bca5c7c-1b51-473e-a930-611e55920e39",
+        "xmlns"=>"http://ec2.amazonaws.com/doc/2008-12-01/",
+        "reservationSet" => {
+          "item" => [ {
+            "reservationId" => "r-db68e3b2", 
+            "requesterId" => "058890971305", 
+            "ownerId" => "358110980006",
+            "groupSet" => { "item" => [ { "groupId" => "default" } ] }, 
+            "instancesSet" => { "item" => [ 
+              {
+                "productCodes" => nil, 
+                "kernelId" => "aki-some-kernel", 
+                "amiLaunchIndex" => "0", 
+                "keyName" => "gsg-keypair", 
+                "ramdiskId" => "ari-b31cf9da", 
+                "launchTime" => "2009-04-20T01:30:35.000Z", 
+                "instanceType" => "m1.large", 
+                "imageId" => "ami-some-image", 
+                "privateDnsName" => nil, 
+                "reason" => nil, 
+                "placement" => { 
+                  "availabilityZone" => "us-east-1c" 
+                }, 
+                "dnsName" => nil, 
+                "instanceId" => "i-some-instance", 
+                "instanceState" => {
+                  "name" => "running", 
+                  "code"=>"0" 
+                } 
+              },
+              { 
+                "productCodes" => nil, 
+                "kernelId" => "aki-some-kernel", 
+                "amiLaunchIndex" => "0", 
+                "keyName" => "gsg-keypair", 
+                "ramdiskId" => "ari-b31cf9da", 
+                "launchTime" => "2009-04-20T01:30:35.000Z", 
+                "instanceType" => "m1.large", 
+                "imageId" => "ami-some-image", 
+                "privateDnsName" => nil, 
+                "reason" => nil, 
+                "placement" => { 
+                  "availabilityZone" => "us-east-1c" 
+                }, 
+                "dnsName" => nil, 
+                "instanceId" => "i-another-instance", 
+                "instanceState" => {
+                  "name" => "pending", 
+                  "code"=>"0" 
+                } 
+              } ] } } ] } 
+      }
+  
+      RUN_INSTANCES_SINGLE_RESULT_XML = {
+        "reservationId" => "r-276ee54e", 
+        "groupSet" => { "item" => [ { 
+          "groupId" => "default" 
+        } ] }, 
+        "requestId" => "a29db909-d8ef-4a14-80c1-c53157c0cd49", 
+        "instancesSet" => { 
+          "item" => [ { 
+            "kernelId" => "aki-some-kernel", 
+            "amiLaunchIndex" => "0", 
+            "keyName" => "gsg-keypair", 
+            "ramdiskId" => "ari-b31cf9da", 
+            "launchTime" => "2009-04-20T01:39:12.000Z", 
+            "instanceType" => "m1.large", 
+            "imageId" => "ami-some-image", 
+            "privateDnsName" => nil, 
+            "reason" => nil, 
+            "placement" => { 
+              "availabilityZone" => "us-east-1a"
+            }, 
+            "dnsName" => nil, 
+            "instanceId" => "i-some-instance", 
+            "instanceState" => { 
+              "name" => "pending", 
+              "code" => "0" 
+            } 
+        } ] }, 
+        "ownerId"=>"358110980006", 
+        "xmlns"=>"http://ec2.amazonaws.com/doc/2008-12-01/"
+      }
+  
+      TERMINATE_INSTANCES_SINGLE_RESULT_XML = {
+        "requestId" => "c80c4770-eaab-45ce-972d-10e928e3f80c", 
+        "instancesSet" => {
+          "item" => [ { 
+            "previousState" => { 
+              "name" => "running", 
+              "code"=>"16"
+            }, 
+            "shutdownState" => { 
+              "name" => "shutting-down", 
+              "code" => "32"
+            }, 
+            "instanceId" => "i-some-instance" } ] }, 
+        "xmlns"=>"http://ec2.amazonaws.com/doc/2008-12-01/"
+      }
+  
+      DESCRIBE_INSTANCES_SINGLE_RESULT_TERMINATED_XML = {
+        "requestId" => "8b4fb505-de40-41b2-b18e-58f9bcba6f09", 
+        "reservationSet" => { 
+          "item" => [ { 
+            "reservationId" => "r-75961c1c", 
+            "groupSet" => { 
+              "item" => [ { 
+                "groupId" => "default" 
+              } ]
+            }, 
+            "instancesSet" => {
+              "item" => [ { 
+                "productCodes" => nil, 
+                "kernelId" => "aki-some-kernel", 
+                "amiLaunchIndex" => "0", 
+                "keyName" => "gsg-keypair", 
+                "ramdiskId" => "ari-b31cf9da", 
+                "launchTime" => "2009-04-22T00:54:06.000Z", 
+                "instanceType" => "c1.xlarge", 
+                "imageId" => "ami-some-image", 
+                "privateDnsName" => nil, 
+                "reason" => "User initiated (2009-04-22 00:59:53 GMT)", 
+                "placement" => { 
+                  "availabilityZone" => nil
+                }, 
+                "dnsName" => nil, 
+                "instanceId" => "i-some-instance", 
+                "instanceState" => { 
+                  "name" => "terminated", 
+                  "code" => "48"
+                } 
+              } ]
+            }, 
+            "ownerId" => "358110980006" 
+          } ] }, 
+        "xmlns"=>"http://ec2.amazonaws.com/doc/2008-12-01/"
+      }
+    
+      describe "find" do
+        it "should raise ActiveResource::ResourceNotFound if the given instance ID is not found" do
+          stub_connection_with DESCRIBE_INSTANCES_NO_RESULTS_XML
+          lambda do
+            Instance.find("i-some-instance")
+          end.should raise_error(ActiveResource::ResourceNotFound)
+        end
+    
+        it "should return an object with the appropriate instance ID when an instance with the given ID is found" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          Instance.find("i-some-instance").instance_id.should == "i-some-instance"
+        end
+    
+        it "should return more than one object if multiple IDs are requested" do
+          stub_connection_with DESCRIBE_INSTANCES_MULTIPLE_RESULTS_RUNNING_XML
+          Instance.find(:all, :instance_ids => ["i-some-instance", "i-another-instance"]).map(&:instance_id).should == [ "i-some-instance", "i-another-instance" ]
+        end
+    
+        it "should map camelized XML properties to Ruby-friendly underscored method names" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          instance = Instance.find("i-some-instance")
+          instance.image_id.should == "ami-some-image"
+          instance.key_name.should == "gsg-keypair"
+          instance.instance_type.should == Awsymandias::EC2.instance_types["m1.large"]
+          instance.placement.availability_zone.should == "us-east-1c"
+        end
+      end
+  
+      describe "to_params" do
+        it "should be able to reproduce a reasonable set of its launch params as a hash" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          Instance.find("i-some-instance").to_params.should == {
+            :image_id => "ami-some-image",
+            :key_name => "gsg-keypair",
+            :instance_type => Awsymandias::EC2.instance_types["m1.large"],
+            :availability_zone => "us-east-1c"
+          }
+        end
+      end
+  
+      describe "running?" do        
+        it "should return false if it contains an instances set with the given instance ID and its state is pending" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_PENDING_XML
+          Instance.find("i-some-instance").should_not be_running
+        end
+    
+        it "should return true if it contains an instances set with the given instance ID and its state is running" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          Instance.find("i-some-instance").should be_running
+        end
+      end
+  
+      describe "reload" do
+        it "should reload an instance without replacing the object" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_PENDING_XML
+          instance = Instance.find("i-some-instance")
+          instance.should_not be_running
+      
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          instance.reload.should be_running
+        end    
+      end
+    
+      describe "launch" do
+        it "should launch a new instance given some values" do
+          mock_connection = mock("a connection")
+          mock_connection.should_receive(:run_instances).with(hash_including(
+            :image_id => "an_id",
+            :key_name => "gsg-keypair",
+            :instance_type => "m1.small",
+            :availability_zone => Awsymandias::EC2::AvailabilityZones::US_EAST_1A
+          )).and_return(RUN_INSTANCES_SINGLE_RESULT_XML)
+      
+          mock_connection.should_receive(:describe_instances).and_return(DESCRIBE_INSTANCES_SINGLE_RESULT_PENDING_XML)
+      
+          Awsymandias::EC2.stub!(:connection).and_return mock_connection
+      
+          Awsymandias::EC2::Instance.launch(
+            :image_id => "an_id",
+            :key_name => "gsg-keypair",
+            :instance_type => Awsymandias::EC2::InstanceTypes::M1_SMALL,
+            :availability_zone => Awsymandias::EC2::AvailabilityZones::US_EAST_1A        
+          ).instance_id.should == "i-some-instance"
+        end
+    
+        it "should convert the instance type it's given to a string as needed" do
+          mock_connection = mock("a connection")
+          mock_connection.should_receive(:run_instances).with(hash_including(
+            :instance_type => "m1.small"
+          )).and_return(RUN_INSTANCES_SINGLE_RESULT_XML)
+          mock_connection.should_receive(:describe_instances).and_return(stub("response").as_null_object)
+          Awsymandias::EC2.stub!(:connection).and_return mock_connection
+          
+          Awsymandias::EC2::Instance.launch(:instance_type => Awsymandias::EC2::InstanceTypes::M1_SMALL)
+        end
+      end
+    
+      describe "terminate!" do
+        it "should terminate a running instance" do
+          mock_connection = mock("a connection")
+          mock_connection.should_receive(:describe_instances).and_return(
+            DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML,
+            DESCRIBE_INSTANCES_SINGLE_RESULT_TERMINATED_XML
+          )
+          mock_connection.should_receive(:terminate_instances).and_return(
+            TERMINATE_INSTANCES_SINGLE_RESULT_XML
+          )
+      
+          Awsymandias::EC2.stub!(:connection).and_return mock_connection
+      
+          instance = Awsymandias::EC2::Instance.find("a result id")
+          instance.should be_running
+          instance.terminate!
+          instance.should_not be_running
+          instance.should be_terminated
+        end
+      end
+    
+      describe "instance_type" do
+        it "should return its instance_type attribute as an InstanceType object" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          Instance.find("i-some-instance").instance_type.should == Awsymandias::EC2::InstanceTypes::M1_LARGE
+        end
+      end
+  
+      describe "launch_time" do
+        it "should return its launch_time attribute as an instance of Time" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_PENDING_XML
+          Awsymandias::EC2::Instance.find("i-some-instance").launch_time.should == Time.parse("2009-04-20T01:30:35.000Z")
+        end
+      end
+  
+      describe "uptime" do
+        it "should be zero seconds if it is not yet running" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_PENDING_XML
+          Awsymandias::EC2::Instance.find("i-some-instance").uptime.should == 0.seconds
+        end
+        
+        it "should calculate the uptime of a running instance in terms of its launch time" do
+          time_now = Time.now
+          Time.stub!(:now).and_return time_now
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          instance = Awsymandias::EC2::Instance.find("i-some-instance")
+          instance.uptime.should == (time_now - instance.launch_time)
+        end
+      end
+  
+      describe "running_cost" do
+        it "should be zero if the instance has not yet been launched" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_PENDING_XML
+          Awsymandias::EC2::Instance.find("i-some-instance").running_cost.should == Money.new(0)
+        end
+        
+        it "should be a single increment if the instance was launched 5 minutes ago" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          instance = Awsymandias::EC2::Instance.find("i-some-instance")
+          instance.attributes['launch_time'] = 5.minutes.ago.to_s
+          expected_cost = instance.instance_type.price_per_hour
+          instance.running_cost.should == expected_cost
+        end
+        
+        it "should be a single increment if the instance was launched 59 minutes ago" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          instance = Awsymandias::EC2::Instance.find("i-some-instance")
+          instance.attributes['launch_time'] = 59.minutes.ago.to_s
+          expected_cost = instance.instance_type.price_per_hour
+          instance.running_cost.should == expected_cost
+        end
+        
+        it "should be two increments if the instance was launched 61 minutes ago" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          instance = Awsymandias::EC2::Instance.find("i-some-instance")
+          instance.attributes['launch_time'] = 61.minutes.ago.to_s
+          expected_cost = instance.instance_type.price_per_hour * 2
+          instance.running_cost.should == expected_cost          
+        end
+        
+        it "should be three increments if the instance was launched 150 minutes ago" do
+          stub_connection_with DESCRIBE_INSTANCES_SINGLE_RESULT_RUNNING_XML
+          instance = Awsymandias::EC2::Instance.find("i-some-instance")
+          instance.attributes['launch_time'] = 150.minutes.ago.to_s
+          expected_cost = instance.instance_type.price_per_hour * 3
+          instance.running_cost.should == expected_cost          
+        end
+      end
+    end
+
+    describe ApplicationStack = Awsymandias::EC2::ApplicationStack do
+      class SimpleDBStub
+        def initialize
+          @store = {}
+        end
+
+        def list_domains
+          [ @store.keys ]
+        end
+
+        def put_attributes(domain, name, attributes)
+          @store[domain][name] = attributes
+        end
+
+        def get_attributes(domain, name)
+          @store[domain][name]
+        end
+  
+        def delete_attributes(domain, name)
+          @store[domain][name] = nil
+        end
+
+        def create_domain(domain)
+          @store[domain] = {}
+        end
+      end
+
+      attr_accessor :simpledb
+
+      def stub_instance(stubs={})
+        Instance.new({:instance_id => "i-12345a3c"}.merge(stubs))
+      end
+
+      before :each do
+        @simpledb = SimpleDBStub.new
+        Awsymandias::SimpleDB.stub!(:connection).and_return @simpledb
+      end
+  
+      it "should have a name" do
+        ApplicationStack.new("foo").name.should == "foo"
+      end
+
+      describe "roles" do
+        it "should be empty by default" do
+          ApplicationStack.new("foo").roles.should be_empty
+        end
+  
+        it "should be settable through the initializer" do
+          stack = ApplicationStack.new("foo", :roles => { :app1 => {} })
+          stack.roles[:app1].should == {}
+        end
+      end
+
+      describe "role" do
+        it "should allow the definition of a basic, empty role" do
+          stack = ApplicationStack.new("foo") do |s|
+            s.role :app1
+          end
+          stack.roles[:app1].should == {}
+        end
+  
+        it "should use the parameters given to the role definition" do
+          stack = ApplicationStack.new("foo") do |s|
+            s.role :app1, :foo => "bar"
+          end
+          stack.roles[:app1].should == { :foo => "bar" }
+        end
+  
+        it "should allow for the creation of multiple roles" do
+          stack = ApplicationStack.new("foo") do |s|
+            s.role :app1, :foo => "bar"
+            s.role :app2, :foo => "baz"
+          end
+          stack.roles[:app1].should == { :foo => "bar" }
+          stack.roles[:app2].should == { :foo => "baz" }
+        end
+  
+        it "should map multiple roles to the same set of parameters" do
+          stack = ApplicationStack.new("foo") do |s|
+            s.role :app1, :app2, :foo => "bar"
+          end
+          stack.roles[:app1].should == { :foo => "bar" }
+          stack.roles[:app2].should == { :foo => "bar" }
+        end
+  
+        it "should create an accessor mapped to the new role, nil by default" do
+          stack = ApplicationStack.new("foo") do |s|
+            s.role :app1, :foo => "bar"
+          end
+          stack.app1.should be_nil
+        end
+      end
+
+      describe "sdb_domain" do
+        it "should map to ApplicationStack::DEFAULT_SDB_DOMAIN upon creation" do
+          ApplicationStack.new("foo").sdb_domain.should == ApplicationStack::DEFAULT_SDB_DOMAIN
+        end
+  
+        it "should be configurable" do
+          ApplicationStack.new("foo", :sdb_domain => "a domain").sdb_domain.should == "a domain"
+        end
+      end
+  
+      describe "launch" do
+        it "should launch its roles when launched" do
+          s = ApplicationStack.new("test") do |s| 
+            s.role "db1",  :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE
+            s.role "app1", :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE
+          end
+  
+          Instance.should_receive(:launch).with({ :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE }).and_return(mock("instance1", :instance_id => "a"))
+          Instance.should_receive(:launch).with({ :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE }).and_return(mock("instance2", :instance_id => "b"))
+  
+          s.launch
+        end
+  
+        it "should set the getter for the particular instance to the return value of launching the instance" do      
+          s = ApplicationStack.new("test") do |s| 
+            s.role "db1",  :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE
+            s.role "app1", :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE
+          end
+    
+          instances = [ stub_instance, stub_instance ]
+    
+          Instance.stub!(:launch).with({ :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE }).and_return instances.first
+          Instance.stub!(:launch).with({ :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE }).and_return instances.last
+    
+          s.db1.should be_nil
+          s.app1.should be_nil
+          
+          s.launch
+    
+          s.db1.should == instances.first
+          s.app1.should == instances.last
+        end
+  
+        it "should store details about the newly launched instances" do
+          Awsymandias::EC2::Instance.stub!(:launch).and_return stub_instance(:instance_id => "abc123")
+          Awsymandias::EC2::ApplicationStack.new("test") do |s| 
+            s.role "db1", :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE
+          end.launch
+    
+          simpledb.get_attributes(ApplicationStack::DEFAULT_SDB_DOMAIN, "test").should == { "db1" => "abc123" }
+        end
+      end
+
+      describe "launched?" do    
+        it "should be false initially" do
+          s = ApplicationStack.new("test") {|s| s.role "db1", :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE}
+          s.should_not be_launched
+        end
+  
+        it "should be true if launched and instances are non-empty" do
+          s = ApplicationStack.new("test") { |s| s.role "db1" }
+          Awsymandias::EC2::Instance.stub!(:launch).and_return stub_instance
+          s.launch
+          s.should be_launched
+        end
+  
+        it "should attempt to determine whether or not it's been previously launched" do
+          Awsymandias::SimpleDB.put ApplicationStack::DEFAULT_SDB_DOMAIN, "test", "db1" => ["instance_id"]
+          an_instance = stub_instance :instance_id => "instance_id"
+          Instance.should_receive(:find).with(:all, :instance_ids => [ "instance_id" ]).and_return [ an_instance ]
+          s = ApplicationStack.new("test") { |s| s.role "db1" }
+          s.should be_launched
+          s.db1.should == an_instance
+        end
+      end
+
+      describe "running?" do
+        it "should be false initially" do
+          ApplicationStack.new("test") {|s| s.role "db1"}.should_not be_running
+        end
+  
+        it "should be false if launched but all instances are pended" do
+          Instance.stub!(:launch).and_return stub_instance(:instance_state => { :name => "pending" })
+          ApplicationStack.new("test") {|s| s.role "db1"}.launch.should_not be_running
+        end
+  
+        it "should be false if launched and some instances are pended" do
+          s = ApplicationStack.new("test") do |s| 
+            s.role "db1", :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE
+            s.role "app1", :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE
+          end
+    
+          Instance.stub!(:launch).
+            with({ :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE }).
+            and_return stub_instance(:instance_state => { :name => "pending" })
+      
+          Instance.stub!(:launch).
+            with({ :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE }).
+            and_return stub_instance(:instance_state => { :name => "running" })
+      
+          s.launch
+          s.should_not be_running
+        end
+  
+        it "should be true if launched and all instances are running" do
+          s = ApplicationStack.new("test") do |s| 
+            s.role "db1", :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE
+            s.role "app1", :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE
+          end
+    
+          Instance.stub!(:launch).
+            with({ :instance_type => Awsymandias::EC2::InstanceTypes::C1_XLARGE }).
+            and_return stub_instance(:instance_state => { :name => "running" })
+      
+          Instance.stub!(:launch).
+            with({ :instance_type => Awsymandias::EC2::InstanceTypes::M1_LARGE }).
+            and_return stub_instance(:instance_state => { :name => "running" })
+      
+          s.launch
+          s.should be_running
+        end
+      end
+
+      describe "terminate!" do
+        it "should not do anything if not running" do
+          s = ApplicationStack.new("test") { |s| s.role "db1" }
+          Awsymandias::EC2.should_receive(:connection).never
+          s.terminate!
+        end
+  
+        it "should terminate all instances if running" do
+          s = ApplicationStack.new("test") { |s| s.role "db1" }
+          mock_instance = mock("an_instance", :instance_id => "i-foo")
+          mock_instance.should_receive(:terminate!)
+          Instance.stub!(:launch).and_return(mock_instance)
+          s.launch
+          s.terminate!      
+        end
+  
+        it "should remove any stored role name mappings" do
+          Awsymandias::SimpleDB.put ApplicationStack::DEFAULT_SDB_DOMAIN, "test", "db1" => ["instance_id"]
+          s = ApplicationStack.new("test") { |s| s.role "db1" }
+          Instance.stub!(:launch).and_return stub('stub').as_null_object
+          s.launch
+          s.terminate!
+          Awsymandias::SimpleDB.get(ApplicationStack::DEFAULT_SDB_DOMAIN, "test").should be_blank
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: bguthrie-awsymandias
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Brian Guthrie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hungryblank-aws-sdb
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: grempe-amazon-ec2
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.2
+    version: 
+description: A library for helping you set up, track, and tear down complicated deployment configurations in Amazon EC2.
+email: btguthrie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/awsymandias.rb
+- spec/awsymandias_spec.rb
+has_rdoc: true
+homepage: http://github.com/bguthrie/awsymandias
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A library for helping you set up, track, and tear down complicated deployment configurations in Amazon EC2.
+test_files: 
+- spec/awsymandias_spec.rb