bguthrie-awsymandias 0.2.1 → 0.3.1

data/.specification

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: onyx-awsymandias
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-14 04:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib
+- lib/awsymandias.rb
+has_rdoc: false
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- bin
+- 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.3.2
+signing_key: 
+specification_version: 3
+summary: 
+test_files: []
+

data/README.rdoc

@@ -4,34 +4,18 @@
 
 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.
 
-  I met a hacker from an antique land
-  Who said: Two tall and heavy mounts of steel
-  Lie in a basement. Near them on a stand,
-  Recessed, a dark CRT lies, whose peel’d
-  Cracked shell of dullest beige, and blinkenlights,
-  Tell that its fact’ry well those old specs read
-  Which yet survive, inked on the lifeless thing,
-  The die that stamp’d them and the power that fed.
-  And on the burned-in screen these words appear:
-  “My name is Awsymandias, king of kings:
-  Look on my racks, ye Mighty, and despair!”
-  No bits at all remain. Not far away
-  A data center waits, its humming air
-  Host to a boundless cloud by th’hour to pay.
-  
-(Apologies to Shelley’s original sonnet. Die-hards will please note that it scans and attempts to follow the original meter and rhyme scheme wherever possible.)
-
 == 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", ... 
+  stack = Awsymandias::EC2::ApplicationStack.define("test") do |s|
+    s.instance :db,  :instance_type => "m1.large", ... 
+    s.instance :app, :instance_type => "c1.xlarge", ... 
+    s.volume :data, :volume_id => "vol-12345", :instance => :db, :unix_device => "/dev/sdj"
   end
 
   # Check if we're running by pulling stack description from SDB; if not, launch asynchronously.
   stack.launch unless stack.launched? || stack.running? 
-  until stack.running?
+  until stack.reload.running?
     sleep(5)
   end
 
