fog-aws 0.4.0 → 0.4.1

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

@@ -23,10 +23,41 @@ module Fog
           merge_attributes(:users => self.users + [user])
         end
 
-        def attach(policy_arn)
+        def attach(policy_or_arn)
           requires :name
 
-          service.attach_group_policy(self.name, policy_arn)
+          arn = if policy_or_arn.respond_to?(:arn)
+                  policy_or_arn.arn
+                else
+                  policy_or_arn
+                end
+
+          service.attach_group_policy(self.name, arn)
+        end
+
+        def attached_policies
+          requires :name
+
+          service.managed_policies(:group_name => self.name)
+        end
+
+        def destroy
+          requires :name
+
+          service.delete_group(self.name)
+          true
+        end
+
+        def detach(policy_or_arn)
+          requires :name
+
+          arn = if policy_or_arn.respond_to?(:arn)
+                  policy_or_arn.arn
+                else
+                  policy_or_arn
+                end
+
+          service.detach_group_policy(self.name, arn)
         end
 
         def save

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

@@ -1,19 +1,16 @@
 require 'fog/aws/models/iam/group'
+require 'fog/aws/iam/paged_collection'
 
 module Fog
   module AWS
     class IAM
-      class Groups < Fog::Collection
+      class Groups < Fog::AWS::IAM::PagedCollection
 
-        attribute :truncated, :aliases => 'IsTruncated', :type => :boolean
-        attribute :marker,    :aliases => 'Marker'
         attribute :username
 
         model Fog::AWS::IAM::Group
 
         def all(options = {})
-          merge_attributes(options)
-
           data, records = if self.username
                             response = service.list_groups_for_user(self.username, options)
                             [response.body, response.body['GroupsForUser']]
@@ -36,23 +33,6 @@ module Fog
         rescue Fog::AWS::IAM::NotFound
           nil
         end
-
-        def each
-          if !block_given?
-            self
-          else
-            subset = dup.all
-
-            subset.each { |f| yield f }
-
-            while subset.truncated
-              subset = subset.all('Marker' => subset.marker, 'MaxItems' => 1000)
-              subset.each { |f| yield f }
-            end
-
-            self
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,63 @@
+require 'fog/aws/models/iam/managed_policy'
+require 'fog/aws/iam/paged_collection'
+
+module Fog
+  module AWS
+    class IAM
+      class ManagedPolicies < Fog::AWS::IAM::PagedCollection
+
+        attribute :username
+        attribute :group_name
+
+        model Fog::AWS::IAM::ManagedPolicy
+
+        def all(options={})
+          data = if self.username
+                   all_by_user(self.username, options)
+                 elsif self.group_name
+                   all_by_group(self.group_name, options)
+                 else
+                   all_policies(options)
+                 end
+
+          load(data)
+        end
+
+        def get(identity)
+          response = service.get_policy(identity)
+
+          new(response.body['Policy'])
+        rescue Fog::AWS::IAM::NotFound
+          nil
+        end
+
+        protected
+
+        def all_by_user(username, options={})
+          body = service.list_attached_user_policies(username, page_params(options)).body
+          merge_attributes(body)
+
+          body['Policies'].map do |policy|
+            service.get_policy(policy['PolicyArn']).body['Policy']
+          end
+        end
+
+        def all_by_group(group_name, options={})
+          body = service.list_attached_group_policies(group_name, page_params(options)).body
+          merge_attributes(body)
+
+          body['Policies'].map do |policy|
+            service.get_policy(policy['PolicyArn']).body['Policy']
+          end
+        end
+
+        def all_policies(options={})
+          body = service.list_policies(page_params(options)).body
+          merge_attributes(body)
+
+          body['Policies']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class IAM
+      class ManagedPolicy < Fog::Model
+        identity  :id, :aliases => 'PolicyId'
+
+        attribute :arn,             :aliases => 'Arn'
+        attribute :attachable,      :aliases => 'IsAttachable', :type => :boolean
+        attribute :attachments,     :aliases => 'AttachmentCount', :type => :integer
+        attribute :created_at,      :aliases => 'CreateDate', :type => :time
+        attribute :default_version, :aliases => 'DefaultVersionId'
+        attribute :description,     :aliases => 'Description'
+        attribute :name,            :aliases => 'PolicyName'
+        attribute :path,            :aliases => 'Path'
+        attribute :updated_at,      :aliases => 'UpdateDate', :type => :time
+
+        def attach(user_or_username)
+          requires :arn
+
+          username = if user_or_username.respond_to?(:identity)
+                       user_or_username.identity
+                     else
+                       user_or_username
+                     end
+
+          service.attach_user_policy(username, self.arn)
+        end
+
+        def document
+          requires :arn, :default_version
+
+          service.get_policy_version(self.arn, self.default_version).
+            body['PolicyVersion']['Document']
+        end
+      end
+    end
+  end
+end

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

