rudy 0.8.5 → 0.9.0

data/lib/rudy/aws/ec2/keypair.rb

@@ -2,7 +2,7 @@
 module Rudy::AWS
   module EC2
     
-    class KeyPair < Storable
+    class Keypair < Storable
       
       field :name
       field :fingerprint
@@ -25,20 +25,20 @@ module Rudy::AWS
 
     end
     
-    class KeyPairs
-      include Rudy::AWS::ObjectBase
-      include Rudy::AWS::EC2::Base
+    module EC2::Keypairs
+      include Rudy::AWS::EC2  # important! include,
+      extend self             # then extend
       
       def create(name)
         raise "No name provided" unless name
-        ret = @ec2.create_keypair(:key_name => name)
-        self.class.from_hash(ret)
+        ret = @@ec2.create_keypair(:key_name => name)
+        from_hash(ret)
       end
       
       def destroy(name)
-        name = name.name if name.is_a?(Rudy::AWS::EC2::KeyPair)
+        name = name.name if name.is_a?(Rudy::AWS::EC2::Keypair)
         raise "No name provided" unless name.is_a?(String)
-        ret = @ec2.delete_keypair(:key_name => name)
+        ret = @@ec2.delete_keypair(:key_name => name)
         (ret && ret['return'] == 'true') # BUG? Always returns true
       end
       
@@ -50,23 +50,24 @@ module Rudy::AWS
       
       def list_as_hash(*names)
         names = names.flatten
-        klist = @ec2.describe_keypairs(:key_name => names)
+        klist = @@ec2.describe_keypairs(:key_name => names)
         return unless klist['keySet'].is_a?(Hash)
         keypairs = {}
         klist['keySet']['item'].each do |oldkp| 
-          kp = self.class.from_hash(oldkp)
+          kp = from_hash(oldkp)
           keypairs[kp.name] = kp
         end
+        keypairs = nil if keypairs.empty?
         keypairs
       end
       
-      def self.from_hash(h)
+      def from_hash(h)
         # keyName: test-c5g4v3pe
         # keyFingerprint: 65:d0:ce:e7:6a:b0:88:4a:9c:c7:2d:b8:33:0c:fd:3b:c8:0f:0a:3c
         # keyMaterial: |-
         #   -----BEGIN RSA PRIVATE KEY-----
         # 
-        keypair = Rudy::AWS::EC2::KeyPair.new
+        keypair = Rudy::AWS::EC2::Keypair.new
         keypair.fingerprint = h['keyFingerprint']
         keypair.name = h['keyName']
         keypair.private_key = h['keyMaterial']
@@ -91,13 +92,7 @@ module Rudy::AWS
       end
       
     end
-    
-    class Keypairs #:nodoc:
-      def initialize(*args)
-        raise "Oops! The correct class uses a capital 'P': Rudy::AWS::EC2::KeyPairs"
-      end
-    end
-    
+        
   end
 end
 

data/lib/rudy/aws/ec2/snapshot.rb

@@ -21,7 +21,7 @@ module Rudy::AWS
         @@sformat % [liner_note,  @volid, @status]
       end
       
-      def inspect
+      def pretty
         lines = []
         lines << liner_note
         field_names.each do |key|
@@ -38,9 +38,10 @@ module Rudy::AWS
       
     end
     
-    class Snapshots
-      include Rudy::AWS::ObjectBase
-      include Rudy::AWS::EC2::Base
+    module Snapshots
+      include Rudy::AWS::EC2  # important! include,
+      extend self             # then extend
+
 
       def list(snap_id=[])
         snapshots = list_as_hash(snap_id)
@@ -51,25 +52,26 @@ module Rudy::AWS
       end
       def list_as_hash(snap_id=[])
         snap_id = [snap_id].flatten.compact
-        slist = @ec2.describe_snapshots(:snapshot_id => snap_id)
+        slist = @@ec2.describe_snapshots(:snapshot_id => snap_id)
         return unless slist['snapshotSet'].is_a?(Hash)
         snapshots = {}
         slist['snapshotSet']['item'].each do |snap| 
