prima-twig 0.34.130 → 0.35.0

data/bin/twig-update-ami

@@ -5,7 +5,7 @@ require_relative '../lib/prima_twig.rb'
 require_relative '../lib/prima_aws_client.rb'
 require 'launchy'
 require 'json'
-require 'aws-sdk-s3'
+require 'aws-sdk'
 
 class TwigUpdateAmi
   include Command
@@ -15,117 +15,70 @@ class TwigUpdateAmi
     exec "gem update prima-twig && twig update-ami #{ARGV.join ' '}" unless `gem outdated`.lines.grep(/^prima-twig \(.*\)/).empty?
     @s3 = Aws::S3::Client.new
     @s3_bucket = 'prima-deploy'
-    @templates_base_url = "https://s3-eu-west-1.amazonaws.com"
+    @instances = JSON.parse File.read('../twig-binaries/cloudformation.json')
   end
 
   def execute!(args)
-      update_amis(args[0], args[1], args[2], args[3], args[4])
+    if args[3] == 'staging'
+      update_amis args[0], args[1], args[2], true
+    else
+      update_amis args[0], args[1], args[2], false
+    end
   end
 
   private
 
-  def update_amis(ami_template, ami_id, ami_name, ami_description, env)
-    output "updating instance definition #{ami_template}".light_green
-    Dir.chdir 'ami'
-    update_instance_name(ami_id, ami_name, ami_description, ami_template)
-    output 'running packer update (this could take some time)'.light_green
-    new_ami_id = update_packer(ami_template, env)
-    # new_ami_id = 'ami-026890988d91ee8c6'
-    Dir.chdir '..'
-    stop_if(new_ami_id.to_s.empty?, 'Failed to generate AMI!'.red)
-    output "new ami id: #{new_ami_id}"
-
-    output 'searching for ami to update...'
-    ami_mappings = JSON.parse(@s3.get_object(bucket: @s3_bucket, key: "ami/ami-mappings.json")["body"].read())
-    old_amis = update_ami_mappings(ami_mappings, ami_template, env, new_ami_id)
-    stop_if(old_amis.empty?, "No ami to update! No #{ami_template} in env #{env}, exiting".yellow)
-
-    output "retrieving stacks that uses old ami ids: #{old_amis}"
-    exports = list_exports()
-    stacks = get_stacks_from_exports(exports, old_amis)
-    stop_if(stacks.empty?, "No stack to update found! This means that ami-mapping file is not in sync, please check manually")
-
-    stacks.each do |stack|
-      output "processing stack #{stack}"
-      if stack.include?('qa')
-        output "skipping stack #{stack} because is a qa"
+  def update_amis(ami_id, ami_name, ami_description, only_staging)
+    @instances['amis'].each do |ami|
+      if only_staging and ami['json'] != 'ecs.json'
+        output "skipping #{ami['json']} because only_staging enabled".yellow
         next
-      else
-        stack_tags = tags_to_hashes(get_stack_tags(stack))
-        stack_tags['TemplateVersion'] = stack_tags['TemplateVersion'].to_i + 1
-
-        if stack.include?('batch')
-          stack_parameters = update_stack_parameters(get_stack_parameters(stack),
-            [
-              { parameter_key: 'AMIID', parameter_value: new_ami_id },
-              { parameter_key: 'TemplateVersion', parameter_value: stack_tags['TemplateVersion'].to_s }
-            ]
-          )
-          if stack.include?('offsite-backups')
-            stack_template = File.read("./cloudformation/stacks/batch/compute-environment-offsite-backups.yml")
-          else
-            stack_template = File.read("./cloudformation/stacks/batch/compute-environment.yml")
+      end
+      output 'updating instance definition'.light_green
+      Dir.chdir 'ami'
+      update_instance_name(ami_id, ami_name, ami_description, ami['json'])
+      output 'running packer update (this could take some time)'.light_green
+      new_ami_id = update_packer ami['json']
+      Dir.chdir '..'
+      output 'new ami id: ' + new_ami_id
+      stop_if new_ami_id.to_s.empty?, 'Failed to generate AMI!'
+      ami['stacks'].each do |stack|
+        if only_staging and not stack['stack_name'].include?('allinone-staging')
+          output "skipping #{stack['stack_name']} because only_staging enabled".yellow
+          next
+        end
+        output 'updating ' + stack['yaml_filename'] + ' and copying onto s3'
+        update_yml_files(new_ami_id, stack['yaml_filename'])
+        copy_yml_files_to_s3(stack['yaml_filename'], stack['s3_key'])
+        output 'updating stack on cloudformation'
+        if stack['stack_name'] and stack_exists?(stack['stack_name'])
+          stack_parameters = get_stack_parameters(stack['stack_name'])
+          stack_parameters.each do |param|
+            if param.parameter_key.eql?('DesiredCapacity')
+              desired_capacity = get_desired_capacity(stack['stack_name'])
+              desired_capacity.nil? ? break : param.parameter_value.sub!(/[0-9]+/, desired_capacity.to_s)
+              break
+            end
           end
