sabat-rudy 0.8.0

data/lib/rudy/aws/s3.rb

@@ -0,0 +1,60 @@
+
+module Rudy::AWS
+  class S3
+    
+    def initialize(access_key=nil, secret_key=nil, region=nil, debug=nil)
+     
+      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'] || ENV['AMAZON_ACCESS_KEY_ID']
+      @secret_access_key = secret_key || ENV['AWS_SECRET_KEY'] || ENV['AMAZON_SECRET_ACCESS_KEY']
+      @base_url = url
+      @debug = debug || StringIO.new
+      
+      
+      AWS::S3::Base.establish_connection!(
+        :access_key_id     => @access_key_id,
+        :secret_access_key => @secret_access_key
+      )
+      
+    end
+    
+    def list_buckets
+      ::AWS::S3::Service.buckets
+    end
+    
+    def create_bucket(name, location=nil)
+      opts = {}
+      opts[:location] = location.to_s.upcase if location
+      ::AWS::S3::Bucket.create(name, opts)
+    end
+    
+    def destroy_bucket(name)
+      ::AWS::S3::Bucket.delete(name)
+    end
+    
+    def find_bucket(name)
+      blist = ::AWS::S3::Service.buckets
+      blist.select { |bobj| bobj.name == name }.first
+    end
+    
+    def list_bucket_objects(name)
+      ::AWS::S3::Bucket.objects(name)
+    end
+    
+    #def store(path, bucket)
+    #  fname = File.basename(path)
+    #  S3Object.store(fname, open(path), bucket)
+    #end
+    
+    def bucket_exists?(name)
+      b = find_bucket(name)
+      !b.nil?
+    end
+  end
+end

data/lib/rudy/aws/sdb.rb

@@ -0,0 +1,312 @@
+
+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
+      include Rudy::AWS::ObjectBase
+      
+      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 = []
+        if doc
+          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
+        end
+        
+        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 = []
+        if doc
+          REXML::XPath.each(doc, '//ItemName/text()') do |item|
+            results << item.to_s
+          end
+        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 = []
+        if doc
+          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
+        end
+        
+        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 = {}
+        if doc
+          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
+        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 = execute_request(nil) {
+          Net::HTTP.new(uri.host, uri.port).send_request(method, uri.request_uri)
+        }
+        
+        if !response.nil?
+        
+          @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?
+        else
+          doc = nil
+        end
+        doc
+      end
+    end
+
+  end
+end
+
+

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

@@ -0,0 +1,47 @@
+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 < Rudy::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/cli.rb

