bguthrie-awsymandias 0.2.1 → 0.3.1

data/lib/awsymandias/extensions/class_extension.rb

@@ -0,0 +1,18 @@
+module ClassExtension
+  
+  if !Class.respond_to?("hash_initializer")
+    def hash_initializer(*attribute_names, &block)
+      define_method(:initialize) do |*args|
+        data = args.first || {}
+        data.symbolize_keys!
+        attribute_names.each do |attribute_name|
+          instance_variable_set "@#{attribute_name}", data[attribute_name]
+        end
+        instance_eval &block if block
+      end
+    end
+  end
+
+end
+
+Class.send :include, ClassExtension

data/lib/awsymandias/extensions/net_http_extension.rb

@@ -0,0 +1,9 @@
+# Supress warning about SSL peer verification
+class Net::HTTP
+  alias_method :old_initialize, :initialize
+  def initialize(*args)
+    old_initialize(*args)
+    @ssl_context = OpenSSL::SSL::SSLContext.new
+    @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+  end
+end

data/lib/awsymandias/instance.rb

@@ -0,0 +1,149 @@
+# 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.
+module Awsymandias
+  class Instance < ActiveResource::Base  
+    attr_accessor :name
+      
+    self.site = "mu"
+  
+    def id;          instance_id;      end
+    def instance_id; aws_instance_id;  end
+    def public_dns;  dns_name;         end
+    def private_dns; private_dns_name; end
+    def dns_hostname; name.to_s.gsub(/_/,'-'); end
+
+    def summarize
+      output = []
+      output << "   Instance '#{name}'\t#{instance_id}\t#{public_dns}\tLaunched #{aws_launch_time}"
+      output << "      #{aws_state}\t#{aws_availability_zone}\t#{aws_instance_type.name}\t#{aws_image_id}"
+      attached_volumes.each do |volume|
+        output << "      #{volume.aws_id} -> #{volume.aws_device}"
+      end
+      output.join("\n")
+    end
+
+    def attached_volumes
+      Awsymandias::RightAws.describe_volumes.select { |volume| volume.aws_instance_id == instance_id }
+    end
+
+    def key_name
+      @attributes['key_name'] || nil
+    end
+
+    def pending?
+      aws_state == "pending"
+    end
+  
+    def running?
+      aws_state == "running"
+    end
+    
+    def port_open?(port)
+      Net::Telnet.new("Host" => public_dns, "Port" => port, "Timeout" => 5) 
+      true
+    rescue Timeout::Error, Errno::ECONNREFUSED
+      false
+    end
+    
+    def snapshot_attached?(snapshot_id)
+      Awsymandias::RightAws.describe_volumes.each do |volume|
+        return true if volume.snapshot_id == snapshot_id && volume.aws_instance_id == instance_id
+      end
+      false
+    end
+
+    def terminated?
+      aws_state == "terminated"
+    end
+  
+    def terminate!
+      Awsymandias::RightAws.connection.terminate_instances self.instance_id
+      reload
+    end
+  
+    def volume_attached_to_unix_device(unix_device)
+      attached_volumes.select { |vol| vol.aws_device == unix_device }.first
+    end
+
+    def reload
+      load( RightAws.connection.describe_instances(self.aws_instance_id).first )
+    end
+    
+    def to_params
+      {
+        :aws_image_id => self.aws_image_id,
+        :ssh_key_name => self.ssh_key_name,
+        :aws_instance_type => self.aws_instance_type,
+        :aws_availability_zone => self.aws_availability_zone
+      }
+    end
+    
+    def to_simpledb
+      { :aws_instance_id => aws_instance_id, 
+        :name => name,
+        :attached_volumes => attached_volumes.map { |vol| vol.to_simpledb }
+      }
+    end
+    
+    def aws_instance_type
+      Awsymandias::EC2.instance_types[@attributes['aws_instance_type']]
+    end
+    
+    def aws_launch_time
+      Time.parse(@attributes['aws_launch_time'])
+    end
+    
+    def uptime
+      return 0.seconds if (pending? || terminated?)
+      Time.now - self.aws_launch_time
+    end
+    
+    def running_cost
+      return Money.new(0) if pending?
+      aws_instance_type.price_per_hour * (uptime / 1.hour).ceil 
+    end
+      
+    class << self
+      def find(*args)
+        opts = args.extract_options!
+        ids = args.first == :all ? opts[:instance_ids] : [args.first].flatten
+        
+        found = RightAws.connection.describe_instances(ids).map do |instance_attributes| 
+          instantiate_record instance_attributes
+        end
+        
+        raise ActiveResource::ResourceNotFound.new("Couldn't find instance #{ids.first}.") if (ids.size == 1 && found.size == 0)
+        (found.size == 1 && args.first != :all) ? found.first : found
+      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::RightAws.connection.run_instances *run_instance_opts_to_args(opts)
+        find(response.first[:aws_instance_id])
+      end
+      
+      private
+      
+      def run_instance_opts_to_args(opts)
+        [
+         opts[:image_id], 
+         opts[:min_count] || 1, 
+         opts[:max_count] || 1, 
+         opts[:group_ids] || 'default',
+         opts[:key_name],
+         
+         opts[:user_data],  
+         opts[:addressing_type], 
+         opts[:instance_type],
+         opts[:kernel_id], 
+         opts[:ramdisk_id], 
+         opts[:availability_zone], 
+         opts[:block_device_mappings]
+        ]
+      end
+    end
+  end
+end

data/lib/awsymandias/load_balancer.rb

@@ -0,0 +1,157 @@
+module Awsymandias
+  class LoadBalancer < ActiveResource::Base      
+    attr_reader :name, :aws_created_at, :availability_zones, :dns_name, :name, :instances, :listeners, :health_check
+
+    def self.find(*names)
+      names = nil if names.is_a?(Array) && names.empty?
+      Awsymandias::RightElb.connection.describe_lbs(names).map { |lb| Awsymandias::LoadBalancer.new lb }
+    end
+
+    def self.launch(attribs)
+      new_lb = LoadBalancer.new(attribs)
+      new_lb.launch
+      new_lb
+    end
+
+    def self.valid_load_balancer_name?(lb_name);  (lb_name.to_s  =~ /\A[a-zA-Z0-9-]+\Z/) != nil; end
+    
+    def initialize(attribs)
+      raise "Load balancer name can only contain alphanumeric characters or a dash." unless LoadBalancer.valid_load_balancer_name?(attribs[:name])
+      
+      @listeners = [attribs[:listeners]].flatten.map { |listener| Listener.new listener }
+      @terminated = false
+      
+      [:availability_zones, :dns_name, :name, :instances].each do |attribute_name| 
+        instance_variable_set "@#{attribute_name.to_s}", attribs[attribute_name]
+      end
+      
+      self.health_check = attribs[:health_check]
+    end
+    
+    def availability_zones=(zones = [])
+      zones = [zones].flatten
+      
+      zones_to_disable = @availability_zones - zones
+      Awsymandias::RightElb.connection.disable_availability_zones_for_lb @name, zones_to_disable if !zones_to_disable.empty?
+      
+      zones_to_enable = zones - @availability_zones
+      Awsymandias::RightElb.connection.enable_availability_zones_for_lb @name, zones_to_enable if !zones_to_enable.empty?
+      
+      @availability_zones = Awsymandias::RightElb.connection.describe_lbs([@name]).first[:availability_zones]
+    end
+
+    def health_check=(attribs)
+      need_to_save = !@health_check.nil?
+      @health_check = HealthCheck.new(self, attribs || {})
+      @health_check.save if launched? && need_to_save
+    end
+
+    def instances=(instance_ids = [])
+      instance_ids = [instance_ids].flatten
+      
+      instances_to_deregister = @instances - instance_ids
+      Awsymandias::RightElb.connection.deregister_instances_from_lb @name, instances_to_deregister if !instances_to_deregister.empty?
+      
+      instances_to_register = instance_ids - @instances
+      Awsymandias::RightElb.connection.register_instances_with_lb @name, instances_to_register if !instances_to_register.empty?
+      
+      @instances = Awsymandias::RightElb.connection.describe_lbs([@name]).first[:instances]
+    end
+
+    def instance_health
+      Awsymandias::RightElb.connection.describe_instance_health @name
+    end
+
+    def launch
+      raise "Load balancers must have at least one listener defined." if @listeners.empty?
+      raise "Load balancers must have at least one availability zone defined." if @availability_zones.empty?
+      
+      listener_params = @listeners.map { |l| l.attributes }      
+      @dns_name = Awsymandias::RightElb.connection.create_lb @name, @availability_zones, listener_params
+    end
+
+    def launched?
+      !@dns_name.nil?
+    end
+
+    def reload
+      return unless launched?
+      data = Awsymandias::RightElb.connection.describe_lbs([self.name]).first
+      data.symbolize_keys!
+      data.keys.each do |attribute_name|
+        instance_variable_set "@#{attribute_name}", data[attribute_name]
+      end
+      self
+    end
+    
+    def summarize
+      output = []
+      output << "   Load Balancer '#{name}':\t#{dns_name || "Not Launched"}"
+      output << "      Health Check:  "
+      health_check.attributes.each_pair {|attrib, value| output.last << "#{attrib}: #{value}\t"}
+      output << "      Avail. Zones: #{availability_zones.join "," }"
+      output << "      Instances: #{instances.join "," }"
+      output << "      Listeners:"
+      listeners.each do |listener|
+        output << "                 "
+        listener.attributes.each_pair {|attrib, value| output.last << "#{attrib}: #{value}\t"}
+      end
+      output.join("\n")
+    end
+    
+    def terminate!
+      Awsymandias::RightElb.connection.delete_lb name
+      @terminated = true
+    end
+    
+    def terminated?
+      @terminated
+    end
+    
+    def to_simpledb
+      name
+    end
+    
+    class HealthCheck
+      ATTRIBUTE_NAMES = [:healthy_threshold, :unhealthy_threshold, :interval, :target, :timeout]
+      attr_accessor *ATTRIBUTE_NAMES
+      
+      DEFAULT_SETTINGS = {:healthy_threshold => 3, 
+                          :unhealthy_threshold => 5, 
+                          :interval => 30, 
+                          :target => "HTTP:80", 
+                          :timeout => 5
+                          }
+                          
+      def initialize(lb, attribs = {})
+        @lb = lb
+        attribs.merge!(HealthCheck::DEFAULT_SETTINGS)
+        
+        HealthCheck::DEFAULT_SETTINGS.each_pair { |key, value| instance_variable_set "@#{key}", value }
+      end
+      
+      def attributes
+        returning({}) do |attribs|
+          HealthCheck::ATTRIBUTE_NAMES.each { |attrib| attribs[attrib] = instance_variable_get "@#{attrib}"}
+        end
+      end
+      
+      def save
+        Awsymandias::RightElb.connection.configure_health_check attributes
+      end
+    end
+    
+    class Listener
+      ATTRIBUTE_NAMES = [:protocol, :load_balancer_port, :instance_port] 
+      hash_initializer *ATTRIBUTE_NAMES
+      attr_reader *ATTRIBUTE_NAMES
+      
+      def attributes
+        returning({}) do |attribs|
+          Listener::ATTRIBUTE_NAMES.each { |attrib| attribs[attrib] = instance_variable_get "@#{attrib}"}
+        end
+      end      
+    end
+
+  end
+end

