solutious-rudy 0.5.1 → 0.6.0

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

@@ -1,234 +1,230 @@
 
 
 module Rudy::AWS
-  class EC2
+  module 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
+      @@sformat = "%s  %10s;%4sGB;  %s  " # cram the terabyte
+      
+      field :awsid
+      field :status
+      field :size
+      field :snapid
+      field :zone
+      field :create_time
+      field :attach_time
+      field :instid
+      field :device
+    
+      def liner_note
+        info = attached? ? "attached to #{@instid}" : @status
+        "%s (%s)" % [(self.awsid || '').bright, info]
+      end
+      
+      def to_s(with_title=false)
+        line = @@sformat % [liner_note, @zone, @size, @device]
+        line << " <- %s" % [@snapid] if @snapid
+        line
+      end
+      
+      def inspect
+        lines = [liner_note]
+        field_names.each do |n|
+           lines << sprintf(" %12s:  %s", n, self.send(n)) if self.send(n)
+         end
+        lines.join($/)
+      end
     
-    def deleting?
-      (status && status == "deleting")
-    end
+      # Alias for status
+      def state
+        status
+      end
     
-    def attached?
-      (status && (status == "attached"))
-    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
     
-    def in_use?
-      (status && (status == "in-use"))
     end
-    
-  end
   
   
-  class EC2::Volumes
-    include Rudy::AWS::ObjectBase
+    class Volumes
+      include Rudy::AWS::ObjectBase
+      include Rudy::AWS::EC2::Base
     
-    unless defined?(KNOWN_STATES)
-      KNOWN_STATES = [:available, :creating, :deleting, :attached, :detaching].freeze 
-    end
+      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
+      # * +size+ the number of GB
+      def create(size, zone, snapid=nil)
+        opts = {
+          :availability_zone => zone.to_s,
+          :size => (size || 1).to_s
+        }
       
-      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
+        opts[:snapshot_id] = snapid if snapid
       
-      ret = execute_request({}) {
-        @aws.detach_volume(:volume_id => vol_id)
-      }
-      (ret['status'] == 'detaching') 
-    end
-    
+        # "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({}) { @ec2.create_volume(opts) }
+      
+        # TODO: use a waiter?
+        #Rudy.waiter(1, 30) do
+        #  ret = @@ec2.volumes.available?(volume.awsid)
+        #end
+      
+        reqid = vol['requestId']
+        Volumes.from_hash(vol) || nil
+      end
     
-    def list(state=nil, vol_id=[])
-      list_as_hash(state, vol_id).values
-    end
+      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['return'] == 'true') 
+      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)
+      def attach(vol_id, inst_id, device)
+        vol_id = Volumes.get_vol_id(vol_id)
+        inst_id = inst_id.is_a?(Rudy::AWS::EC2::Instance) ? inst_id.awsid : inst_id
+        raise NoVolumeID unless vol_id
+        raise VolumeAlreadyAttached, vol_id if attached?(vol_id)
+        raise NoInstanceID unless inst_id
+        raise NoDevice unless device
       
-      opts = { 
-        :volume_id => vol_id ? [vol_id].flatten : [] 
-      }
-      begin
-        
-        vlist = execute_request({}) {
-          @aws.describe_volumes(opts)
+        opts = {
+          :volume_id => vol_id, 
+          :instance_id => inst_id, 
+          :device => device
         }
-        
-      # 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
-    
+        ret = execute_request(false) { @ec2.attach_volume(opts) }
+        (ret['status'] == 'attaching')
+      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 detach(vol_id)
+        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['status'] == 'detaching') 
+      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 list(state=nil, vol_id=[])
+        list_as_hash(state, vol_id).values
+      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 list_as_hash(state=nil, vol_id=[])
+        state &&= state.to_sym
+        state = nil if state == :any
+        # A nil state is fine, but we don't want an unknown one!
+        raise UnknownState, state if state && !Volumes.known_state?(state)
+      
+        opts = { 
+          :volume_id => vol_id ? [vol_id].flatten : [] 
+        }
 
+        vlist = execute_request({}) { @ec2.describe_volumes(opts) }
+
+        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
     
