stax 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52b0ae114cdff3beab9a839cd4ce6aa0c00d8230
-  data.tar.gz: 57967dd9cfcdf63b513dfb197b9961bdcb2551e1
+  metadata.gz: d9678c52393c842e801f8e3c306eb6976049e7d9
+  data.tar.gz: 6732bf5a03a47223ac78300ff338d71df796047c
 SHA512:
-  metadata.gz: 50a8a1d2574ad73215cf9f6f0fc5f820c556422314df2a9990b5bbb1a38238d2c85e83b2ed987e5fc5b586098897c2d870005eb4ef9c232b538a3a74c7124a84
-  data.tar.gz: 741fe79a952dbdfd496799378fc8b988766a35bc59102cd4f234619b4edca4b9fd66162a9f9f66cd889a19e400b6ecfde6378b43b9f44b7b72196c3e56f8d1e4
+  metadata.gz: 97d814ccc5329e44a534213a6100a8f485e4c2c59eac762cc6aa1b5ccabd79c2cb0707f4d82383fcd5d29fb914836cdbfd0f2af9ad5ddbd900a68824af6022e5
+  data.tar.gz: de492742715aaf17fbcd5a57cd4a626469264a6a1af95d7bc5808b58007d28aa02ee9861643affefd33b7d5fe89547c9fc55e08b3b14cf9be6767599230b99b1

data/bin/stax

@@ -2,8 +2,5 @@
 require 'bundler/setup'
 require 'stax'
 
-module Stax
-  add_stack(:botsy)
-end
-
+Stax.load_staxfile
 Stax::Cli.start(ARGV)

data/lib/stax.rb

@@ -1,5 +1,35 @@
-require 'awful'
-require 'awful/cloudformation'
+require 'thor'
+
+require 'stax/aws/sdk'
+require 'stax/aws/cfn'
+
+require 'stax/dsl'
+require 'stax/staxfile'
 require 'stax/base'
+require 'stax/git'
 require 'stax/cli'
-require 'stax/stack'
+require 'stax/subcommand'
+require 'stax/cfer'
+require 'stax/stack'
+require 'stax/stack/cfn'
+require 'stax/stack/crud'
+require 'stax/stack/parameters'
+require 'stax/stack/outputs'
+require 'stax/stack/resources'
+
+require 'stax/mixin/ec2'
+require 'stax/mixin/alb'
+require 'stax/mixin/elb'
+require 'stax/mixin/sg'
+require 'stax/mixin/s3'
+require 'stax/mixin/asg'
+require 'stax/mixin/ecs'
+require 'stax/mixin/sqs'
+require 'stax/mixin/kms'
+require 'stax/mixin/ssm'
+require 'stax/mixin/keypair'
+require 'stax/mixin/emr'
+require 'stax/mixin/ssh'
+require 'stax/mixin/lambda'
+require 'stax/mixin/dynamodb'
+require 'stax/mixin/logs'

data/lib/stax/asg.rb