@@ -0,0 +1,186 @@
+
+require 'drydock'
+
+
+module Rudy
+    
+  # = CLI
+  # 
+  # These classes provide the functionality for the Command
+  # line interfaces. See the bin/ files if you're interested. 
+  # 
+  module CLI
+    class NoCred < RuntimeError #:nodoc
+    end
+    
+    class Output < Storable
+      # TODO: Use for all CLI responses
+      # Messages and errors should be in @@global.format
+      # Should print messages as they come
+    end
+    
+    class CommandBase < Drydock::Command
+      include Rudy::Huxtable
+      
+      attr_reader :config
+      
+    protected
+      def init
+        
+        if Drydock.debug?
+          #Caesars.enable_debug
+          Rudy.enable_debug
+        end
+        
+        # The CLI wants output!
+        Rudy::Huxtable.update_logger STDOUT
+        
+        # Send The Huxtables the global values from the command-line
+        Rudy::Huxtable.update_global @global
+        
+        # Reload configuration. This must come after update_global 
+        # so it will catch the @@global.config path (if supplied).
+        begin
+          Rudy::Huxtable.update_config
+        rescue Caesars::SyntaxError => ex
+          STDERR.puts ex.message
+          STDERR.puts ex.backtrace if @@global.verbose > 0
+          exit 81
+        end
+        
+        # And then update global again b/c some values come from @@config
+        Rudy::Huxtable.update_global
+        
+        @@global.nocolor ? String.disable_color : String.enable_color
+        @@global.yes ? Annoy.enable_skip : Annoy.disable_skip
+      
+        unless @@global.accesskey && @@global.secretkey
+          STDERR.puts "No AWS credentials. Check your configs!"
+          STDERR.puts "Try: rudy init"
+          exit 1
+        end
+        
+        if @@global.environment =~ /^prod/ && Drydock.debug?
+          puts Rudy::Utils.banner("PRODUCTION ACCESS IS DISABLED IN DEBUG MODE")
+          exit 1
+        end
+        
+      end
+      
+      def execute_action(emsg="Failed", &action)
+        begin
+          ret = action.call
+          raise emsg unless ret
+          ret
+        rescue Rudy::AWS::EC2::NoAMI => ex
+          raise Drydock::OptError.new('-a', @alias)
+        end
+      end
+      
+      def execute_check(level=:medium)
+        ret = Annoy.are_you_sure?(level)
+        exit 0 unless ret
+        ret
+      end
+      
+      # Print a default header to the screen for every command.
+      #
+      def print_header
+        
+        # Send The Huxtables the global values again because they could be
+        # updated after initialization but before the command was executed
+        Rudy::Huxtable.update_global @global
+        
+        puts Rudy::CLI.generate_header(@@global, @@config) if @@global.print_header
+        
+        unless @@global.quiet
+          if @@global.environment == "prod"
+            msg = "YOU ARE PLAYING WITH PRODUCTION"
+            puts Rudy::Utils.banner(msg, :normal), $/
+          end
+          puts Rudy::Utils.banner("THIS IS EC2"), $/ if Rudy.in_situ?
+        end
+      end
+      
+      def machine_separator(name, awsid)
+        dashes = 80 - name.size # 
+        dashes = 0 if dashes < 1
+        ('%s %-63s awsid: %s ' % [$/, name, awsid]).att(:reverse)
+      end
+      
+    end
+
+    def self.generate_header(global, config)
+      return "" if global.quiet
+      header = StringIO.new
+      title, name = "RUDY v#{Rudy::VERSION}", config.accounts.aws.name
+      now_utc = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+      criteria = []
+      [:region, :zone, :environment, :role, :position].each do |n|
+        key, val = n.to_s.slice(0,1).att, global.send(n) 
+        key = 'R' if n == :region
+        next unless val
+        criteria << "#{key.att}:#{val.to_s.bright}"
+      end
+      if config.accounts && config.accounts.aws
+        if global.verbose > 0
+          header.puts '%s -- %s -- %s UTC' % [title, name, now_utc]
+        end
+        header.puts '[%s]' % [criteria.join("  ")], $/
+      end
+      header.rewind
+      header.read
+    end
+
+
+    # A base for all Drydock executables (bin/rudy etc...). 
+    class Base
+      extend Drydock
+      
+      before do |obj|
+        # Don't print Rudy header unless requested to
+        obj.global.print_header = false  if (obj.global.verbose == 0)
+        @start = Time.now
+      end
+
+      after do |obj|  
+        if obj.global.verbose > 0
+          puts
+          @elapsed = Time.now - @start
+          puts "Elapsed: %.2f seconds" % @elapsed.to_f if @elapsed > 0.1
+        end
+      end
+      
+      
+      # These globals are used by all bin/ executables
+      global :A, :accesskey, String, "AWS Access Key"
+      global :S, :secretkey, String, "AWS Secret Access Key"
+      global :R, :region, String, "Amazon service region (ie: #{Rudy::DEFAULT_REGION})"
+      global :z, :zone, String, "Amazon Availability zone (ie: #{Rudy::DEFAULT_ZONE})"
+      global :u, :user, String, "Provide a username (ie: #{Rudy::DEFAULT_USER})"
+      global :k, :pkey, String, "Path to the private SSH key"
+      global :f, :format, String, "Output format"
+      global :n, :nocolor, "Disable output colors"
+      global :C, :config, String, "Specify another configuration file to read (ie: #{Rudy::CONFIG_FILE})"
+      global :Y, :yes, "Assume a correct answer to confirmation questions"
+      global :q, :quiet, "Run with less output"
+      global :O, :offline, "Be cool about the internet being down"
+      global :v, :verbose, "Increase verbosity of output (i.e. -v or -vv or -vvv)" do
+        @verbose ||= 0
+        @verbose += 1
+      end
+      global :V, :version, "Display version number" do
+        puts "Rudy version: #{Rudy::VERSION}"
+        exit 0
+      end
+      
+    end
+    
+    
+  end
+
+end
+
+Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'cli', '**', '*.rb')
+
+