data/lib/awsymandias/right_aws.rb

@@ -0,0 +1,73 @@
+module Awsymandias
+  module RightAws
+    class << self    
+      
+      def attach_volume(volume_id, instance_id, unix_device)
+        Awsymandias::Volume.new connection.attach_volume(volume_id, instance_id, unix_device)
+      end
+      
+      def connection
+        @connection ||= ::RightAws::Ec2.new(Awsymandias.access_key_id,  
+                                            Awsymandias.secret_access_key, 
+                                            {:logger => Logger.new("/dev/null")})
+      end      
+
+      def delete_volume(volume_id)
+        connection.delete_volume volume_id
+      end
+
+      def detach_volume(volume_id, instance_id, unix_device)
+        Awsymandias::Volume.new connection.detach_volume(volume_id, instance_id, unix_device)
+      end
+
+      def describe_instances(list = [])
+        connection.describe_instances(list).map { |i| Awsymandias::Instance.new i }
+      end
+
+      def describe_snapshots(list = [])
+        Snapshot.find(*list)
+      end
+    
+      def describe_volumes(list = [])
+        connection.describe_volumes(list).map { |v| Awsymandias::Volume.new v }
+      end
+    
+      def latest_snapshot_based_on(volume_id, raise_if_no_snapshot = true)
+        snapshots_for_volume = connection.describe_snapshots.select { |snapshot| snapshot[:aws_volume_id] == volume_id }
+        snapshot =  snapshots_for_volume.empty? ? 
+                         nil : 
+                         snapshots_for_volume.sort { |a,b| a[:aws_started_at] <=> b[:aws_started_at] }.last
+        raise "Can't find snapshot for master volume #{volume_id}." if (!snapshot || snapshot[:aws_id].nil?) && raise_if_no_snapshot
+        snapshot ? Awsymandias::Snapshot.new(snapshot) : nil
+      end
+
+      def snapshot_size(snapshot_id)
+        connection.describe_volumes([connection.describe_snapshots([snapshot_id]).first[:aws_volume_id]]).first[:aws_size]
+      end  
+    
+      def delete_snapshot(snapshot_id)
+        connection.delete_snapshot snapshot_id
+      end
+
+      def wait_for_create_volume(snapshot_id, availability_zone)
+        new_volume = connection.create_volume snapshot_id, snapshot_size(snapshot_id), availability_zone
+
+        Awsymandias.wait_for "new volume #{new_volume[:aws_id]} from snapshot #{snapshot_id} to become available..", 3 do
+          connection.describe_volumes(new_volume[:aws_id]).first[:aws_status] == 'available'
+        end
+
+        Awsymandias::Volume.new new_volume
+      end
+    
+      def wait_for_create_snapshot(volume_id)
+        new_snapshot = connection.create_snapshot volume_id
+      
+        Awsymandias.wait_for "new snapshot of volume #{volume_id}", 3 do
+          connection.describe_snapshots(new_snapshot[:aws_id]).first[:aws_status] == 'completed'
+        end
+      
+        Awsymandias::Snapshot.new new_snapshot
+      end
+    end
+  end
+end

