aws-tools 0.0.2 → 0.0.3

data/bin/aws_manager.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby
+
+require 'aws-sdk-core'
+require 'yaml'
+require 'optparse'
+require 'erb'
+require 'aws_region'
+
+VALID_COMMANDS=['start', 
+                'stop', 
+                'start_environment',
+                'connect', 
+                'create_db', 
+                'delete_db', 
+                'wait_for_db', 
+                'get_db_endpoint', 
+                'get_instance_status', 
+                'get_instance_ip', 
+                'get_db_status', 
+                'purge_db_snapshots', 
+                'put_cw_metric', 
+                'put_to_bucket', 
+                'run_instance',
+                'sns',
+                'terminate_instance']
+
+def filter_instances(all_instances, statuses)
+  instances = []
+  if statuses.length == 0
+    instances = all_instances
+  else
+    all_instances.each do |i|
+      if statuses.include?(i._instance[:state][:name])
+        instances << i
+      end
+    end
+  end
+  instances
+end
+def locate_instance_choice(instances, instance_id, options={})
+  selection_filter = options.has_key?(:selection_filter) ? options[:selection_filter] : nil
+  if instances.length == 0
+    puts "There are no instances matching criteria"
+    return nil
+  elsif instances.length == 1
+    instances[0]
+  else
+    if !instance_id.nil?
+      instance = nil
+      if instance_id.length > 2 # This is an instance id
+        instances.each do |i|
+          if i.id == instance_id
+            instance = i
+          end
+        end
+        if instance.nil?
+          "Error, can't locate instance with instance id: #{instance_id}"
+          return nil
+        end
+      else
+        if instances.length - 1 >= instance_id.to_i
+          instance = instances[instance_id.to_i]
+        end
+      end
+      return instance
+    else
+      if selection_filter == :first
+        return instances[0]
+      elsif selection_filter == :oldest
+          oldest = instances[0]
+          instances.each do |i|
+            oldest = i if i._instance[:launch_time] < oldest._instance[:launch_time]
+          end
+          return oldest
+      elsif selection_filter == :newest
+        newest = instances[0]
+        instances.each do |i|
+          newest = i if i._instance[:launch_time] > newest._instance[:launch_time]
+        end
+        return newest
+      else
+        puts "Error, there are multiple instances that match these tags.  Please choose one:"
+        puts "index: private_ip / public_ip / instance_id / launch_time"
+        for i in 0..(instances.length - 1)
+          puts "#{i}: #{instances[i]._instance[:private_ip_address]} / #{instances[i]._instance[:public_ip_address]} / #{instances[i]._instance[:instance_id]} / #{instances[i]._instance[:launch_time]}"
+        end
+        ans = STDIN.gets.chomp().to_i
+        return instances[ans]
+      end
+    end
+    nil
+  end
+
+end
+def syntax
+  puts "Syntax:"
+  puts "   EC2 Instance commands:"
+  puts "        aws_manager.rb --region region run_instance <instance template file> "
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] [--choose first|oldest|newest] connect [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] [--choose first|oldest|newest] start [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] [--choose first|oldest|newest] [--keep-one] stop [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] [--choose first|oldest|newest] get_instance_status [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] [--choose first|oldest|newest] get_instance_ip [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] [--choose first|oldest|newest] [--keep-one] terminate_instance [id]"
+  puts "   CW commands:"
+  puts "        aws_manager.rb --region region put_cw_metric csv_metric"
+  puts "   S3 commands:"
+  puts "        aws_manager.rb --region region put_to_bucket filename s3_filename"
+  puts "   RDS commands:"
+  puts "        aws_manager.rb --region region create_db <db template file> "
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] delete_db [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] wait_for_db [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] get_db_status [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] get_db_endpoint [id]"
+  puts "        aws_manager.rb --region region [--environment environment] [--purpose purpose] purge_db_snapshots [id]"
+  puts "   SNS commands:"
+  puts "        aws_manager.rb --region region sns \"<topic_arn>\" \"subject\""
+  puts "        example topic_arn: 'arn:aws:sns:us-east-1:795987318935:prod_app_start_failure'"
+  puts "   Other commands:"
+  puts "        aws_manager.rb --help"
+  puts "\nNote that there are shortened versions of the options flags:"
+  puts "        --region      = -r"
+  puts "        --environment = -e"
+  puts "        --purpose     = -p"
+  puts "        --choose      = -c"
+  puts "        --keep-one    = -k"
+  puts "        --help        = -h"
+  exit
+end
+def main
+  syntax if ARGV.length <= 0
+  params = ARGV.getopts("hr:e:p:fkc:", "choose:", "keep-one", "help", "region:", "environment:", "purpose:")
+  syntax if params['h'] or params['help']
+  purpose = params['p'] || params['purpose']
+  environment = params['e'] || params['environment']
+  region = params['r'] || params['region']
+  keep_one = params['k'] || params['keep-one']
+  selection_criteria = params['c'] || params['choose']
+  selection_criteria = selection_criteria.downcase.to_sym if selection_criteria
+  syntax if selection_criteria and !([:first,:oldest, :newest].include?(selection_criteria))
+  syntax if ARGV.length <= 0
+  command = ARGV.shift
+  save_cl = ARGV.dup
+  name = ARGV.length == 1 ? ARGV.shift : nil
+
+  syntax if !region or !(['or', 'ca', 'va'].include?(region))
+  syntax if !(VALID_COMMANDS.include?(command))
+  
+  cfg = YAML::load File.read("/etc/auth.yaml")
+  region = AwsRegion.new(region, cfg["account_id"], cfg["access_key_id"], cfg["secret_access_key"])
+
+  if command == 'stop'
+    if keep_one and filter_instances(region.find_instances({environment: environment, purpose: purpose  }), ['running']).length < 2
+      puts "Error, there are less than 2 instances, and keep_one flag set.  Exiting."
+      exit
+    end
+    instance = locate_instance_choice(filter_instances(region.find_instances({environment: environment, purpose: purpose  }), ['running']),name, {:selection_filter => selection_criteria})
+    instance.stop(wait=true)
+  elsif command == 'start'
+    instance = locate_instance_choice(filter_instances(region.find_instances({environment: environment, purpose: purpose  }), ['stopped']),name, {:selection_filter => selection_criteria})
+    instance.start(wait=true)
+  elsif command == 'connect'
+    instance = locate_instance_choice(filter_instances(region.find_instances({environment: environment, purpose: purpose  }), ['running']),name, {:selection_filter => selection_criteria})
+    instance.connect
+  elsif command == 'create_db'
+    options = YAML::load File.read(name) if File.exists? name
+    instance = region.create_db_instance(options)
+  elsif command == 'delete_db'
+    instances = region.find_db_instances({:environment => environment, :purpose => purpose, :instance_id => name})
+    instances[0].delete
+  elsif command == 'wait_for_db'
+    instances = region.find_db_instances({:environment => environment, :purpose => purpose, :instance_id => name})
+    instances[0].wait
+  elsif command == 'get_db_endpoint'
+    instances = region.find_db_instances({:environment => environment, :purpose => purpose, :instance_id => name})
+    puts instances[0].endpoint
+  elsif command == 'get_db_status'
+    instances = region.find_db_instances({:environment => environment, :purpose => purpose, :instance_id => name})
+    puts instances[0].status
+  elsif command == 'get_instance_status'
+    instance = locate_instance_choice(filter_instances(region.find_instances({environment: environment, purpose: purpose  }), []), name, {:selection_filter => selection_criteria})
+    puts instance.state
+  elsif command == 'get_instance_ip'
+    instance = locate_instance_choice(filter_instances(region.find_instances({environment: environment, purpose: purpose  }), []), name, {:selection_filter => selection_criteria})
+    puts instance.public_ip
+  elsif command == 'purge_db_snapshots'
+    instances = region.find_db_instances({:environment => environment, :purpose => purpose, :instance_id => name})
+    instances[0].purge_db_snapshots
+  elsif command == 'put_cw_metric'
+    syntax if ARGV.length <= 1
+    instance = region.create_cw_instance
+    instance.put_metric(name)
+  elsif command == 'put_to_bucket'
+    syntax if ARGV.length <= 0
+    (bucket,file_identity) = ARGV[0].split(/:/)
+    syntax if bucket.strip.length <=0 or file_identity.strip.length <= 0
+    instance = region.find_bucket({bucket: bucket})
+    instance.put_file(name, file_identity)
+  elsif command == 'run_instance'
+    instance_template = name
+    if !File.exists?(instance_template)
+      puts "Cannot find instance template to build server from: #{instance_template}"
+      exit
+    end
+    image_options = YAML.load(ERB.new(File.read(instance_template)).result)
+    instance = region.create_instance(image_options)
+  elsif command == 'terminate_instance'
+    if keep_one and filter_instances(region.find_instances({environment: environment, purpose: purpose  }), ['running']).length < 2
+      puts "There are less than 2 instances, and keep_one flag set.  Exiting."
+      exit
+    end
+    instance = locate_instance_choice(filter_instances(region.find_instances({environment: environment, purpose: purpose  }), []), name, {:selection_filter => selection_criteria})
+    if instance.nil?
+      puts "No instances matching criteria found #{{environment: environment, purpose: purpose, selection_filter: selection_criteria}.inspect}"
+    else
+      instance.terminate
+    end
+  elsif command == 'sns'
+    instance = region.create_sns_instance
+    instance.publish save_cl[0], save_cl[1]
+    exit
+  elsif
+    syntax
+  end
+end
+
+main()

