tass 0.2.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3f94224d11a7c396b61b38b44d026139f06b038
-  data.tar.gz: 70597218851be9ffe6d8cd1eccef2db50d144a22
+  metadata.gz: d63df49ef7d75eeec0d74aef90721a098a829efa
+  data.tar.gz: 23bf79d63f1bb9157c51896c85e05ed28ed20f47
 SHA512:
-  metadata.gz: 34905de3f29c57247d272728b3ca0a510703a8129a8148f23d843ce57b6a445fb4dcc37c97026c7631ecaf2f8c067645be3ffa4ec8be2dd6616abc557e35f411
-  data.tar.gz: 8750964d46b84e5e55b32ae5cc3909b8d0af0e402db82b14d4dda9f410234820183cda03f0754138c392a9f6ef2813ac4e396bf1de75f2602c048c52d976fc0e
+  metadata.gz: 921b36ca3ccf7eab2817009c1493357b87f11377b13b92099f7a5af0439c9d29e3aa4fe55f5f189928edee0fcd46eff8253b947af901e4b2bb58a28b5908a96b
+  data.tar.gz: 6a1edbb35badfd93bb59c988982581b9bd0cb9be651ebabef6dda8fcb88620b7a14b341e3d66758c240777f0328e5185f6988334c70b6ff9758035e7be14b4ff

data/bin/tass

@@ -2,20 +2,31 @@
 
 require 'tapjoy/autoscaling_bootstrap'
 
+def common_args
+  opt :filename, 'Specify config file to load', type: :string, required: true
+  opt :prompt, 'Enable/disable prompts', default: true
+  opt :env, 'Specify which environment config to load', type: :string
+end
+
 def confirm_config(aws_env, misc_config, opts)
   use_vpc = true if misc_config[:vpc_subnets]
-  unless Tapjoy::AutoscalingBootstrap::Base.new.confirm_config(**aws_env,
-    **misc_config, **opts, use_vpc: use_vpc)
+  has_elb = true if misc_config.key?(:elb)
+  Tapjoy::AutoscalingBootstrap::Base.new.confirm_config(**aws_env,
+    **misc_config, **opts, use_vpc: use_vpc, has_elb: has_elb,
+    config: misc_config)
+end
 
-    abort('Cannot continue if configuration is not correct.  Please fix.')
-  end
+def configure_environment(opts)
+  config, aws_env, user_data = Tapjoy::AutoscalingBootstrap::Base.new.configure_environment(opts)
+  Aws.config[:region] = config[:aws_region]
+  [config, aws_env, user_data]
 end
 
-SUB_COMMANDS = %w(create update audit)
+SUB_COMMANDS = %w(create update audit scale)
 Trollop::options do
   usage '[SUB_COMMAND] [options]'
   synopsis "\nConfigures autoscaling groups.\nAvailable subcommands are: #{SUB_COMMANDS}"
-  version "#{File.basename($0)} #{Tapjoy::AutoscalingBootstrap::VERSION} \u00A9 2015 Tapjoy, Inc."
+  version "#{File.basename($PROGRAM_NAME)} #{Tapjoy::AutoscalingBootstrap::VERSION} \u00A9 2015 Tapjoy, Inc."
   stop_on SUB_COMMANDS
 end
 
@@ -27,33 +38,43 @@ when 'create'
     usage 'create [options]'
     synopsis 'This command creates new autoscaling groups, and overwrites existing ones.'
 
-    opt :filename, 'Specify config file to load', type: :string, required: true
-    opt :config_dir, 'Specify the directory for configuration files', type: :string, short: :none, default: Tapjoy::AutoscalingBootstrap.config_dir
-    opt :env, 'Specify which environment config to load', type: :string
     opt :clobber_elb, 'Force ELB creation', default: false, short: :none
     opt :clobber_as, 'Force AS group creation', default: false, short: :none
-    opt :prompt, 'Enable/disable prompts', default: true
+    common_args
   end
 
-  config, aws_env, user_data = Tapjoy::AutoscalingBootstrap::Base.new.configure_environment(opts[:filename], opts[:env], opts[:config_dir])
-  Aws.config[:region] = config[:aws_region]
-  confirm_config(aws_env, config, opts)
+  config, aws_env, user_data = configure_environment(opts)
 
   Tapjoy::AutoscalingBootstrap::Base.new.check_clobber(opts, config)