data/lib/awsymandias/right_elb.rb

@@ -0,0 +1,16 @@
+module Awsymandias
+  module RightElb
+    class << self    
+      def connection
+        @connection ||= ::RightAws::ElbInterface.new(Awsymandias.access_key_id,  
+                                                     Awsymandias.secret_access_key, 
+                                                     {:logger => Logger.new("/dev/null")})
+      end
+      
+      def describe_lbs(list = [])
+        LoadBalancer.find(*list)
+      end
+      
+    end
+  end
+end

data/lib/awsymandias/simple_db.rb

@@ -0,0 +1,46 @@
+module Awsymandias
+  module SimpleDB # :nodoc
+    class << self
+      def connection(opts={})
+        @connection ||= ::RightAws::SdbInterface.new Awsymandias.access_key_id || ENV['AMAZON_ACCESS_KEY_ID'],
+                                                   Awsymandias.secret_access_key || ENV['AMAZON_SECRET_ACCESS_KEY'],
+                                                   { :logger => Logger.new("/dev/null") }.merge(opts)
+      end
+
+      def put(domain, name, stuff, replace = true)
+        stuff.each_pair { |key, value| stuff[key] = value.to_yaml.gsub("\n","\\n") }
+        connection.put_attributes handle_domain(domain), name, stuff, replace
+      end
+
+      def get(domain, name)
+        stuff = connection.get_attributes(handle_domain(domain), name)[:attributes] || {}
+        stuff.inject({}) do |hash, (key, value)|
+          hash[key.to_sym] = YAML.load(value.first.gsub("\\n","\n"))
+          hash
+        end
+      end
+
+      def delete(domain, name)
+        connection.delete_attributes handle_domain(domain), name
+      end
+
+      def query(domain_name, query_expression = nil, max_number_of_items = nil, next_token = nil)
+        connection.query(domain_name, query_expression, max_number_of_items, next_token)[:items]
+      end
+
+      def query_with_attributes(domain_name, attributes=[], query_expression = nil, max_number_of_items = nil, next_token = nil)
+        connection.query_with_attributes(domain_name, attributes=[], query_expression, max_number_of_items, next_token)[:items]
+      end
+
+      private
+
+      def domain_exists?(domain)
+        connection.list_domains[:domains].include?(domain)
+      end      
+
+      def handle_domain(domain)
+        returning(domain) { connection.create_domain(domain) unless domain_exists?(domain) }
+      end
+    end
+  end  
+end