fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

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/iam/role.rb

@@ -0,0 +1,36 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class IAM
+
+      class Role < Fog::Model
+        
+        identity  :id, :aliases => 'RoleId'
+        attribute :rolename, :aliases => 'RoleName'
+        attribute :create_date, :aliases => 'CreateDate', :type => :time
+        attribute :assume_role_policy_document, :aliases => 'AssumeRolePolicyDocument'
+        attribute :arn, :aliases => 'Arn'
+        attribute :path, :aliases => 'Path'
+        
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :rolename
+          requires :assume_role_policy_document
+          
+          data = service.create_role(rolename, assume_role_policy_document).body["Role"]
+          merge_attributes(data)
+          true
+        end
+
+        def destroy
+          requires :rolename
+          
+          service.delete_role(rolename)
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/iam/roles.rb

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/aws/models/iam/role'
+
+module Fog
+  module AWS
+    class IAM
+
+      class Roles < Fog::Collection
+
+        model Fog::AWS::IAM::Role
+
+        def initialize(attributes = {})
+          super
+        end
+
+        def all
+          data = service.list_roles.body['Roles']
+          load(data)
+        end
+
+        def get(identity)
+          role = nil
+          begin
+            role = service.roles.new( service.get_role( identity ).data[:body]["Role"] )
+          rescue Excon::Errors::NotFound # ignore not found error
+          end
+          role
+        end
+
+        def new(attributes = {})
+          if not attributes.has_key?(:assume_role_policy_document)
+            attributes[:assume_role_policy_document] = Fog::AWS::IAM::EC2_ASSUME_ROLE_POLICY.to_s
+          end
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/iam/user.rb

@@ -10,6 +10,7 @@ module Fog
         attribute :path, :aliases => 'Path'
         attribute :arn, :aliases => 'Arn'
         attribute :user_id, :aliases => 'UserId'
+        attribute :created_at, :aliases => 'CreateDate', :type => :time
 
         def save
           requires :id

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

@@ -30,6 +30,8 @@ module Fog
         attribute :backup_retention_period, :aliases => 'BackupRetentionPeriod', :type => :integer
         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
 
@@ -120,7 +122,8 @@ module Fog
             'PreferredBackupWindow'         => preferred_backup_window,
             'MultiAZ'                       => multi_az,
             'LicenseModel'                  => license_model,
-            'DBSubnetGroupName'             => db_subnet_group_name
+            'DBSubnetGroupName'             => db_subnet_group_name,
+            'PubliclyAccessible'            => publicly_accessible
           }
 
           options.delete_if {|key, value| value.nil?}

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

@@ -18,6 +18,7 @@ module Fog
         attribute  :allocated_storage, :aliases => 'AllocatedStorage', :type => :integer
         attribute  :availability_zone, :aliases => 'AvailabilityZone'
         attribute  :type, :aliases => 'SnapshotType'
+        attribute  :publicly_accessible, :aliases => 'PubliclyAccessible'
 
         def ready?
           state == 'available'

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

@@ -21,10 +21,33 @@ module Fog
           super
         end
 
+        # 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 = filters
-          data = service.describe_db_snapshots(filters).body['DescribeDBSnapshotsResult']['DBSnapshots']
-          load(data) # data is an array of attribute hashes
+          self.filters.merge!(filters)
+
+          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)
+          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)

data/lib/fog/aws/models/storage/directories.rb

@@ -22,7 +22,7 @@ module Fog
             :prefix     => 'prefix'
           })
           data = service.get_bucket(key, options).body
-          directory = new(:key => data['Name'])
+          directory = new(:key => data['Name'], :is_persisted => true)
           options = {}
           for k, v in data
             if ['CommonPrefixes', 'Delimiter', 'IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(k)

data/lib/fog/aws/models/storage/directory.rb

@@ -9,14 +9,12 @@ module Fog
       class Directory < Fog::Model
         VALID_ACLS = ['private', 'public-read', 'public-read-write', 'authenticated-read']
 
-        # See http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUT.html
-        INVALID_LOCATIONS = ['us-east-1']
-
         attr_reader :acl
 
         identity  :key,           :aliases => ['Name', 'name']
 
-        attribute :creation_date, :aliases => 'CreationDate'
+        attribute :creation_date, :aliases => 'CreationDate', :type => 'time'
+        attribute :location,      :aliases => 'LocationConstraint', :type => 'string'
 
         def acl=(new_acl)
           unless VALID_ACLS.include?(new_acl)
@@ -35,16 +33,12 @@ module Fog
         end
 
         def location
-          requires :key
-          attributes[:location] || bucket_location || self.service.region
+          @location ||= (bucket_location || self.service.region)
         end
 
+        # NOTE: you can't change the region once the bucket is created
         def location=(new_location)
-          if INVALID_LOCATIONS.include?(new_location)
-            raise ArgumentError, "location must not include any of #{INVALID_LOCATIONS.join(', ')}. See http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUT.html"
-          else
-            merge_attributes(:location => new_location)
-          end
+          @location = new_location
         end
 
         def files
@@ -86,11 +80,9 @@ module Fog
         def public_url
           requires :key
           if service.get_bucket_acl(key).body['AccessControlList'].detect {|grant| grant['Grantee']['URI'] == 'http://acs.amazonaws.com/groups/global/AllUsers' && grant['Permission'] == 'READ'}
-            if key.to_s =~ Fog::AWS::COMPLIANT_BUCKET_NAMES
-              "https://#{key}.s3.amazonaws.com"
-            else
-              "https://s3.amazonaws.com/#{key}"
-            end
+            service.request_url(
+              :bucket_name => key
+            )
           else
             nil
           end
@@ -103,18 +95,29 @@ module Fog
 
           options['x-amz-acl'] = acl if acl
 
-          if location = attributes[:location] || (self.service.region != 'us-east-1' && self.service.region)
+          # http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUT.html
+          # Ignore the default region us-east-1
+          if !persisted? && location != DEFAULT_REGION
             options['LocationConstraint'] = location
           end
 
           service.put_bucket(key, options)
+          attributes[:is_persisted] = true
 
           true
         end
 
+        def persisted?
+          # is_persisted is true in case of directories.get or after #save
+          # creation_date is set in case of directories.all
+          attributes[:is_persisted] || !!attributes[:creation_date]
+        end
+
         private
 
         def bucket_location
+          requires :key
+          return nil unless persisted?
           data = service.get_bucket_location(key)
           data.body['LocationConstraint']
         end