solutious-rudy 0.4.0 → 0.5.0

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

@@ -0,0 +1,92 @@
+require 'rye'
+
+module Rudy::AWS
+  class EC2
+    
+    class KeyPair < Storable
+      attr_accessor :private_key  # not a storable field
+      
+      field :name
+      field :fingerprint
+      
+      def to_s
+        "%-20s   %s" % [self.name, self.fingerprint]
+      end
+      
+      def public_key
+        return unless @private_key
+        k = Rye::Key.new(@private_key)
+        k.public_key.to_ssh2
+      end
+
+    end
+    
+    class KeyPairs
+      include Rudy::AWS::ObjectBase
+      
+      def create(name)
+        raise "No name provided" unless name
+        ret = @aws.create_keypair(:key_name => name)
+        self.class.from_hash(ret)
+      end
+      
+      def destroy(name)
+        name = name.name if name.is_a?(Rudy::AWS::EC2::KeyPair)
+        raise "No name provided" unless name.is_a?(String)
+        ret = @aws.delete_keypair(:key_name => name)
+        (ret && ret['return'] == 'true') # BUG? Always returns true
+      end
+      
+      def list(*names)
+        keypairs = list_as_hash(names)
+        keypairs &&= keypairs.values
+        keypairs
+      end
+      
+      def list_as_hash(*names)
+        names = names.flatten
+        klist = @aws.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)
+          keypairs[kp.name] = kp
+        end
+        keypairs
+      end
+      
+      def self.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.fingerprint = h['keyFingerprint']
+        keypair.name = h['keyName']
+        keypair.private_key = h['keyMaterial']
+        keypair
+      end
+      
+      def any?
+        keypairs = list || []
+        !keypairs.empty?
+      end
+      
+      def get(name)
+        keypairs = list(name) || []
+        return if keypairs.empty?
+        keypairs.first
+      end
+      
+      def exists?(name)
+        begin
+          kp = get(name)
+          kp.is_a?(Rudy::AWS::EC2::KeyPair)
+        rescue => ex
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+
+
+module Rudy::AWS
+  class EC2
+    class Snapshot < Storable
+      field :awsid
+      field :progress
+      field :created
+      field :volid
+      field :status
+      
+      def to_s
+        "%s:%s (%s) %s" [self.awsid, self.volid, self.created, self.status]
+      end
+      
+      def completed?
+        self.status && self.status == 'completed'
+      end
+      
+    end
+    
+    class Snapshots
+      include Rudy::AWS::ObjectBase
+      
+
+      def list(*snap_id)
+        snapshots = list_as_hash(snap_id)
+        snapshots &&= snapshots.values
+        snapshots
+      end
+      def list_as_hash(*snap_id)
+        snap_id = snap_id.flatten
+        slist = @aws.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)
+          snapshots[kp.awsid] = kp
+        end
+        snapshots
+      end
+      
+      def create(vol_id)
+        vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+        snap = @aws.create_snapshot(:volume_id => vol_id)
+        self.class.from_hash(snap)
+      end
+      
+      def destroy(snap_id)
+        ret = @aws.delete_snapshot(:snapshot_id => snap_id)
+        (ret && ret['return'] == 'true') 
+      end
+      
+      
+      def Snapshots.from_hash(h)
+        #snapshotSet: 
+        #  item: 
+        #  - snapshotId: snap-5493653d
+        #    volumeId: vol-0836d761
+        #    status: completed
+        #    startTime: "2009-03-29T20:15:10.000Z"
+        #    progress: 100%
+        vol = Rudy::AWS::EC2::Snapshot.new
+        vol.awsid = h['snapshotId']
+        vol.volid = h['volumeId']
+        vol.created = h['startTime']
+        vol.progress = h['progress']
+        vol.status = h['status']
+        vol 
+      end
+      
+      def any?
+        !(list_as_hash || {}).empty?
+      end
+      
+      def get(snap_id)
+        list(snap_id).first || nil
+      end
+      
+      def exists?(id)
+        !get(snap_id).nil?
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,234 @@
+
+
+module Rudy::AWS
+  class EC2
+    class Volume < Storable
+    field :awsid
+    field :status
+    field :size
+    field :snapid
+    field :zone
+    field :create_time
+    field :attach_time
+    field :instid
+    field :device
+    
+    def to_s
+      lines = ["Volume: #{self.awsid.bright}"]
+      field_names.each do |n|
+         lines << sprintf(" %12s: %s", n, self.send(n)) if self.send(n)
+       end
+      lines.join($/)
+    end
+    
+    # Alias for status
+    def state
+      status
+    end
+    
+    def available?
+      (status && status == "available")
+    end
+    
+    def creating?
+      (status && status == "creating")
+    end
+    
+    def deleting?
+      (status && status == "deleting")
+    end
+    
+    def attached?
+      (status && (status == "attached"))
+    end
+    
+    def in_use?
+      (status && (status == "in-use"))
+    end
+    
+  end
+  
+  
+  class EC2::Volumes
+    include Rudy::AWS::ObjectBase
+    
+    unless defined?(KNOWN_STATES)
+      KNOWN_STATES = [:available, :creating, :deleting, :attached, :detaching].freeze 
+    end
+    
+    def attach(inst_id, vol_id, device)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      inst_id = inst_id.is_a?(Rudy::AWS::EC2::Instance) ? inst_id.awsid : inst_id
+      
+      ret = execute_request(false) {
+        @aws.attach_volume(:volume_id => vol_id, :instance_id => inst_id, :device => device)
+      }
+      (ret['status'] == 'attaching')
+    end
+    
+    def detach(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      
+      ret = execute_request({}) {
+        @aws.detach_volume(:volume_id => vol_id)
+      }
+      (ret['status'] == 'detaching') 
+    end
+    
+    
+    def list(state=nil, vol_id=[])
+      list_as_hash(state, vol_id).values
+    end
+    
+    def list_as_hash(state=nil, vol_id=[])
+      state &&= state.to_sym
+      state = nil if state == :any
+      raise "Unknown state: #{state}" if state && !Volumes.known_state?(state)
+      
+      opts = { 
+        :volume_id => vol_id ? [vol_id].flatten : [] 
+      }
+      begin
+        
+        vlist = execute_request({}) {
+          @aws.describe_volumes(opts)
+        }
+        
+      # 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 
+        vlist = {}
+      end
+      volumes = {}
+      return volumes unless vlist['volumeSet'].is_a?(Hash)
+      vlist['volumeSet']['item'].each do |vol|
+        v = Volumes.from_hash(vol)
+        next if state && v.state != state.to_s
+        volumes[v.awsid] = v
+      end
+      volumes
+    end
+    
+    
+    # * +size+ the number of GB
+    def create(size, zone, snapid=nil)
+      opts = {
+        :availability_zone => zone.to_s,
+        :size => (size || 1).to_s
+      }
+      
+      opts[:snapshot_id] = snapid if snapid
+      
+      # "status"=>"creating", 
+      # "size"=>"1", 
+      # "snapshotId"=>nil, 
+      # "requestId"=>"d42ff744-48b5-4f47-a3f0-7aba57a13eb9", 
+      # "availabilityZone"=>"us-east-1b", 
+      # "createTime"=>"2009-03-17T20:10:48.000Z", 
+      # "volumeId"=>"vol-48826421"
+      vol = execute_request({}) { 
+        @aws.create_volume(opts)
+      }
+      
+      reqid = vol['requestId']
+      Volumes.from_hash(vol) || nil
+    end
+    
+    
+    def destroy(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      ret = execute_request({}) { 
+         @aws.delete_volume(:volume_id => vol_id)
+      }
+      (ret['return'] == 'true') 
+    end
+    
+    def self.from_hash(h)
+      # --- 
+      # volumeSet: 
+      #   item: 
+      #   - status: available
+      #     size: "1"
+      #     snapshotId: 
+      #     availabilityZone: us-east-1b
+      #     attachmentSet: 
+      #     createTime: "2009-03-17T20:10:48.000Z"
+      #     volumeId: vol-48826421
+      #     attachmentSet: 
+      #       item: 
+      #       - attachTime: "2009-03-17T21:49:54.000Z"
+      #         status: attached
+      #         device: /dev/sdh
+      #         instanceId: i-956af3fc
+      #         volumeId: vol-48826421
+      #     
+      # requestId: 8fc30e5b-a9c3-4fe0-a979-0f71e639a7c7
+      vol = Rudy::AWS::EC2::Volume.new
+      vol.status = h['status']
+      vol.size = h['size']
+      vol.snapid = h['snapshotId']
+      vol.zone = h['availabilityZone']
+      vol.awsid = h['volumeId']
+      vol.create_time = 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.instid = item['instanceId']
+      end
+      vol
+    end
+
+    
+    def any?(state=nil,vol_id=[])
+      !(list(state, vol_id) || []).empty?
+    end
+    
+    def exists?(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      !get(vol_id).nil?
+    end
+    
+    def get(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      list(:any, vol_id).first || nil
+    end
+    
+    def deleting?(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      return false unless vol_id
+      vol = get(vol_id)
+      (vol && vol.status == "deleting")
+    end
+    
+    def available?(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      return false unless vol_id
+      vol = get(vol_id)
+      (vol && vol.status == "available")
+    end
+    
+    def attached?(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      return false unless vol_id
+      vol = get(vol_id)
+      (vol && (vol.status == "attached"))
+    end
+    
+    def in_use?(vol_id)
+      vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      return false unless vol_id
+      vol = get(vol_id)
+      (vol && (vol.status == "in-use"))
+    end
+      
+    # Is +state+ a known EC2 volume state? See: KNOWN_STATES
+    def self.known_state?(state)
+      return false unless state
+      state &&= state.to_sym
+      KNOWN_STATES.member?(state)
+    end
+  end
+end
+end

data/lib/rudy/aws/simpledb.rb

@@ -2,52 +2,70 @@
 
 
 module Rudy::AWS
-
-  
   class SimpleDB
     class Domains 
       include Rudy::AWS::ObjectBase
       
       def create(name)
         @aws.create_domain(name)
+        true
       end
       
       def destroy(name)
-        @aws.delete_domain(name)
+        @aws.delete_domain(name)  # Always returns nil, wtf?
+        true
       end
     
       def list
-        @aws.list_domains
+        domains = (@aws.list_domains || [[]])  # Nested array, again wtf?
+        domains.first.flatten
       end
     end
     
-    def destroy(domain, item, attributes={})
-      @aws.delete_attributes(domain, item, attributes)
+    def destroy(domain, item)
+      @aws.delete_attributes(domain, item)
+      true
     end
     
     def store(domain, item, attributes={}, replace=false)
+      replace &&= true  # Accept any value as true
       @aws.put_attributes(domain, item, attributes, replace)
     end
     
     def query(domain, query=nil, max=nil)
-      @aws.query(domain, query, max)
+      items = @aws.query(domain, query, max)
+      return nil if !items || items.empty? || items == [[], ""]  # NOTE: wtf, aws-sdb?
+      # [["produce", "produce1", "produce2"], ""]
+      clean_items = items.first
+      clean_items
     end
     
     def query_with_attributes(domain, query, max=nil)
-      items = {}
-      query(domain, query)[:items].each do |item|
-        items[item] = get_attributes(domain, item)[:attributes]
+      items = @aws.query_with_attributes(domain, query, max)
+      return nil if !items || items.empty? || items == [[], ""]  # NOTE: wtf, aws-sdb?
+      clean_items = {}
+      # aws-sdb returns the following (another nested array -- wtf X 9):
+      # [[{"device"=>["/dev/sdh"], "Name"=>"disk-us-east-1b-stella-app-01-stella", "zone"=>["us-east-1b"], 
+      # "size"=>["1"], "region"=>["us-east-1"], "role"=>["app"], "rtype"=>["disk"], "awsid"=>[""], 
+      # "environment"=>["stella"], "position"=>["01"], "path"=>["/stella"]}], ""]
+      items.first.each do |item|
+        clean_items[item.delete('Name')] = item
       end
-      items
+      clean_items
     end
     
     def select(query)
-      list = @aws2.select(query) || []
-      list[0]
+      items = @aws.select(query) || []
+      return nil if !items || items.empty? || items == [[], ""]  # NOTE: wtf, aws-sdb?
+      clean_items = {}
+      items.first.each do |item|
+        clean_items[item.delete('Name')] = item
+      end
+      clean_items
     end
     
-    def get_attributes(domain, item, attribute=nil)
-      @aws.get_attributes(domain, item, attribute)
+    def get(domain, item)
+      @aws.get_attributes(domain, item)
     end
   end
 end