fog 0.0.3

data/lib/fog/aws/models/ec2/volume.rb

@@ -0,0 +1,47 @@
+module Fog
+  module AWS
+    class EC2
+
+      class Volume < Fog::Model
+
+        attr_accessor :attachment_time,
+                      :availability_zone,
+                      :device,
+                      :instance_id
+                      :size,
+                      :snapshot_id,
+                      :status,
+                      :volume_id
+        
+        def initialize(attributes = {})
+          if attributes['attachmentSet']
+            attributes.merge!(attributes.delete('attachmentSet'))
+          end
+          remap_attributes(attributes, {
+            'attachmentTime'    => :attachment_time,
+            'availabilityZone'  => :availability_zone,
+            'createTime'        => :create_time,
+            'instanceId'        => :instance_id,
+            'snapshotId'        => :snapshot_id,
+            'status'            => :status
+            'volumeId'          => :volume_id
+          })
+          super
+        end
+
+        def delete
+          connection.delete_volume(@volume_id)
+        end
+
+        def save
+          data = connection.create_volume(@availability_zone, @size, @snapshot_id).body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          update_attributes(new_attributes)
+          data
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/ec2/volumes.rb

@@ -0,0 +1,36 @@
+module Fog
+  module AWS
+    class EC2
+
+      def volumes
+        Fog::AWS::EC2::Volumes.new(:connection => self)
+      end
+
+      class Volumes < Fog::Collection
+
+        def all(volume_id = [])
+          data = connection.describe_volumes(volume_id)
+          volumes = []
+          data['volumeSet'].each do |volume|
+            volumes << Fog::AWS::EC2::Volume.new({
+              :connection => connection
+            }.merge!(volume))
+          end
+          volumes
+        end
+
+        def create(attributes = {})
+          volume = new(attributes)
+          volume.save
+          volume
+        end
+
+        def new(attributes = {})
+          Fog::AWS::EC2::Volume.new(attributes.merge!(:connection => connection))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/s3/bucket.rb

