solutious-rudy 0.5.1 → 0.6.0

data/lib/rudy/aws/sdb/error.rb

@@ -0,0 +1,46 @@
+module Rudy
+  module AWS
+    class SDB
+
+      class Error < RuntimeError ; end
+
+      class RequestError < Error
+        attr_reader :request_id
+
+        def initialize(message, request_id=nil)
+          super(message)
+          @request_id = request_id
+        end
+      end
+
+      class InvalidDomainNameError < RequestError ; end
+      class InvalidParameterValueError < RequestError ; end
+      class InvalidNextTokenError < RequestError ; end
+      class InvalidNumberPredicatesError < RequestError ; end
+      class InvalidNumberValueTestsError < RequestError ; end
+      class InvalidQueryExpressionError < RequestError ; end
+      class MissingParameterError < RequestError ; end
+      class NoSuchDomainError < RequestError ; end
+      class NumberDomainsExceededError < RequestError ; end
+      class NumberDomainAttributesExceededError < RequestError ; end
+      class NumberDomainBytesExceededError < RequestError ; end
+      class NumberItemAttributesExceededError < RequestError ; end
+      class RequestTimeoutError < RequestError ; end
+
+      class FeatureDeprecatedError < RequestError ; end
+
+      class ConnectionError < Error
+        attr_reader :response
+
+        def initialize(response)
+          super(
+            "#{response.code} \
+             #{response.message if response.respond_to?(:message)}"
+          )
+          @response = response
+        end
+      end
+      
+    end
+  end
+end

data/lib/rudy/aws/sdb.rb

