aws-asg-fleet 0.0.3 → 0.0.4

data/README.md

@@ -121,20 +121,11 @@ fleet.update_launch_configuration('new-launch-config',
 That will create a new launch configuration, and add it to all the
 groups, replacing the old one.
 
-Above, we showed how to add a group you've already created to the fleet.
-You can also create a group *based on the existing template group*. This
-method will create a new group using options you pass in, but any
-options you don't specify will be pulled from the template group. Policies
-and alarms also get duplicated for the new group:
-
-```ruby
-fleet.groups.create('yet-another-group',
-  :load_balancers => [ 'my-other-elb' ])
-```
-
 ## How It Works
 
 Fleets are identified using tags on Auto Scaling groups. When you create
 a new fleet 'my-fleet', it adds the tag key "asgfleet:my-fleet" with
 value "template". Other groups added to the fleet get tagged with key
-"asgfleet:my-fleet" and value "member".
+"asgfleet:my-fleet" and value "member". If you don't have a group tagged
+with "template" and attempt to perform a `update_launch_configuration`, it
+will use the first group tagged as a member instead.

data/asg-fleet.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "aws-asg-fleet"
-  spec.version       = "0.0.3"
+  spec.version       = "0.0.4"
   spec.authors       = ["Zach Wily"]
   spec.email         = ["zach@zwily.com"]
   spec.description   = %q{AWS Auto Scaling Fleets}

data/lib/aws/auto_scaling/fleet.rb

@@ -10,24 +10,43 @@ module AWS
       # @return [String]
       attr_reader :name
 
+      def tag_name
+        "asgfleet:#{name}"
+      end
+
       # @return [Group]
       def template_group
         tag = TagCollection.new(:config => config)
-          .filter(:key, "asgfleet:#{name}")
+          .filter(:key, tag_name)
           .filter(:value, "template")
           .first
+
+        return nil unless tag
+        tag.resource
+      end
+
+      # @return [Group]
+      def any_group
+        tag = TagCollection.new(:config => config)
+          .filter(:key, tag_name)
+          .first
+
         return nil unless tag
         tag.resource
       end
 
+      def template_or_any_group
+        template_group || any_group
+      end
+
       def exists?
-        !template_group.nil?
+        !any_group.nil?
       end
 
       def groups
         FleetGroupCollection.new(self)
       end
-      
+
       # Suspends all scaling processes in all Auto Scaling groups in the
       # fleet.
       def suspend_all_processes
@@ -56,7 +75,7 @@ module AWS
       #   existing launch configuration on the template scaling group.
       #
       def update_launch_configuration name, options = {}
-        old_lc = template_group.launch_configuration
+        old_lc = template_or_any_group.launch_configuration
         image_id = options[:image_id] || old_lc.image_id
         instance_type = options[:instance_type] || old_lc.instance_type
 

data/lib/aws/auto_scaling/fleet_collection.rb

@@ -34,17 +34,6 @@ module AWS
       def [] name
         Fleet.new(name, :config => config)
       end
-
-      protected
-
-      def _each_item options
-        TagCollection.new(:config => config).filter(:value, "template").each do |tag|
-          if tag[:key] =~ /^asgfleet:/
-            name = tag[:key].split(':', 2)[1]
-            yield Fleet.new(name, :config => config)
-          end
-        end
-      end
     end
   end
 end

data/lib/aws/auto_scaling/fleet_group_collection.rb

@@ -18,141 +18,6 @@ module AWS
       def << group
         group.set_fleet @fleet.name
       end
-
-      # Create a group within a Fleet.
-      #
-      # To create a group you supply a name, and any desired Auto
-      # Scaling group options. Any options not specified will be pulled
-      # from the template group for the fleet. Scaling policies and
-      # alarms will also be created for the new Group, based on those
-      # associated with the template.
-      #
-      # @param [String] name The name of the new group to create in the
-      #   fleet. Must be unique in your account.
-      #
-      # @param [Hash] options
-      #
-      # @option (see GroupOptions#group_options)
-      #
-      # @return [Group]
-      def create name, options = {}
-        ## Clone the group
-        template_group = @fleet.template_group
-
-        options = Fleet.options_from(template_group,
-          :load_balancers, :min_size, :max_size, :launch_configuration,
-          :availability_zones, :default_cooldown, :desired_capacity,
-          :health_check_grace_period, :health_check_type, :placement_group,
-          :termination_policies, :subnets).merge(options)
-
-        # merge together tags from options and the template
-        new_tags = template_group.tags.to_a.map do |t|
-          {
-            :key => t[:key],
-            :value => t[:value],
-            :propagate_at_launch => t[:propagate_at_launch]
-          }
-        end
-        if options[:tags]
-          options[:tags].each do |tag|
-            existing_tag = new_tags.find {|t| t[:key] == tag[:key] }
-            if existing_tag
-              existing_tag.merge! tag
-            else
-              new_tags << tag
-            end
-          end
-        end
-        # change the fleet tag value from "template" to "member"
-        fleet_tag = new_tags.find {|t| t[:key] == "asgfleet:#{@fleet.name}" }
-        fleet_tag[:value] = "member"
-        options[:tags] = new_tags
-
-        group = GroupCollection.new(:config => config).create name, options
-
-        # Match metric collection with the template
-        # (If this call ever supports specifying a granularity of other than
-        # '1Minute', this will need to change.)
-        group.enable_metrics_collection(template_group.enabled_metrics.keys)
-
-        # Copy notification configurations
-        template_group.notification_configurations.each do |template_nc|
-          group.notification_configurations.create(
-            :topic => template_nc.topic_arn,
-            :types => template_nc.notification_types,
-          )
-        end
-
-        ## Clone the scaling policies and alarms from the group
-        cloudwatch = AWS::CloudWatch.new(:config => config)
-        template_group.scaling_policies.each do |template_policy|
-          policy_options = Fleet.options_from(template_policy,
-            :adjustment_type, :scaling_adjustment, :cooldown, :min_adjustment_step)
-
-          policy = group.scaling_policies.create template_policy.name, policy_options
-
-          template_policy.alarms.keys.each do |template_alarm_name|
-            template_alarm = cloudwatch.alarms[template_alarm_name]
-
-            # try to generate a unique alarm name first by replacing the name
-            # of the template group with the new group. if that doesn't work, then
-            # just append the new group's name
-            alarm_name = template_alarm.name.gsub(template_group.name, group.name)
-            if alarm_name == template_group.name
-              alarm_name = "#{alarm_name}-#{group.name}"
-            end
-
-            alarm_options = Fleet.options_from(template_alarm,
-              :namespace, :metric_name, :comparison_operator, :evaluation_periods,
-              :period, :statistic, :threshold, :actions_enabled, :alarm_description,
-              :unit)
-
-            # For dimensions, copy them all except for the one
-            # referencing the ASG - replace that with the right group.
-            alarm_options[:dimensions] = template_alarm.dimensions.map do |dimension|
-              if dimension[:name] == "AutoScalingGroupName"
-                { :name => "AutoScalingGroupName", :value => group.name }
-              else
-                dimension
-              end
-            end
-
-            # For actions, we want to go through them all, replacing any
-            # ARNs referencing the template_policy with ones pointing to
-            # our new policy. For ARNs we don't recognize, we just copy
-            # them, assuming the user wants those ARNs to continue to
-            # fire.
-            [ :insufficient_data_actions, :ok_actions, :alarm_actions ].each do |key|
-              new_actions = template_alarm.send(key).map do |arn|
-                if arn == template_policy.arn
-                  policy.arn
-                else
-                  arn
-                end
-              end
-
-              unless new_actions.empty?
-                alarm_options[key] = new_actions
-              end
-            end
-
-            alarm = cloudwatch.alarms.create alarm_name, alarm_options
-            if !template_alarm.enabled?
-              alarm.disable
-            end
-          end
-        end
-
-        group
-      end
-
-      protected
-
-      def _each_item options
-        TagCollection.new(:config => config).filter(:key, "asgfleet:#{@fleet.name}").each do |tag|
-          yield tag.resource
-        end
-      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aws-asg-fleet
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-23 00:00:00.000000000 Z
+date: 2014-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk