stax 0.0.1 → 0.0.2

data/lib/stax/mixin/alb.rb

@@ -0,0 +1,45 @@
+require 'stax/aws/alb'
+
+module Stax
+  module Alb
+    def self.included(thor)
+      thor.desc(:alb, 'ALB subcommands')
+      thor.subcommand(:alb, Cmd::Alb)
+    end
+  end
+
+  module Cmd
+    class Alb < SubCommand
+
+      COLORS = {
+        healthy:     :green,
+        unhealthy:   :red,
+        unavailable: :red,
+      }
+
+      no_commands do
+        def stack_albs
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::ElasticLoadBalancingV2::LoadBalancer')
+        end
+      end
+
+      desc 'dns', 'ALB DNS names'
+      def dns
+        puts Aws::Alb.describe(stack_albs.map(&:physical_resource_id)).map(&:dns_name)
+      end
+
+      desc 'status', 'ALB instance status'
+      def status
+        stack_albs.each do |alb|
+          Aws::Alb.target_groups(alb.physical_resource_id).each do |t|
+            debug("ALB status for #{alb.logical_resource_id} #{t.protocol}:#{t.port} #{t.target_group_name}")
+            print_table Aws::Alb.target_health(t.target_group_arn).map { |h|
+              [h.target.id, h.target.port, color(h.target_health.state, COLORS), h.target_health.reason, h.target_health.description]
+            }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/asg.rb

@@ -0,0 +1,115 @@
+require 'stax/aws/asg'
+
+module Stax
+  module Asg
+    def self.included(thor)
+      thor.desc(:asg, 'ASG subcommands')
+      thor.subcommand(:asg, Cmd::Asg)
+    end
+  end
+
+  module Cmd
+    class Asg < SubCommand
+      COLORS = {
+        ## lifecycle states
+        Pending: :yellow, InService: :green, Terminating: :red,
+        ## health statuses
+        Healthy: :green, Unhealthy: :red,
+        ## same for asg instances describe
+        HEALTHY: :green, UNHEALTHY: :red,
+        ## activity status
+        Successful: :green, Failed: :red, Cancelled: :red,
+        ## instance state
+        running: :green, stopped: :yellow, terminated: :red,
+      }
+
+      class_option :groups, aliases: '-g', type: :array, default: nil, desc: 'limit ASGs returned by id'
+
+      no_commands do
+        def stack_asgs
+          a = Aws::Cfn.resources_by_type(my.stack_name, 'AWS::AutoScaling::AutoScalingGroup')
+          filter_asgs(a, options[:groups])
+        end
+
+        def filter_asgs(asgs, groups)
+          return asgs unless groups
+          ids = groups.map { |g| prepend(:asg, g) }
+          asgs.select { |g| ids.include?(g.logical_resource_id) }
+        end
+      end
+
+      desc 'ls', 'list ASGs for stack'
+      def ls
+        print_table Aws::Asg.describe(stack_asgs.map(&:physical_resource_id)).map { |a|
+          [
+            a.auto_scaling_group_name[0,40],
+            a.launch_configuration_name[0,40],
+            "#{a.instances.length}/#{a.desired_capacity}",
+            "#{a.min_size}-#{a.max_size}",
+            a.availability_zones.map{ |az| az[-1,1] }.sort.join(','),
+            a.created_time
+          ]
+        }
+      end
+
+      desc 'status', 'status of instances by ASG'
+      def status
+        stack_asgs.each do |asg|
+          debug("ASG status for #{asg.physical_resource_id}")
+          print_table Aws::Asg.instances(asg.physical_resource_id).map { |i|
+            [
+              i.instance_id,
+              i.availability_zone,
+              color(i.lifecycle_state, COLORS),
+              color(i.health_status, COLORS),
+              i.launch_configuration_name,
+            ]
+          }
+        end
+      end
+
+      desc 'terminate [ID_REGEXES]', 'terminate matching instances'
+      method_option :decrement, aliases: '-d', type: :boolean, default: false, desc: 'decrement desired count after terminate'
+      def terminate(*ids)
+         instances = Aws::Asg.instances(stack_asgs.map(&:physical_resource_id))
+         instances.select do |i|
+           ids.any? { |id| i.instance_id.match(id) }
+         end.each do |i|
+           yes?("Terminate #{i.instance_id}?", :yellow) && Aws::Asg.terminate(i.instance_id, options[:decrement])
+         end
+      end
+
+      desc 'old', 'ASG instances with outdated launch config'
+      method_option :terminate, aliases: '-t', type: :boolean, default: false, desc: 'terminate outdated instances'
+      method_option :decrement, aliases: '-d', type: :boolean, default: false, desc: 'decrement desired count after terminate'
+      def old
+        Aws::Asg.describe(stack_asgs.map(&:physical_resource_id)).map do |a|
+          Aws::Asg.instances(a.auto_scaling_group_name).select do |i|
+            i.launch_configuration_name != a.launch_configuration_name
+          end
+        end.flatten.tap do |list|
+          print_table list.map { |i| [i.instance_id, i.auto_scaling_group_name, i.launch_configuration_name] }
+          if options[:terminate]
+            list.each do |i|
+              yes?("Terminate #{i.instance_id}?", :yellow) && Aws::Asg.terminate(i.instance_id, options[:decrement])
+            end
+          end
+        end
+      end
+
+      desc 'scale', 'ASG scale instance count'
+      method_option :desired_capacity, aliases: '-d', type: :numeric, default: nil, desc: 'set desired instance count'
+      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?
+        stack_asgs.each do |a|
+          debug("Scaling to #{opt} for #{a.logical_resource_id} #{a.physical_resource_id}")
+          Aws::Asg.update(a.physical_resource_id, opt)
+        end
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/dynamodb.rb

