aws-sdk-euca 1.8.5

data/lib/aws/iam/login_profile.rb

@@ -0,0 +1,99 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class IAM
+
+    # A login profile is a user name and password that enables a user
+    # to log in to the {http://aws.amazon.com/console AWS Management
+    # Console}. Without a login profile, a user cannot access the
+    # console. (For information about accessing and using the AWS
+    # Management Console, see
+    # {http://docs.amazonwebservices.com/IAM/latest/UserGuide/Using_AWSManagementConsole.html
+    # Using the AWS Management Console}.)
+    #
+    # @example Setting a password for a user's login profile
+    #   user.login_profile.password = "TheNewPassword"
+    #
+    # @example Deleting the login profile for a user
+    #   user.login_profile.delete
+    #
+    class LoginProfile < Resource
+
+      # @private
+      def initialize(user, opts = {})
+        @user = user
+        super
+      end
+
+      # @attr_reader [User] The user to which this login profile
+      #   belongs.
+      attr_reader :user
+
+      # @attr_reader [Time] The time at which the login profile was
+      #   created.
+      attribute :create_date
+
+      # Sets a new password for the login profile, creating the
+      # profile if no profile currently exists for the user.
+      #
+      # @param [String] password The new password for the user.
+      def password=(password)
+        options = resource_options(:password => password)
+        client.update_login_profile(options)
+        password
+      rescue Errors::NoSuchEntity => e
+        client.create_login_profile(options)
+        password
+      end
+
+      # Deletes the login profile for the specified user, which
+      # terminates the user's ability to access AWS services through
+      # the IAM login page.
+      #
+      # @note Deleting a user's login profile does not prevent a user
+      #   from accessing IAM through the command line interface or the
+      #   API. To prevent all user access you must also either make
+      #   the access key inactive or delete it. For more information
+      #   about making keys inactive or deleting them, see
+      #   {User#access_keys}.
+      #
+      # @return [nil]
+      #
+      def delete
+        client.delete_login_profile(resource_options)
+        nil
+      end
+
+      # @return [Boolean] True if a login profile exists for the user.
+      def exists?
+        client.get_login_profile(resource_options)
+      rescue Errors::NoSuchEntity => e
+        false
+      else
+        true
+      end
+
+      populates_from(:get_login_profile, :create_login_profile) do |resp|
+        resp.login_profile if resp.login_profile.user_name == user.name
+      end
+
+      protected
+      def resource_identifiers
+        [[:user_name, user.name]]
+      end
+
+    end
+
+  end
+end

data/lib/aws/iam/mfa_device.rb

@@ -0,0 +1,52 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class IAM
+
+    class MFADevice
+
+      include Core::Model
+
+      # @param [User] user The user the MFA device is associated with.
+      # @param [String] serial_number The MFA device's unique serial number.
+      def initialize user, serial_number, options = {}
+        @user = user
+        @serial_number = serial_number
+        super
+      end
+
+      # @return [User] Returns the MFA device's user.
+      attr_reader :user
+
+      # @return [String] Returns the MFA device's serial number
+      attr_reader :serial_number
+
+      # Deactivates the MFA device and removes it from association
+      # with the user for which it was originally enabled.  You must
+      # call {MFADeviceCollection#enable} to enable the device again.
+      #
+      # @return [nil]
+      def deactivate
+        client.deactivate_mfa_device({
+          :user_name => user.name, 
+          :serial_number => serial_number,
+        })
+        nil
+      end
+
+      alias_method :delete, :deactivate
+
+    end
+
+  end
+end

data/lib/aws/iam/mfa_device_collection.rb

