aws-sdk-euca 1.8.5

data/lib/aws/iam/collection.rb

@@ -0,0 +1,83 @@
+# 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
+    module Collection
+
+      include Core::Collection::WithLimitAndNextToken
+
+      # Common methods for collection classes that can be filtered by
+      # a path prefix.
+      module WithPrefix
+
+        include Collection
+
+        # @return [String] The path prefix by which the collection is
+        #   filtered.
+        attr_reader :prefix
+
+        # @private
+        def initialize options = {}
+          @prefix = options[:prefix]
+          super
+        end
+
+        # Returns a collection object including only those groups whose
+        # paths begin with the supplied prefix.
+        #
+        # @param [String] prefix The path prefix for filtering the
+        #   results.
+        #
+        # @return [GroupCollection]
+        def with_prefix prefix
+          prefix = "/#{prefix}".sub(%r{^//}, "/")
+          self.class.new(:prefix => prefix, :config => config)
+        end
+
+        protected
+        def _each_item marker, max_items, options = {}, &block
+            
+          prefix = options.delete(:prefix) || self.prefix
+
+          options[:path_prefix] = "/#{prefix}".sub(%r{^//}, "/") if prefix
+
+          super(marker, max_items, options, &block)
+
+        end
+
+      end
+
+      protected
+      def request_method
+        name = Core::Inflection.ruby_name(self.class.name).sub(/_collection$/, '')
+        "list_#{name}s"
+      end
+
+      protected
+      def _each_item marker, max_items, options = {}, &block
+
+        options[:marker] = marker if marker
+        options[:max_items] = max_items if max_items
+
+        response = client.send(request_method, options)
+
+        each_item(response, &block)
+
+        response.data[:marker]
+
+      end
+
+    end
+
+  end
+end

data/lib/aws/iam/config.rb

@@ -0,0 +1,18 @@
+# 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.
+
+AWS::Core::Configuration.module_eval do
+  
+  add_service 'IAM', 'iam', 'iam.amazonaws.com'
+  
+end

data/lib/aws/iam/errors.rb

@@ -0,0 +1,22 @@
+# 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
+    module Errors
+
+      extend Core::LazyErrorClasses
+
+    end
+  end
+end

data/lib/aws/iam/group.rb

@@ -0,0 +1,111 @@
+# 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
+
+    # Represents a group of users.  Groups don't directly interact
+    # with AWS; only users do. The main reason to create groups is to
+    # collectively assign permissions to the users so they can do
+    # their jobs. For example, you could have a group called Admins
+    # and give that group the types of permissions admins typically
+    # need.
+    # @attr [String] name The group's name.
+    # @attr_reader [String] id The group's unique ID.
+    # @attr_reader [Time] create_date When the group was created.
+    # @attr_reader [String] arn The group's ARN (Amazon Resource Name).
+    # @attr [String] path The group's path.  Paths are used to identify
+    #   which division or part of an organization the group belongs to.
+    class Group < Resource
+
+      prefix_update_attributes
+
+      # @private
+      def initialize(name, options = {})
+        options[:name] = name
+        super
+      end
+
+      mutable_attribute :name, :static => true, :from => :group_name
+
+      attribute :id, :static => true, :from => :group_id
+
+      attribute :create_date, :static => true
+
+      attribute :arn
+
+      mutable_attribute :path do
+        translates_input do |path|
+          path = "/#{path}" unless path[0] == ?/
+          path = "#{path}/" unless path[-1] == ?/
+          path
+        end
+      end
+
+      populates_from(:get_group, :create_group) do |resp|
+        resp[:group] if resp[:group][:group_name] == name
+      end
+
+      populates_from(:list_groups, :list_groups_for_user) do |resp|
+        resp[:groups].find {|g| g[:group_name] == name }
+      end
+
+      # (see Resource#exists?)
+      def exists?; super; end
+
+      # Deletes the group.  The group must not contain any users or
+      # have any attached policies.
+      def delete
+        client.delete_group(:group_name => name)
+        nil
+      end
+
+      # Provides access to the users in the group.  For example:
+      #
+      #   # get the names of all the users in the group
+      #   group.users.map(&:name)
+      #
+      #   # remove all users from the group
+      #   group.users.clear
+      #
+      # @return [GroupUserCollection] An object representing all the
+      #   users in the group.
+      def users
+        GroupUserCollection.new(self)
+      end
+
+      # Provides access to the policies associated with the group.
+      # For example:
+      #
+      #   # get the policy named "ReadOnly"
+      #   group.policies["ReadOnly"]
+      #
+      #   # remove all policies associated with the group
+      #   group.policies.clear
+      #
+      # @return [GroupPolicyCollection] An object representing all the
+      #   policies associated with the group.
+      def policies
+        GroupPolicyCollection.new(self)
+      end
+
+      # @private
+      protected
+      def resource_identifiers
+        [[:group_name, name]]
+      end
+
+    end
+
+  end
+end

data/lib/aws/iam/group_collection.rb

@@ -0,0 +1,132 @@
+# 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 collection that provides access to IAM groups
+    # belonging to this account.
+    #
+    #   iam = AWS::IAM.new
+    #   groups = iam.groups
+    #
+    # == Creating a Group
+    #
+    # You can create a group using the {#create} method:
+    #
+    #   group = iam.groups.create("Developers")
+    #
+    # == Getting a Group by Name
+    #
+    # You can get a reference to a server certificate using array notation:
+    #
+    #   group = iam.groups["Developers"]
+    #
+    # == Enumerating Groups
+    #
+    # Group collections can also be used to enumerate groups:
+    #
+    #   groups.each do |group|
+    #     puts group.name
+    #   end
+    #
+    # You can limit the groups returned by passing a +:prefix+ option
+    # to any of the enumerator methods.  When you pass a prefix, only
+    # the certificates whose paths start with the given string will be
+    # returned.
+    class GroupCollection
+
+      include Collection::WithPrefix
+
+      # Creates a group.
+      #
+      # @param [String] name Name of the group to create. Do not
+      #   include the path in this value.
+      #
+      # @param [Hash] options Options for creating the group.
+      #
+      # @option options [String] :path The path to the group.
+      def create(name, options = {})
+        client_opts = { :group_name => name }.merge(options)
+        if path = client_opts[:path]
+          client_opts[:path] = "/#{path}/".
+            sub(%r{^//}, "/").
+            sub(%r{//$}, "/")
+        end
+        resp = client.create_group(client_opts)
+        Group.new(resp.group.group_name, :config => config)
+      end
+
+      # Yields once for each group.
+      #
+      # You can limit the number of groups yielded using +:limit+ and
+      # +:path_prefix+.
+      #
+      # @param [Hash] options
+      #
+      # @option options [String] :path_prefix ('/') A path prefix that
+      #   filters according to the path of the group.
+      #
+      # @option options [Integer] :limit The maximum number of groups
+      #   to yield.
+      #
+      # @option options [Integer] :batch_size The maximum number of
+      #   groups to retrieve in each service request.
+      #
+      # @yieldparam [Group] group
+      # @return [nil]
+      def each options = {}, &block
+        super(options, &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).
+      #
+      #   groups.enumerator(:path_prefix => '/admin').collect(&:name)
+      #
+      # @param (see #each)
+      # @option (see #each)
+      # @return [Enumerator]
+      def enumerator options = {}
+        super(options)
+      end
+
+      # Returns a reference to the group with the given name:
+      #
+      #   group = iam.groups['groupname']
+      #
+      # @param [String] name Name of the group to return a reference for.
+      # @return [Group] Returns a reference to the named group.
+      def [] name
+        Group.new(name, :config => config)
+      end
+
+      # @private
+      protected
+      def each_item response, &block
+        response.groups.each do |item|
+
+          group = Group.new_from(:list_groups, item,
+                                 item.group_name,
+                                 :config => config)
+
+          yield(group)
+
+        end
+      end
+
+    end
+
+  end
+end

data/lib/aws/iam/group_policy_collection.rb

@@ -0,0 +1,47 @@
+# 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 collection that provides access to the policies associated
+    # with an IAM group.  The interface mimics a hash containing
+    # string keys and values that are instances of {Policy}.  For
+    # example:
+    #
+    #  # add or replace a policy named "ReadOnly"
+    #  policy = AWS::IAM::Policy.new do |p|
+    #    # ...
+    #  end
+    #  group.policies["ReadOnly"] = policy
+    #  group.policies.has_key?("ReadOnly")  # => true
+    #
+    # All of the methods for this class are defined in the
+    # {PolicyCollection} module.
+    class GroupPolicyCollection
+
+      include PolicyCollection
+
+      # @attr_reader [Group] The group.
+      attr_reader :group
+
+      # @private
+      def initialize group, opts = {}
+        @group = group
+        super
+      end
+
+    end
+
+  end
+end

data/lib/aws/iam/group_user_collection.rb

@@ -0,0 +1,84 @@
+# 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 collection that provides access to IAM users belonging to a
+    # particular group.
+    #
+    #   group = AWS::IAM.new.groups.first
+    #   users = group.users
+    #   users.each { |u| puts u.name }
+    #
+    class GroupUserCollection
+
+      include Core::Collection::Simple
+
+      # @private
+      def initialize group, options = {}
+        @group = group
+        super
+      end
+
+      # @attr_reader [Group] The group.
+      attr_reader :group
+
+      # Adds a user to the group.
+      #
+      # @param [User] user The user to add.
+      # @return [nil]
+      def add(user)
+
+        client.add_user_to_group(
+          :group_name => group.name,
+          :user_name => user.name)
+
+        nil
+
+      end
+
+      # Remove a user from the group.
+      #
+      # @param [User] user The user to remove.
+      # @return [nil]
+      def remove(user)
+
+        client.remove_user_from_group(
+          :group_name => group.name,
+          :user_name => user.name)
+
+        nil
+
+      end
+
+      # Removes all users from this group.
+      # @return [nil]
+      def clear
+        each {|user| remove(user) }
+      end
+
+      # @private
+      protected
+      def _each_item options = {}, &block
+        response = client.get_group(:group_name => group.name)
+        response.users.each do |u|
+          user = User.new_from(:get_group, u, u.user_name, :config => config)
+          yield(user)
+        end
+      end
+
+    end
+
+  end
+end