gapinc-fog 1.12.1.2.1 → 1.14.0

data/lib/fog/aws/models/auto_scaling/activities.rb

@@ -4,14 +4,22 @@ module Fog
   module AWS
     class AutoScaling
       class Activities < Fog::Collection
-
         model Fog::AWS::AutoScaling::Activity
 
-        def all
+        attribute :filters
+
+        # Creates a new scaling policy.
+        def initialize(attributes={})
+          self.filters = attributes
+          super(attributes)
+        end
+
+        def all(filters = filters)
           data = []
           next_token = nil
+          self.filters = filters
           loop do
-            result = service.describe_scaling_activities('NextToken' => next_token).body['DescribeScalingActivitiesResult']
+            result = service.describe_scaling_activities(filters.merge('NextToken' => next_token)).body['DescribeScalingActivitiesResult']
             data += result['Activities']
             next_token = result['NextToken']
             break if next_token.nil?

data/lib/fog/aws/models/auto_scaling/groups.rb

@@ -4,19 +4,22 @@ module Fog
   module AWS
     class AutoScaling
       class Groups < Fog::Collection
-
         model Fog::AWS::AutoScaling::Group
 
+        attribute :filters
+
         # Creates a new auto scaling group.
         def initialize(attributes={})
+          self.filters = attributes
           super
         end
 
-        def all
+        def all(filters = filters)
           data = []
           next_token = nil
+          self.filters = filters
           loop do
-            result = service.describe_auto_scaling_groups('NextToken' => next_token).body['DescribeAutoScalingGroupsResult']
+            result = service.describe_auto_scaling_groups(filters.merge('NextToken' => next_token)).body['DescribeAutoScalingGroupsResult']
             data += result['AutoScalingGroups']
             next_token = result['NextToken']
             break if next_token.nil?

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

@@ -6,16 +6,20 @@ module Fog
       class Policies < Fog::Collection
         model Fog::AWS::AutoScaling::Policy
 
+        attribute :filters
+
         # Creates a new scaling policy.
         def initialize(attributes={})
-          super
+          self.filters = attributes
+          super(attributes)
         end
 
-        def all
+        def all(filters = filters)
           data = []
           next_token = nil
+          self.filters = filters
           loop do
-            result = service.describe_policies('NextToken' => next_token).body['DescribePoliciesResult']
+            result = service.describe_policies(filters.merge('NextToken' => next_token)).body['DescribePoliciesResult']
             data += result['ScalingPolicies']
             next_token = result['NextToken']
             break if next_token.nil?

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

@@ -71,7 +71,7 @@ module Fog
 
         def server
           requires :server_id
-          service.servers('instance-id' => server_id)
+          service.servers.get(server_id)
         end
 
         def server=(new_server)

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

@@ -0,0 +1,11 @@
+require 'fog/core/model'
+module Fog
+  module AWS
+    class ELB
+      class BackendServerDescription < Fog::Model
+        attribute :policy_names,      :aliases => 'PolicyNames'
+        attribute :instance_port,     :aliases => 'InstancePort'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'fog/aws/models/elb/backend_server_description'
+module Fog
+  module AWS
+    class ELB
+      class BackendServerDescriptions < Fog::Collection
+
+        model Fog::AWS::ELB::BackendServerDescription
+
+        attr_accessor :data, :load_balancer
+
+        def all
+          load(data)
+        end
+
+        def get(instance_port)
+          all.detect{|e| e.instance_port == instance_port}
+        end
+
+      end
+    end
+  end
+end

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

@@ -32,7 +32,6 @@ module Fog
               'PolicyNames' => new_listener.policy_names
             }]
           end