data/lib/aws_region.rb

@@ -1,12 +1,26 @@
-#!/usr/bin/env ruby
 require 'aws-sdk-core'
 require 'yaml'
 require 'json'
 
-class AwsRegion
-  attr_accessor :ec2, :region, :rds, :account_id, :elb, :cw, :s3
+class AwsBase
+  def log(msg)
+    @logger.write("#{Time.now.strftime("%b %D, %Y %H:%S:%M:")} #{msg}\n") if @logger
+  end
+end
+
+# AwsRegion is a simplified wrapper on top of a few of the Aws core objects
+# The main goal is to expose a extremely simple interface for some our most
+# frequently used Aws facilities.
+class AwsRegion < AwsBase
+  attr_accessor :ec2, :region, :rds, :account_id, :elb, :cw, :s3, :sns  
   REGIONS = {'or' => "us-west-2", 'ca' => "us-west-1", 'va' => 'us-east-1'}
-  def initialize(region, account_id, access_key_id, secret_access_key)
+
+  # @param region [String] must be one of the keys of the {AwsRegion::REGIONS REGIONS} static hash
+  # @param account_id [String] Aws account id
+  # @param access_key_id [String] Aws access key id
+  # @param secret_access_key [String] Aws secret access key
+  def initialize(region, account_id, access_key_id, secret_access_key, logger = nil)
+    @logger = logger
     @region = REGIONS[region]
     @account_id = account_id
     Aws.config = {:access_key_id => access_key_id,
@@ -16,12 +30,22 @@ class AwsRegion
     @elb = Aws::ElasticLoadBalancing.new({:region => @region})
     @cw = Aws::CloudWatch.new({:region => @region})
     @s3 = Aws::S3.new({:region => @region})
+    @sns = Aws::SNS.new({:region => @region})
+  end
 
-    def find_instances(options={})
-      instances = []
-      @ec2.describe_instances[:reservations].each do |i|
-       i.instances.each do |y|
-        instance = AwsInstance.new(self,{:instance => y})
+  # Simple EC2 Instance finder.  Can find using instance_id, or using
+  # :environment and :purpose instance tags which must both match.
+  #
+  # @param options [Hash] containing search criteria.  Values can be:
+  #   * :instance_id - identifies an exact instance
+  #   * :environment - instance tag
+  #   * :purpose     - instance tag
+  # @return [Array<AwsInstance>] instances found to match criteria
+  def find_instances(options={})
+    instances = []
+    @ec2.describe_instances[:reservations].each do |i|
+      i.instances.each do |y|
+        instance = AwsInstance.new(self, {:instance => y})
         if instance.state != 'terminated'
           if options.has_key?(:environment) and options.has_key?(:purpose)
             instances << instance if  instance.tags[:environment] == options[:environment] and instance.tags[:purpose] == options[:purpose]
@@ -29,81 +53,132 @@ class AwsRegion
             instances << instance if instance.id == options[:instance_id]
           end
         end
-       end
-      end
-      return instances
-    end
-    def find_db_instances(options={})
-      instances = []
-      @rds.describe_db_instances[:db_instances].each do |i|
-        instance = AwsDbInstance.new(self, {:instance => i})
-        if options.has_key?(:instance_id) and
-           (!options.has_key?(:environment) or !options.has_key?(:purpose)) and
-           instance.id == options[:instance_id]
-           instances << instance
-        elsif instance.id == options[:instance_id] and
-              instance.tags[:environment] == options[:environment] and
-              instance.tags[:purpose] == options[:purpose]
-          instances << instance
-        end
       end
-      instances
     end
+    return instances
+  end
 
-    def find_buckets(options={})
-      buckets = []
-      _buckets = @s3.list_buckets()
-      _buckets[:buckets].each do |b|
-          buckets << AwsBucket.new(self, {id: b[:name]})  if b[:name] == options[:bucket]
+  # Simple DB Instance finder.  Can find using instance_id, or using
+  # :environment and :purpose instance tags which must both match.
+  #
+  # @param options [Hash] containing search criteria.  Values can be:
+  #   * :instance_id - identifies an exact instance
+  #   * :environment - instance tag
+  #   * :purpose     - instance tag
+  # @return [Array<AwsDbInstance>] instances found to match criteria
+  def find_db_instances(options={})
+    instances = []
+    @rds.describe_db_instances[:db_instances].each do |i|
+      instance = AwsDbInstance.new(self, {:instance => i})
+      if options.has_key?(:instance_id)
+        instance.id == options[:instance_id]
+        instances << instance
+      elsif instance.tags[:environment] == options[:environment] and
+          instance.tags[:purpose] == options[:purpose]
+        instances << instance
       end
-      buckets
     end
-    def create_instance(options={})
-      AwsInstance.new(self, options)
-    end
-    def create_db_instance(options={})
-      AwsDbInstance.new(self, options)
-    end
-    def create_cw_instance(options={})
-      AwsCw.new(self, options)
+    instances
+  end
+
+
+  # Search region for a bucket by name
+  #
+  # @param options [Hash] containing search criteria.  Values can be:
+  #   * :bucket  -  Bucket name
+  # @return [Array<AwsBucket>] instances found to match criteria
+  def find_buckets(options={})
+    buckets = []
+    _buckets = @s3.list_buckets()
+    _buckets[:buckets].each do |b|
+      buckets << AwsBucket.new(self, {id: b[:name]}) if b[:name] == options[:bucket]
+    end
+    buckets
+  end
+
+  # Construct new EC2 instance
+  #
+  # @param options [Hash] containing initialization parameters.  See {AwsInstance#initialize}
+  # @return [AwsInstance]
+  def create_instance(options={})
+    AwsInstance.new(self, options)
+  end
+
+  # Construct new DB instance
+  #
+  # @param options [Hash] containing initialization parameters.  See {AwsDbInstance#initialize}
+  # @return [AwsDbInstance]
+  def create_db_instance(options={})
+    AwsDbInstance.new(self, options)
+  end
+
+  # Construct new CloudWatch instance
+  #
+  # @param options [Hash] containing initialization parameters.  See {AwsCw#initialize}
+  # @return [AwsCw]
+  def create_cw_instance(options={})
+    AwsCw.new(self, options)
+  end
+
+  # Construct new AwsBucket instance
+  #
+  # @param options [Hash] containing initialization parameters.  See {AwsBucket#initialize}
+  # @return [AwsBucket]
+  def create_bucket(options={})
+    AwsBucket.new(self, options)
+  end
+
+  def create_sns_instance
+    AwsSns.new(self)
+  end
+
+  class AwsSns
+    attr_accessor :region
+    def initialize(region)
+      @region = region
     end
-    def create_bucket(options={})
-      AwsBucket.new(self, options)
-    end
-    def remove_instance_from_lb(instance, lb_name)
-      lb = @elb.describe_load_balancers({:load_balancer_names => [lb_name]})
-      if lb and lb[:load_balancer_descriptions].length > 0
-        lb[:load_balancer_descriptions][0][:instances].each do |lbi|
-          if lbi[:instance_id] == instance
-            @elb.deregister_instances_from_load_balancer({:load_balancer_name => lb_name,
-                                                          :instances => [{:instance_id => instance}]})
-          end
-        end
-      end
+    def publish(topic_arn, subject) #, message)
+      @region.sns.publish(topic_arn: topic_arn, message: "unused for texts", subject: subject)
     end
   end
 
-  class AwsCw
+# Methods for dealing with CloudWatch
+  class AwsCw  < AwsBase
     attr_accessor :region
+
+    # @param region [String] - Value from REGION static hash
     def initialize(region, options={})
       @region = region
     end
+
+    # Put a cw metric
+    # @param arg_csv [String] - CSV row: "namespace,name,value,dims"
+    # * Note that dims is formatted as an arbitrary semicolon separated list of name:value dimensions.  For example:
+    #   * "activeservers,count,10,env:prod;purp:test"
+    # @return [Aws::PageableResponse]
     def put_metric(arg_csv)
       (namespace, name, value, dims) = arg_csv.split(",")
       dimensions = []
       dims.split(";").each do |d|
-        (n,v) = d.split(":")
+        (n, v) = d.split(":")
         dimensions << {:name => n, :value => v}
       end
       args = {:namespace => namespace}
       metric ={:metric_name => name, :value => value.to_f, :timestamp => Time.now, :dimensions => dimensions}
       args[:metric_data] = [metric]
       @region.cw.put_metric_data(args)
-    end    
+    end
   end
 
-  class AwsBucket
+  # Methods for dealing with S3 buckets
+  class AwsBucket  < AwsBase
     attr_accessor :region
+
+    # Constructs a bucket instance from an existing bucket, or creates a new one with the name
+    # @param region [String]  - Value from REGION static hash
+    # @param options [Hash] - Possible values:
+    # * :id - id of existing bucket
+    # * :bucket - Name of bucket to find or create
     def initialize(region, options={})
       @region = region
       if options.has_key?(:id)
@@ -120,9 +195,17 @@ class AwsRegion
         @id = bucket
       end
     end
+
+    # Delete this bucket instance
+    # @return [AwsPageableResponse]]
     def delete
       @region.s3.delete_bucket({bucket: @id})
     end
+
+    # Put a local file to this bucket
+    # @param filename [String]  - local file name
+    # @param file_identity [String] - S3 file path
+    # @return [AwsPageableResponse]
     def put_file(filename, file_identity)
       File.open(filename, 'r') do |reading_file|
         resp = @region.s3.put_object(
@@ -134,13 +217,16 @@ class AwsRegion
       end
     end
 
+    # puts a local file to an s3 object in bucket on path
+    # example: put_local_file(:bucket=>"bucket", :local_file_path=>"/tmp/bar/foo.txt", :aws_path=>"b")
+    # would make an s3 object named foo.txt in bucket/b
+    # @param local_file_path [String] - Location of file to put
+    # @param aws_path [String] - S3 path to put the file
+    # @param options [Hash] - Can contain any valid S3 bucket options see [docs](http://docs.aws.amazon.com/sdkforruby/api/frames.html)
     def put(local_file_path, aws_path, options={})
-      # puts a local file to an s3 object in bucket on path
-      # example: put_local_file {:bucket=>"bucket", :local_file_path=>"/tmp/bar/foo.txt", :aws_path=>"b"}
-      # would make an s3 object named foo.txt in bucket/b
       aws_path = aws_path[0..-2] if aws_path[-1..-1] == '/'
       s3_path = "#{aws_path}/#{File.basename(local_file_path)}"
-      puts "s3 writing #{local_file_path} to bucket #{@id} path: #{aws_path} s3 path: #{s3_path}"
+      log "s3 writing #{local_file_path} to bucket #{@id} path: #{aws_path} s3 path: #{s3_path}"
       f = File.open local_file_path, 'rb'
       options[:bucket] = @id
       options[:key] = s3_path
@@ -151,68 +237,110 @@ class AwsRegion
       result
     end
 
+    # prefix is something like: hchd-A-A-Items
+    # This will return in an array of strings the names of all objects in s3 in
+    # the :aws_path under :bucket starting with passed-in prefix
+    # example: :aws_path=>'development', :prefix=>'broadhead'
+    #           would return array of names of objects in said bucket
+    #           matching (in regex terms) development/broadhead.*
+    # @param options [Hash] - Can contain:
+    # * :aws_path - first part of S3 path to search
+    # * :prefix - Actually suffix of path to search.
+    # @return [Array<Hash>] - 0 or more objects
     def find(options={})
-      # prefix is something like: hchd-A-A-Items
-      # This will return in an array of strings the names of all objects in s3 in
-      # the :aws_path under :bucket starting with passed-in prefix
-      # example: :bucket=>'mazama-inventory', :aws_path=>'development', :prefix=>'broadhead'
-      #           would return array of names of objects in said bucket
-      #           matching (in regex terms) development/broadhead.*
-      # return empty array if no matching objects exist
       aws_path = options[:aws_path]
-      prefix   = options[:prefix]
+      prefix = options[:prefix]
       aws_path = '' if aws_path.nil?
       aws_path = aws_path[0..-2] if aws_path[-1..-1] == '/'
-      puts "s3 searching bucket:#{@id} for #{aws_path}/#{prefix}"
+      log "s3 searching bucket:#{@id} for #{aws_path}/#{prefix}"
       objects = @region.s3.list_objects(:bucket => @id,
-                                 :prefix => "#{aws_path}/#{prefix}")
+                                        :prefix => "#{aws_path}/#{prefix}")
       f = objects.contents.collect(&:key)
-      puts "s3 searched  got: #{f.inspect}"
+      log "s3 searched  got: #{f.inspect}"
       f
     end
 
+    # writes contents of S3 object to local file
+    # example: get( :s3_path_to_object=>development/myfile.txt',
+    #               :dest_file_path=>'/tmp/foo.txt')
+    #          would write to local /tmp/foo.txt a file retrieved from s3
+    #          at development/myfile.txt
+    # @param options [Hash] - Can contain:
+    # * :s3_path_to_object - S3 object path
+    # * :dest_file_path - local file were file will be written
+    # @return [Boolean]
     def get(options={})
-      # writes to local file an s3 object in :bucket at :s3_path_to_object to :dest_file_path
-      # example: get_object_as_local_file( {:bucket=>'mazama-inventory',
-      #                                     :s3_path_to_object=>development/myfile.txt',
-      #                                     :dest_file_path=>'/tmp/foo.txt'})
-      #          would write to local /tmp/foo.txt a file retrieved from s3 in 'mazama-inventory' bucket
-      #          at development/myfile.txt
-      s3_path_to_object = options[:s3_path_to_object]
-      dest_file_path    = options[:dest_file_path]
-      File.delete dest_file_path if File.exists?(dest_file_path)
-      puts "s3 get bucket:#{@id} path:#{s3_path_to_object} dest:#{dest_file_path}"
-      response = @region.s3.get_object(:bucket => @id,
-                                       :key    => s3_path_to_object)
-      response.body.rewind
-      # I DO NOT KNOW what happens if the body is "too big". I didn't see a method in the
-      # API to chunk it out... but perhaps response.body does this already.
-      File.open(dest_file_path, 'wb') do |file|
-        response.body.each { |chunk| file.write chunk }
-      end
-      puts "s3 got " + `ls -l #{dest_file_path}`.strip
-      nil
+      begin
+        s3_path_to_object = options[:s3_path_to_object]
+        dest_file_path = options[:dest_file_path]
+        File.delete dest_file_path if File.exists?(dest_file_path)
+        log "s3 get bucket:#{@id} path:#{s3_path_to_object} dest:#{dest_file_path}"
+        response = @region.s3.get_object(:bucket => @id,
+                                         :key => s3_path_to_object)
+        response.body.rewind
+        File.open(dest_file_path, 'wb') do |file|
+          response.body.each { |chunk| file.write chunk }
+        end
+      rescue Exception => e
+        return false
+      end
+      true
     end
 
+    # deletes from s3 an object at :s3_path_to_object
+    # @param options [Hash] - Can be:
+    # * :s3_path_to_object
+    # @return [Boolean]
     def delete_object(options={})
-      # deletes from s3 an object in :bucket at :s3_path_to_object
-      s3_path_to_object = options[:s3_path_to_object]
-      puts "s3 delete  #{s3_path_to_object}"
-      @region.s3.delete_object( :bucket => @id,
-                                :key    => s3_path_to_object)
-      puts "s3 deleted."
+      begin
+        s3_path_to_object = options[:s3_path_to_object]
+        log "s3 delete  #{s3_path_to_object}"
+        @region.s3.delete_object(:bucket => @id,
+                                 :key => s3_path_to_object)
+      rescue Exception => e
+        return false
+      end
+      true
     end
 
+    # delete all objects in a bucket
+    # @return [Boolean]
     def delete_all_objects
-      response = @region.s3.list_objects({:bucket => @id})
-      response[:contents].each do |obj|
-        @region.s3.delete_object( :bucket => @id,
-                                  :key    => obj[:key])
+      begin
+        response = @region.s3.list_objects({:bucket => @id})
+        response[:contents].each do |obj|
+          @region.s3.delete_object(:bucket => @id,
+                                   :key => obj[:key])
+        end
+      rescue Exception => e
+        return false
       end
+      true
     end
   end
-  class AwsDbInstance
+
+  # Class to handle RDS Db instances
+  class AwsDbInstance  < AwsBase
     attr_accessor :id, :tags, :region, :endpoint
+
+    # Creates an AwsDbInstance for an existing instance or creates a new database
+    # @param region [String] - - Value from REGION static hash
+    # @param options [Hash] - Can contain:
+    # * :instance - If specified, create an instance of this class using this RDS instance.
+    # * :opts - [Hash] - Includes parameters for constructing the database.  The format is:
+    #   * :db_instance_identifier - RDS instance identifier
+    #   * :db_subnet_group_name - DB Subgroup name
+    #   * :publicly_accessible - [true|false]
+    #   * :db_instance_class - RDS db instance class
+    #   * :availability_zone - RDS/Aws availability zone
+    #   * :multi_az - [true|false]
+    #   * :engine - RDS engine (Only tested with Mysql at this point)
+    # * :tags - Tags to be applied to RDS instance. The follow are required.  Arbitrary tags may also be added.
+    #   * :environment - Environment  designation - can be anything.  Used to locate instance with other aws-tools
+    #   * :purpose - Purpose  designation - can be anything.  Used to locate instance with other aws-tools
+    #   * :name - Name will appear in the Aws web page if you set this
+    #   * :snapshot_name - Name of the snapshot that will be used to construct the new instance.  This name will be matched with the  RDS db_instance_identifier.  The latest snapshot will be used.
+    #   * :vpc_security_group_ids: - Comma separated list of security groups that will be applied to this instance
     def initialize(region, options = {})
       @region = region
       opts = options[:opts]
@@ -220,11 +348,11 @@ class AwsRegion
         @id = opts[:db_instance_identifier]
         snapshot_name = options[:snapshot_name]
         if 0 < @region.find_db_instances({:instance_id => @id}).length
-          puts "Error, instance: #{@id} already exists"
+          log "Error, instance: #{@id} already exists"
           return
         end
         last = self.get_latest_db_snapshot({:snapshot_name => snapshot_name})
-        puts "Restoring: #{last.db_instance_identifier}, snapshot: #{last.db_instance_identifier} from : #{last.snapshot_create_time}"
+        log "Restoring: #{last.db_instance_identifier}, snapshot: #{last.db_instance_identifier} from : #{last.snapshot_create_time}"
         opts[:db_snapshot_identifier] = last.db_snapshot_identifier
         response = @region.rds.restore_db_instance_from_db_snapshot(opts)
         @_instance = response[:db_instance]
@@ -234,8 +362,8 @@ class AwsRegion
 
         self.wait
 
-        opts = { :db_instance_identifier => @id,
-                 :vpc_security_group_ids => options[:vpc_security_group_ids]}
+        opts = {:db_instance_identifier => @id,
+                :vpc_security_group_ids => options[:vpc_security_group_ids]}
         @region.rds.modify_db_instance(opts)
       else
         @_instance = options[:instance]
@@ -249,62 +377,83 @@ class AwsRegion
       @endpoint = @_instance.endpoint[:address]
     end
 
+    # Delete a database and be sure to capture a final stapshot
+    # @return [Boolean] - A return value of true only means that the command was issued.  The caller should follow up later with a call to determine status in order to know when the delete has been completed
     def delete(options={})
-      puts "Deleting database: #{@id}"
-      opts = { :db_instance_identifier => @id,
-               :skip_final_snapshot => false,
-               :final_db_snapshot_identifier => "#{@id}-#{Time.now.strftime("%Y-%m-%d-%H-%M-%S")}" }
-      i = @region.rds.delete_db_instance(opts)
+      log "Deleting database: #{@id}"
+      opts = {:db_instance_identifier => @id,
+              :skip_final_snapshot => false,
+              :final_db_snapshot_identifier => "#{@id}-#{Time.now.strftime("%Y-%m-%d-%H-%M-%S")}"}
+      begin
+        i = @region.rds.delete_db_instance(opts)
+      rescue  Exception => e
+        return false
+      end
+      true
     end
 
+    # Purge db snapshots, keep just one - the latest
+    # @return [Boolean]
     def purge_db_snapshots
       latest = 0
       @region.rds.describe_db_snapshots[:db_snapshots].each do |i|
-         if i.snapshot_type == "manual" and i.db_instance_identifier == @id
-           if i.snapshot_create_time.to_i > latest
-             latest = i.snapshot_create_time.to_i
-           end
-         end
+        if i.snapshot_type == "manual" and i.db_instance_identifier == @id
+          if i.snapshot_create_time.to_i > latest
+            latest = i.snapshot_create_time.to_i
+          end
+        end
       end
       @region.rds.describe_db_snapshots[:db_snapshots].each do |i|
-         if i.snapshot_type == "manual" and i.db_instance_identifier == @id
-           if i.snapshot_create_time.to_i != latest
-             puts "Removing snapshot: #{i.db_snapshot_identifier}/#{i.snapshot_create_time.to_s}"
-             begin
-               @region.rds.delete_db_snapshot({:db_snapshot_identifier => i.db_snapshot_identifier})
-             rescue
-               puts "Error removing snapshot: #{i.db_snapshot_identifier}/#{i.snapshot_create_time.to_s}"
-             end
-           else
-             puts "Keeping snapshot: #{i.db_snapshot_identifier}/#{i.snapshot_create_time.to_s}"
-           end
-         end
-       end
+        if i.snapshot_type == "manual" and i.db_instance_identifier == @id
+          if i.snapshot_create_time.to_i != latest
+            log "Removing snapshot: #{i.db_snapshot_identifier}/#{i.snapshot_create_time.to_s}"
+            begin
+              @region.rds.delete_db_snapshot({:db_snapshot_identifier => i.db_snapshot_identifier})
+            rescue
+              log "Error removing snapshot: #{i.db_snapshot_identifier}/#{i.snapshot_create_time.to_s}"
+              return false
+            end
+          else
+            log "Keeping snapshot: #{i.db_snapshot_identifier}/#{i.snapshot_create_time.to_s}"
+          end
+        end
+      end
+      true
     end
 
+    # Wait for the database to get to a state - we are usually waiting for it to be "available"
+    # @param options [Hash] - Can be:
+    # * :desired_status - Default: "available" - The RDS Status that is sought
+    # * :timeout - Default: 600 seconds. - The time to wait for the status before returning failure
+    # @return [Boolean]
     def wait(options = {:desired_status => "available",
                         :timeout => 600})
       inst = @region.find_db_instances({:instance_id => @id})[0]
       if !inst
-        puts "Error, instance: #{@id} not found"
-        return
+        log "Error, instance: #{@id} not found"
+        return false
       end
       t0 = Time.now.to_i
       while inst.status != options[:desired_status]
         inst = @region.find_db_instances({:instance_id => @id})[0]
-        puts "Database: #{@id} at #{@endpoint}.  Current status: #{inst.status}"
+        log "Database: #{@id} at #{@endpoint}.  Current status: #{inst.status}"
         if Time.now.to_i - t0 > options[:timeout]
-          puts "Timed out waiting for database: #{@id} at #{@endpoint} to move into status: #{options[:desired_status]}.  Current status: #{inst.status}"
-          return
+          log "Timed out waiting for database: #{@id} at #{@endpoint} to move into status: #{options[:desired_status]}.  Current status: #{inst.status}"
+          return false
         end
         sleep 20
       end
+      return true
     end
 
+    # Get the status of a database
+    # @return [String] - Current status of this database
     def status
-       @_instance.db_instance_status
+      @_instance.db_instance_status
     end
 
+    # Get the name of the latest snapshot
+    # @return [Hash] - Hash describing RDS Snapshot.  See [RDS Tech Docs](http://docs.aws.amazon.com/sdkforruby/api/Aws/RDS/V20130909.html)
     def get_latest_db_snapshot(options={})
       snapshot_name = options.has_key?(:snapshot_name) ? options[:snapshot_name] : @id
 
@@ -320,25 +469,41 @@ class AwsRegion
     end
 
   end
-  class AwsInstance
+
+  # Class to handle EC2 Instances
+  class AwsInstance  < AwsBase
     attr_accessor :id, :tags, :region, :private_ip, :public_ip, :_instance
+
     def initialize(region, options = {})
+      @tags = {}
       @region = region
-      if !options.has_key?(:instance)
-        resp = @region.ec2.run_instances(options)
+      if options.has_key?(:instance)
+        @_instance = options[:instance]
+        @id = @_instance[:instance_id]
+        @public_ip = @_instance[:public_ip_address]
+        @private_ip = @_instance[:private_ip_address]
+      else
+        resp = @region.ec2.run_instances(options[:template])
         raise "Error creating instance using options" if resp.nil? or resp[:instances].length <= 0
         @_instance = resp[:instances][0]
-      else
-        @_instance = options[:instance]
+        @id = @_instance[:instance_id]
+        @tags = options[:tags]
+        self.add_tags(@tags)
+        self.wait
+        instance = @region.ec2.describe_instances(:instance_ids => [@id])[0][0].instances[0]
+        @public_ip = instance[:public_ip_address]
+        @private_ip = instance[:private_ip_address]
+        raise "could not get ip address" if @public_ip.nil? && @private_ip.nil?
+        self.inject_into_environment
       end
-      @id = @_instance[:instance_id]
-      @tags = {}
       @_instance.tags.each do |t|
         @tags[t[:key].to_sym] = t[:value]
       end
-      @public_ip = @_instance[:public_ip_address]
-      @private_ip = @_instance[:private_ip_address]
     end
+
+
+    # Determine the state of an ec2 instance
+    # @param use_cached_state [Boolean] - When true will use a cached version of the state rather than querying EC2 directly
     def state(use_cached_state=true)
       if !use_cached_state
         response = @region.ec2.describe_instances({instance_ids: [@id]})
@@ -354,49 +519,57 @@ class AwsRegion
         @_instance.state[:name].strip()
       end
     end
+
+    # Start an EC2 instance
+    # @param wait [Boolean] - When true, will wait for instance to move into "running" state before returning
     def start(wait=false)
       if self.state(use_cached_state = false) != "stopped"
-        puts "Instance cannot be started - #{@region.region}://#{@id} is in the state: #{self.state}"
+        log "Instance cannot be started - #{@region.region}://#{@id} is in the state: #{self.state}"
         return
       end
-      puts "Starting instance: #{@region.region}://#{@id}"
+      log "Starting instance: #{@region.region}://#{@id}"
       @region.ec2.start_instances({:instance_ids => [@id]})
       if wait
         begin
           sleep 10
-          puts "Starting instance: #{@region.region}://#{@id} - state: #{self.state}"
+          log "Starting instance: #{@region.region}://#{@id} - state: #{self.state}"
         end while self.state(use_cached_state = false) != "running"
       end
       if @tags.has_key?("elastic_ip")
         @region.ec2.associate_address({:instance_id => @id, :public_ip => @tags['elastic_ip']})
-        puts "Associated ip: #{@tags['elastic_ip']} with instance: #{@id}"
+        log "Associated ip: #{@tags['elastic_ip']} with instance: #{@id}"
       elsif @tags.has_key?("elastic_ip_allocation_id")
         @region.ec2.associate_address({:instance_id => @id, :allocation_id => @tags['elastic_ip_allocation_id']})
-        puts "Associated allocation id: #{@tags['elastic_ip_allocation_id']} with instance: #{@id}"
+        log "Associated allocation id: #{@tags['elastic_ip_allocation_id']} with instance: #{@id}"
       end
       if @tags.has_key?("elastic_lb")
         self.add_to_lb(@tags["elastic_lb"])
-        puts "Adding instance: #{@id} to '#{@tags['elastic_lb']}' load balancer"
+        log "Adding instance: #{@id} to '#{@tags['elastic_lb']}' load balancer"
       end
     end
-    def set_security_groups(groups)
-      resp = @region.ec2.modify_instance_attribute({:instance_id => @id,
-                                                    :groups => groups})
-    end
+
+    # Add tags to an instance
+    # @param h_tags [Hash] - Hash of tags to add to instance
     def add_tags(h_tags)
       tags = []
-      h_tags.each do |k,v|
+      h_tags.each do |k, v|
         tags << {:key => k.to_s, :value => v}
       end
       resp = @region.ec2.create_tags({:resources => [@id],
                                       :tags => tags})
     end
 
+    # Add an instance to an elastic lb
+    # @param lb_name [String] - Name of elastic load balancer
     def add_to_lb(lb_name)
       @region.elb.register_instances_with_load_balancer({:load_balancer_name => lb_name,
                                                          :instances => [{:instance_id => @id}]})
     end
 
+    # Remove instance from elastic lb
+    # @param instance [AwsInstance] Instance to remove from lb
+    # @param lb_name [String] Lb name from which the instance is to be removed
+    # @return [Aws::PageableResponse]
     def remove_from_lb(lb_name)
       lb = @region.elb.describe_load_balancers({:load_balancer_names => [lb_name]})
       if lb and lb[:load_balancer_descriptions].length > 0
@@ -404,48 +577,178 @@ class AwsRegion
           if lb_i[:instance_id] == @id
             @elb.deregister_instances_from_load_balancer({:load_balancer_name => lb_name,
                                                           :instances => [{:instance_id => @id}]})
+            sleep 30
           end
         end
       end
     end
 
+    # Terminates ec2 instance
     def terminate()
+      eject_from_environment
       @region.ec2.terminate_instances({:instance_ids => [@id]})
     end
 
-    def archive_logs()
-    end
-
+    # Stops an ec2 instance
+    # @param wait [Boolean] - When true, will wait for the instance to be completely stopped before returning
     def stop(wait=false)
       if self.state(use_cached_state = false) != "running"
-        puts "Instance cannot be stopped - #{@region.region}://#{@id} is in the state: #{self.state}"
+        log "Instance cannot be stopped - #{@region.region}://#{@id} is in the state: #{self.state}"
         return
       end
+      self.eject_from_environment
       if @tags.has_key?("elastic_lb")
-        puts "Removing instance: #{@id} from '#{@tags['elastic_lb']}' load balancer"
+        log "Removing instance: #{@id} from '#{@tags['elastic_lb']}' load balancer"
         remove_from_lb(tags["elastic_lb"])
       end
-      puts "Stopping instance: #{@region.region}://#{@id}"
+      log "Stopping instance: #{@region.region}://#{@id}"
       @region.ec2.stop_instances({:instance_ids => [@id]})
       while self.state(use_cached_state = false) != "stopped"
         sleep 10
-        puts "Stopping instance: #{@region.region}://#{@id} - state: #{self.state}"
+        log "Stopping instance: #{@region.region}://#{@id} - state: #{self.state}"
       end if wait
       if self.state(use_cached_state = false) == "stopped"
-        puts "Instance stopped: #{@region.region}://#{@id}"
+        log "Instance stopped: #{@region.region}://#{@id}"
       end
     end
+
+    # Connects using ssh to an ec2 instance
     def connect
       if self.state(use_cached_state = false) != "running"
-        puts "Cannot connect, instance: #{@region.region}://#{@id} due to its state: #{self.state}"
+        log "Cannot connect, instance: #{@region.region}://#{@id} due to its state: #{self.state}"
         return
       end
       ip = self.public_ip != "" ? self.public_ip : self.private_ip
-      #puts "Connecting: ssh -i ~/.ssh/ec2.#{@region.region}.pem #{@tags[:user]}@#{ip}"
-      #exec "ssh -i ~/.ssh/ec2.#{@region.region}.pem #{@tags[:user]}@#{ip}"
-      puts "Connecting: ssh #{@tags[:user]}@#{ip}"
+      log "Connecting: ssh #{@tags[:user]}@#{ip}"
       exec "ssh #{@tags[:user]}@#{ip}"
     end
+    def eject_from_environment
+      if @tags.has_key?(:elastic_lb)
+        log "Removing instance: #{@id} from '#{@tags[:elastic_lb]}' load balancer"
+        self.remove_from_lb(tags[:elastic_lb])
+      end
+      if @tags.has_key?(:security_groups_foreign)
+        self.revoke_sg_ingress(@tags[:security_groups_foreign].split(","))
+      end
+    end
+
+    def inject_into_environment
+      if @tags.has_key?(:elastic_ip)
+        @region.ec2.associate_address({:instance_id => @id, :public_ip => @tags[:elastic_ip]})
+        log "Associated ip: #{@tags[:elastic_ip]} with instance: #{@id}"
+      elsif @tags.has_key?(:elastic_ip_allocation_id)
+        @region.ec2.associate_address({:instance_id => @id, :allocation_id => @tags[:elastic_ip_allocation_id]})
+        log "Associated allocation id: #{@tags[:elastic_ip_allocation_id]} with instance: #{@id}"
+      end
+      if @tags.has_key?(:mount_points)
+        mounts = @tags[:mount_points].split(";")
+        mounts.each do |mnt|
+          (volume_id,device) = mnt.split(",")
+          log "Mounting volume: #{volume_id} on #{device}"
+          self.mount(volume_id, device)
+        end
+      end
+      if @tags.has_key?(:security_group_ids)
+        self.set_security_groups(@tags[:security_group_ids].split(","))
+      end
+      if @tags.has_key?(:security_groups_foreign)
+        self.authorize_sg_ingress(@tags[:security_groups_foreign].split(","))
+      end
+
+      # if any of the above fails, we probably do not want it in the lb
+      if @tags.has_key?(:elastic_lb)
+        self.add_to_lb(@tags[:elastic_lb])
+        log "Adding instance: #{@id} to '#{@tags[:elastic_lb]}' load balancer"
+      end
+    end
+    def wait(options = {:timeout => 300, :desired_status => "running"})
+      t0 = Time.now.to_i
+      begin
+        sleep 10
+        log "Waiting on instance: #{@region.region}://#{@id} - current state: #{self.state}"
+        return if Time.now.to_i - t0 > options[:timeout]
+      end while self.state(use_cached_state = false) != options[:desired_status]
+    end
+
+    def set_security_groups(groups)
+      # only works on instances in a vpc
+      @region.ec2.modify_instance_attribute({:instance_id => @id, :groups => groups})
+    end
+
+    # Does a security group allow ingress on a port for the public IP of this instance
+    # @param group_port [String] - security_group:port  like "sg_xxxxxx:8080"
+    # @return [Boolean] true if the security group allows ingress for the public IP of this instance on a certain port
+    def has_sg_rule?(group_port)
+      options = get_simple_sg_options(group_port)
+      options_cidr_ip = options[:ip_permissions][0][:ip_ranges][0][:cidr_ip]
+      group_id = options[:group_id]
+      raise "missing security group_id" if group_id.nil?
+      sg = @region.ec2.describe_security_groups(:group_ids => [group_id]).data.security_groups[0]
+      sg.ip_permissions.each do |p|
+        if p.ip_protocol == "tcp" &&
+            p.from_port == options[:ip_permissions][0][:from_port] &&
+            p.to_port == options[:ip_permissions][0][:to_port]
+          p[:ip_ranges].each do |ipr|
+            return true if ipr.cidr_ip == options_cidr_ip
+          end
+        end
+      end
+      false
+    end
+
+    # authorize security group ingress for public ip of this instance on port
+    # @param groups [Array] - each element is String: "security_group_id:port". For example: ["sg-0xxxxx:80", "sg-0xxxxx:8443", "sg-0yyyyy:3000"]
+    def authorize_sg_ingress(groups)
+      raise "no public ip" unless @public_ip.to_s.match /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
+      groups.each do |gp|
+        options = get_simple_sg_options(gp)
+        if has_sg_rule?(gp)
+          log "security group rule #{gp} for #{self.public_ip} already exists"
+        else
+          @region.ec2.authorize_security_group_ingress options
+          log "added #{self.public_ip} to security group for :port #{gp}"
+        end
+      end
+    end
+
+    # revoke security group ingress for public ip of this instance on port
+    # @param groups [Array] - each element is String: "security_group_id:port". For example: ["sg-0xxxxx:80", "sg-0xxxxx:8443", "sg-0yyyyy:3000"]
+    def revoke_sg_ingress(groups)
+      # revoke the public ip of this instance for ingress on port for security group
+      # groups is array of strings: security_group_id:port
+      raise "no public ip" unless @public_ip.to_s.match /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
+      groups.each do |gp|
+        options = get_simple_sg_options(gp)
+        if has_sg_rule?(gp)
+          @region.ec2.revoke_security_group_ingress options
+          log "removed #{self.public_ip} from security group for :port #{gp}"
+        else
+          log "not removing #{self.public_ip} rule #{gp} because it does not exist"
+        end
+      end
+    end
+    def mount(volume_id, device)
+      @region.ec2.attach_volume({:instance_id => @id,
+                                 :volume_id => volume_id,
+                                 :device => device})
+    end
+
+    # construct hash for authorize/revoke ingress and has_sg_rule?
+    # @param group_id_port [String] - security_group:port  like "sg_xxxxxx:8080"
+    # @return [Hash] - Hash for ec2 call for security group management
+    def get_simple_sg_options(group_id_port)
+      security_group_id, port = group_id_port.split(':')
+      port = port.to_s.to_i
+      raise "no security group id" unless security_group_id.to_s.length > 0
+      raise "no, or invalid port" unless port.to_s.to_i > 0
+      {:group_id => security_group_id,
+       :ip_permissions => [ :ip_protocol => "tcp",
+                            :from_port => port,
+                            :to_port => port,
+                            :ip_ranges => [:cidr_ip => "#{self.public_ip}/32"]
+                          ]
+      }
+    end
 
 
   end

metadata

@@ -1,58 +1,73 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: aws-tools
-version: !ruby/object:Gem::Version
-  version: 0.0.2
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
 platform: ruby
-authors:
+authors: 
 - Kevin Connors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-12-02 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
 description: A set of simple tools to bind some essential functions of aws resources
 email: karmet@gmail.com
-executables: []
+executables: 
+- aws_manager.rb
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - lib/aws_region.rb
+has_rdoc: true
 homepage: http://rubygems.org/gems/aws-tools
-licenses:
+licenses: 
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 1.3.6
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: A set of simple tools to bind some essential functions of aws resources
 test_files: []
+

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YjkzYzUwNTA3MWE0YTE1NDAzYmY5ZDcxZWI2ZjBlNzFlNGQ4NTc2Zg==
-  data.tar.gz: !binary |-
-    OTg4ZmVmMjNlMjJkZTQyY2NmYTU0NTc4ZDdiODFhMWQ2OWE3NTVjMQ==
-SHA512:
-  metadata.gz: !binary |-
-    ZGRkOTFhYTRmOWZjMWI2N2ExMjEzOWJjMzU5MjlhMGY2N2Q5YmRmYjk3ZDY0
-    NGRjYjRlMWJmZGE1ZjkxZTZhOWQ5OTYzZGY1ZmM4MjNlM2Q4OWI2NGVhNWNm
-    OWYxNTgwM2NhMzg4Nzk2MWI3YjQzZTYzNjExNGMwYTAzNDllZGM=
-  data.tar.gz: !binary |-
-    MzY2NTY4OTAzOTk3ZjZlZDZhMzA3Y2JmMmVmMjAxNTQ3ZmI5YjcxNzdjOGFl
-    ZDgxYzg3ODYxMTY3MjEwZWI1MjFmNTI3ZmJhNWMzNjczYmY1NjhjZmE4ZTE4
-    Y2IzNjRhODM1MzdmNTU4M2Y3MDlmZjJmMjE0NDg0NWQ3Zjc4MTg=