@@ -1,21 +1,23 @@
 require 'fog/aws/models/iam/policy'
+require 'fog/aws/iam/paged_collection'
 
 module Fog
   module AWS
     class IAM
-      class Policies < Fog::Collection
+      class Policies < Fog::AWS::IAM::PagedCollection
+
         model Fog::AWS::IAM::Policy
 
         attribute :username
         attribute :group_name
 
-        def all
+        def all(options={})
           requires_one :username, :group_name
 
           policies = if self.username
-                       all_by_user(self.username)
-                     else
-                       all_by_group(self.group_name)
+                       all_by_user(self.username, options)
+                     else self.group_name
+                       all_by_group(self.group_name, options)
                      end
 
           load(policies) # data is an array of attribute hashes
@@ -24,13 +26,13 @@ module Fog
         def get(identity)
           requires_one :username, :group_name
 
-          data = if self.username
-                   service.get_user_policy(identity, self.username)
-                 else
-                   service.get_group_policy(identity, self.group_name)
-                 end.body['Policy']
+          response = if self.username
+                       service.get_user_policy(identity, self.username)
+                     else self.group_name
+                       service.get_group_policy(identity, self.group_name)
+                     end
 
-          new(data)
+          new(response.body['Policy'])
         rescue Fog::AWS::IAM::NotFound
           nil
         end
@@ -44,16 +46,18 @@ module Fog
         # AWS method get_user_policy and list_group_policies only returns an array of policy names, this is kind of useless,
         # that's why it has to loop through the list to get the details of each element. I don't like it because it makes this method slow
 
-        def all_by_group(group_name)
-          response = service.list_group_policies(group_name)
+        def all_by_group(group_name, options={})
+          response = service.list_group_policies(group_name, page_params(options))
+          merge_attributes(response.body)
 
           response.body['PolicyNames'].map do |policy_name|
             service.get_group_policy(policy_name, group_name).body['Policy']
           end
         end
 
-        def all_by_user(username)
-          response = service.list_user_policies(username)
+        def all_by_user(username, options={})
+          response = service.list_user_policies(username, page_params(options))
+          merge_attributes(response.body)
 
           response.body['PolicyNames'].map do |policy_name|
             service.get_user_policy(policy_name, username).body['Policy']

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

@@ -15,6 +15,36 @@ module Fog
           service.access_keys(:username => id)
         end
 
+        def attach(policy_or_arn)
+          requires :identity
+
+          arn = if policy_or_arn.respond_to?(:arn)
+                  policy_or_arn.arn
+                else
+                  policy_or_arn
+                end
+
+          service.attach_user_policy(self.identity, arn)
+        end
+
+        def detach(policy_or_arn)
+          requires :identity
+
+          arn = if policy_or_arn.respond_to?(:arn)
+                  policy_or_arn.arn
+                else
+                  policy_or_arn
+                end
+
+          service.detach_user_policy(self.identity, arn)
+        end
+
+        def attached_policies
+          requires :identity
+
+          service.managed_policies(:username => self.identity)
+        end
+
         def destroy
           requires :id
 
@@ -23,13 +53,15 @@ module Fog
         end
 
         def groups
+          requires :identity
+
           service.groups(:username => self.identity)
         end
 
         def policies
-          requires :id
+          requires :identity
 
-          service.policies(:username => id)
+          service.policies(:username => self.identity)
         end
 
         def password=(password)