@@ -0,0 +1,140 @@
+require 'awful/auto_scaling'
+
+module Stax
+  module Asg
+    def self.included(thor)     # magic to make mixins work in Thor
+      thor.class_eval do        # ... so magical
+
+        class_option :groups, aliases: '-g', type: :array, default: nil, desc: 'limit ASGs returned by id'
+
+        no_commands do
+          def auto_scaling_groups
+            cf(:resources, [stack_name], type: ['AWS::AutoScaling::AutoScalingGroup'], quiet: true).tap do |asgs|
+              if options[:groups]
+                ids = options[:groups].map { |group| prepend(:asg, group) }
+                asgs.select! { |g| ids.include?(g.logical_resource_id) }
+              end
+            end
+          end
+
+          def auto_scaling_instances
+            asg(:instances, auto_scaling_groups.map(&:physical_resource_id), describe: true, quiet: true)
+          end
+
+          ## get instance details from ec2
+          def auto_scaling_describe_instances
+            asgs = auto_scaling_groups.map(&:physical_resource_id)
+            fail_task("No matching autoscaling groups") if asgs.empty?
+            asg(:ips, auto_scaling_groups.map(&:physical_resource_id), quiet: true)
+          end
+
+          def asg_status
+            auto_scaling_groups.each do |asg|
+              debug("ASG status for #{asg.physical_resource_id}")
+              asg(:instances, [asg.physical_resource_id], long: true)
+            end
+          end
+
+          def asg_enter_standby(asg, *instances)
+            debug("Taking #{instances.join(',')} out of ELB for #{asg}")
+            instances.each do |instance| # one at a time so we can rescue each one
+              begin
+                asg(:enter_standby, [asg, instance])
+              rescue Aws::AutoScaling::Errors::ValidationError => e
+                warn(e.message)
+              end
+            end
+          end
+
+          def asg_exit_standby(asg, *instances)
+            debug("Putting #{instances.join(',')} back into ELB")
+            instances.each do |instance| # one at a time so we can rescue each one
+              begin
+                asg(:exit_standby, [asg, instance])
+              rescue Aws::AutoScaling::Errors::ValidationError => e
+                warn(e.message)
+              end
+            end
+          end
+
+          ## defaults, override in subclass
+          def ssh_options
+            {
+              User: 'core',
+              StrictHostKeyChecking: 'no',
+              UserKnownHostsFile: '/dev/null'
+            }
+          end
+
+          ## return num instances, filter by ids if non-nil
+          def ssh_instances(num, ids)
+            instances = auto_scaling_describe_instances
+            instances.select!{ |i| ids.include?(i.instance_id) } if ids
+            num ? instances.last(num) : instances
+          end
+        end
+
+        desc 'scale', 'scale number of instances in ASGs for stack'
+        method_option :desired_capacity, aliases: '-d', type: :numeric, default: nil, desc: 'desired instance count for each ASG'
+        method_option :min_size,         aliases: '-m', type: :numeric, default: nil, desc: 'set minimum capacity'
+        method_option :max_size,         aliases: '-M', type: :numeric, default: nil, desc: 'set maximum capacity'
+        def scale
+          opt = options.slice(:desired_capacity, :min_size, :max_size)
+          fail_task('No change requested') if opt.empty?
+
+          auto_scaling_groups.tap do |asgs|
+            warn('No matching auto-scaling groups') if asgs.empty?
+          end.each do |asg|
+            id = asg.physical_resource_id
+            debug("Scaling to #{opt} for #{id}")
+            asg(:update, [id], opt)
+          end
+        end
+
+        desc 'old', 'list or terminate old instances from ASGs'
+        method_option :terminate, aliases: '-t', type: :boolean, default: false, desc: 'terminate old instances'
+        def old
+          verb = options[:terminate] ? 'Terminating' : 'Listing'
+          debug("#{verb} out-of-date instances in autoscaling groups")
+          asgs = auto_scaling_groups.map(&:physical_resource_id)
+          asg(:old_instances, asgs, terminate: options[:terminate])
+        end
+
+        desc 'standby', 'enter (or exit) standby for ASGs'
+        method_option :exit,   aliases: '-x', type: :boolean, default: false, desc: 'exit standby instead of enter'
+        def standby
+          auto_scaling_instances.each_with_object(Hash.new {|h,k| h[k]=[]}) do |i, h|
+            h[i.auto_scaling_group_name] << i.instance_id
+          end.each do |asg, ins|
+            options[:exit] ? asg_exit_standby(asg, *ins) : asg_enter_standby(asg, *ins)
+          end
+        end
+
+        desc 'ssh [CMD]', 'ssh to ASG instances'
+        method_option :number,    aliases: '-n', type: :numeric, default: nil,   desc: 'number of instances to ssh'
+        method_option :verbose,   aliases: '-v', type: :boolean, default: false, desc: 'verbose ssh client logging'
+        method_option :instances, aliases: '-i', type: :array,   default: nil,   desc: 'match on these instance IDs'
+        def ssh(*cmd)
+          keyfile = try(:key_pair_get) # get private key from param store
+          try(:let_me_in_allow)        # open security group
+
+          ## build ssh -o options
+          opts = ssh_options.merge(
+            IdentityFile: keyfile.try(:path),
+            LogLevel:     (options[:verbose] ? 'DEBUG' : nil)
+          ).reject{ |_,v| v.nil? }.map{ |k,v| "-o #{k}=#{v}" }.join(' ')
+
+          ## loop instances
+          ssh_instances(options[:number], options[:instances]).each do |i|
+            debug("SSH to #{i.instance_id} #{i.public_ip_address}")
+            system "ssh #{opts} #{i.public_ip_address} #{cmd.join(' ')}"
+          end
+        ensure
+          keyfile.try(:unlink)         # remove private key
+          try(:let_me_in_revoke)       # close security group
+        end
+
+      end
+    end
+  end
+end

data/lib/stax/aws/alb.rb

@@ -0,0 +1,28 @@
+module Stax
+  module Aws
+    class Alb < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::ElasticLoadBalancingV2::Client.new
+        end
+
+        def describe(alb_arns)
+          client.describe_load_balancers(load_balancer_arns: alb_arns).load_balancers
+        end
+
+        def target_groups(alb_arn)
+          paginate(:target_groups) do |marker|
+            client.describe_target_groups(load_balancer_arn: alb_arn, marker: marker)
+          end
+        end
+
+        def target_health(tg_arn)
+          client.describe_target_health(target_group_arn: tg_arn).target_health_descriptions.flatten(1)
+        end
+
+      end
+    end
+  end
+end

data/lib/stax/aws/asg.rb

@@ -0,0 +1,34 @@
+module Stax
+  module Aws
+    class Asg < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::AutoScaling::Client.new
+        end
+
+        def describe(names)
+          paginate(:auto_scaling_groups) do |token|
+            client.describe_auto_scaling_groups(auto_scaling_group_names: Array(names), next_token: token)
+          end
+        end
+
+        def instances(names)
+          ids = describe(names).map(&:instances).flatten.map(&:instance_id)
+          paginate(:auto_scaling_instances) do |token|
+            client.describe_auto_scaling_instances(instance_ids: ids, next_token: token)
+          end
+        end
+
+        def update(name, opt = {})
+          client.update_auto_scaling_group(opt.merge(auto_scaling_group_name: name))
+        end
+
+        def terminate(id, decrement = false)
+          client.terminate_instance_in_auto_scaling_group(instance_id: id, should_decrement_desired_capacity: decrement)
+        end
+      end
+    end
+  end
+end

