fog-maestrodev 1.7.0.20121114190951

data/lib/fog/aws/models/elasticache/security_groups.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/elasticache/security_group'
+
+module Fog
+  module AWS
+    class Elasticache
+
+      class SecurityGroups < Fog::Collection
+        model Fog::AWS::Elasticache::SecurityGroup
+
+        def all
+          load(
+            connection.describe_cache_security_groups.body['CacheSecurityGroups']
+          )
+        end
+
+        def get(identity)
+          new(
+            connection.describe_cache_security_groups(
+              identity
+            ).body['CacheSecurityGroups'].first
+          )
+        rescue Fog::AWS::Elasticache::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/elb/listener.rb

@@ -0,0 +1,59 @@
+require 'fog/core/model'
+module Fog
+  module AWS
+    class ELB
+      class Listener < Fog::Model
+
+        attribute :policy_names,      :aliases => 'PolicyNames'
+        attribute :instance_port,     :aliases => 'InstancePort'
+        attribute :instance_protocol, :aliases => 'InstanceProtocol'
+        attribute :lb_port,           :aliases => 'LoadBalancerPort'
+        attribute :protocol,          :aliases => 'Protocol'
+        attribute :ssl_id,            :aliases => 'SSLCertificateId'
+
+        def initialize(attributes={})
+          # set defaults, which may be overridden in super
+          merge_attributes(:policy_names => [], :instance_port => 80, :instance_protocol => 'HTTP', :lb_port => 80, :protocol => 'HTTP')
+          super
+        end
+
+        def save
+          requires :load_balancer, :instance_port, :lb_port, :protocol, :instance_protocol
+          connection.create_load_balancer_listeners(load_balancer.id, [to_params])
+          reload
+        end
+
+        def destroy
+          requires :load_balancer, :lb_port
+          connection.delete_load_balancer_listeners(load_balancer.id, [lb_port])
+          reload
+        end
+
+        # Return the policy associated with this load balancer
+        def policy
+          load_balancer.policies.get(policy_names.first)
+        end
+
+        def reload
+          load_balancer.reload
+        end
+
+        def load_balancer
+          collection.load_balancer
+        end
+
+        def to_params
+          {
+            'InstancePort'     => instance_port,
+            'InstanceProtocol' => instance_protocol,
+            'LoadBalancerPort' => lb_port,
+            'Protocol'         => protocol,
+            'SSLCertificateId' => ssl_id
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/elb/listeners.rb

@@ -0,0 +1,32 @@
+require 'fog/aws/models/elb/listener'
+module Fog
+  module AWS
+    class ELB
+      class Listeners < Fog::Collection
+
+        model Fog::AWS::ELB::Listener
+
+        attr_accessor :data, :load_balancer
+
+        def all
+          load(munged_data)
+        end
+
+        def get(lb_port)
+          all.detect{|listener| listener.lb_port == lb_port}
+        end
+
+        private
+        # Munge an array of ListenerDescription hashes like:
+        # {'Listener' => listener, 'PolicyNames' => []}
+        # to an array of listeners with a PolicyNames key
+        def munged_data
+          data.map {|description|
+            description['Listener'].merge('PolicyNames' => description['PolicyNames'])
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/elb/load_balancer.rb

@@ -0,0 +1,173 @@
+require 'fog/core/model'
+module Fog
+  module AWS
+    class ELB
+
+      class LoadBalancer < Fog::Model
+
+        identity  :id,                    :aliases => 'LoadBalancerName'
+        attribute :availability_zones,    :aliases => 'AvailabilityZones'
+        attribute :created_at,            :aliases => 'CreatedTime'
+        attribute :dns_name,              :aliases => 'DNSName'
+        attribute :health_check,          :aliases => 'HealthCheck'
+        attribute :instances,             :aliases => 'Instances'
+        attribute :source_group,          :aliases => 'SourceSecurityGroup'
+        attribute :hosted_zone_name,      :aliases => 'CanonicalHostedZoneName'
+        attribute :hosted_zone_name_id,   :aliases => 'CanonicalHostedZoneNameID'
+        attribute :subnet_ids,            :aliases => 'Subnets'
+        attribute :security_groups,       :aliases => 'SecurityGroups'
+        attribute :scheme,                :aliases => 'Scheme'
+        attribute :vpc_id,                :aliases => 'VPCId'
+
+        def initialize(attributes={})
+          if attributes[:subnet_ids] ||= attributes['Subnets']
+            attributes[:availability_zones] ||= attributes['AvailabilityZones'] 
+          else
+            attributes[:availability_zones] ||= attributes['AvailabilityZones']  || %w(us-east-1a us-east-1b us-east-1c us-east-1d)
+          end
+          unless attributes['ListenerDescriptions']
+            new_listener = Fog::AWS::ELB::Listener.new
+            attributes['ListenerDescriptions'] = [{
+              'Listener' => new_listener.to_params,
+              'PolicyNames' => new_listener.policy_names
+            }]
+          end
+          attributes['Policies'] ||= {'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => []}
+          super
+        end
+
+        def register_instances(instances)
+          requires :id
+          data = connection.register_instances_with_load_balancer(instances, id).body['RegisterInstancesWithLoadBalancerResult']
+          data['Instances'].map!{|h| h['InstanceId']}
+          merge_attributes(data)
+        end
+
+        def deregister_instances(instances)
+          requires :id
+          data = connection.deregister_instances_from_load_balancer(instances, id).body['DeregisterInstancesFromLoadBalancerResult']
+          data['Instances'].map!{|h| h['InstanceId']}
+          merge_attributes(data)
+        end
+
+        def enable_availability_zones(zones)
+          requires :id
+          data = connection.enable_availability_zones_for_load_balancer(zones, id).body['EnableAvailabilityZonesForLoadBalancerResult']
+          merge_attributes(data)
+        end
+
+        def disable_availability_zones(zones)
+          requires :id
+          data = connection.disable_availability_zones_for_load_balancer(zones, id).body['DisableAvailabilityZonesForLoadBalancerResult']
+          merge_attributes(data)
+        end
+        
+        def attach_subnets(subnet_ids)
+          requires :id
+          data = connection.attach_load_balancer_to_subnets(subnet_ids, id).body['AttachLoadBalancerToSubnetsResult']
+          merge_attributes(data)
+        end
+
+        def detach_subnets(subnet_ids)
+          requires :id
+          data = connection.detach_load_balancer_from_subnets(subnet_ids, id).body['DetachLoadBalancerFromSubnetsResult']
+          merge_attributes(data)
+        end
+        
+        def apply_security_groups(security_groups)
+          requires :id
+          data = connection.apply_security_groups_to_load_balancer(security_groups, id).body['ApplySecurityGroupsToLoadBalancerResult']
+          merge_attributes(data)
+        end
+
+        def instance_health
+          requires :id
+          @instance_health ||= connection.describe_instance_health(id).body['DescribeInstanceHealthResult']['InstanceStates']
+        end
+
+        def instances_in_service
+          instance_health.select{|hash| hash['State'] == 'InService'}.map{|hash| hash['InstanceId']}
+        end
+
+        def instances_out_of_service
+          instance_health.select{|hash| hash['State'] == 'OutOfService'}.map{|hash| hash['InstanceId']}
+        end
+
+        def configure_health_check(health_check)
+          requires :id
+          data = connection.configure_health_check(id, health_check).body['ConfigureHealthCheckResult']['HealthCheck']
+          merge_attributes(:health_check => data)
+        end
+
+        def listeners
+          Fog::AWS::ELB::Listeners.new({
+            :data => attributes['ListenerDescriptions'],
+            :connection => connection,
+            :load_balancer => self
+          })
+        end
+
+        def policies
+          Fog::AWS::ELB::Policies.new({
+            :data => attributes['Policies'],
+            :connection => connection,
+            :load_balancer => self
+          })
+        end
+
+        def set_listener_policy(port, policy_name)
+          requires :id
+          policy_name = [policy_name].flatten
+          connection.set_load_balancer_policies_of_listener(id, port, policy_name)
+          reload
+        end
+
+        def set_listener_ssl_certificate(port, ssl_certificate_id)
+          requires :id
+          connection.set_load_balancer_listener_ssl_certificate(id, port, ssl_certificate_id)
+          reload
+        end
+
+        def unset_listener_policy(port)
+          set_listener_policy(port, [])
+        end
+
+        def ready?
+          # ELB requests are synchronous
+          true
+        end
+
+        def save
+          requires :id
+          requires :listeners
+          # with the VPC release, the ELB can have either availability zones or subnets
+          # if both are specified, the availability zones have preference
+          #requires :availability_zones
+          if (availability_zones || subnet_ids)
+            connection.create_load_balancer(availability_zones, id, listeners.map{|l| l.to_params}) if availability_zones
+            connection.create_load_balancer(nil, id, listeners.map{|l| l.to_params}, {:subnet_ids => subnet_ids, :security_groups => security_groups, :scheme => scheme}) if subnet_ids && !availability_zones
+          else
+            throw Fog::Errors::Error.new("No availability zones or subnet ids specified")
+          end
+
+          # reload instead of merge attributes b/c some attrs (like HealthCheck)
+          # may be set, but only the DNS name is returned in the create_load_balance
+          # API call
+          reload
+        end
+
+        def reload
+          super
+          @instance_health = nil
+          self
+        end
+
+        def destroy
+          requires :id
+          connection.delete_load_balancer(id)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/elb/load_balancers.rb

@@ -0,0 +1,38 @@
+require 'fog/aws/models/elb/load_balancer'
+module Fog
+  module AWS
+    class ELB
+      class LoadBalancers < Fog::Collection
+        model Fog::AWS::ELB::LoadBalancer
+
+        # Creates a new load balancer
+        def initialize(attributes={})
+          super
+        end
+
+        def all
+          result = []
+          marker = nil
+          finished = false
+          while !finished
+            data = connection.describe_load_balancers('Marker' => marker).body
+            result.concat(data['DescribeLoadBalancersResult']['LoadBalancerDescriptions'])
+            marker = data['DescribeLoadBalancersResult']['NextMarker']
+            finished = marker.nil?
+          end
+          load(result) # data is an array of attribute hashes
+        end
+
+        def get(identity)
+          if identity
+            data = connection.describe_load_balancers('LoadBalancerNames' => identity).body['DescribeLoadBalancersResult']['LoadBalancerDescriptions'].first
+            new(data)
+          end
+        rescue Fog::AWS::ELB::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/elb/policies.rb

@@ -0,0 +1,40 @@
+require 'fog/aws/models/elb/policy'
+module Fog
+  module AWS
+    class ELB
+      class Policies < Fog::Collection
+
+        model Fog::AWS::ELB::Policy
+
+        attr_accessor :data, :load_balancer
+
+        def all
+          load(munged_data)
+        end
+
+        def get(id)
+          all.detect{|policy| id == policy.id}
+        end
+
+        private
+        # Munge a hash like:
+        # {'LBCookieStickinessPolicies' => [policies...],
+        # 'AppCookieStickinessPolicies' => [policies...]}
+        # to a single array of policies with a cookie_stickiness value
+        def munged_data
+          munged_data = []
+          data['LBCookieStickinessPolicies'].each do |policy|
+            munged_data << policy.merge(:cookie_stickiness => :lb)
+          end
+           data['AppCookieStickinessPolicies'].each do |policy|
+            munged_data << policy.merge(:cookie_stickiness => :app)
+          end
+           munged_data
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/fog/aws/models/elb/policy.rb

@@ -0,0 +1,52 @@
+require 'fog/core/model'
+module Fog
+  module AWS
+    class ELB
+
+      class Policy < Fog::Model
+        identity :id, :aliases => 'PolicyName'
+
+        attribute :cookie,     :aliases => 'CookieName'
+        attribute :expiration, :aliases => 'CookieExpirationPeriod'
+
+        attr_accessor :cookie_stickiness # Either :app or :lb
+
+        def save
+          requires :id, :load_balancer, :cookie_stickiness
+          connection_method = nil
+          args = [load_balancer.id, id]
+          case cookie_stickiness
+          when :app
+            requires :cookie
+            method = :create_app_cookie_stickiness_policy
+            args << cookie
+          when :lb
+            method = :create_lb_cookie_stickiness_policy
+            args << expiration if expiration
+          else
+            raise ArgumentError.new('cookie_stickiness must be :app or :lb')
+          end
+
+          connection.send(method, *args)
+          reload
+        end
+
+        def destroy
+          requires :id, :load_balancer
+          connection.delete_load_balancer_policy(load_balancer.id, id)
+          reload
+        end
+
+        def reload
+          load_balancer.reload
+        end
+
+        def load_balancer
+          collection.load_balancer
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/glacier/archive.rb

@@ -0,0 +1,70 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Archive < Fog::Model
+
+        identity  :id
+        attribute :description
+        attribute :body
+
+        attr_accessor :multipart_chunk_size #must be a power of 2 multiple of 1MB
+
+        def vault
+          @vault
+        end
+
+        def save
+          requires :body, :vault
+
+          if multipart_chunk_size && body.respond_to?(:read)
+            self.id = multipart_save
+          else
+            data = connection.create_archive(vault.id, body, 'description' => description)
+            self.id = data.headers['x-amz-archive-id']
+          end
+          true
+        end
+        
+        def destroy
+          requires :id
+          connection.delete_archive(vault.id,id)
+        end
+
+        private
+
+        def vault=(new_vault)
+          @vault = new_vault
+        end
+
+        def multipart_save
+          # Initiate the upload
+          res = connection.initiate_multipart_upload vault.id, multipart_chunk_size, 'description' => description
+          upload_id = res.headers["x-amz-multipart-upload-id"]
+
+          hash = Fog::AWS::Glacier::TreeHash.new
+
+          body.rewind if body.respond_to?(:rewind)
+          offset = 0
+          while (chunk = body.read(multipart_chunk_size)) do
+            part_hash = hash.add_part(chunk)
+            part_upload = connection.upload_part(vault.id, upload_id, chunk, offset, part_hash  )
+            offset += chunk.bytesize
+          end
+
+        rescue
+          # Abort the upload & reraise
+          connection.abort_multipart_upload(vault.id, upload_id) if upload_id
+          raise
+        else
+          # Complete the upload
+          connection.complete_multipart_upload(vault.id, upload_id, offset, hash.hexdigest).headers['x-amz-archive-id']
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/glacier/archives.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/glacier/archive'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Archives < Fog::Collection
+
+        model Fog::AWS::Glacier::Archive
+        attribute :vault
+        #you can't list a vault's archives
+        def all
+          nil
+        end
+
+        def get(key)
+          new(:id => key)
+        end
+
+        def new(attributes = {})
+          requires :vault
+          super({ :vault => vault }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/glacier/job.rb

@@ -0,0 +1,65 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Job < Fog::Model
+
+        ARCHIVE = 'archive-retrieval'
+        INVENTORY = 'inventory-retrieval'
+
+        identity  :id,              :aliases => "JobId"
+        attribute :action,          :aliases => "Action"
+        attribute :archive_id,      :aliases => "ArchiveId"
+        attribute :archive_size,    :aliases => "ArchiveSizeInBytes", :type => :integer
+        attribute :completed,       :aliases => "Completed", :type => :boolean
+        attribute :completed_at,    :aliases => "CompletionDate", :type => :time
+        attribute :created_at,      :aliases => "CreationDate", :type => :time
+        attribute :inventory_size,  :aliases => "InventorySizeInBytes", :type => :integer
+        attribute :description,     :aliases=> "JobDescription"
+        attribute :tree_hash,       :aliases=> "SHA256TreeHash"
+        attribute :sns_topic,       :aliases => "SNSTopic"
+        attribute :status_code,     :aliases=> "StatusCode"
+        attribute :status_message,  :aliases=> "StatusMessage"
+        attribute :vault_arn,       :aliases=> "VaultARN"
+        attribute :format
+        attribute :type
+
+
+        def ready?
+          completed
+        end
+
+        def save
+          requires :vault, :type
+          specification = {'Type' => type, 'ArchiveId' => archive_id, 'Format' => format, 'Description' => description, 'SNSTopic' => sns_topic}.reject{|k,v| v.nil?}
+
+          data = connection.initiate_job(vault.id, specification)
+          self.id = data.headers['x-amz-job-id']
+          reload
+        end
+
+        def vault
+          @vault
+        end
+
+        #pass :range => 1..1234 to only retrieve those bytes
+        #pass :io => f to stream the response to that tio
+        def get_output(options={})
+          if io = options.delete(:io)
+            options = options.merge :response_block => lambda {|chunk, remaining_bytes, total_bytes| io.write chunk}
+          end
+          options['Range'] = options.delete :range
+          connection.get_job_output(vault.id, id, options)
+        end
+
+        private
+        def vault=(new_vault)
+          @vault = new_vault
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/glacier/jobs.rb

@@ -0,0 +1,45 @@
+require 'fog/core/collection'
+require 'fog/aws/models/glacier/job'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Jobs < Fog::Collection
+
+        model Fog::AWS::Glacier::Job
+        attribute :vault
+        attribute :filters
+        
+        def initialize(attributes)
+          self.filters = {}
+          super
+        end
+
+        # acceptable filters are:
+        # statuscode InProgress/Failed/Succeeded
+        # completed (true/false)
+        def all(filters = self.filters)
+          self.filters = filters
+          data = connection.list_jobs(vault.id, self.filters).body['JobList']
+          load(data)
+        end
+
+        def get(key)
+          data = connection.describe_job(vault.id, key).body
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :vault
+          super({ :vault => vault }.merge!(attributes))
+        end
+
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/glacier/vault.rb

@@ -0,0 +1,53 @@
+require 'fog/core/model'
+require 'fog/aws/models/glacier/archives'
+require 'fog/aws/models/glacier/jobs'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Vault < Fog::Model
+
+        identity  :id,                    :aliases => 'VaultName'
+        attribute :created_at,            :aliases => 'CreationDate', :type => :time
+        attribute :last_inventory_at,     :aliases => 'LastInventoryDate', :type => :time
+        attribute :number_of_archives,    :aliases => 'NumberOfArchives', :type => :integer
+        attribute :size_in_bytes,         :aliases => 'SizeInBytes', :type => :integer
+        attribute :arn,                   :aliases => 'VaultARN'
+
+        def ready?
+          # Glacier requests are synchronous
+          true
+        end
+
+        def archives
+          @archives ||= Fog::AWS::Glacier::Archives.new(:vault => self, :connection => connection)
+        end
+
+        def jobs(filters={})
+          Fog::AWS::Glacier::Jobs.new(:vault => self, :connection => connection, :filters => filters)
+        end
+
+        def set_notification_configuration(topic, events)
+          connection.set_vault_notification_configuration(id, topic, events)
+        end
+
+        def delete_notification_configuration
+          connection.delete_vault_notification_configuration
+        end
+        
+        def save
+          requires :id
+          connection.create_vault(id)
+          reload
+        end
+
+        def destroy
+          requires :id
+          connection.delete_vault(id)
+        end
+
+      end
+    end
+  end
+end