@@ -0,0 +1,77 @@
+module Fog
+  module AWS
+    class S3
+
+      class Bucket < Fog::Model
+
+        attribute :creation_date, 'CreationDate'
+        attribute :location
+        attribute :name,          'Name'
+        attribute :owner
+
+        def initialize(attributes = {})
+          super
+        end
+
+        def buckets
+          @buckets
+        end
+
+        def destroy
+          connection.delete_bucket(@name)
+          buckets.delete(name)
+          true
+        rescue Fog::Errors::NotFound
+          false
+        end
+
+        def location
+          data = s3.get_bucket_location(@name)
+          data.body['LocationConstraint']
+        end
+
+        def objects
+          @objects ||= begin
+            Fog::AWS::S3::Objects.new(
+              :bucket       => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        def payer
+          data = connection.get_request_payment(@name)
+          data.body['Payer']
+        end
+
+        def payer=(new_payer)
+          connection.put_request_payment(@name, new_payer)
+          @payer = new_payer
+        end
+
+        def reload
+          new_attributes = buckets.get(@name).attributes
+          merge_attributes(new_attributes)
+        end
+
+        def save
+          options = {}
+          if @location
+            options['LocationConstraint'] = @location
+          end
+          connection.put_bucket(@name, options)
+          buckets[name] = self
+          true
+        end
+
+        private
+
+        def buckets=(new_buckets)
+          @buckets = new_buckets
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/s3/buckets.rb

@@ -0,0 +1,83 @@
+module Fog
+  module AWS
+    class S3
+
+      def buckets
+        Fog::AWS::S3::Buckets.new(:connection => self)
+      end
+
+      class Buckets < Fog::Collection
+
+        def all
+          data = connection.get_service.body
+          owner = Fog::AWS::S3::Owner.new(data.delete('Owner').merge!(:connection => connection))
+          self.delete_if {true}
+          data['Buckets'].each do |bucket|
+            self[bucket['Name']] = Fog::AWS::S3::Bucket.new({
+              :buckets    => self,
+              :connection => connection,
+              :owner      => owner
+            }.merge!(bucket))
+          end
+          self
+        end
+
+        def create(attributes = {})
+          bucket = new(attributes)
+          bucket.save
+          bucket
+        end
+
+        def get(name, options = {})
+          remap_attributes(options, {
+            :is_truncated => 'IsTruncated',
+            :marker       => 'Marker',
+            :max_keys     => 'MaxKeys',
+            :prefix       => 'Prefix'
+          })
+          data = connection.get_bucket(name, options).body
+          bucket = Fog::AWS::S3::Bucket.new({
+            :buckets    => self,
+            :connection => connection,
+            :name       => data['Name']
+          })
+          self[bucket.name] = bucket
+          objects_data = {}
+          for key, value in data
+            if ['IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(key)
+              objects_data[key] = value
+            end
+          end
+          bucket.objects.merge_attributes(objects_data)
+          data['Contents'].each do |object|
+            owner = Fog::AWS::S3::Owner.new(object.delete('Owner').merge!(:connection => connection))
+            bucket.objects[object['key']] = Fog::AWS::S3::Object.new({
+              :bucket     => bucket,
+              :connection => connection,
+              :objects    => self,
+              :owner      => owner
+            }.merge!(object))
+          end
+          bucket
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          Fog::AWS::S3::Bucket.new(
+            attributes.merge!(
+              :connection => connection,
+              :buckets    => self
+            )
+          )
+        end
+
+        def reload
+          all
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/s3/object.rb

@@ -0,0 +1,76 @@
+module Fog
+  module AWS
+    class S3
+
+      class Object < Fog::Model
+
+        attribute :body
+        attribute :content_length,  'Content-Length'
+        attribute :content_type,    'Content-Type'
+        attribute :etag,            ['Etag', 'ETag']
+        attribute :key,             'Key'
+        attribute :last_modified,   ['Last-Modified', 'LastModified']
+        attribute :owner
+        attribute :size,            'Size'
+        attribute :storage_class,   'StorageClass'
+
+        def initialize(attributes = {})
+          super
+        end
+
+        def bucket
+          @bucket
+        end
+
+        def copy(target_bucket_name, target_object_key)
+          data = connection.copy_object(bucket.name, @key, target_bucket_name, target_object_key).body
+          target_bucket = connection.buckets.new(:name => target_bucket_name)
+          target_object = target_bucket.objects.new(attributes.merge!(:key => target_object_key))
+          copy_data = {}
+          for key, value in data
+            if ['ETag', 'LastModified'].include?(key)
+              copy_data[key] = value
+            end
+          end
+          target_object.merge_attributes(copy_data)
+          target_object.objects[target_object_key] = target_object
+          target_object
+        end
+
+        def destroy
+          connection.delete_object(bucket.name, @key)
+          objects.delete(@key)
+          true
+        end
+
+        def objects
+          @objects
+        end
+
+        def reload
+          new_attributes = objects.get(@key).attributes
+          merge_attributes(new_attributes)
+        end
+
+        def save(options = {})
+          data = connection.put_object(bucket.name, @key, @body, options)
+          @etag = data.headers['ETag']
+          objects[@key] = self
+          true
+        end
+
+        private
+
+        def bucket=(new_bucket)
+          @bucket = new_bucket
+        end
+
+        def objects=(new_objects)
+          @objects = new_objects
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/s3/objects.rb

@@ -0,0 +1,97 @@
+module Fog
+  module AWS
+    class S3
+
+      class Objects < Fog::Collection
+
+        attribute :is_truncated,  'IsTruncated'
+        attribute :marker,        'Marker'
+        attribute :max_keys,      'MaxKeys'
+        attribute :prefix,        'Prefix'
+
+        def initialize(attributes = {})
+          super
+        end
+
+        def all(options = {})
+          merge_attributes(options)
+          self.delete_if {true}
+          objects = bucket.buckets.get(bucket.name, attributes).objects
+          objects.keys.each do |key|
+            self[key] = objects[key]
+          end
+          self
+        end
+
+        def bucket
+          @bucket
+        end
+
+        def create(attributes = {})
+          object = new(attributes)
+          object.save
+          object
+        end
+
+        def get(key, options = {})
+          data = connection.get_object(bucket.name, key, options)
+          object_data = {
+            :body => data.body,
+            :key  => key
+          }
+          for key, value in data.headers
+            if ['Content-Length', 'Content-Type', 'ETag', 'Last-Modified'].include?(key)
+              object_data[key] = value
+            end
+          end
+          self[object_data['key']] = Fog::AWS::S3::Object.new({
+            :bucket     => bucket,
+            :connection => connection,
+            :objects    => self
+          }.merge!(object_data))
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def head(key, options = {})
+          data = connection.head_object(bucket.name, key, options)
+          object_data = {
+            :key => key
+          }
+          for key, value in data.headers
+            if ['Content-Length', 'ETag', 'Last-Modified'].include?(key)
+              object_data[key] = value
+            end
+          end
+          self[object_data['key']] = Fog::AWS::S3::Object.new({
+            :bucket     => bucket,
+            :connection => connection,
+            :objects    => self
+          }.merge!(object_data))
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          Fog::AWS::S3::Object.new({
+            :bucket     => bucket,
+            :connection => connection,
+            :objects    => self
+          }.merge!(attributes))
+        end
+
+        def reload
+          all
+        end
+
+        private
+
+        def bucket=(new_bucket)
+          @bucket = new_bucket
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/s3/owner.rb

@@ -0,0 +1,18 @@
+module Fog
+  module AWS
+    class S3
+
+      class Owner < Fog::Model
+
+        attribute :display_name,  'DisplayName'
+        attribute :id,            'ID'
+
+        def initialize(attributes = {})
+          super
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/parsers/ec2/allocate_address.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module AWS
+      module EC2
+
+        class AllocateAddress < Fog::Parsers::Base
+
+          def end_element(name)
+            case name
+            when 'publicIp', 'requestId'
+              @response[name] = @value
+            end
+          end
+
+        end
+      end
+    end
+  end
+end