data/lib/fog/aws/parsers/iam/list_managed_policies.rb

@@ -14,12 +14,37 @@ module Fog
             @response['Policies'] << policy
           end
 
+          def start_element(name,attrs = [])
+            case name
+            when 'AttachedPolicies'
+              @stack << name
+            when 'AttachedPolicy'
+              @policy = fresh_policy
+            when 'member'
+              if @stack.last == 'AttachedPolicies'
+                @policy = fresh_policy
+              end
+            end
+            super
+          end
+
           def end_element(name)
             case name
             when 'RequestId', 'Marker'
               @response[name] = value
             when 'IsTruncated'
               @response[name] = (value == 'true')
+            when 'PolicyArn', 'PolicyName'
+              @policy[name] = value
+            when 'AttachedPolicies'
+              if @stack.last == 'AttachedPolicies'
+                @stack.pop
+              end
+            when 'member'
+              if @stack.last == 'AttachedPolicies'
+                finished_policy(@policy)
+                @policy = nil
+              end
             end
             super
           end

data/lib/fog/aws/parsers/iam/policy_version.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Parsers
+    module AWS
+      module IAM
+        class PolicyVersion < Fog::Parsers::Base
+          def reset
+            super
+            @version = {}
+            @response = { 'PolicyVersion' => @version }
+          end
+
+          def end_element(name)
+            case name
+            when 'RequestId'
+              @response[name] = value
+            when 'VersionId'
+              @version[name] = value
+            when 'IsDefaultVersion'
+              @version[name] = (value == 'true')
+            when 'Document'
+              @version[name] = if decoded_string = URI.decode(value)
+                                 Fog::JSON.decode(decoded_string) rescue value
+                               else
+                                 value
+                               end
+            end
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/region_methods.rb

@@ -1,7 +1,7 @@
 module Fog
   module AWS
     module RegionMethods
-      def validate_aws_region host, region
+      def validate_aws_region(host, region)
         if host.end_with?('.amazonaws.com') && !['ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'sa-east-1', 'us-gov-west-1', 'eu-central-1'].include?(region)
           raise ArgumentError, "Unknown region: #{region.inspect}"
         end

data/lib/fog/aws/requests/compute/allocate_address.rb

@@ -27,27 +27,29 @@ module Fog
 
       class Mock
         def allocate_address(domain = 'standard')
-          domain = domain == 'vpc' ? 'vpc' : 'standard'
+          unless describe_addresses.body['addressesSet'].size < self.data[:limits][:addresses]
+            raise Fog::Compute::AWS::Error, "AddressLimitExceeded => Too many addresses allocated"
+          end
+
           response = Excon::Response.new
-          if describe_addresses.body['addressesSet'].size < self.data[:limits][:addresses]
-            response.status = 200
-            public_ip = Fog::AWS::Mock.ip_address
-            data = {
-              'instanceId' => nil,
-              'publicIp'   => public_ip,
-              'domain'     => domain
-            }
-            if domain == 'vpc'
-              data['allocationId'] = "eipalloc-#{Fog::Mock.random_hex(8)}"
-            end
-            self.data[:addresses][public_ip] = data
-            response.body = data.reject {|k, v| k == 'instanceId' }.merge('requestId' => Fog::AWS::Mock.request_id)
-            response
-          else
-            response.status = 400
-            response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>AddressLimitExceeded</Code><Message>Too many addresses allocated</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestID></Response>"
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+          response.status = 200
+
+          domain    = domain == 'vpc' ? 'vpc' : 'standard'
+          public_ip = Fog::AWS::Mock.ip_address
+
+          data = {
+            'instanceId' => nil,
+            'publicIp'   => public_ip,
+            'domain'     => domain
+          }
+
+          if domain == 'vpc'
+            data['allocationId'] = "eipalloc-#{Fog::Mock.random_hex(8)}"
           end
+
+          self.data[:addresses][public_ip] = data
+          response.body = data.reject {|k, v| k == 'instanceId' }.merge('requestId' => Fog::AWS::Mock.request_id)
+          response
         end
       end
     end