-        else
-          stack_parameters = update_stack_parameters(get_stack_parameters(stack),
-            [
-              { parameter_key: 'AMIID', parameter_value: new_ami_id },
-              { parameter_key: 'DesiredCapacity', parameter_value: get_desired_capacity(stack).to_s },
-              { parameter_key: 'TemplateVersion', parameter_value: stack_tags['TemplateVersion'].to_s }
-            ]
-          )
-          stack_template = File.read("./cloudformation/stacks/asg/#{stack.to_s.split("/")[1]}.yml")
+          update_stack_url(stack['stack_name'], stack['template_url'], stack_parameters)
         end
-        update_stack(stack, stack_template, stack_parameters, hashes_to_tags(stack_tags))
       end
-    end
 
-    stacks.each do |stack|
-      if stack.include?('qa')
-        next
+      unless ami['batch_compute_environments'].nil? or only_staging
+        ami['batch_compute_environments'].each do |ce|
+          update_batch_compute_environment(ce, new_ami_id)
+        end
       end
-      wait_for_stack_ready(stack, ['CREATE_FAILED', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'DELETE_IN_PROGRESS', 'DELETE_FAILED', 'DELETE_COMPLETE', 'UPDATE_ROLLBACK_FAILED', 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', 'UPDATE_ROLLBACK_COMPLETE', 'ROLLBACK_COMPLETE'])
-    end
-
-    output 'writing new ami mapping'
-    File.open("ami/ami-mappings.json", 'w+') do |f|
-      mapping_file = JSON.pretty_generate(ami_mappings)
-      f.write(mapping_file)
-      @s3.put_object(bucket: @s3_bucket, key: "ami/ami-mappings.json", body: mapping_file)
-    end
-
-    output 'Update finished! ( ͡° ͜ʖ ͡°)'
-  end
-
-  def get_stacks_from_exports(exports, old_amis)
-    stacks = []
-    old_amis.each do |old_ami|
-      exports.each do |export|
-        if export.value.eql?(old_ami)
-          stacks.insert(0,export.exporting_stack_id)
+      ami['stacks'].each do |stack|
+        if only_staging and not stack['stack_name'].include?('allinone-staging')
+          output "skipping #{stack['stack_name']} because only_staging enabled".yellow
+          next
+        end
+        if stack['stack_name'] and stack_exists?(stack['stack_name'])
+          wait_for_stack_ready(stack['stack_name'], ['CREATE_FAILED', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'DELETE_IN_PROGRESS', 'DELETE_FAILED', 'DELETE_COMPLETE', 'UPDATE_ROLLBACK_FAILED', 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', 'UPDATE_ROLLBACK_COMPLETE', 'ROLLBACK_COMPLETE'])
         end
       end
     end
-    stacks
-  end
-
-  def update_ami_mappings(mappings, ami_template, env, new_ami_id)
-    old_values = []
-    mappings.each do |item|
-       if item['ami_template'].eql?(ami_template) and item['env'].eql?(env)
-         old_values.insert(0,item['ami_id'])
-         item['ami_id'] = new_ami_id
-       end
-     end
-    old_values.uniq
-  end
-
-  def update_stack_parameters(stack_parameters, new_parameters)
-    new_parameters.each do |new_param|
-      stack_parameters.reject{ |k| k["parameter_key"] == new_param["parameter_key"] }
-      stack_parameters.push(new_param)
-    end
-    stack_parameters
   end
 
   def update_instance_name(ami_id, ami_name, ami_description, ecs_json_path)
@@ -143,17 +96,121 @@ class TwigUpdateAmi
   def get_desired_capacity(stack_name)
     stack_outputs = get_stack_outputs(stack_name)
     stack_outputs.each do |out|
-      if out.export_name.include?('EC2Fleet') or out.export_name.include?('AutoScalingGroup')
+      if out.export_name.include?('ECSAutoScalingGroup')
         return get_autoscaling_capacity(out.output_value)
+      elsif out.export_name.include?('SpotFleet')
+        return get_spotfleet_capacity(out.output_value)
       end
     end
+    return nil
   end
 
-  def update_packer(json_filename, env)
-    execute_command "AWS_MAX_ATTEMPTS=90 AWS_POLL_DELAY_SECONDS=60 packer build -var datadog_apikey=`biscuit get -f ../configs/secrets/common.yml common_production_apikey_datadog` -var github_token=`biscuit get -f ../configs/secrets/common.yml common_private_repo_github_token` -var drone_key=\"`biscuit get -f ../configs/secrets/common.yml drone_license_key`\" -var env=#{env} -machine-readable ./#{json_filename} | tee build.log"
+  def update_packer(json_filename)
+    execute_command "packer build  -var datadog_apikey=`biscuit get -f ../configs/secrets/common.yml common_production_apikey_datadog` -machine-readable ./#{json_filename} | tee build.log"
     `grep 'artifact,0,id' build.log | cut -d, -f6 | cut -d: -f2`.sub(/\n/, '')
   end
 
+  def update_yml_files(ami_id, yaml_filename)
+    file_content = File.read yaml_filename
+
+    file_content.sub!(/ami-[0-9a-z]{8}/, ami_id)
+
+    File.open yaml_filename, 'w' do |f|
+      f.write file_content
+    end
+
+    if yaml_filename.include? 'spotfleet'
+      old_handle = (File.read yaml_filename)[/InstanceReadyWaitHandleUpdate[0-9]+/]
+      if old_handle
+        handle_version = old_handle.sub('InstanceReadyWaitHandleUpdate', '').to_i + 1
+
+        old_condition = (File.read yaml_filename)[/InstanceReadyWaitConditionUpdate[0-9]+/]
+        condition_version = old_condition.sub('InstanceReadyWaitConditionUpdate', '').to_i + 1
+
+        file_content = File.read yaml_filename
+        file_content.gsub!(old_handle, 'InstanceReadyWaitHandleUpdate' + handle_version.to_s)
+        file_content.gsub!(old_condition, 'InstanceReadyWaitConditionUpdate' + condition_version.to_s)
+
+        File.open yaml_filename, 'w' do |f|
+          f.write file_content
+        end
+      end
+    end
+  end
+
+  def copy_yml_files_to_s3(source, s3_key)
+    body = File.read source
+    @s3.put_object(
+      body: body,
+      bucket: @s3_bucket,
+      key: s3_key
+    )
+  end
+
+  def update_batch_compute_environment(stack, ami_id)
+    output 'updating ' + stack['yaml_filename'] + ' to add a new compute environment'
+
+    file_content = File.read stack['yaml_filename']
+    file_content.gsub!(/(\w+:\s+)!(\w+)/i, '\1QuaCeraUnPuntoEsclamativo\2')
+    file_content_original = file_content.clone
+    old_ce_name = file_content[/#{stack['label']}[0-9]*/]
+    new_ce_version = old_ce_name.sub(stack['label'], '').to_i + 1
+    new_ce_name = stack['label'] + new_ce_version.to_s
+    file_content.gsub!(old_ce_name, new_ce_name)
+    File.open stack['yaml_filename'] + 'new', 'w' do |f|
+      f.write file_content
+    end
+    update_yml_files(ami_id, stack['yaml_filename'] + 'new')
+
+    stack_body = YAML.load(file_content_original)
+    stack_body_new = YAML.load_file(stack['yaml_filename'] + 'new')
+    stack_body_merged = stack_body.deep_merge stack_body_new
+    File.open(stack['yaml_filename'], 'w') do |file|
+      file.write stack_body_merged.to_yaml.gsub('QuaCeraUnPuntoEsclamativo', '!')
+    end
+
+    output 'updating stack on cloudformation, (step 1)'
+    copy_yml_files_to_s3(stack['yaml_filename'], stack['s3_key'])
+    if not stack['stack_name'] or not stack_exists?(stack['stack_name'])
+      return false
+    end
+
+    update_stack_url(stack['stack_name'], stack['template_url'], get_stack_parameters(stack['stack_name']))
+    wait_for_stack_ready(stack['stack_name'], ['CREATE_FAILED', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'DELETE_IN_PROGRESS', 'DELETE_FAILED', 'DELETE_COMPLETE', 'UPDATE_ROLLBACK_FAILED', 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', 'UPDATE_ROLLBACK_COMPLETE', 'ROLLBACK_COMPLETE'])
+
+    output "retrieving the list of stacks that are currently using the stack #{stack['stack_name']}"
+    job_stacks = list_import_stacks old_ce_name + '-production'
+    job_stacks.each do |job_stack_name|
+      output "updating the stack #{job_stack_name} to use to the new compute environment"
+      stack_body = get_stack_template(job_stack_name)
+      stack_parameters = get_stack_parameters(job_stack_name).reject{ |k| k.parameter_key == 'ComputeEnvironmentExportName' }
+      stack_parameters.push(
+        {
+          parameter_key: "ComputeEnvironmentExportName",
+          parameter_value: new_ce_name
+        }
+      )
+      update_stack(job_stack_name, stack_body, stack_parameters)
+    end
+    job_stacks.each do |job_stack_name|
+      wait_for_stack_ready(job_stack_name, ['CREATE_FAILED', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'DELETE_IN_PROGRESS', 'DELETE_FAILED', 'DELETE_COMPLETE', 'UPDATE_ROLLBACK_FAILED', 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', 'UPDATE_ROLLBACK_COMPLETE', 'ROLLBACK_COMPLETE'])
+    end
+
+    file_content = File.read stack['yaml_filename'] + 'new'
+    File.open stack['yaml_filename'], 'w' do |f|
+      f.write file_content.gsub('QuaCeraUnPuntoEsclamativo', '!')
+    end
+
+    output "updating stack #{stack['stack_name']} on cloudformation to remove the old compute environment"
+    copy_yml_files_to_s3(stack['yaml_filename'], stack['s3_key'])
+    update_stack_url(stack['stack_name'], stack['template_url'], get_stack_parameters(stack['stack_name']))
+    wait_for_stack_ready(stack['stack_name'], ['CREATE_FAILED', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'DELETE_IN_PROGRESS', 'DELETE_FAILED', 'DELETE_COMPLETE', 'UPDATE_ROLLBACK_FAILED', 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', 'UPDATE_ROLLBACK_COMPLETE', 'ROLLBACK_COMPLETE'])
+
+    File.delete(stack['yaml_filename'] + 'new')
+
+    output "cloudformation stack update for #{stack['stack_name']} done!"
+  end
+
   def help_content
     <<-HELP
 
@@ -171,7 +228,7 @@ class TwigUpdateAmi
     -----------
 
       from artemide main folder run
-      `twig-update-ami ${AMI_TEMPLATE} ${AMI_ID} ${AMI_NAME} ${AMI_DESCRIPTION} ${ENV}`
+      `twig-update-ami ${AMI_ID} ${AMI_NAME} ${AMI_DESCRIPTION}`
 
     Subcommand for Twig: <http://rondevera.github.io/twig/>
     Author: Eugenio Laghi <https://github.com/eugeniolaghi>

data/lib/prima_aws_client.rb

@@ -1,11 +1,4 @@
-require 'aws-sdk-autoscaling'
-require 'aws-sdk-batch'
-require 'aws-sdk-cloudformation'
-require 'aws-sdk-cloudfront'
-require 'aws-sdk-ec2'
-require 'aws-sdk-ecs'
-require 'aws-sdk-elasticloadbalancingv2'
-require 'aws-sdk-s3'
+require 'aws-sdk'
 require 'colorize'
 #
 module PrimaAwsClient
@@ -21,16 +14,8 @@ module PrimaAwsClient
     @asg ||= Aws::AutoScaling::Client.new
   end
 
-  def ec2_client
-    @ec2 ||= Aws::EC2::Client.new
-  end
-
-  def alb_client
-    @alb ||= Aws::ElasticLoadBalancingV2::Client.new
-  end
-
-  def ecs_client
-    @ecs ||= Aws::ECS::Client.new
+  def appscaling_client
+    @appscaling ||= Aws::ApplicationAutoScaling::Client.new
   end
 
   def stack_list
@@ -55,66 +40,17 @@ module PrimaAwsClient
     stacks
   end
 
-  def cluster_list
-    stacks = []
-    next_token = ''
-    loop do
-      print '.'.yellow; STDOUT.flush
-      options = next_token != '' ? { next_token: next_token } : {}
-      begin
-        resp = cf_client.describe_stacks(options)
-      rescue Aws::CloudFormation::Errors::Throttling => e
-        output 'Throttling, retrying in 15 seconds'.red
-        sleep 15
-        resp = cf_client.describe_stacks(options)
-      end
-      stacks += resp.stacks
-      break unless resp.next_token
-      next_token = resp.next_token
-    end
-    puts '.'.yellow; STDOUT.flush
-    stacks.keep_if { |stack| stack.stack_name.include? 'ecs-cluster-qa-' }
-    stacks
-  end
-
-  def list_exports
-    exports = []
-    next_token = ''
-    loop do
-      print '.'.yellow; STDOUT.flush
-      options = next_token != '' ? { next_token: next_token } : {}
-      begin
-        resp = cf_client.list_exports(options)
-      rescue Aws::CloudFormation::Errors::Throttling => e
-        output 'Throttling, retrying in 15 seconds'.red
-        sleep 15
-        resp = cf_client.list_exports(options)
-      end
-      exports += resp.exports
-      break unless resp.next_token
-      next_token = resp.next_token
-    end
-    puts '.'.yellow; STDOUT.flush
-    exports
-  end
-
-  def create_stack(stack_name, stack_body, parameters = [], tags = [], role = nil)
-    cf_args = {
-      stack_name: stack_name,
-      template_body: stack_body,
-      parameters: parameters,
-      tags: tags,
-      capabilities: ['CAPABILITY_IAM'],
-      on_failure: 'ROLLBACK'
-    }
-
-    if role != nil then
-      cf_args.merge!(role_arn: role)
-    end
-
+  def create_stack(stack_name, stack_body, parameters = [], tags = [])
     begin
-      cf_client.create_stack(cf_args)
-    rescue Aws::CloudFormation::Errors::Throttling, Aws::CloudFormation::Errors::LimitExcedeedException => e
+      cf_client.create_stack(
+        stack_name: stack_name,
+        template_body: stack_body,
+        parameters: parameters,
+        tags: tags,
+        capabilities: ['CAPABILITY_IAM'],
+        on_failure: 'ROLLBACK'
+      )
+    rescue Aws::CloudFormation::Errors::Throttling => e
       output 'Throttling, retrying in 15 seconds'.red
       sleep 15
       create_stack(stack_name, stack_body, parameters = [], tags = [])
@@ -123,21 +59,15 @@ module PrimaAwsClient
     end
   end
 
-  def update_stack(stack_name, template_body, parameters = [], tags = [], role = nil)
-    cf_args = {
-      stack_name: stack_name,
-      template_body: template_body,
-      parameters: parameters,
-      tags: tags,
-      capabilities: ['CAPABILITY_IAM']
-    }
-
-    if role != nil then
-      cf_args.merge!(role_arn: role)
-    end
-
+  def update_stack(stack_name, template_body, parameters = [], tags = [])
     begin
-      cf_client.update_stack(cf_args)
+      cf_client.update_stack(
+        stack_name: stack_name,
+        template_body: template_body,
+        parameters: parameters,
+        tags: tags,
+        capabilities: ['CAPABILITY_IAM']
+      )
     rescue Aws::CloudFormation::Errors::Throttling => e
       output 'Throttling, retrying in 15 seconds'.red
       sleep 15
@@ -149,21 +79,15 @@ module PrimaAwsClient
     end
   end
 
-  def update_stack_url(stack_name, template_url, parameters = [], tags = [], role = nil)
-    cf_args = {
-      stack_name: stack_name,
-      template_url: template_url,
-      parameters: parameters,
-      tags: tags,
-      capabilities: ['CAPABILITY_IAM']
-    }
-
-    if role != nil then
-      cf_args.merge!(role_arn: role)
-    end
-
+  def update_stack_url(stack_name, template_url, parameters = [], tags = [])
     begin
-      cf_client.update_stack(cf_args)
+      cf_client.update_stack(
+        stack_name: stack_name,
+        template_url: template_url,
+        parameters: parameters,
+        tags: tags,
+        capabilities: ['CAPABILITY_IAM']
+      )
     rescue Aws::CloudFormation::Errors::Throttling => e
       output 'Throttling, retrying in 15 seconds'.red
       sleep 15
@@ -219,24 +143,6 @@ module PrimaAwsClient
     output "\nStack #{stack_name} pronto!\n".green
   end
 
-  def wait_for_stack_removal(stack_name)
-    ready = false
-    sleep_seconds = 13
-    sleep 10
-    output "Attendo che lo stack #{stack_name} finisca di essere cancellato...\n".yellow
-    while !ready
-      ready = true if stack_deleted?(stack_name)
-      seconds_elapsed = 0
-      loop do
-        break if seconds_elapsed >= sleep_seconds
-        print '.'.yellow; STDOUT.flush
-        sleep 1
-        seconds_elapsed += 1
-      end
-    end
-    output "\nStack #{stack_name} eliminato!\n".green
-  end
-
   def get_stack_tags(name)
     begin
       resp = cf_client.describe_stacks(stack_name: name)
@@ -300,23 +206,6 @@ module PrimaAwsClient
     ['CREATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_COMPLETE', 'ROLLBACK_COMPLETE'].include? stack_status
   end
 
-  def stack_deleted?(stack_name, failed_statuses = ['ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'DELETE_FAILED', 'UPDATE_ROLLBACK_FAILED', 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS'])
-    begin
-      resp = cf_client.describe_stacks(
-        stack_name: stack_name
-      )
-      stack_status = resp.stacks[0].stack_status
-    rescue Aws::CloudFormation::Errors::Throttling => e
-      print 'Throttling'.red; STDOUT.flush
-      return false
-    rescue Aws::CloudFormation::Errors::ValidationError => e
-      print 'Stack deleted'
-      return true
-    end
-    raise "The stack #{stack_name} errored out" if failed_statuses.include? stack_status
-    ['DELETE_COMPLETE'].include? stack_status
-  end
-
   def artifact_exists?(bucket, path)
     resp = s3_client.list_objects(
       bucket: bucket,
@@ -337,29 +226,6 @@ module PrimaAwsClient
     output "#{s3_bucket}/#{destination_path} uploadato con successo!\n".green
   end
 
-  def wait_for_artifact(bucket, path)
-    ready = artifact_exists?(bucket, path)
-    sleep_seconds = 13
-    output "Attendo che sia pronto l'artefatto #{path}...\n".yellow
-    retries = 0
-    while !ready
-      ready = true if artifact_exists?(bucket, path)
-      seconds_elapsed = 0
-      loop do
-        break if seconds_elapsed >= sleep_seconds
-        print '.'.yellow; STDOUT.flush
-        sleep 1
-        seconds_elapsed += 1
-      end
-      retries += 1
-      if retries > 150
-        output "\n Timeout raggiunto aspettando #{path}\n".red
-        exit
-      end
-    end
-    output "\nArtefatto #{path} creato!\n".green
-  end
-
   def list_import_stacks(export_name)
     stacks = []
     next_token = ''
@@ -380,115 +246,13 @@ module PrimaAwsClient
     stacks
   end
 
-  def describe_stack_resource(cluster_stack_name, logical_resource_id)
-    begin
-      resp = cf_client.describe_stack_resource({stack_name: cluster_stack_name, logical_resource_id: logical_resource_id})
-    rescue Aws::CloudFormation::Errors::Throttling => e
-      output 'Throttling, retrying in 15 seconds'.red
-      sleep 15
-      resp = describe_stack_resource(cluster_stack_name, logical_resource_id)
-    end
-  end
-
-  def describe_instances(instance_ids)
-    begin
-      resp = ec2_client.describe_instances({instance_ids: instance_ids})
-    rescue Aws::CloudFormation::Errors::Throttling => e
-      output 'Throttling, retrying in 15 seconds'.red
-      sleep 15
-      resp = describe_instances(instance_ids)
-    end
-  end
-
-  def describe_auto_scaling_groups(auto_scaling_group_names, max_records)
-    begin
-      resp = asg_client.describe_auto_scaling_groups({
-        auto_scaling_group_names: auto_scaling_group_names,
-        max_records: max_records
-      })
-    rescue Aws::CloudFormation::Errors::Throttling => e
-      output 'Throttling, retrying in 15 seconds'.red
-      sleep 15
-      resp = describe_auto_scaling_groups(auto_scaling_group_names, max_records)
-    end
-  end
-
-  def describe_load_balancers(load_balancer_arns)
-    begin
-      resp = alb_client.describe_load_balancers({load_balancer_arns: load_balancer_arns})
-    rescue Aws::ElasticLoadBalancingV2::Errors::Throttling => e
-      output 'Throttling, retrying in 15 seconds'.red
-      sleep 15
-      resp = describe_load_balancers(load_balancer_arns)
-    end
-  end
-
-  def update_ecs_service(cluster, service, deployment_configuration)
-    begin
-      resp = ecs_client.update_service(
-        cluster: cluster,
-        service: service,
-        deployment_configuration: deployment_configuration
-      )
-    rescue Aws::CloudFormation::Errors::Throttling => e
-      output 'Throttling, retrying in 15 seconds'.red
-      sleep 15
-      resp = update_ecs_service(cluster, service, deployment_configuration)
-    end
-  end
-
-  def describe_ecs_tasks(cluster, tasks)
-    begin
-      resp = ecs_client.describe_tasks({
-        cluster: cluster,
-        tasks: tasks
-      })
-    rescue Aws::CloudFormation::Errors::Throttling => e
-      output 'Throttling, retrying in 15 seconds'.red
-      sleep 15
-      resp = describe_ecs_tasks(cluster, tasks)
-    end
-  end
-
-  def run_ecs_task(cluster, task_definition, overrides, count)
-    begin
-      resp = ecs_client.run_task({
-        cluster: cluster,
-        task_definition: task_definition,
-        overrides: overrides,
-        count: count
-      })
-    rescue Aws::CloudFormation::Errors::Throttling => e
-      output 'Throttling, retrying in 15 seconds'.red
-      sleep 15
-      resp = run_ecs_task(cluster, task_definition, overrides, count)
-    end
-  end
-
   def get_autoscaling_capacity(asg_name)
     resp = asg_client.describe_auto_scaling_groups(auto_scaling_group_names: [asg_name])
     resp.auto_scaling_groups[0].desired_capacity
   end
 
   def get_spotfleet_capacity(fleet_arn)
-    resp = ec2_client.describe_spot_fleet_requests(spot_fleet_request_ids: [fleet_arn])
-    resp.spot_fleet_request_configs[0].spot_fleet_request_config.target_capacity
-  end
-
-  def hashes_to_tags(hashes)
-    tags = []
-    hkeys = hashes.keys
-    hkeys.each do |hkey|
-      tags.insert(0, { key: hkey, value: hashes[hkey].to_s })
-    end
-    tags
-  end
-
-  def tags_to_hashes(tags)
-    hash = Hash.new
-    tags.each do |tags_obj|
-      hash[tags_obj.key] = tags_obj.value
-    end
-    hash
+    resp = appscaling_client.describe_scalable_targets(service_namespace: 'ec2', resource_ids: ["spot-fleet-request/#{fleet_arn}"])
+    resp.scalable_targets[0].min_capacity
   end
 end