@@ -48,6 +32,26 @@ This should allow you to re-launch and deploy that AWS stack from any one of sev
 * {Paul Gross}[http://www.pgrs.net] {github}[http://github.com/pgr0ss] {email}[mailto:pgross@gmail.com]
 * Rob Sweet (rob@ldg.net)
 * Kris Hicks (krishicks at gmail dot com)
+* {Tony Pitluga}[http://tonypitluga.blogspot.com/] {github}[http://github.com/pitluga] {email}[mailto:tony.pitluga@gmail.com]
+
+== Brief Expository Sonnet
+
+  I met a hacker from an antique land
+  Who said: Two tall and heavy mounts of steel
+  Lie in a basement. Near them on a stand,
+  Recessed, a dark CRT lies, whose peel’d
+  Cracked shell of dullest beige, and blinkenlights,
+  Tell that its fact’ry well those old specs read
+  Which yet survive, inked on the lifeless thing,
+  The die that stamp’d them and the power that fed.
+  And on the burned-in screen these words appear:
+  “My name is Awsymandias, king of kings:
+  Look on my racks, ye Mighty, and despair!”
+  No bits at all remain. Not far away
+  A data center waits, its humming air
+  Host to a boundless cloud by th’hour to pay.
+  
+(Apologies to Shelley’s original. Diehards will please note that it scans and attempts to follow the original meter and rhyme scheme wherever possible.)
 
 == License
 

data/Rakefile

@@ -3,12 +3,28 @@ 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"]
+
+namespace :spec do
+
+  desc "runs all the unit specs"
+  Spec::Rake::SpecTask.new(:unit) do |t|
+    t.rcov = true
+    t.rcov_opts = ["--text-summary", "--include-file lib/awsymandias", "--exclude gems,spec"]
+    t.spec_files = FileList['spec/unit/**/*_spec.rb']
+  end
+
+  desc "runs all the integration specs (requires AMAZON_ACCESS_KEY_ID and AMAZON_SECRET_ACCESS_KEY env variables to be set)"
+  Spec::Rake::SpecTask.new(:integration) do |t|
+    t.rcov = true
+    t.rcov_opts = ["--text-summary", "--include-file lib/awsymandias", "--exclude gems,spec"]
+    t.spec_files = FileList['spec/integration/**/*_spec.rb']
+  end
+  
 end
 
+desc "runs all the specs"
+task :spec => [:'spec:unit', :'spec:integration']
+
 task :default => [:spec]
 
 desc "Open an irb session preloaded with this library"

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.1

data/awsymandias.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{awsymandias}
-  s.version = "0.2.1"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Guthrie"]
-  s.date = %q{2009-07-15}
+  s.date = %q{2009-08-11}
   s.description = %q{A library for helping you set up, track, and tear down complicated deployment configurations in Amazon EC2.}
   s.email = %q{btguthrie@gmail.com}
   s.extra_rdoc_files = [
@@ -14,20 +14,36 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     ".specification",
      "README.rdoc",
      "Rakefile",
      "VERSION",
      "awsymandias.gemspec",
      "lib/awsymandias.rb",
-     "spec/awsymandias_spec.rb",
-     "vendor/aws-sdb/LICENSE",
-     "vendor/aws-sdb/README",
-     "vendor/aws-sdb/Rakefile",
-     "vendor/aws-sdb/lib/aws_sdb.rb",
-     "vendor/aws-sdb/lib/aws_sdb/error.rb",
-     "vendor/aws-sdb/lib/aws_sdb/service.rb",
-     "vendor/aws-sdb/spec/aws_sdb/service_spec.rb",
-     "vendor/aws-sdb/spec/spec_helper.rb"
+     "lib/awsymandias/addons/right_elb_interface.rb",
+     "lib/awsymandias/ec2.rb",
+     "lib/awsymandias/ec2/application_stack.rb",
+     "lib/awsymandias/extensions/class_extension.rb",
+     "lib/awsymandias/extensions/net_http_extension.rb",
+     "lib/awsymandias/instance.rb",
+     "lib/awsymandias/load_balancer.rb",
+     "lib/awsymandias/right_aws.rb",
+     "lib/awsymandias/right_elb.rb",
+     "lib/awsymandias/simple_db.rb",
+     "lib/awsymandias/snapshot.rb",
+     "lib/awsymandias/stack_definition.rb",
+     "lib/awsymandias/volume.rb",
+     "spec/integration/instance_spec.rb",
+     "spec/unit/addons/right_elb_interface_spec.rb",
+     "spec/unit/awsymandias_spec.rb",
+     "spec/unit/ec2/application_stack_spec.rb",
+     "spec/unit/instance_spec.rb",
+     "spec/unit/load_balancer_spec.rb",
+     "spec/unit/right_aws_spec.rb",
+     "spec/unit/simple_db_spec.rb",
+     "spec/unit/snapshot_spec.rb",
+     "spec/unit/stack_definition_spec.rb",
+     "tags"
   ]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/bguthrie/awsymandias}
@@ -36,7 +52,16 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{A library for helping you set up, track, and tear down complicated deployment configurations in Amazon EC2.}
   s.test_files = [
-    "spec/awsymandias_spec.rb"
+    "spec/integration/instance_spec.rb",
+     "spec/unit/addons/right_elb_interface_spec.rb",
+     "spec/unit/awsymandias_spec.rb",
+     "spec/unit/ec2/application_stack_spec.rb",
+     "spec/unit/instance_spec.rb",
+     "spec/unit/load_balancer_spec.rb",
+     "spec/unit/right_aws_spec.rb",
+     "spec/unit/simple_db_spec.rb",
+     "spec/unit/snapshot_spec.rb",
+     "spec/unit/stack_definition_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/awsymandias.rb

@@ -1,352 +1,57 @@
-Dir[File.dirname(__FILE__) + "/../vendor/**/lib"].each { |dir| $: << dir }
+unless defined?(Awsymandias)
+  Dir[File.dirname(__FILE__) + "/../vendor/**/lib"].each { |dir| $: << dir }
+  $: << File.dirname(__FILE__)
+  
+  require 'right_aws'
+  require "sdb/right_sdb_interface"
+  require 'money'
+  require 'activesupport'
+  require 'activeresource'
+  require 'net/telnet'
 
-require 'EC2'
-require 'aws_sdb'
-require 'money'
-require 'activesupport'
-require 'activeresource'
-require 'net/telnet'
+  Dir[File.dirname(__FILE__) + "/awsymandias/extensions/**/*.rb"].each { |file| require file }
+  Dir[File.dirname(__FILE__) + "/awsymandias/**/*.rb"].each { |file| require file }
 
-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 Support
-    module Hash
-      # Ganked from ActiveResource 2.3.2.
-      def reformat_incoming_param_data(params)
-        case params.class.to_s
-          when "Hash"
-            params.inject({}) do |h,(k,v)|
-              h[k.to_s.underscore.tr("-", "_")] = reformat_incoming_param_data(v)
-              h
-            end
-          when "Array"
-            params.map { |v| reformat_incoming_param_data(v) }
-          else
-            params
-        end
-      end
-    end
-  end
+  module Awsymandias
   
-  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
+      attr_writer :access_key_id, :secret_access_key
+      attr_accessor :verbose
     
-    InstanceType = Struct.new(:name, :price_per_hour)
+      Awsymandias.verbose = false
     
-    # 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 Awsymandias::Support::Hash
-      extend  Awsymandias::Support::Hash # reformat_incoming_param_data
-      
-      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"
+      def access_key_id
+        @access_key_id || AMAZON_ACCESS_KEY_ID || ENV['AMAZON_ACCESS_KEY_ID'] 
       end
     
-      def running?
-        instance_state.name == "running"
-      end
-      
-      def port_open?(port)
-        Net::Telnet.new("Host" => public_dns, "Port" => port) && true rescue false
-      end
-      
-      def terminated?
-        instance_state.name == "terminated"
+      def secret_access_key
+        @secret_access_key || AMAZON_SECRET_ACCESS_KEY || ENV['AMAZON_SECRET_ACCESS_KEY']
       end
     
-      def terminate!
-        Awsymandias::EC2.connection.terminate_instances :instance_id => self.instance_id
-        reload
+      def stack_names
+        Awsymandias::SimpleDB.query('application-stack', "").flatten.select { |stack_name| !stack_name.blank? }
       end
     
-      def reload
-        load(reformat_incoming_param_data(
-          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"].sum([]) do |item_set|
-              item_set["instancesSet"]["item"].map do |item|
-                instantiate_record(reformat_incoming_param_data(item))
-              end
-            end
-          end
+      def wait_for(message, refresh_seconds, &block)
+        print "Waiting for #{message}.." if Awsymandias.verbose
+        while !block.call
+          print "." if Awsymandias.verbose
+          sleep(refresh_seconds)      
         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(reformat_incoming_param_data(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?
+        verbose_output "OK!"
       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? || ( @instances = retrieve_role_to_instance_id_mapping ).any?
-      end
-          
-      def running?
-        launched? && @instances.values.all?(&:running?)
-      end
-      
-      def port_open?(port)
-        @instances.values.all? { |instance| instance.port_open?(port) }
-      end
-      
-      def running_cost
-        return Money.new(0) unless launched?
-        @instances.values.sum { |instance| instance.running_cost }
-      end
-      
-      def inspect
-        ( [ "Environment #{@name}, running? #{running?}" ] + roles.map do |role_name, opts|
-          "** #{role_name}: #{opts.inspect}"
-        end ).join("\n")
+      def verbose_output(message)
+        puts message if Awsymandias.verbose
       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 )
+      def describe_stacks
+        Awsymandias.stack_names.each do |stack_name|
+          stack = EC2::ApplicationStack.find(stack_name)
+          puts stack.summarize if stack
+          puts ""
         end
-        
-        def remove_role_to_instance_id_mapping!
-          Awsymandias::SimpleDB.delete @sdb_domain, @name
-        end
-        
-        def retrieve_role_to_instance_id_mapping
-          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
   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'],
-          :logger            => Logger.new("/dev/null")
-        }.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