+  unless confirm_config(aws_env, config, opts)
+    abort('Cannot continue if configuration is not correct.  Please fix.')
+  end
   Tapjoy::AutoscalingBootstrap::AutoscalingGroup.new.create(opts, config, aws_env, user_data)
+
+  if config.key?(:elb)
+    config[:elb].each do |elb|
+      elb.each do |elb_name, elb_config|
+        Tapjoy::AutoscalingBootstrap.elb_name = elb_name
+        elb_hash = {
+          elb_name => config[:default_elb_parameters].merge!(elb[elb_name])
+        }
+
+        Tapjoy::AutoscalingBootstrap::ELB.new(
+          elb_hash, config[:clobber_elb], config[:zones],
+          config[:security_groups])
+      end
+    end
+  end
+
 when 'update'
   opts = Trollop.options do
     # Set help message
     usage 'update [options]'
     synopsis 'This command creates new launch configurations based on existing autoscaling groups using local instance configuration files as overrides.'
-    opt :filename, 'Specify config file to load', type: :string, required: true
-    opt :config_dir, 'Specify the directory for configuration files', type: :string, short: :none, default: Tapjoy::AutoscalingBootstrap.config_dir
-    opt :env, 'Specify which environment config to load', type: :string
-    opt :prompt, 'Enable/disable prompts', default: true
+    common_args
   end
 
-  config, aws_env, user_data = Tapjoy::AutoscalingBootstrap::Base.new.configure_environment(opts[:filename], opts[:env], opts[:config_dir])
-  Aws.config[:region] = config[:aws_region]
+  config, aws_env, user_data = configure_environment(opts)
   confirm_config(aws_env, config, opts)
 
   Tapjoy::AutoscalingBootstrap::LaunchConfiguration.new(config, aws_env, user_data)
@@ -61,17 +82,23 @@ when 'audit'
   opts = Trollop.options do
     usage 'audit'
     synopsis 'This command compares local configuration files for a given cluster to the existing launch configuration and autoscaling group running in AWS.'
-    opt :filename, 'Specify config file to load', type: :string, required: true
-    opt :config_dir, 'Specify the directory for configuration files', type: :string, short: :none, default: Tapjoy::AutoscalingBootstrap.config_dir
-    opt :env, 'Specify which environment config to load', required: true, type: :string
-    opt :prompt, 'Enable/disable prompts', default: true
+    common_args
   end
 
-  config, aws_env, user_data = Tapjoy::AutoscalingBootstrap::Base.new.configure_environment(opts[:filename], opts[:env], opts[:config_dir])
-  Aws.config[:region] = config[:aws_region]
+  config, aws_env, user_data = configure_environment(opts)
 
-  config.merge!(aws_env.merge({user_data: Base64.encode64("#{user_data}")}))
+  config.merge!(aws_env.merge(user_data: Base64.encode64("#{user_data}")))
   Tapjoy::AutoscalingBootstrap::Audit.new(config)
+when 'scale'
+  opts = Trollop.options do
+    usage 'scale [options]'
+    synopsis 'This command is used to scale up/down auto scaling groups'
+    common_args
+    opt :instance_ids, 'Instance IDs to scale down', type: :strings
+  end
+
+  config, aws_env, user_data = configure_environment(opts)
+  Tapjoy::AutoscalingBootstrap::Autoscaling::Group.new.scale(config)
 else
   Trollop.educate
 end

data/lib/tapjoy/autoscaling_bootstrap.rb

@@ -30,6 +30,7 @@ require_relative 'autoscaling_bootstrap/autoscaling_group'
 require_relative 'autoscaling_bootstrap/launch_configuration'
 require_relative 'autoscaling_bootstrap/version'
 require_relative 'autoscaling_bootstrap/audit'
+require_relative 'autoscaling_bootstrap/ec2'
 
 module Tapjoy
   # Module for Autoscaling Bootstrap
@@ -45,24 +46,6 @@ module Tapjoy
         @elb_name = str
       end
 
-      # If you're using AutoscalingBootstrap to join to a list of existing ELBs, that array
-      # goes here. This list can include or not include the provided elb_name, the
-      # array + a custom elb_name will be uniq-ed before being passed to Amazon
-      def elb_list=(list)
-        @elb_list = list
-      end
-
-      def elb_list
-        @elb_list ||= []
-      end
-
-      # This is the list of elbs passed to the autoscaling configuration. It will include
-      # the created elb, as well as the specific list of elbs to join. It will call uniq
-      # on the list in case you accidentally specify the same elb twice
-      def elbs_to_join
-        (elb_list + [Tapjoy::AutoscalingBootstrap.elb_name]).uniq
-      end
-
       def policy
         @policy = Tapjoy::AutoscalingBootstrap::Autoscaling::Policy.new
       end
@@ -83,9 +66,8 @@ module Tapjoy
         @config_dir ||= ENV['TASS_CONFIG_DIR'] || "#{ENV['HOME']}/.tass"
       end
 
-      def is_valid_env?(config_dir, env)
-        env_list = self.supported_envs(config_dir)
-        puts config_dir
+      def valid_env?(config_dir, env)
+        env_list = supported_envs(config_dir)
         unless env_list.include?(env)
           Trollop.die :env, "Currently supported enviroments are #{env_list.join(',')}"
         end
@@ -93,7 +75,7 @@ module Tapjoy
 
       def supported_envs(listing)
         envs = []
-        Dir.entries("#{listing}/config/common").each do |file|
+        Dir.entries(listing).each do |file|
           next unless file.end_with?('yaml')
           next if file.start_with?('defaults')
           envs << file.chomp!('.yaml')
@@ -111,17 +93,16 @@ module Tapjoy
       end
 
       # Using variables passed in, generate user data file
-      def generate_user_data(config)
+      def generate_user_data(userdata_dir, bootstrap_script, config)
 
         ERB.new(
-          File.new("#{config[:config_dir]}/userdata/#{config[:bootstrap_script]}").read,nil,'-'
+          File.new(File.join(userdata_dir, bootstrap_script)).read, nil, '-'
         ).result(binding)
       end
 
       # Check if we allow clobbering and need to clobber
       def check_clobber(opts, config)
         fail Tapjoy::AutoscalingBootstrap::Errors::ClobberRequired if check_as_clobber(**opts, **config)
-        fail Tapjoy::AutoscalingBootstrap::Errors::ELB::ClobberRequired if check_elb_clobber(**opts, **config)
         puts "We don't need to clobber"
       end
 
@@ -130,41 +111,40 @@ module Tapjoy
         create_as_group && Tapjoy::AutoscalingBootstrap.group.exists && !clobber_as
       end
 
-      # Check ELB clobber
-      def check_elb_clobber(create_elb:, clobber_elb:, **unused_values)
-        elb = Tapjoy::AutoscalingBootstrap::ELB.new
-        create_elb && elb.exists && !clobber_elb
-      end
-
       # Get AWS Environment
       def get_security_groups(config_dir, env, group)
 
         # Check environment file
-        unless File.readable?("#{config_dir}/config/common/#{env}.yaml")
+        unless File.readable?("#{config_dir}/#{env}.yaml")
           fail Tapjoy::AutoscalingBootstrap::Errors::InvalidEnvironment
         end
 
         security_groups = {security_groups: group.split(',')}
       end
 
+      # Clean list of ELBs
+      def elb_list(config)
+        config[:elb].map(&:keys).flatten.join(',')
+      end
+
       # Confirm config settings before running autoscaling code
       def confirm_config(keypair:, zones:, security_groups:, instance_type:,
         image_id:, iam_instance_profile:, prompt:, use_vpc: use_vpc,
-        vpc_subnets: nil, **unused_values)
-
-        elb_name = Tapjoy::AutoscalingBootstrap.elb_name
+        vpc_subnets: nil, has_elb: has_elb, config:, termination_policies:,
+        **unused_values)
 
         puts '  Preparing to configure the following autoscaling group:'