-          attributes['Policies'] ||= {'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => []}
           super
         end
 
@@ -99,6 +98,14 @@ module Fog
           merge_attributes(:health_check => data)
         end
 
+        def backend_server_descriptions
+          Fog::AWS::ELB::BackendServerDescriptions.new({
+            :data => attributes['BackendServerDescriptions'],
+            :service => service,
+            :load_balancer => self
+          })
+        end
+
         def listeners
           Fog::AWS::ELB::Listeners.new({
             :data => attributes['ListenerDescriptions'],
@@ -109,12 +116,17 @@ module Fog
 
         def policies
           Fog::AWS::ELB::Policies.new({
-            :data => attributes['Policies'],
+            :data => policy_descriptions,
             :service => service,
             :load_balancer => self
           })
         end
 
+        def policy_descriptions
+          requires :id
+          @policy_descriptions ||= service.describe_load_balancer_policies(id).body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"]
+        end
+
         def set_listener_policy(port, policy_name)
           requires :id
           policy_name = [policy_name].flatten
@@ -159,6 +171,7 @@ module Fog
         def reload
           super
           @instance_health = nil
+          @policy_descriptions = nil
           self
         end
 

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

@@ -17,19 +17,35 @@ module Fog
         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
+          data.inject([]){|m,e|
+            policy_attribute_descriptions = e["PolicyAttributeDescriptions"]
+
+            policy = {
+              :id => e["PolicyName"],
+              :type_name => e["PolicyTypeName"],
+              :policy_attributes => policy_attributes(policy_attribute_descriptions)
+            }
+
+            case e["PolicyTypeName"]
+            when 'AppCookieStickinessPolicyType'
+              cookie_name = policy_attribute_descriptions.detect{|h| h['AttributeName'] == 'CookieName'}['AttributeValue']
+              policy['CookieName'] = cookie_name if cookie_name
+            when 'LBCookieStickinessPolicyType'
+              cookie_expiration_period = policy_attribute_descriptions.detect{|h| h['AttributeName'] == 'CookieExpirationPeriod'}['AttributeValue'].to_i
+              policy['CookieExpirationPeriod'] = cookie_expiration_period if cookie_expiration_period > 0
+            end
+
+            m << policy
+            m
+          }
+        end
+
+        def policy_attributes(policy_attribute_descriptions)
+          policy_attribute_descriptions.inject({}){|m,e|
+            m[e["AttributeName"]] = e["AttributeValue"]
+            m
+          }
         end
 
       end
@@ -37,4 +53,3 @@ module Fog
     end
   end
 end
-

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

@@ -8,23 +8,33 @@ module Fog
 
         attribute :cookie,     :aliases => 'CookieName'
         attribute :expiration, :aliases => 'CookieExpirationPeriod'
+        attribute :type_name
+        attribute :policy_attributes
 
         attr_accessor :cookie_stickiness # Either :app or :lb
 
         def save
-          requires :id, :load_balancer, :cookie_stickiness
+          requires :id, :load_balancer
           service_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
+
+          if cookie_stickiness
+            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
           else
-            raise ArgumentError.new('cookie_stickiness must be :app or :lb')
+            requires :type_name, :policy_attributes
+            method = :create_load_balancer_policy
+            args << type_name
+            args << policy_attributes
           end
 
           service.send(method, *args)

data/lib/fog/aws/models/rds/instance_option.rb

@@ -0,0 +1,21 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+
+      class InstanceOption < Fog::Model
+
+        attribute :multi_az_capable, :aliases => 'MultiAZCapable', :type => :boolean
+        attribute :engine, :aliases => 'Engine'
+        attribute :license_model, :aliases => 'LicenseModel'
+        attribute :read_replica_capable, :aliases => 'ReadReplicaCapable', :type => :boolean
+        attribute :engine_version, :aliases => 'EngineVersion'
+        attribute :availability_zones, :aliases => 'AvailabilityZones', :type => :array
+        attribute :db_instance_class, :aliases => 'DBInstanceClass'
+        attribute :vpc, :aliases => 'Vpc', :type => :boolean
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/rds/instance_options.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/rds/instance_option'
+
+module Fog
+  module AWS
+    class RDS
+
+      class InstanceOptions < Fog::PagedCollection
+        attribute :filters
+        attribute :engine
+        model Fog::AWS::RDS::InstanceOption
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # This method deliberately returns only a single page of results
+        def all(filters=filters)
+          self.filters.merge!(filters)
+
+          result = service.describe_orderable_db_instance_options(engine, self.filters).body['DescribeOrderableDBInstanceOptionsResult']
+          self.filters[:marker] = result['Marker']
+          load(result['OrderableDBInstanceOptions'])
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/rds/log_file.rb

@@ -0,0 +1,26 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+
+      class LogFile < Fog::Model
+
+        attribute :rds_id, :aliases => 'DBInstanceIdentifier'
+        attribute :name, :aliases => 'LogFileName'
+        attribute :size, :aliases => 'Size', :type => :integer
+        attribute :last_written, :aliases => 'LastWritten', :type => :time
+        attribute :content, :aliases => 'LogFileData'
+        attribute :marker, :aliases => 'Marker'
+        attribute :more_content_available, :aliases => 'AdditionalDataPending', :type => :boolean
+
+        def content_excerpt(marker=nil)
+          result = service.download_db_logfile_portion(self.rds_id, self.name, {:marker => marker})
+          merge_attributes(result.body['DownloadDBLogFilePortionResult'])
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/rds/log_files.rb

@@ -0,0 +1,50 @@
+require 'fog/core/collection'
+require 'fog/aws/models/rds/log_file'
+
+module Fog
+  module AWS
+    class RDS
+
+      class LogFiles < Fog::Collection
+        attribute :filters
+        attribute :rds_id
+        model Fog::AWS::RDS::LogFile
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # This method deliberately returns only a single page of results
+        def all(filters=filters)
+          self.filters.merge!(filters)
+
+          result = service.describe_db_log_files(rds_id, self.filters).body['DescribeDBLogFilesResult']
+          self.filters[:marker] = result['Marker']
+          load(result['DBLogFiles'])
+        end
+
+        def each(filters=filters)
+          if block_given?
+            begin
+              page = self.all(filters)
+              # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
+              base_each = Fog::Collection.instance_method(:each)
+              base_each.bind(page).call { |log_file| yield log_file }
+            end while self.filters[:marker]
+          end
+          self
+        end
+
+        def get(file_name=nil)
+          if file_name
+            matches = self.select {|log_file| log_file.name.upcase == file_name.upcase}
+            return matches.first unless matches.empty?
+          end
+        rescue Fog::AWS::RDS::NotFound
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/rds/server.rb

@@ -31,6 +31,7 @@ module Fog
         attribute :license_model, :aliases => 'LicenseModel'
         attribute :db_subnet_group_name, :aliases => 'DBSubnetGroupName'
         attribute :publicly_accessible, :aliases => 'PubliclyAccessible'
+        attribute :vpc_security_groups, :aliases => 'VpcSecurityGroups'
 
         attr_accessor :password, :parameter_group_name, :security_group_names, :port
 

data/lib/fog/aws/models/rds/snapshots.rb

@@ -21,26 +21,33 @@ module Fog
           super
         end
 
-        # This will return a single page based on the current or provided filters,
-        # updating the filters with the marker for the next page.  Calling this repeatedly
-        # will iterate through pages.
+        # This method does NOT return all snapshots. Its implementation deliberately returns a single page
+        # of results for any one call. It will return a single page based on the current or provided filters,
+        # updating the filters with the marker for the next page. Calling this repeatedly will iterate
+        # through pages. See the implementation of each for an example of such iteration.
+        #
+        # It is arguably incorrect for the method not to return all snapshots, particularly considering the
+        # implementation in the corresponding 'elb' files. But this implementation has been released, and
+        # backwards-compatibility requires leaving it as implemented.
         def all(filters = filters)
           self.filters.merge!(filters)
 
-          snapshots = service.describe_db_snapshots(filters)
-          self.filters[:marker] = snapshots.body['DescribeDBSnapshotsResult']['Marker']
-          data = snapshots.body['DescribeDBSnapshotsResult']['DBSnapshots']
-          load(data)
+          page = service.describe_db_snapshots(self.filters).body['DescribeDBSnapshotsResult']
+          self.filters[:marker] = page['Marker']
+          load(page['DBSnapshots'])
         end
 
         # This will execute a block for each snapshot, fetching new pages of snapshots as required.
         def each(filters = filters)
-          begin
-            page = self.all(filters)
-            # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
-            base_each = Fog::Collection.instance_method(:each)
-            base_each.bind(page).call {|snapshot| yield snapshot}
-          end while self.filters[:marker]
+          if block_given?
+            begin
+              page = self.all(filters)
+              # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
+              base_each = Fog::Collection.instance_method(:each)
+              base_each.bind(page).call { |snapshot| yield snapshot }
+            end while self.filters[:marker]
+          end
+          self
         end
 
         def get(identity)