data/lib/stax/aws/cfn.rb

@@ -0,0 +1,102 @@
+module Stax
+  module Aws
+    class Cfn < Sdk
+
+      ## stack statuses that are not DELETE_COMPLETE
+      STATUSES = %i[
+        CREATE_IN_PROGRESS CREATE_FAILED CREATE_COMPLETE
+        ROLLBACK_IN_PROGRESS ROLLBACK_FAILED ROLLBACK_COMPLETE
+        DELETE_IN_PROGRESS DELETE_FAILED
+        UPDATE_IN_PROGRESS UPDATE_COMPLETE_CLEANUP_IN_PROGRESS UPDATE_COMPLETE
+        UPDATE_ROLLBACK_IN_PROGRESS UPDATE_ROLLBACK_FAILED UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS UPDATE_ROLLBACK_COMPLETE
+        REVIEW_IN_PROGRESS
+      ]
+
+      COLORS = {
+        CREATE_COMPLETE:      :green,
+        DELETE_COMPLETE:      :green,
+        UPDATE_COMPLETE:      :green,
+        CREATE_FAILED:        :red,
+        DELETE_FAILED:        :red,
+        UPDATE_FAILED:        :red,
+        ROLLBACK_IN_PROGRESS: :red,
+        ROLLBACK_COMPLETE:    :red,
+      }
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::CloudFormation::Client.new
+        end
+
+        def stacks
+          paginate(:stack_summaries) do |token|
+            client.list_stacks(stack_status_filter: STATUSES, next_token: token)
+          end
+        end
+
+        def template(name)
+          client.get_template(stack_name: name).template_body
+        end
+
+        def resources(name)
+          paginate(:stack_resource_summaries) do |token|
+            client.list_stack_resources(stack_name: name, next_token: token)
+          end
+        end
+
+        def resources_by_type(name, type)
+          resources(name).select do |r|
+            r.resource_type == type
+          end
+        end
+
+        def events(name)
+          paginate(:stack_events) do |token|
+            client.describe_stack_events(stack_name: name, next_token: token)
+          end
+        rescue ::Aws::CloudFormation::Errors::ValidationError => e
+          puts e.message
+        end
+
+        def id(name, id)
+          client.describe_stack_resource(stack_name: name, logical_resource_id: id).stack_resource_detail.physical_resource_id
+        end
+
+        def parameters(name)
+          client.describe_stacks(stack_name: name).stacks.first.parameters
+        end
+
+        def describe(name)
+          client.describe_stacks(stack_name: name).stacks.first
+        end
+
+        def exists?(name)
+          Cfn.describe(name) && true
+        rescue ::Aws::CloudFormation::Errors::ValidationError
+          false
+        end
+
+        def outputs(name)
+          describe(name).outputs.each_with_object(HashWithIndifferentAccess.new) do |o, h|
+            h[o.output_key] = o.output_value
+          end
+        end
+
+        def output(name, key)
+          outputs(name)[key]
+        end
+
+        def delete(name)
+          client.delete_stack(stack_name: name)
+        end
+
+        def protection(name, enable)
+          client.update_termination_protection(stack_name: name, enable_termination_protection: enable)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stax/aws/dynamodb.rb

@@ -0,0 +1,27 @@
+module Stax
+  module Aws
+    class DynamoDB < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::DynamoDB::Client.new
+        end
+
+        def table(name)
+          client.describe_table(table_name: name).table
+        end
+
+        def gsi(name)
+          client.describe_table(table_name: name).table.global_secondary_indexes || []
+        end
+
+        def lsi(name)
+          client.describe_table(table_name: name).table.local_secondary_indexes || []
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stax/aws/ec2.rb

@@ -0,0 +1,22 @@
+module Stax
+  module Aws
+    class Ec2 < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::EC2::Client.new
+        end
+
+        ## return instances tagged by stack with name
+        def instances(name)
+          filter = {name: 'tag:aws:cloudformation:stack-name', values: [name]}
+          paginate(:reservations) do |token|
+            client.describe_instances(filters: [filter], next_token: token)
+          end.map(&:instances).flatten
+        end
+
+      end
+    end
+  end
+end

data/lib/stax/aws/ecr.rb

@@ -0,0 +1,25 @@
+require 'base64'
+
+module Stax
+  module Aws
+    class Ecr < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::ECR::Client.new
+        end
+
+        def auth
+          client.get_authorization_token.authorization_data
+        end
+
+        def exists?(repo, tag)
+          !client.batch_get_image(repository_name: repo, image_ids: [{image_tag: tag}]).images.empty?
+        end
+
+      end
+
+    end
+  end
+end