-        puts "  Launch Config:  #{Tapjoy::AutoscalingBootstrap.config_name}"
-        puts "  Auto Scaler:    #{Tapjoy::AutoscalingBootstrap.scaler_name}"
-        puts "  ELB:            #{elb_name}" unless elb_name.eql? 'NaE'
-        puts "  Key Pair:       #{keypair}"
-        puts "  Zones:          #{zones.join(',')}"
-        puts "  Groups:         #{security_groups.sort.join(',')}"
-        puts "  Instance Type:  #{instance_type}"
-        puts "  Image ID:       #{image_id}"
-        puts "  IAM Role:       #{iam_instance_profile}"
-        puts "  VPC Subnets:    #{vpc_subnets}" if use_vpc
+        puts "  Launch Config:        #{Tapjoy::AutoscalingBootstrap.config_name}"
+        puts "  Auto Scaler:          #{Tapjoy::AutoscalingBootstrap.scaler_name}"
+        puts "  ELB:                  #{elb_list(config)}" if has_elb
+        puts "  Key Pair:             #{keypair}"
+        puts "  Zones:                #{zones.join(',')}"
+        puts "  Groups:               #{security_groups.sort.join(',')}"
+        puts "  Instance Type:        #{instance_type}"
+        puts "  Image ID:             #{image_id}"
+        puts "  IAM Role:             #{iam_instance_profile}"
+        puts "  VPC Subnets:          #{vpc_subnets}" if use_vpc
+        puts "  Termination Policies: #{termination_policies.sort.join(',')}"
 
         puts "\n\nNOTE! Continuing may have adverse effects if you end up " \
         "deleting an IN-USE PRODUCTION scaling group. Don't be dumb."
@@ -174,41 +154,41 @@ module Tapjoy
 
       # configure environment
 
-      def configure_environment(filename, env=nil, config_dir)
-        if filename.include?(File::SEPARATOR)
-          facet_file    = filename
-          config_dir   = File.expand_path('../../..', facet_file)
-        else
-          facet_file    = File.join(config_dir, 'config', 'clusters', filename)
-        end
+      def configure_environment(opts)
+        filename = opts[:filename]
+        facet_file    = filename
+        config_dir    = File.expand_path('../..', facet_file)
+        userdata_dir  = "#{File.expand_path('../../..', facet_file)}/userdata"
 
-        common_path   = File.join(config_dir, 'config', 'common')
+        common_path   = File.join(config_dir, 'common')
         defaults_hash = self.load_yaml(File.join(common_path, 'defaults.yaml'))
         facet_hash    = self.load_yaml(facet_file)
-        env         ||= facet_hash[:environment]
-        env         ||= defaults_hash[:environment]
-        Tapjoy::AutoscalingBootstrap.is_valid_env?(config_dir, env)
+        env = opts[:env] || facet_hash[:environment] || defaults_hash[:environment]
+        Tapjoy::AutoscalingBootstrap.valid_env?(common_path, env)
         env_hash      = self.load_yaml(File.join(common_path, "#{env}.yaml"))
 
         new_config = defaults_hash.merge!(env_hash).merge(facet_hash)
         new_config[:config_dir] = config_dir
-        aws_env = self.get_security_groups(config_dir, env, new_config[:group])
+        new_config[:instance_ids] = opts[:instance_ids] if opts.key?(:instance_ids)
+        aws_env = self.get_security_groups(common_path, env, new_config[:group])
+        new_config.merge!(aws_env)
 
+        new_config[:autoscale] = false unless new_config[:scaling_type].eql?('dynamic')
+        new_config[:tags] << {Name: new_config[:name]}
         Tapjoy::AutoscalingBootstrap.scaler_name = "#{new_config[:name]}-group"
         Tapjoy::AutoscalingBootstrap.config_name = "#{new_config[:name]}-config"
         # If there's no ELB, then Not a ELB
-        puts new_config[:elb_name]
-        Tapjoy::AutoscalingBootstrap.elb_name = new_config[:elb_name] || 'NaE'
-        Tapjoy::AutoscalingBootstrap.create_elb = new_config[:create_elb]
-        Tapjoy::AutoscalingBootstrap.elb_list = new_config[:elb_list] || []
-        user_data = self.generate_user_data(new_config)
-        return new_config, aws_env, user_data
+        user_data = self.generate_user_data(userdata_dir,
+          new_config[:bootstrap_script], new_config)
+
+        [new_config, aws_env, user_data]
       end
 
       # Exponential backup
       def aws_wait(tries)
-        puts "Sleeping for #{2 ** tries}..."
-        sleep 2 ** tries
+        backoff_sleep = 2 ** tries
+        puts "Sleeping for #{backoff_sleep}..."
+        sleep backoff_sleep
       end
 
       # Check if security group exists and create it if it does not

data/lib/tapjoy/autoscaling_bootstrap/AWS/Autoscaling/group.rb

@@ -9,11 +9,10 @@ module Tapjoy
               @client ||= Tapjoy::AutoscalingBootstrap::AWS::Autoscaling.client
             end
 