@@ -0,0 +1,62 @@
+require 'stax/aws/dynamodb'
+
+module Stax
+  module DynamoDB
+    def self.included(thor)
+      thor.desc(:dynamodb, 'Dynamo subcommands')
+      thor.subcommand(:dynamodb, Cmd::DynamoDB)
+    end
+  end
+
+  module Cmd
+    class DynamoDB < SubCommand
+
+      COLORS = {
+        CREATING: :yellow,
+        UPDATING: :yellow,
+        DELETING: :red,
+        ACTIVE:   :green,
+      }
+
+      no_commands do
+        def stack_tables
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::DynamoDB::Table')
+        end
+      end
+
+      desc 'tables', 'list tables for stack'
+      def tables
+        print_table stack_tables.map { |r|
+          t = Aws::DynamoDB.table(r.physical_resource_id)
+          [ t.table_name, color(t.table_status, COLORS), t.item_count, t.table_size_bytes, t.creation_date_time ]
+        }
+      end
+
+      desc 'gsi ID', 'list global secondary indexes for table with ID'
+      def gsi(id)
+        print_table Aws::DynamoDB.gsi(my.resource(id)).map { |i|
+          hash  = i.key_schema.find{ |k| k.key_type == 'HASH' }&.attribute_name
+          range = i.key_schema.find{ |k| k.key_type == 'RANGE' }&.attribute_name
+          [i.index_name, hash, range, i.projection.projection_type, i.index_size_bytes, i.item_count]
+        }.sort
+      end
+
+      desc 'lsi ID', 'list local secondary indexes for table with ID'
+      def lsi(id)
+        print_table Aws::DynamoDB.lsi(my.resource(id)).map { |i|
+          hash  = i.key_schema.find{ |k| k.key_type == 'HASH' }&.attribute_name
+          range = i.key_schema.find{ |k| k.key_type == 'RANGE' }&.attribute_name
+          [i.index_name, hash, range, i.projection.projection_type, i.index_size_bytes, i.item_count]
+        }.sort
+      end
+
+      desc 'keys ID', 'get hash and range keys of table with ID'
+      def keys(id)
+        print_table Aws::DynamoDB.table(my.resource(id)).key_schema.each_with_object({}) { |schema, h|
+          h[schema.key_type.downcase.to_sym] = schema.attribute_name
+        }
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/ec2.rb

