class AWS::AutoScaling::NotificationConfigurationCollection

group.notification_configurations.create(:topic => ‘sns-topic-arn’)
Scaling group:
Just like with enumeration, you can create them from the Auto
:topic => ‘sns-topic-arn’)
:group => ‘auto-scaling-group-name’,
auto_scaling.notification_configurations.create(
You can create a notification configuration like so:
## Creating Notification Configurations
end
# …
group.notification_configurations.each do |config|
group = auto_scaling.groups[‘group-name’]

You can also limit them to a single Auto Scaling group:
end
# …
auto_scaling.notification_configurations.each do |config|
auto_scaling = AWS::AutoScaling.new
You can enumerated ALL configurations from the AWS::AutoScaling class.
## Enumerating Notification Configurations
Allows you to enumerate and create notification configurations.#

def create options = {}

Returns:
  • (NotificationConfiguration) -

Options Hash: (**options)
  • :types (Array) -- A list of notification
  • :group (Group, String) -- An Auto Scaling {Group} object
  • :topic (required, SNS::Topic, String) -- An {SNS::Topic}

Parameters:
  • options (Hash) -- 
def create options = {}
  topic_arn = options[:topic].is_a?(SNS::Topic) ?
    options[:topic].arn : options[:topic]
  unless group = @group
    if group = options[:group]
      group = Group.new(group) unless group.is_a?(Group)
    else
      raise ArgumentError, 'missing required :group option'
    end
  end
  unless types = options[:types]
    types = AutoScaling.new(:config => config).notification_types
  end
  notification_config = NotificationConfiguration.new(group, topic_arn)
  notification_config.notification_types = types
  notification_config
end

def each &block

Other tags:
    Yieldparam: notification_config -

Other tags:
    Yield: - 
def each &block
  #
  # <grumble> We can't use the standard pageable collection mixin here.
  # When you provide :max_records it returns each notification
  # type as an individual record, instead of notification configurations
  # with grouped types.  This makes it very possible to
  # get a part of a configuration in one page of results with the
  # rest in the next page.
  #
  # So instead we will request and group them all before yielding.
  #
  next_token = nil
  groups = {}
  begin
    client_opts = {}
    client_opts[:next_token] = next_token if next_token
    client_opts[:auto_scaling_group_names] = [@group.name] if @group
    resp = client.describe_notification_configurations(client_opts)
    resp.notification_configurations.each do |c|
      group_name = c.auto_scaling_group_name
      groups[group_name] ||= {}
      groups[group_name][c.topic_arn] ||= []
      groups[group_name][c.topic_arn] << c.notification_type
    end
    next_token = resp.data[:next_token]
  end while next_token
  groups.each_pair do |group_name, topics|
    topics.each_pair do |topic_arn, types|
      notification_config = NotificationConfiguration.new(
        Group.new(group_name, :config => config), topic_arn, types)
      yield(notification_config)
    end
  end
end

def initialize options = {}

Other tags:
    Api: - private 
def initialize options = {}
  @group = options[:group]
  if @group
    super(@group, options)
  else
    super(options)
  end
end