@@ -0,0 +1,127 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class IAM
+
+    # @attr_reader [User] user Returns the user that owns this collection.
+    class MFADeviceCollection
+
+      include Collection
+
+      # @param [User] user The user that owns this device collection.
+      def initialize user, options = {}
+        @user = user
+        super
+      end
+
+      # @return [User] Returns the user that this mfa device collection
+      #   belongs to.
+      attr_reader :user
+
+      # Enables an MFA device for this user.
+      # @param [String] serial_number The serial number that uniquely 
+      #   identifies the MFA device
+      # @param [String] authentication_code_1 An authentication code emitted 
+      #   by the device.
+      # @param [String] authentication_code_2 A subsequent authentication 
+      #   code emitted by the device.
+      # @return [MFADevice] Returns the newly enabled MFA device.
+      def enable serial_number, authentication_code_1, authentication_code_2
+        client.enable_mfa_device({
+          :user_name => user.name,
+          :serial_number => serial_number,
+          :authentication_code_1 => authentication_code_1.to_s,
+          :authentication_code_2 => authentication_code_2.to_s,
+        })
+        self[serial_number]
+      end
+
+      alias_method :create, :enable
+
+      # @param [String] serial_number The serial number of the MFA device you
+      #   want to disable.
+      # @return [nil]
+      def disable serial_number
+        self[serial_number].disable
+        nil
+      end
+
+      # @param [String] serial_number The serial number of an MFA device.
+      # @return [MFADevice] Returns a reference to an MFA device with the
+      #   given serial number.
+      def [] serial_number
+        MFADevice.new(user, serial_number)
+      end
+
+      # Deactivates all of the MFA devices in this collection.
+      # Virtual MFA devices in this collection will not be
+      # deleted. Instead they will be available in the
+      # {IAM#virtual_mfa_devices} collection so that they can either
+      # be deleted or enabled for different users.
+      #
+      # @return [nil]
+      def clear
+        each do |device| 
+          device.deactivate
+        end
+        nil
+      end
+
+      # Yields once for each MFA device.  
+      #
+      # You can limit the number of devices yielded using +:limit+.
+      #
+      # @param [Hash] options
+      # @option options [Integer] :limit The maximum number of devices to yield.
+      # @option options [Integer] :batch_size The maximum number of devices 
+      #   receive each service reqeust.
+      # @yieldparam [User] user 
+      # @return [nil]
+      def each options = {}, &block
+        super(options.merge(:user_name => user.name), &block)
+      end
+
+      # Returns an enumerable object for this collection.  This can be
+      # useful if you want to call an enumerable method that does
+      # not accept options (e.g. +collect+, +first+, etc).
+      #
+      #   mfa_devices.enumerator(:limit => 10).collect(&:serial_number)
+      #
+      # @param (see #each)
+      # @option (see #each)
+      # @return [Enumerator]
+      def enumerator options = {}
+        super(options)
+      end
+
+      # @private
+      protected
+      def each_item response, &block
+        response.mfa_devices.each do |item|
+
+          if item.serial_number =~ /^arn:/
+            mfa_device = VirtualMfaDevice.new_from(:list_mfa_devices, item,
+                                                   item.serial_number,
+                                                   :config => config)
+          else
+            mfa_device = MFADevice.new(user, item.serial_number)
+          end
+
+          yield(mfa_device)
+
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/iam/policy.rb

@@ -0,0 +1,46 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class IAM
+
+    # (see AWS::Core::Policy)
+    class Policy < Core::Policy
+
+      def to_h
+        hash = super
+        hash.delete('Id')
+        hash['Statement'].each do |statement|
+          statement.delete('Sid')
+          statement.delete('Principal')
+        end
+        hash
+      end
+
+      class Statement < Core::Policy::Statement
+
+        ACTION_MAPPING = { }
+
+        protected
+        def resource_arn resource
+          case resource
+          when User then resource.arn
+          else super(resource)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws/iam/policy_collection.rb