-            def resize(min_size: 0, max_size: 0, desired_capacity:0)
+            def resize(min: 0, max: 0, desired:0)
               self.client.update_auto_scaling_group(
                 auto_scaling_group_name: Tapjoy::AutoscalingBootstrap.scaler_name,
-                min_size: min_size, max_size: max_size,
-                desired_capacity: desired_capacity)
+                min_size: min, max_size: max, desired_capacity: desired)
             end
 
             def delete(force_delete: true)
@@ -30,31 +29,36 @@ module Tapjoy
               )[0][0]
             end
 
+            def detach
+              self.client.detach_instances(
+                instance_ids: describe.instances.map(&:instance_id),
+                auto_scaling_group_name: Tapjoy::AutoscalingBootstrap.scaler_name,
+                should_decrement_desired_capacity: true,
+              )
+            end
+
             def create(zones:, health_check_type: nil, tags:,
-              vpc_subnets: nil, create_elb:, **unused_values)
+              vpc_subnets: nil, termination_policies: , **unused_values)
 
               group_hash = {
                 auto_scaling_group_name: Tapjoy::AutoscalingBootstrap.scaler_name,
                 availability_zones: zones,
                 launch_configuration_name: Tapjoy::AutoscalingBootstrap.config_name,
                 min_size: 0, max_size: 0, desired_capacity: 0,
-                termination_policies: ['OldestInstance'],
+                termination_policies: termination_policies,
                 vpc_zone_identifier: vpc_subnets,
                 tags: Tapjoy::AutoscalingBootstrap::Autoscaling::Group.new.generate_tags(tags)
               }
 
-              # If we've chosen to explicitly create an ELB and assign to this ASG
-              # OR if we've given it a list of ELBs to join (or both)
-              if create_elb || !Tapjoy::AutoscalingBootstrap.elb_list.empty?
-                group_hash.merge!({
-                  load_balancer_names: Tapjoy::AutoscalingBootstrap.elbs_to_join,
-                  health_check_type: health_check_type,
-                  health_check_grace_period: 300,
-                  })
-              end
-
               self.client.create_auto_scaling_group(**group_hash)
             end
+
+            def attach_elb(elb_list)
+              self.client.attach_load_balancers({
+                auto_scaling_group_name: Tapjoy::AutoscalingBootstrap.scaler_name,
+                load_balancer_names: elb_list.split(','),
+              })
+            end
           end
         end
       end

data/lib/tapjoy/autoscaling_bootstrap/AWS/ec2.rb

@@ -1,7 +1,7 @@
 module Tapjoy
   module AutoscalingBootstrap
     module AWS
-    # This class contains AWS methods for ELB
+    # This class contains AWS methods for EC2
       module EC2
         class << self
           def client
@@ -16,6 +16,24 @@ module Tapjoy
             self.client.create_security_group(group_name: group,
               description: "Security group for #{Tapjoy::AutoscalingBootstrap.scaler_name}")
           end
+
+          def describe_instances_by_tag(config)
+            self.client.describe_instances(filters: [
+              {name: 'tag:Name', values: [config[:name]]},
+              {name: 'instance-state-name', values: %w(running)}
+              ])
+          end
+
+          def toggle_termination_protection(instance_id, state)
+            client.modify_instance_attribute(
+              instance_id: instance_id,
+              attribute: 'disableApiTermination',
+              value: state)
+          end
+
+          def terminate_instances(instance_ids)
+            client.terminate_instances(instance_ids: instance_ids)
+          end
         end
       end
     end

data/lib/tapjoy/autoscaling_bootstrap/audit.rb

@@ -22,7 +22,7 @@ module Tapjoy
         config[:key_name] = config.delete :keypair
         config[:launch_configuration_name] = Tapjoy::AutoscalingBootstrap.config_name
         keys = %w(bootstrap_script chef_server_url clobber clobber_elb
-          create_as_group config_dir)
+          create_as_group)
         delete_keys(config, keys)
 
         config

data/lib/tapjoy/autoscaling_bootstrap/autoscaling/group.rb

@@ -61,8 +61,60 @@ module Tapjoy
           tag_array
         end
 
+        # Scale auto scaling groups
+        def scale(config)
+          if config[:scaling_type].eql?('dynamic')
+            Tapjoy::AutoscalingBootstrap::AWS::Autoscaling::Group.resize(
+              **config[:instance_counts])
+          elsif config[:scaling_type].eql?('static')
+            scale_static(config)
+          else
+            abort('Unknown scaling type')
+          end
+        end
+
         private
 