-          kp = self.class.from_hash(snap)
+          kp = self.from_hash(snap)
           snapshots[kp.awsid] = kp
         end
+        snapshots = nil if snapshots.empty?
         snapshots
       end
       
       def create(vol_id)
         vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
-        shash = @ec2.create_snapshot(:volume_id => vol_id)
+        shash = @@ec2.create_snapshot(:volume_id => vol_id)
         snap = Snapshots.from_hash(shash)
         snap
       end
       
       def destroy(snap_id)
-        ret = @ec2.delete_snapshot(:snapshot_id => snap_id)
+        ret = @@ec2.delete_snapshot(:snapshot_id => snap_id)
         (ret && ret['return'] == 'true') 
       end
       
@@ -99,10 +101,15 @@ module Rudy::AWS
         list(snap_id).first || nil
       end
       
-      def exists?(id)
+      def exists?(snap_id)
         !get(snap_id).nil?
       end
       
+      def completed?(snap_id)
+        s = get(snap_id)
+        return false if s.nil?
+        s.completed?
+      end
     end
     
   end

data/lib/rudy/aws/ec2/volume.rb

@@ -7,14 +7,19 @@ module Rudy::AWS
       
       field :awsid
       field :status
-      field :size
+      field :size  => Integer
       field :snapid
-      field :zone
-      field :create_time
-      field :attach_time
+      field :zone  => Symbol
+      field :created => Time
+      field :attached => Time
       field :instid
       field :device
     
+      def postprocess
+        @zone &&= @zone.to_sym
+        @size &&= @size.to_i
+      end
+      
       def liner_note
         info = attached? ? "attached to #{@instid}" : @status
         "%s (%s)" % [(self.awsid || '').bright, info]
@@ -26,7 +31,7 @@ module Rudy::AWS
         line
       end
       
-      def inspect
+      def pretty
         lines = [liner_note]
         field_names.each do |n|
            lines << sprintf(" %12s:  %s", n, self.send(n)) if self.send(n)
@@ -48,10 +53,11 @@ module Rudy::AWS
     end
   
   
-    class Volumes
-      include Rudy::AWS::ObjectBase
-      include Rudy::AWS::EC2::Base
-    
+    module Volumes
+      include Rudy::AWS::EC2  # important! include,
+      extend self             # then extend
+      
+      
       unless defined?(KNOWN_STATES)
         KNOWN_STATES = [:available, :creating, :deleting, :attached, :detaching].freeze 
       end
@@ -72,11 +78,11 @@ module Rudy::AWS
         # "availabilityZone"=>"us-east-1b", 
         # "createTime"=>"2009-03-17T20:10:48.000Z", 
         # "volumeId"=>"vol-48826421"
-        vol = execute_request({}) { @ec2.create_volume(opts) }
+        vol = Rudy::AWS::EC2.execute_request({}) { @@ec2.create_volume(opts) }
       
         # TODO: use a waiter?
         #Rudy.waiter(1, 30) do
-        #  ret = @@ec2.volumes.available?(volume.awsid)
+        #  ret = @@@ec2.volumes.available?(volume.awsid)
         #end
       
         reqid = vol['requestId']
@@ -86,7 +92,7 @@ module Rudy::AWS
       def destroy(vol_id)
         vol_id = Volumes.get_vol_id(vol_id)
         raise VolumeNotAvailable, vol_id unless available?(vol_id)
-        ret = execute_request({}) { @ec2.delete_volume(:volume_id => vol_id) }
+        ret = Rudy::AWS::EC2.execute_request({}) { @@ec2.delete_volume(:volume_id => vol_id) }
         (ret['return'] == 'true') 
       end
     
@@ -103,7 +109,7 @@ module Rudy::AWS
           :instance_id => inst_id, 
           :device => device.to_s    # Solaris devices are numbers
         }