@@ -0,0 +1,37 @@
+require 'stax/aws/ec2'
+
+module Stax
+  module Ec2
+    def self.included(thor)
+      thor.desc(:ec2, 'EC2 subcommands')
+      thor.subcommand(:ec2, Cmd::Ec2)
+    end
+  end
+
+  module Cmd
+    class Ec2 < SubCommand
+      COLORS = {
+        running:    :green,
+        stopped:    :yellow,
+        terminated: :red,
+      }
+
+      desc 'ls', 'list instances for stack'
+      def ls
+        print_table Aws::Ec2.instances(my.stack_name).map { |i|
+          name = i.tags.find { |t| t.key == 'Name' }&.value
+          [
+            name,
+            i.instance_id,
+            i.instance_type,
+            i.placement.availability_zone,
+            color(i.state.name, COLORS),
+            i.private_ip_address,
+            i.public_ip_address
+          ]
+        }
+      end
+    end
+
+  end
+end

data/lib/stax/mixin/ecs.rb

@@ -0,0 +1,114 @@
+require 'stax/aws/ecs'
+
+module Stax
+  module Ecs
+    def self.included(thor)
+      thor.desc(:ecs, 'ECS subcommands')
+      thor.subcommand(:ecs, Cmd::Ecs)
+    end
+  end
+
+  module Cmd
+    class Ecs < SubCommand
+      COLORS = {
+        ACTIVE:   :green,
+        INACTIVE: :red,
+        RUNNING:  :green,
+        STOPPED:  :red,
+      }
+
+      no_commands do
+        def ecs_cluster_name
+          @_ecs_cluster_name ||= my.stack_name
+        end
+
+        def ecs_task_definitions
+          @_ecs_task_definitions ||= Aws::Cfn.resources_by_type(my.stack_name, 'AWS::ECS::TaskDefinition' )
+        end
+
+        def ecs_task_definition(id)
+          Aws::Cfn.id(my.stack_name, id)
+        end
+
+        def ecs_services
+          @_ecs_services ||= Aws::Cfn.resources_by_type(my.stack_name,  'AWS::ECS::Service')
+        end
+      end
+
+      desc 'clusters', 'ECS cluster for stack'
+      def clusters
+        print_table Aws::Ecs.clusters(ecs_cluster_name).map { |c|
+          [
+            c.cluster_name,
+            color(c.status, COLORS),
+            "instances:#{c.registered_container_instances_count}",
+            "pending:#{c.pending_tasks_count}",
+            "running:#{c.running_tasks_count}",
+          ]
+        }
+      end
+
+      desc 'services', 'ECS services for stack'
+      def services
+        print_table Aws::Ecs.services(ecs_cluster_name, ecs_services.map(&:physical_resource_id)).map { |s|
+          [s.service_name, color(s.status, COLORS), s.task_definition.split('/').last, "#{s.running_count}/#{s.desired_count}"]
+        }
+      end
+
+      desc 'definitions', 'ECS task definitions for stack'
+      def definitions
+        print_table ecs_task_definitions.map { |r|
+          t = Aws::Ecs.task_definition(r.physical_resource_id)
+          [r.logical_resource_id, t.family, t.revision, color(t.status, COLORS)]
+        }
+      end
+
+     desc 'tasks' , 'ECS tasks for stack'
+     method_option :status, aliases: '-s', type: :string, default: 'RUNNING', desc: 'status to list'
+     def tasks
+       print_table Aws::Ecs.tasks(ecs_cluster_name, options[:status].upcase).map { |t|
+         [
+           t.task_arn.split('/').last,
+           t.task_definition_arn.split('/').last,
+           t.container_instance_arn.split('/').last,
+           color(t.last_status, COLORS),
+           "(#{t.desired_status})",
+           t.started_by,
+         ]
+       }
+     end
+
+     desc 'instances', 'ECS instances'
+     def instances
+       print_table Aws::Ecs.instances(ecs_cluster_name).map { |i|
+         [
+           i.container_instance_arn.split('/').last,
+           i.ec2_instance_id,
+           i.agent_connected,
+           color(i.status, COLORS),
+           i.running_tasks_count,
+           "(#{i.pending_tasks_count})",
+           "agent #{i.version_info.agent_version}",
+           i.version_info.docker_version,
+         ]
+       }
+     end
+
+     desc 'run_task [ID]', 'run task by id'
+     def run_task(id)
+       Aws::Ecs.run(ecs_cluster_name, Aws::Cfn.id(my.stack_name, id)).tap do |tasks|
+         puts tasks.map(&:container_instance_arn)
+       end
+     end
+
+     desc 'stop_task [TASK]', 'stop task'
+     def stop_task(task)
+       Aws::Ecs.stop(ecs_cluster_name, task).tap do |task|
+         puts task.container_instance_arn
+       end
+     end
+
+    end
+
+  end
+end