@@ -0,0 +1,188 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'uri'
+
+module AWS
+  class IAM
+
+    # Shared methods exposing a collection of policy documents
+    # associated with an IAM resource (a {User} or a {Group}).  Policy
+    # collections can be constructed using {Group#policies} and
+    # {User#policies}.
+    module PolicyCollection
+
+      include Collection
+
+      # Retrieves a policy document by name.
+      #
+      # @param [String] name The name of the policy to retrieve.
+      #
+      # @return [Policy] The policy with the given name.  If no such
+      #   policy exists, this method returns +nil+.
+      def [] name
+        resp = get_policy(:policy_name => name)
+        Policy.from_json(URI.unescape(resp.policy_document))
+      rescue Errors::NoSuchEntity => e
+        nil
+      end
+
+      # Adds or replaces a policy document.
+      #
+      # @param [String] name The name of the policy document.
+      #
+      # @param [Policy,String] document The policy document.  This can
+      #   be a JSON string, or any object that responds to +to_json+.
+      #   The {Policy} class provides a convenient way to construct
+      #   policy documents that you can use with AWS IAM.
+      def []= name, document
+        document = document.to_json if document.respond_to?(:to_json) and
+          !document.kind_of?(String)
+        put_policy(:policy_name => name,
+                   :policy_document => document)
+      end
+
+      # Deletes a policy by name.  This method is idempotent; if no
+      # policy exists with the given name, the method does nothing.
+      #
+      # @param [String] name The name of the policy document.
+      def delete(name)
+        delete_policy(:policy_name => name)
+        nil
+      rescue Errors::NoSuchEntity => e
+        nil
+      end
+
+      # Retrieves multiple policy documents by name.  This method
+      # makes one request to AWS IAM per argument.
+      #
+      # @param names Each argument is the name of a policy to retrieve.
+      #
+      # @return [Array<Policy>] An array containing the requested
+      #   policy documents, in the same order as the argument list.
+      #   If a requested policy does not exist, the array member
+      #   corresponding to that argument will be +nil+.
+      def values_at(*names)
+        names.map { |n| self[n] }
+      end
+
+      # @return [Enumerator<String>] An enumerator for retrieving all
+      #   the policy names that are currently associated with the
+      #   resource.
+      def keys
+        enumerator(:names_only => true)
+      end
+      alias_method :names, :keys
+
+      # @return [Enumerator<Policy>] An enumerator for retrieving all
+      #   the policy documents that are currently associated with the
+      #   resource.
+      def values
+        enumerator(:values_only => true)
+      end
+
+      # Removes all policies from the collection.
+      def clear
+        keys.each { |k| delete(k) }
+      end
+
+      # @param [String] name The name of the policy to check.
+      #
+      # @return [Boolean] True if there is a policy with the given name.
+      def has_key? name
+        get_policy(:policy_name => name)
+        true
+      rescue Errors::NoSuchEntity => e
+        false
+      end
+      alias_method :include?, :has_key?
+      alias_method :key?, :has_key?
+      alias_method :member?, :has_key?
+
+      # @yield [name, policy] The name and document for each policy
+      #   that is associated with the resource.  Like +Hash#each+,
+      #   this method is sensitive to the arity of the provided block;
+      #   if the block takes two arguments, they will be the name and
+      #   document.  If it accepts only one argument, it will be an
+      #   array containing the name and document.
+      def each opts = {}, &block
+        opts = opts.dup
+        names_only = opts.delete(:names_only)
+        values_only = opts.delete(:values_only)
+        super(client_opts(opts)) do |pn|
+          case
+          when names_only
+            yield pn
+          when values_only
+            yield self[pn]
+          when block.arity == 2
+            yield pn, self[pn]
+          else
+            yield [pn, self[pn]]
+          end
+        end
+      end
+
+      # @return [Hash] The contents of the collection as a hash.
+      def to_h
+        inject({}) do |hash, (name, policy)|
+          hash[name] = policy
+          hash
+        end
+      end
+
+      protected
+      def get_policy(opts = {})
+        client.send("get_#{resource_name}_policy",
+                    client_opts(opts))
+      end
+
+      protected
+      def put_policy(opts = {})
+        client.send("put_#{resource_name}_policy",
+                    client_opts(opts))
+      end
+
+      protected
+      def request_method
+        :"list_#{resource_name}_policies"
+      end
+
+      protected
+      def delete_policy(opts = {})
+        client.send("delete_#{resource_name}_policy",
+                    client_opts(opts))
+      end
+
+      protected
+      def client_opts(opts = {})
+        Hash[[[:"#{resource_name}_name",
+               send(resource_name).name]]].merge(opts)
+      end
+
+      protected
+      def resource_name
+        raise NotImplementedError unless
+          self.class.name =~ /AWS::IAM::(.*)PolicyCollection$/
+        $1.downcase
+      end
+
+      protected
+      def each_item(response, &block)
+        response.data[:policy_names].each(&block)
+      end
+
+    end
+
+  end
+end