class AWS::IAM::GroupCollection

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.

Public Instance Methods

[](name) click to toggle source

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.

# File lib/aws/iam/group_collection.rb, line 111
def [] name
  Group.new(name, :config => config)
end
create(name, options = {}) click to toggle source

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.

# File lib/aws/iam/group_collection.rb, line 59
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
each(options = {}) click to toggle source

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]

Calls superclass method
# File lib/aws/iam/group_collection.rb, line 88
def each options = {}, &block
  super(options, &block)
end
enumerator(options = {}) click to toggle source

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]

Calls superclass method
# File lib/aws/iam/group_collection.rb, line 101
def enumerator options = {}
  super(options)
end

Protected Instance Methods

each_item(response) { |group| ... } click to toggle source

@api private

# File lib/aws/iam/group_collection.rb, line 117
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