data/lib/stax/mixin/elb.rb

@@ -0,0 +1,42 @@
+require 'stax/aws/elb'
+
+module Stax
+  module Elb
+    def self.included(thor)
+      thor.desc(:elb, 'ELB subcommands')
+      thor.subcommand(:elb, Cmd::Elb)
+    end
+  end
+
+  module Cmd
+    class Elb < SubCommand
+
+      COLORS = {
+        InService:    :green,
+        OutOfService: :red,
+      }
+
+      no_commands do
+        def stack_elbs
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::ElasticLoadBalancing::LoadBalancer')
+        end
+      end
+
+      desc 'dns', 'ALB DNS names'
+      def dns
+        puts Aws::Elb.describe(stack_elbs.map(&:physical_resource_id)).map(&:dns_name)
+      end
+
+      desc 'status', 'ELB instance status'
+      def status
+        stack_elbs.each do |elb|
+          debug("ELB status for #{elb.logical_resource_id} #{elb.physical_resource_id}")
+          print_table Aws::Elb.instance_health(elb.physical_resource_id).map { |i|
+            [i.instance_id, color(i.state, COLORS), i.reason_code, i.description]
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/emr.rb

@@ -0,0 +1,69 @@
+require 'stax/aws/emr'
+require 'yaml'
+
+module Stax
+  module Emr
+    def self.included(thor)
+      thor.desc(:emr, 'Emr subcommands')
+      thor.subcommand(:emr, Cmd::Emr)
+    end
+  end
+
+  module Cmd
+    class Emr < SubCommand
+
+      COLORS = {
+        RUNNING:                :green,
+        WAITING:                :green,
+        TERMINATING:            :red,
+        TERMINATED:             :red,
+        TERMINATED_WITH_ERRORS: :red,
+      }
+
+      no_commands do
+        def stack_emr_clusters
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::EMR::Cluster')
+        end
+      end
+
+      desc 'status', 'EMR cluster state'
+      def status
+        print_table stack_emr_clusters.map { |r|
+          c = Aws::Emr.describe(r.physical_resource_id)
+          [color(c.status.state, COLORS), c.status.state_change_reason.message]
+        }
+      end
+
+      desc 'describe', 'describe EMR clusters'
+      def describe
+        stack_emr_clusters.each do |r|
+          Aws::Emr.describe(r.physical_resource_id).tap do |c|
+            puts YAML.dump(stringify_keys(c.to_hash))
+          end
+        end
+      end
+
+      desc 'groups', 'EMR instance groups'
+      def groups
+        stack_emr_clusters.each do |r|
+          debug("Instance groups for #{r.logical_resource_id} #{r.physical_resource_id}")
+          print_table Aws::Emr.groups(r.physical_resource_id).map { |g|
+            [g.id, color(g.status.state, COLORS), g.name, g.instance_type, g.running_instance_count, g.market]
+          }
+        end
+      end
+
+      desc 'instances', 'EMR instances'
+      def instances
+        stack_emr_clusters.each do |r|
+          debug("Instances for #{r.logical_resource_id} #{r.physical_resource_id}")
+          group_names = Aws::Emr.groups(r.physical_resource_id).each_with_object({}) { |g,h| h[g.id] = g.name }
+          print_table Aws::Emr.instances(r.physical_resource_id).map { |i|
+            [i.id, i.ec2_instance_id, group_names[i.instance_group_id], i.instance_type, color(i.status.state, COLORS), i.public_ip_address]
+          }
+        end
+      end
+
+    end
+  end
+end