+        # Logic for scaling static clusters
+        def scale_static(config)
+          current_count = Tapjoy::AutoscalingBootstrap::EC2.count_static_instances(config)
+          count_delta = config[:instance_counts][:desired] - current_count
+          if count_delta < 0
+            count_delta = count_delta.abs
+            puts "Scaling #{count_delta} instances down"
+            abort('Instances to terminate must be specified') unless config.key?(:instance_ids)
+            unless config[:instance_ids].length.eql?(count_delta)
+              fail Tapjoy::AutoscalingBootstrap::Errors::IncorrectNumberIds
+            end
+            disable_termination_protection(config[:instance_ids])
+            Tapjoy::AutoscalingBootstrap::AWS::EC2.terminate_instances(config[:instance_ids])
+          elsif count_delta > 0
+            puts 'Scaling up...'
+            puts count_delta
+            Tapjoy::AutoscalingBootstrap::AWS::Autoscaling::Group.resize(
+              min: 0, max: count_delta, desired: count_delta)
+            wait_for_asg_to_populate(config[:instance_counts][:desired], config)
+            enable_termination_protection
+            Tapjoy::AutoscalingBootstrap::AWS::Autoscaling::Group.detach
+          else
+            puts 'No action needed'
+          end
+        end
+
+        # Helper method to disable termination protection
+        def disable_termination_protection(instance_ids)
+          instance_ids.each do |instance|
+            Tapjoy::AutoscalingBootstrap::EC2.disable_termination_protection(instance)
+          end
+        end
+        # Helper method to enable termination protection
+        def enable_termination_protection
+          asg = Tapjoy::AutoscalingBootstrap::AWS::Autoscaling::Group.describe
+          asg.instances.map(&:instance_id).each do |instance|
+            Tapjoy::AutoscalingBootstrap::EC2.enable_termination_protection(instance)
+          end
+        end
+
         # Clear out existing autoscaling group
         def zero_autoscale_group
           Tapjoy::AutoscalingBootstrap::AWS::Autoscaling::Group.resize
@@ -107,6 +159,17 @@ module Tapjoy
             Tapjoy::AutoscalingBootstrap::Base.new.aws_wait(tries)
           end
         end
+
+        # Wait for ASG to populate
+        def wait_for_asg_to_populate(desired, config)
+          current_count = Tapjoy::AutoscalingBootstrap::EC2.count_static_instances(config)
+          tries = 0
+          until current_count.eql?(desired) do
+            tries += 1
+            Tapjoy::AutoscalingBootstrap::Base.new.aws_wait(tries)
+            current_count = Tapjoy::AutoscalingBootstrap::EC2.count_static_instances(config)
+          end
+        end
       end
     end
   end

data/lib/tapjoy/autoscaling_bootstrap/autoscaling/policy.rb

@@ -12,7 +12,7 @@ module Tapjoy
 
         # Create autoscaling policy
         def create(policy, scale)
-          return unless Tapjoy::AutoscalingBootstrap.group.exists
+          fail Tapjoy::AutoscalingBootstrap::Errors::InvalidAutoscalingGroup unless Tapjoy::AutoscalingBootstrap.group.exists
           Tapjoy::AutoscalingBootstrap::AWS::Autoscaling.put_scaling_policy(
             policy_name: policy, **scale)
         end

data/lib/tapjoy/autoscaling_bootstrap/autoscaling_group.rb

@@ -3,25 +3,7 @@ module Tapjoy
     # This class is the central launching point for new autoscaling group creation
     class AutoscalingGroup
       # Initialize the class
-      def create(opts, new_config, aws_env, user_data,
-
-        # ELB Parameters
-        elb_health_target: "#{new_config[:instance_protocol]}:#{new_config[:instance_port]}/healthz",
-        elb_protocol: new_config[:instance_protocol],
-        elb_name: "#{new_config[:name].gsub('_','-')}-discovery"
-      )
-
-        if new_config[:create_elb]
-          new_config.merge!({
-            elb_health_target: elb_health_target,
-            elb_protocol:      elb_protocol,
-            elb_name:          elb_name
-          })
-
-          Tapjoy::AutoscalingBootstrap::ELB.new.create(new_config, aws_env)
-        else
-          puts "\nNo ELB required"
-        end
+      def create(opts, new_config, aws_env, user_data)
 
         Tapjoy::AutoscalingBootstrap::ConfigureAutoscalers.new(**new_config,
           aws_env: aws_env, user_data: user_data, misc_config: new_config)