@@ -0,0 +1,298 @@
+
+require 'time'
+require 'cgi'
+require 'uri'
+require 'net/http'
+require 'base64'
+require 'openssl'
+require 'rexml/document'
+require 'rexml/xpath'
+
+module Rudy
+  module AWS
+    class SDB
+      class NoAccessKey < RuntimeError; end
+      class NoSecretKey < RuntimeError; end
+        
+      require 'rudy/aws/sdb/error'
+      
+      def initialize(access_key=nil, secret_key=nil, region=nil, debug=nil)
+        raise NoAccessKey if access_key.nil? || access_key.empty?
+        raise NoSecretKey if secret_key.nil? || secret_key.empty?
+          
+        url ||= 'http://sdb.amazonaws.com'
+        # There is a bug with passing :server to EC2::Base.new so 
+        # we'll use the environment variable for now. 
+        #if region && Rudy::AWS.valid_region?(region)
+        #  "#{region}.sdb.amazonaws.com"
+        #end
+        
+        @access_key_id = access_key || ENV['AWS_ACCESS_KEY']
+        @secret_access_key = secret_key || ENV['AWS_SECRET_KEY']
+        @base_url = url
+        @debug = debug || StringIO.new
+      end
+
+      def list_domains(max = nil, token = nil)
+        params = { 'Action' => 'ListDomains' }
+        params['NextToken'] =
+          token unless token.nil? || token.empty?
+        params['MaxNumberOfDomains'] =
+          max.to_s unless max.nil? || max.to_i == 0
+        doc = call(:get, params)
+        results = []
+        REXML::XPath.each(doc, '//DomainName/text()') do |domain|
+          results << domain.to_s
+        end
+        #return results, REXML::XPath.first(doc, '//NextToken/text()').to_s
+        results
+      end
+
+      def create_domain(domain)
+        call(:post, { 'Action' => 'CreateDomain', 'DomainName'=> domain.to_s })
+        true
+      end
+
+      def destroy_domain(domain)
+        call(
+          :delete,
+          { 'Action' => 'DeleteDomain', 'DomainName' => domain.to_s }
+        )
+        true
+      end
+      
+      
+      # Takes a zipped Array or Hash of criteria.
+      # Returns a string suitable for a SimpleDB Select
+      def self.generate_select(*args)
+        fields, domain, args = *args
+        q = args.is_a?(Hash) ? args : Hash[*args.flatten]
+        query = []
+        q.each do |n,v| 
+          query << "#{Rudy::AWS.escape n}='#{Rudy::AWS.escape v}'"
+        end
+        "select * from #{domain} where " << query.join(' and ')
+      end
+
+      
+      # Takes a zipped Array or Hash of criteria.
+      # Returns a string suitable for a SimpleDB Query
+      def self.generate_query(*args)
+        q = args.first.is_a?(Hash)? args.first : Hash[*args.flatten]
+        query = []
+        q.each do |n,v| 
+          query << "['#{Rudy::AWS.escape n}'='#{Rudy::AWS.escape v}']"
+        end
+        query.join(" intersection ")
+      end
+
+
+      def select(select, token = nil)
+        params = {
+          'Action' => 'Select',
+          'SelectExpression' => select,
+        }
+        params['NextToken'] =
+          token unless token.nil? || token.empty?
+
+        doc = call(:get, params)
+        results = []
+        REXML::XPath.each(doc, "//Item") do |item|
+          name = REXML::XPath.first(item, './Name/text()').to_s
+
+          attributes = {'Name' => name}
+          REXML::XPath.each(item, "./Attribute") do |attr|
+            key = REXML::XPath.first(attr, './Name/text()').to_s
+            value = REXML::XPath.first(attr, './Value/text()').to_s
+            ( attributes[key] ||= [] ) << value
+          end
+          results << attributes
+        end
+        #return results, REXML::XPath.first(doc, '//NextToken/text()').to_s
+        
+        hash_results = {}
+        results.each do |item|
+          hash_results[item.delete('Name')] = item
+        end
+        
+        hash_results.empty? ? nil : hash_results
+      end
+      
+      # <QueryResult><ItemName>in-c2ffrw</ItemName><ItemName>in-72yagt</ItemName><ItemName>in-52j8gj</ItemName>
+      def query(domain, query, max = nil, token = nil)
+        params = {
+          'Action' => 'Query',
+          'QueryExpression' => query,
+          'DomainName' => domain.to_s
+        }
+        params['NextToken'] =
+          token unless token.nil? || token.empty?
+        params['MaxNumberOfItems'] =
+          max.to_s unless max.nil? || max.to_i == 0
+
+
+        doc = call(:get, params)
+        results = []
+        REXML::XPath.each(doc, '//ItemName/text()') do |item|
+          results << item.to_s
+        end
+        
+        #return results, REXML::XPath.first(doc, '//NextToken/text()').to_s
+        results.empty? ? nil : results
+        
+      end
+
+
+
+      # <QueryWithAttributesResult><Item><Name>in-c2ffrw</Name><Attribute><Name>code</Name><Value>in-c2ffrw</Value></Attribute><Attribute><Name>date_created</Name><Value>2008-10-31</Value></Attribute></Item><Item>
+      def query_with_attributes(domain, query, max = nil, token = nil)
+        params = {
+          'Action' => 'QueryWithAttributes',
+          'QueryExpression' => query,
+          'DomainName' => domain.to_s
+        }
+        params['NextToken'] =
+          token unless token.nil? || token.empty?
+        params['MaxNumberOfItems'] =
+          max.to_s unless max.nil? || max.to_i == 0
+
+        doc = call(:get, params)
+        results = []
+        REXML::XPath.each(doc, "//Item") do |item|
+          name = REXML::XPath.first(item, './Name/text()').to_s
+
+          attributes = {'Name' => name}
+          REXML::XPath.each(item, "./Attribute") do |attr|
+            key = REXML::XPath.first(attr, './Name/text()').to_s
+            value = REXML::XPath.first(attr, './Value/text()').to_s
+            ( attributes[key] ||= [] ) << value
+          end
+          results << attributes
+        end
+        #return results, REXML::XPath.first(doc, '//NextToken/text()').to_s
+        
+        hash_results = {}
+        results.each do |item|
+          hash_results[item.delete('Name')] = item
+        end
+        
+        hash_results
+      end
+
+
+
+      def put_attributes(domain, item, attributes, replace = true)
+        replace = true if replace == :replace
+        params = {
+          'Action' => 'PutAttributes',
+          'DomainName' => domain.to_s,
+          'ItemName' => item.to_s
+        }
+        count = 0
+        
+        attributes.each do | key, values |
+          ([]<<values).flatten.each do |value|
+            params["Attribute.#{count}.Name"] = key.to_s
+            params["Attribute.#{count}.Value"] = value.to_s
+            params["Attribute.#{count}.Replace"] = replace
+            count += 1
+          end
+        end
+        
+        call(:put, params)
+        
+        true
+      end
+      alias :put :put_attributes
+      
+      def get_attributes(domain, item)
+        doc = call(
+          :get,
+          {
+            'Action' => 'GetAttributes',
+            'DomainName' => domain.to_s,
+            'ItemName' => item.to_s
+          }
+        )
+        attributes = {}
+        REXML::XPath.each(doc, "//Attribute") do |attr|
+          key = REXML::XPath.first(attr, './Name/text()').to_s
+          value = REXML::XPath.first(attr, './Value/text()').to_s
+          ( attributes[key] ||= [] ) << value
+        end
+        attributes = nil if attributes.empty?
+        attributes
+      end
+      alias :get :get_attributes
+      
+      
+      def delete_attributes(domain, item)
+        call(
+          :delete,
+          {
+            'Action' => 'DeleteAttributes',
+            'DomainName' => domain.to_s,
+            'ItemName' => item.to_s
+          }
+        )
+        true
+      end
+      alias :destroy :delete_attributes
+      
+
+
+    protected
+
+      def call(method, params)
+        params.merge!( {
+            'Version' => '2007-11-07',
+            'SignatureVersion' => '1',
+            'AWSAccessKeyId' => @access_key_id,
+            'Timestamp' => Time.now.gmtime.iso8601
+          }
+        )
+        data = ''
+        query = []
+        
+        params.keys.sort_by { |k| k.upcase }.each do |key|
+          data << "#{key}#{params[key].to_s}"
+          query << "#{key}=#{CGI::escape(params[key].to_s)}"
+        end
+        
+        digest = OpenSSL::Digest::Digest.new('sha1')
+        hmac = OpenSSL::HMAC.digest(digest, @secret_access_key, data)
+        signature = Base64.encode64(hmac).strip
+        query << "Signature=#{CGI::escape(signature)}"
+        query = query.join('&')
+        url = "#{@base_url}?#{query}"
+        uri = URI.parse(url)
+        @debug.puts("#{url}") if @debug
+        
+        response =
+          Net::HTTP.new(uri.host, uri.port).send_request(method, uri.request_uri)
+        @debug.puts("#{response.code}\n#{response.body}") if @debug
+        raise(ConnectionError.new(response)) unless (200..400).include?(
+          response.code.to_i
+        )
+        
+        doc = REXML::Document.new(response.body)
+        error = doc.get_elements('*/Errors/Error')[0]
+        raise(
+          Module.class_eval(
+            "AwsSdb::#{error.get_elements('Code')[0].text}Error"
+          ).new(
+            error.get_elements('Message')[0].text,
+            doc.get_elements('*/RequestID')[0].text
+          )
+        ) unless error.nil?
+        
+        doc
+      end
+    end
+
+  end
+end
+
+require 'aws_sdb/error'
+require 'aws_sdb/service'
+

data/lib/rudy/aws.rb

@@ -1,30 +1,28 @@
 
 
-require 'EC2'
-require 'aws_sdb'
+require 'EC2'       # What a
+require 'aws_sdb'   # motley
+require 'aws/s3'    # crew
 
 module Rudy
   module AWS
     extend self
-    @@ec2 = @@sdb = @@s3 = nil
     
+    unless defined?(Rudy::AWS::VALID_REGIONS)
+      VALID_REGIONS = ['eu-west-1', 'us-east-1'].freeze
+    end
     
-    def ec2; @@ec2; end
-    def sdb; @@sdb; end
-    def  s3; @@s3;  end
+    def valid_region?(r); VALID_REGIONS.member?(r.to_s || ''); end
     
-    def set_access_identifiers(accesskey, secretkey, logger=nil)
-      @@ec2 ||= Rudy::AWS::EC2.new(accesskey, secretkey)
-      @@sdb ||= Rudy::AWS::SimpleDB.new(accesskey, secretkey)
-      #@@s3 ||= Rudy::AWS::S3.new(accesskey, secretkey)
+    # Modifies +str+ by removing <tt>[\0\n\r\032\\\\]</tt> and escaping <tt>[\'\"]</tt>
+    def escape(str)
+      str.to_s.tr("[\0\n\r\032\\\\]", '').gsub(/([\'\"])/, '\\1\\1')
     end
-      
+    def escape!(str)
+      str.to_s.tr!("[\0\n\r\032\\\\]", '').gsub!(/([\'\"])/, '\\1\\1')
+    end
+    
     module ObjectBase
-      attr_accessor :aws
-      def initialize(aws_connection)
-        @aws = aws_connection
-      end
-      
       
     protected
 
@@ -42,14 +40,21 @@ module Rudy
           Timeout::timeout(timeout) do
             response = request.call
           end
-        rescue ::EC2::Error => ex
-          STDERR.puts ex.message
-        rescue ::EC2::InvalidInstanceIDMalformed => ex
-          STDERR.puts ex.message
+        # Raise the EC2 exceptions
+        rescue ::EC2::Error, ::EC2::InvalidInstanceIDMalformed => ex  
+          raise Rudy::AWS::Error, ex.message
+        
+        # NOTE: The InternalError is returned for non-existent volume IDs. 
+        # It's probably a bug so we're ignoring it -- Dave. 
+        rescue ::EC2::InternalError => ex
+          raise Rudy::AWS::Error, ex.message
+          
         rescue Timeout::Error => ex
           STDERR.puts "Timeout (#{timeout}): #{ex.message}!"
         rescue SocketError => ex
           STDERR.puts "Socket Error. Check your Internets!"
+          STDERR.puts ex.message
+          STDERR.puts ex.backtrace
         ensure
           response ||= default
         end
@@ -57,47 +62,14 @@ module Rudy
       end
     end
     
-
-  
-    class S3
-      @@logger = StringIO.new
-
-      attr_reader :aws
-
-      def initialize(access_key, secret_key)
-       # @aws = RightAws::S3.new(access_key, secret_key, {:logger => Logger.new(@@logger)})
-      end
-    end
-    
-    class SimpleDB
-      @@logger = StringIO.new
-    
-      attr_reader :domains
-      attr_reader :aws
-    
-      def initialize(access_key, secret_key)
-        @aws = AwsSdb::Service.new(:access_key_id => access_key, :secret_access_key => secret_key, :logger => Logger.new(@@logger))
-        @domains = Rudy::AWS::SimpleDB::Domains.new(@aws)
-      end
-
-    end
-    
-    require 'rudy/aws/simpledb'
+    require 'rudy/aws/sdb'
     require 'rudy/aws/ec2'
     require 'rudy/aws/s3'
     
+    Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'aws', '{ec2,s3,sdb}', "*.rb")
+    
+    class Error < ::EC2::Error; end
   end
   
 end
 
-# Require EC2, S3, Simple DB class
-begin
-  # TODO: Use autoload
-  Dir.glob(File.join(RUDY_LIB, 'rudy', 'aws', '{ec2,s3,sdb}', "*.rb")).each do |path|
-    require path
-  end
-rescue LoadError => ex
-  puts "Error: #{ex.message}"
-  exit 1
-end
-

data/lib/rudy/{metadata/backup.rb → backup.rb}

@@ -51,7 +51,7 @@ module Rudy
       def time_stamp
         #return [@date, @time] if @date && @time
         now = Time.now.utc
-        datetime = Backup.format_timestamp(now).split(RUDY_DELIM)
+        datetime = Backup.format_timestamp(now).split(Rudy::DELIM)
         @unixtime = now.to_i
         @date, @time, @second = datetime
       end
@@ -66,7 +66,7 @@ module Rudy
       def to_query(more=[], remove=[])
         criteria = [:rtype, :zone, :environment, :role, :position, :path, :date, :time, :second, *more]
         criteria -= [*remove].flatten
-        query = "select * from #{RUDY_DOMAIN} where unixtime > '0' "
+        query = "select * from #{Rudy::DOMAIN} where unixtime > '0' "
         criteria.each do |n|
           query << "and #{n} = '#{self.send(n.to_sym)}'"
         end
@@ -88,7 +88,7 @@ module Rudy
       # 20090224-1813-36
       def Backup.format_timestamp(dat)
         mon, day, hour, min, sec = [dat.mon, dat.day, dat.hour, dat.min, dat.sec].collect { |v| v.to_s.rjust(2, "0") }
-        [dat.year, mon, day, RUDY_DELIM, hour, min, RUDY_DELIM, sec].join
+        [dat.year, mon, day, Rudy::DELIM, hour, min, Rudy::DELIM, sec].join
       end
       
       # Times are converted to UTC
@@ -99,7 +99,7 @@ module Rudy
         dirs = pat.split sep if pat
         dirs.shift while dirs && (dirs[0].nil? || dirs[0].empty?)
         timestamp = Backup.format_timestamp(dat.utc)
-        [rtype, zon, env, rol, pos, dirs, timestamp].flatten.join(RUDY_DELIM)
+        [rtype, zon, env, rol, pos, dirs, timestamp].flatten.join(Rudy::DELIM)
       end
       
       
@@ -110,22 +110,22 @@ module Rudy
       end
       
       def save
-        @@sdb.store(RUDY_DOMAIN, name, self.to_hash, :replace) # Always returns nil
+        @@sdb.store(Rudy::DOMAIN, name, self.to_hash, :replace) # Always returns nil
         true
       end
       
       def destroy
-        @@sdb.destroy(RUDY_DOMAIN, name)
+        @@sdb.destroy(Rudy::DOMAIN, name)
         true
       end
       
       def refresh
-        h = @@sdb.get(RUDY_DOMAIN, name) || {}
+        h = @@sdb.get(Rudy::DOMAIN, name) || {}
         from_hash(h)
       end
       
       def Backup.get(dname)
-        h = @@sdb.get(RUDY_DOMAIN, dname) || {}
+        h = @@sdb.get(Rudy::DOMAIN, dname) || {}
         from_hash(h)
       end
       

data/lib/rudy/cli/aws/ec2/addresses.rb

@@ -0,0 +1,105 @@
+
+
+module Rudy; module CLI; 
+module AWS; module EC2;
+  
+  class Addresses < Rudy::CLI::CommandBase
+    
+    def addresses_create
+      radd = Rudy::AWS::EC2::Addresses.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      address = radd.create
+      puts @@global.verbose > 0 ? address.inspect : address.dump(@@global.format)
+    end
+    
+    def addresses_destroy_valid?
+      raise Drydock::ArgError.new("IP address", @alias) unless @argv.ipaddress
+      @radd = Rudy::AWS::EC2::Addresses.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      raise "#{@argv.ipaddress} is not allocated to you" unless @radd.exists?(@argv.ipaddress)
+      raise "#{@argv.ipaddress} is associated!" if @radd.associated?(@argv.ipaddress)
+      true
+    end
+    def addresses_destroy
+      address = @radd.get(@argv.ipaddress)
+      raise "Could not fetch #{address.ipaddress}" unless address
+      
+      puts "Destroying address: #{@argv.ipaddress}"
+      puts "NOTE: this IP address will become available to other EC2 customers.".color(:blue)
+      execute_check(:medium)
+      execute_action { @radd.destroy(@argv.ipaddress) }
+      self.addresses
+    end
+
+    def associate_addresses_valid?
+      raise Drydock::ArgError.new('IP address', @alias) if !@argv.ipaddress && !@option.newaddress
+      raise Drydock::OptError.new('instance ID', @alias) if !@option.instance
+      true
+    end
+    def associate_addresses
+      radd = Rudy::AWS::EC2::Addresses.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      rinst = Rudy::AWS::EC2::Instances.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      
+      raise "Instance #{@argv.instid} does not exist!" unless rinst.exists?(@option.instance)
+      
+      if @option.newaddress
+        print "Creating address... "
+        tmp = radd.create
+        puts "#{tmp.ipaddress}"
+        address = tmp.ipaddress
+      else
+        address = @argv.ipaddress
+      end
+      
+      raise "#{address} is not allocated to you" unless radd.exists?(address)
+      raise "#{address} is already associated!" if radd.associated?(address)
+          
+      instance = rinst.get(@option.instance)
+      
+      # If an instance was recently disassoiciated, the dns_public may
+      # not be updated yet
+      instance_name = instance.dns_public
+      instance_name = instance.awsid if !instance_name || instance_name.empty?
+      
+      puts "Associating #{address} to #{instance_name} (#{instance.groups.join(', ')})"
+      execute_check(:low)
+      execute_action { radd.associate(address, instance.awsid) }
+      address = radd.get(address)
+      puts @@global.verbose > 0 ? address.inspect : address.dump(@@global.format)
+    end
+    
+    def disassociate_addresses_valid?
+      raise "You have not supplied an IP addresses" unless @argv.ipaddress
+      true
+    end
+    def disassociate_addresses
+      radd = Rudy::AWS::EC2::Addresses.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      rinst = Rudy::AWS::EC2::Instances.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      raise "#{@argv.ipaddress} is not allocated to you" unless radd.exists?(@argv.ipaddress)
+      raise "#{@argv.ipaddress} is not associated!" unless radd.associated?(@argv.ipaddress)
+      
+      address = radd.get(@argv.ipaddress)
+      instance = rinst.get(address.instid)
+      
+      puts "Disassociating #{address.ipaddress} from #{instance.awsid} (#{instance.groups.join(', ')})"
+      execute_check(:medium)
+      execute_action { radd.disassociate(@argv.ipaddress) }
+      address = radd.get(@argv.ipaddress)
+      puts @@global.verbose > 0 ? address.inspect : address.dump(@@global.format)
+    end
+    
+    def addresses
+      radd = Rudy::AWS::EC2::Addresses.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      addresses = radd.list || []
+      
+      addresses.each do |address|
+        puts @@global.verbose > 0 ? address.inspect : address.dump(@@global.format)
+      end
+      
+      puts "No Addresses" if addresses.empty?
+    end
+    
+    
+  end
+
+end; end
+end; end
+