-        ret = execute_request(false) { @ec2.attach_volume(opts) }
+        ret = Rudy::AWS::EC2.execute_request(false) { @@ec2.attach_volume(opts) }
         (ret['status'] == 'attaching')
       end
     
@@ -111,16 +117,20 @@ module Rudy::AWS
         vol_id = Volumes.get_vol_id(vol_id)
         raise NoVolumeID unless vol_id
         raise VolumeNotAttached, vol_id unless attached?(vol_id)
-        ret = execute_request({}) { @ec2.detach_volume(:volume_id => vol_id) }
+        ret = Rudy::AWS::EC2.execute_request({}) { 
+          @@ec2.detach_volume(:volume_id => vol_id) 
+        }
         (ret['status'] == 'detaching') 
       end
     
     
-      def list(state=nil, vol_id=[])
-        list_as_hash(state, vol_id).values
+      def list(state=nil, vol_id=[], &each_vol)
+        volumes = list_as_hash(state, vol_id, &each_vol)
+        volumes &&= volumes.values
+        volumes
       end
     
-      def list_as_hash(state=nil, vol_id=[])
+      def list_as_hash(state=nil, vol_id=[], &each_vol)
         state &&= state.to_sym
         state = nil if state == :any
         # A nil state is fine, but we don't want an unknown one!
@@ -130,7 +140,9 @@ module Rudy::AWS
           :volume_id => vol_id ? [vol_id].flatten : [] 
         }
 
-        vlist = execute_request({}) { @ec2.describe_volumes(opts) }
+        vlist = Rudy::AWS::EC2.execute_request({}) { 
+          @@ec2.describe_volumes(opts) 
+        }
 
         volumes = {}
         return volumes unless vlist['volumeSet'].is_a?(Hash)
@@ -139,16 +151,21 @@ module Rudy::AWS
           next if state && v.state != state.to_s
           volumes[v.awsid] = v
         end
+        volumes.values.each { |v| each_vol.call(v) } if each_vol
+        volumes = nil if volumes.empty?
         volumes
       end
     
       def any?(state=nil,vol_id=[])
-        !list(state, vol_id).nil?
+        vols = list(state, vol_id)
+        !vols.nil?
       end
     
       def exists?(vol_id)
         vol_id = Volumes.get_vol_id(vol_id)
         vol = get(vol_id)
+        return false if vol.nil?
+        return false if vol.deleting?
         !vol.nil?
       end
     
@@ -195,14 +212,15 @@ module Rudy::AWS
         vol.snapid = h['snapshotId']
         vol.zone = h['availabilityZone']
         vol.awsid = h['volumeId']
-        vol.create_time = h['createTime']
+        vol.created = h['createTime']
         if h['attachmentSet'].is_a?(Hash)
           item = h['attachmentSet']['item'].first
           vol.status = item['status']   # Overwrite "available status". Possibly a bad idea. 
           vol.device = item['device']
-          vol.attach_time = item['attachTime']
+          vol.attached = item['attachTime']
           vol.instid = item['instanceId']
         end
+        vol.postprocess
         vol
       end
 
@@ -223,8 +241,3 @@ module Rudy::AWS
   end
 end
 
-
-class Rudy::AWS::EC2::Volumes
-  
-
-end

data/lib/rudy/aws/ec2/zone.rb

@@ -19,9 +19,9 @@ module Rudy::AWS
 
     end
     
-    class Zones
-      include Rudy::AWS::ObjectBase
-      include Rudy::AWS::EC2::Base
+    module Zones
+      include Rudy::AWS::EC2  # important! include,
+      extend self             # then extend
       
       def list(*names)
         zones = list_as_hash(names)
@@ -31,13 +31,14 @@ module Rudy::AWS
       
       def list_as_hash(*names)
         names = names.flatten
-        zlist = @ec2.describe_availability_zones(:zone_name => names)
+        zlist = @@ec2.describe_availability_zones(:zone_name => names)
         return unless zlist['availabilityZoneInfo'].is_a?(Hash)
         zones = {}
         zlist['availabilityZoneInfo']['item'].each do |zhash| 
           zon = Zones.from_hash(zhash)
           zones[zon.name] = zon
         end
+        zones = nil if zones.empty?
         zones
       end
 

data/lib/rudy/aws/s3.rb

@@ -3,7 +3,8 @@ module Rudy::AWS
   class S3
     
     def initialize(access_key=nil, secret_key=nil, region=nil, debug=nil)
-     
+      require 'aws/s3'    
+      
       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. 

data/lib/rudy/aws/sdb.rb

@@ -13,7 +13,6 @@ module Rudy
     class SDB
       class NoAccessKey < RuntimeError; end
       class NoSecretKey < RuntimeError; end
-      include Rudy::AWS::ObjectBase
       
       require 'rudy/aws/sdb/error'
       
@@ -33,7 +32,7 @@ module Rudy
         @base_url = url
         @debug = debug || StringIO.new
       end
-
+      
       def list_domains(max = nil, token = nil)
         params = { 'Action' => 'ListDomains' }
         params['NextToken'] =
@@ -63,12 +62,11 @@ module Rudy
       end
       
       
-      # Takes a zipped Array or Hash of criteria.
+      # Takes a Hash of criteria.
       # Returns a string suitable for a SimpleDB Select
-      def self.generate_select(fields, domain, *args)
-        q = args.first.is_a?(Hash)? args.first : Hash[*args.flatten]
+      def self.generate_select(domain, fields={})
         query = []
-        q.each_pair do |n,v| 
+        fields.each_pair do |n,v| 
           query << "#{Rudy::AWS.escape n}='#{Rudy::AWS.escape v}'"
         end
         str = "select * from #{domain} " 
@@ -76,18 +74,6 @@ module Rudy
         str
       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 = {
@@ -122,72 +108,6 @@ module Rudy
         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
@@ -252,7 +172,35 @@ module Rudy
 
 
     protected
+    
+      
+      # Execute AWS requests safely. This will trap errors and return
+      # a default value (if specified).
+      # * +default+ A default response value
+      # * +request+ A block which contains the AWS request
+      # Returns the return value from the request is returned untouched
+      # or the default value on error or if the request returned nil. 
+      def execute_request(default=nil, timeout=nil, &request)
+        timeout ||= 15
+        raise "No block provided" unless request
+        response = nil
+        begin
+          Timeout::timeout(timeout) do
+            response = request.call
+          end
 
+        rescue Timeout::Error => ex
+          STDERR.puts "Timeout (#{timeout}): #{ex.message}!"
+        rescue SocketError => ex
+          #STDERR.puts ex.message
+          #STDERR.puts ex.backtrace
+          raise SocketError, "Check your Internets!" unless Rudy::Huxtable.global.offline
+        ensure
+          response ||= default
+        end
+        response
+      end
+      
       def call(method, params)
         params.merge!( {
             'Version' => '2007-11-07',
@@ -276,7 +224,8 @@ module Rudy
         query = query.join('&')
         url = "#{@base_url}?#{query}"
         uri = URI.parse(url)
-        @debug.puts("#{url}") if @debug
+        
+        #Rudy::Huxtable.ld url if Rudy.debug?
         
         response = execute_request(nil) {
           Net::HTTP.new(uri.host, uri.port).send_request(method, uri.request_uri)
@@ -294,7 +243,7 @@ module Rudy
           error = doc.get_elements('*/Errors/Error')[0]
           raise(
             Module.class_eval(
-              "AwsSdb::#{error.get_elements('Code')[0].text}Error"
+              "Rudy::AWS::SDB::#{error.get_elements('Code')[0].text}Error"
             ).new(
               error.get_elements('Message')[0].text,
               doc.get_elements('*/RequestID')[0].text