data/lib/tapjoy/autoscaling_bootstrap/ec2.rb

@@ -0,0 +1,26 @@
+module Tapjoy
+  module AutoscalingBootstrap
+    # This class contains tass methods for EC2
+    module EC2
+      class << self
+        def count_static_instances(config)
+          find_static_instances(config).length
+        end
+
+        def enable_termination_protection(instance_id)
+          Tapjoy::AutoscalingBootstrap::AWS::EC2.toggle_termination_protection(instance_id, 'true')
+        end
+
+        def disable_termination_protection(instance_id)
+          Tapjoy::AutoscalingBootstrap::AWS::EC2.toggle_termination_protection(instance_id, 'false')
+        end
+
+        private
+        def find_static_instances(config)
+          response = Tapjoy::AutoscalingBootstrap::AWS::EC2.describe_instances_by_tag(config)
+          response.reservations
+        end
+      end
+    end
+  end
+end

data/lib/tapjoy/autoscaling_bootstrap/elb.rb

@@ -2,16 +2,32 @@ module Tapjoy
   module AutoscalingBootstrap
     # This class configures elastic load balancers
     class ELB
-      # Initialize the class
-      def initialize
+      def initialize(elb_hash, clobber_elb, zones, security_groups)
+        elb_config = build_config(elb_hash, zones, security_groups)
+        check_valid_config(elb_config)
+
+        if exists && clobber_elb
+          delete
+          create(elb_config)
+        elsif exists
+          Tapjoy::AutoscalingBootstrap::AWS::Autoscaling::Group.attach_elb(
+            Tapjoy::AutoscalingBootstrap.elb_name)
+        else
+          create(elb_config)
+        end
       end
 
-      # Create load balancer
-      def create(config, aws_env)
+      # Build config hash
+      def build_config(elb_hash, zones, security_groups)
+        elb_config = elb_hash[Tapjoy::AutoscalingBootstrap.elb_name]
+        elb_config[:elb_protocol] ||= elb_config[:instance_protocol]
+        elb_config[:elb_health_target] ||= "#{elb_config[:instance_protocol]}:#{elb_config[:instance_port]}/healthz"
+        elb_config.merge!({zones: zones, groups: security_groups})
+      end
 
-        check_valid_config(config)
-        delete if exists
-        Tapjoy::AutoscalingBootstrap::AWS::ELB.create(**config, **aws_env)
+      # Create load balancer
+      def create(config)
+        Tapjoy::AutoscalingBootstrap::AWS::ELB.create(**config)
         health_check(config)
       end
 

data/lib/tapjoy/autoscaling_bootstrap/errors.rb

@@ -25,6 +25,15 @@ module Tapjoy
           abort("ERROR: Specified autoscaling group doesn't exist")
         end
       end
+
+      # Raise if an incorrect number of instance ids have been specified
+      class IncorrectNumberIds < ArgumentError
+        def initialize
+          error = 'Number of instance IDs specified must match the number '\
+          'of instances scaled down'
+          abort(error)
+        end
+      end
     end
   end
 end

data/lib/tapjoy/autoscaling_bootstrap/version.rb

@@ -1,9 +1,9 @@
 module Tapjoy
   module AutoscalingBootstrap
     module Version
-      MAJOR = 0
-      MINOR = 2
-      PATCH = 2
+      MAJOR = 1
+      MINOR = 0
+      PATCH = 0
     end
 
     VERSION = [Version::MAJOR, Version::MINOR, Version::PATCH].join('.')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tass
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Ali Tayarani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-22 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
 description: TASS is the suite of tools that the Tapjoy Operations team uses to manage
   autoscaling groups and launch configurations.
 email: ali.tayarani@tapjoy.com
@@ -150,6 +164,7 @@ files:
 - lib/tapjoy/autoscaling_bootstrap/aws.rb
 - lib/tapjoy/autoscaling_bootstrap/cloudwatch.rb
 - lib/tapjoy/autoscaling_bootstrap/configure_autoscaler.rb
+- lib/tapjoy/autoscaling_bootstrap/ec2.rb
 - lib/tapjoy/autoscaling_bootstrap/elb.rb
 - lib/tapjoy/autoscaling_bootstrap/errors.rb
 - lib/tapjoy/autoscaling_bootstrap/errors/elb.rb