-    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 any?(state=nil,vol_id=[])
+        !list(state, 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 exists?(vol_id)
+        vol_id = Volumes.get_vol_id(vol_id)
+        vol = get(vol_id)
+        !vol.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 get(vol_id)
+        vol_id = Volumes.get_vol_id(vol_id)
+        list(:any, vol_id).first || nil
+      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
+      # deleting?, available?, etc...
+      %w[deleting available attached in-use].each do |state|
+        define_method("#{state.tr('-', '_')}?") do |vol_id|
+          vol_id = Volumes.get_vol_id(vol_id)
+          return false unless vol_id
+          vol = get(vol_id)
+          (vol && vol.status == state)
+        end
+      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
+      # Creates a Rudy::AWS::EC2::Volume object from:
+      #
+      #     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
+      #
+      def self.from_hash(h)
+        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
+
+      # * +vol_id+ is a String or Rudy::AWS::EC2::Volume
+      # Returns the volume ID
+      def self.get_vol_id(vol_id)
+        (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
+      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
     
-    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
+
+
+class Rudy::AWS::EC2::Volumes
+  
+
+end

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

@@ -0,0 +1,77 @@
+
+module Rudy::AWS
+  module EC2
+    
+    class Zone < Storable
+      
+      field :name
+      field :region
+      field :state  
+      
+      def liner_note
+        "%-10s  %9s  %s" % [self.name, self.region, self.state]
+      end
+      
+      def to_s(titles=false)
+        str = titles ? "%-20s   %s#{$/}" % ['name', 'region', 'state'] : ""
+        str << liner_note
+      end
+
+    end
+    
+    class Zones
+      include Rudy::AWS::ObjectBase
+      include Rudy::AWS::EC2::Base
+      
+      def list(*names)
+        zones = list_as_hash(names)
+        zones &&= zones.values
+        zones
+      end
+      
+      def list_as_hash(*names)
+        names = names.flatten
+        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
+      end
+
+      def self.from_hash(h)
+        zone = Rudy::AWS::EC2::Zone.new
+        zone.name = h['zoneName']
+        zone.region = h['regionName']
+        zone.state = h['zoneState']
+        zone
+      end
+      
+      def any?
+        zones = list || []
+        !zones.empty?
+      end
+      
+      def get(name)
+        zones = list(name) || []
+        return if zones.empty?
+        zones.first
+      end
+      
+      def zone?(name)
+        begin
+          kp = get(name)
+          kp.is_a?(Rudy::AWS::EC2::Zone)
+        rescue => ex
+          false
+        end
+      end
+      
+    end
+    
+  end
+end
+
+

data/lib/rudy/aws/ec2.rb

@@ -1,28 +1,59 @@
 
-module Rudy::AWS
-  class EC2
-    @@logger = StringIO.new
-
-    attr_reader :instances
-    attr_reader :images
-    attr_reader :addresses
-    attr_reader :groups
-    attr_reader :volumes
-    attr_reader :snapshots
-    attr_reader :aws
-    attr_reader :keypairs
-
-    def initialize(access_key, secret_key)
-      ec2 = ::EC2::Base.new(:access_key_id => access_key, :secret_access_key => secret_key)
-      @instances = Rudy::AWS::EC2::Instances.new(ec2)
-      @images = Rudy::AWS::EC2::Images.new(ec2)
-      @groups = Rudy::AWS::EC2::Groups.new(ec2)
-      @addresses = Rudy::AWS::EC2::Addresses.new(ec2)
-      @snapshots = Rudy::AWS::EC2::Snapshots.new(ec2)
-      @volumes = Rudy::AWS::EC2::Volumes.new(ec2)
-      @keypairs = Rudy::AWS::EC2::KeyPairs.new(ec2)
+module Rudy; module AWS
+  module EC2
+    module Base
+      attr_accessor :ec2
+      def initialize(access_key=nil, secret_key=nil, region=nil, logger=nil)
+        
+        if region
+          raise InvalidRegion, region unless Rudy::AWS.valid_region?(region)
+          host = "#{region}.ec2.amazonaws.com"
+        elsif ENV['EC2_URL']
+          host = URL.parse(ENV['EC2_URL']).host
+        end
+        
+        host ||= DEFAULT_EC2_HOST
+        port ||= DEFAULT_EC2_PORT
+        
+        @ec2 = ::EC2::Base.new(:port => port, :server=> host, :access_key_id => access_key, :secret_access_key => secret_key)
+        @logger = logger
+      end
+    end
+    
+    class NoRunningInstances < Rudy::Error; end
+    class MalformedResponse < Rudy::Error; end
+    class InvalidRegion < Rudy::Error; end
+    class UnknownState < Rudy::Error; end
+    class NoGroup < Rudy::Error; end
+    class NoKeyPair < Rudy::Error; end
+    class NoAMI < Rudy::Error; end
+    
+    class NoAddress < Rudy::Error; end
+    class UnknownAddress < Rudy::Error; end
+    class NoInstanceID < Rudy::Error; end
+    class AddressAssociated < Rudy::Error; end
+    class ErrorCreatingAddress < Rudy::Error; end
+    class AddressNotAssociated < Rudy::Error; end
+    class InsecureKeyPairPermissions < Rudy::Error; end
+    
+    class InsecureKeyPairPermissions < Rudy::Error; end
+    class ErrorCreatingKeyPair < Rudy::Error; end
+    class NoPrivateKeyFile < Rudy::Error; end
+    class KeyPairExists < Rudy::Error; end
+    class KeyPairAlreadyDefined < Rudy::Error
+      def message
+        "A keypair is defined for #{@obj}. Check your Rudy config."
+      end
     end
-  
+    
+    class VolumeAlreadyAttached < Rudy::Error; end
+    class VolumeNotAvailable < Rudy::Error; end
+    class VolumeNotAttached < Rudy::Error; end
+    class NoInstanceID < Rudy::Error; end
+    class NoVolumeID < Rudy::Error; end
+    class UnknownState < Rudy::Error; end
+    class NoDevice < Rudy::Error; end
+    
+    
   end
-  
-end
+end; end

data/lib/rudy/aws/s3.rb

@@ -1,3 +1,57 @@
 
 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)
+      ::AWS::S3::Bucket.create(name)
+    end
+    
+    def destroy_bucket(name)
+      ::AWS::S3::Bucket.delete(name)
+    end
+    
+    def find_bucket(name)
+      ::AWS::S3::Bucket.delete(name)
+    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