stax 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9678c52393c842e801f8e3c306eb6976049e7d9
-  data.tar.gz: 6732bf5a03a47223ac78300ff338d71df796047c
+  metadata.gz: 0444c2ae4f050d73ba7cfd720eca476667102bf2
+  data.tar.gz: 764f80db2e413eade8840ef8f04c33d93003e190
 SHA512:
-  metadata.gz: 97d814ccc5329e44a534213a6100a8f485e4c2c59eac762cc6aa1b5ccabd79c2cb0707f4d82383fcd5d29fb914836cdbfd0f2af9ad5ddbd900a68824af6022e5
-  data.tar.gz: de492742715aaf17fbcd5a57cd4a626469264a6a1af95d7bc5808b58007d28aa02ee9861643affefd33b7d5fe89547c9fc55e08b3b14cf9be6767599230b99b1
+  metadata.gz: bb84fb5b04019ef607f8f4a6658414fdda2b3dbf641a31bbedadfb785ab20f1e76c8d039529c71a52d5f18419ead4c5594297bdfc7303efef8ccb4f8d0ef0191
+  data.tar.gz: f65676b1870954bcc39c5d53a0ecd7b238d5b2fafd7bd2ea5761fc993dece0e33c7b8c2205ebf6a61021b148ba01f84f8856a523fd4d4c2fa6ff3bbfcea6fb41

data/lib/stax.rb

@@ -8,6 +8,7 @@ require 'stax/staxfile'
 require 'stax/base'
 require 'stax/git'
 require 'stax/cli'
+require 'stax/meta'
 require 'stax/subcommand'
 require 'stax/cfer'
 require 'stax/stack'
@@ -32,4 +33,6 @@ require 'stax/mixin/emr'
 require 'stax/mixin/ssh'
 require 'stax/mixin/lambda'
 require 'stax/mixin/dynamodb'
-require 'stax/mixin/logs'
+require 'stax/mixin/logs'
+require 'stax/mixin/apigw'
+require 'stax/mixin/firehose'

data/lib/stax/aws/apigw.rb

@@ -0,0 +1,24 @@
+
+module Stax
+  module Aws
+    class APIGateway < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::APIGateway::Client.new
+        end
+
+        def api(id)
+          client.get_rest_api(rest_api_id: id)
+        end
+
+        def stages(id, deployment = nil)
+          client.get_stages(rest_api_id: id, deployment_id: deployment).item
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stax/aws/dynamodb.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module Stax
   module Aws
     class DynamoDB < Sdk
@@ -20,6 +22,81 @@ module Stax
           client.describe_table(table_name: name).table.local_secondary_indexes || []
         end
 
+        def key_schema(name)
+          client.describe_table(table_name: name).table.key_schema
+        end
+
+        ## key schema as a hash
+        def keys(name)
+          key_schema(name).each_with_object({}) do |s, h|
+            h[s.key_type.downcase.to_sym] = s.attribute_name
+          end
+        end
+
+        def do_scan(opt)
+          exclusive_start_key = nil
+          loop do
+            r = client.scan(opt.merge(exclusive_start_key: exclusive_start_key))
+            yield r
+            exclusive_start_key = r.last_evaluated_key
+            break unless exclusive_start_key
+          end
+        end
+
+        def scan(opt)
+          do_scan(opt) do |r|
+            r.items.each do |item|
+              puts JSON.generate(item)
+            end
+          end
+        end
+
+        def count(opt)
+          total = 0
+          do_scan(opt.merge(select: 'COUNT')) do |r|
+            total += r.count
+          end
+          return total
+        end
+
+        def query(opt)
+          exclusive_start_key = nil
+          loop do
+            r = client.query(opt.merge(exclusive_start_key: exclusive_start_key))
+            r.items.each do |item|
+              puts JSON.generate(item)
+            end
+            exclusive_start_key = r.last_evaluated_key
+            break unless exclusive_start_key
+          end
+        end
+
+        def list_backups(opt = {})
+          last_arn = nil
+          backups = []
+          loop do
+            r = client.list_backups(opt.merge(exclusive_start_backup_arn: last_arn))
+            backups += r.backup_summaries
+            last_arn = r.last_evaluated_backup_arn
+            break unless last_arn
+          end
+          backups
+        end
+
+        def create_backup(table_name, backup_name)
+          client.create_backup(
+            table_name:  table_name,
+            backup_name: backup_name,
+          ).backup_details
+        end
+
+        def restore_backup(table_name, backup_arn)
+          client.restore_table_from_backup(
+            target_table_name: table_name,
+            backup_arn:        backup_arn,
+          ).table_description
+        end
+
       end
 
     end

data/lib/stax/aws/ecs.rb

@@ -16,6 +16,10 @@ module Stax
           client.describe_services(cluster: cluster, services: services).services
         end
 
+        def update_service(opt)
+          client.update_service(opt).service
+        end
+
         def task_definition(name)
           client.describe_task_definition(task_definition: name).task_definition
         end
@@ -27,7 +31,12 @@ module Stax
         end
 
         def tasks(cluster, status = :RUNNING)
-          client.describe_tasks(cluster: cluster, tasks: list_tasks(cluster, status)).tasks
+          tasks = list_tasks(cluster, status)
+          if tasks.empty?
+            []
+          else
+            client.describe_tasks(cluster: cluster, tasks: tasks).tasks
+          end
         end
 
         def list_instances(cluster)

data/lib/stax/aws/firehose.rb

@@ -0,0 +1,19 @@
+module Stax
+  module Aws
+    class Firehose < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::Firehose::Client.new
+        end
+
+        def describe(name)
+          client.describe_delivery_stream(delivery_stream_name: name).delivery_stream_description
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stax/aws/lambda.rb

@@ -26,6 +26,10 @@ module Stax
           client.invoke(opt)
         end
 
+        def update_code(opt)
+          client.update_function_code(opt)
+        end
+
       end
 
     end

data/lib/stax/aws/logs.rb

@@ -18,6 +18,10 @@ module Stax
           client.describe_log_streams(opt).log_streams
         end
 
+        def delete_group(name)
+          client.delete_log_group(log_group_name: name)
+        end
+
       end
 
     end

data/lib/stax/cfer.rb

@@ -5,6 +5,7 @@ module Stax
     class_option :use_previous_value, aliases: '-u', type: :array, default: [], desc: 'params to use previous value'
 
     no_commands do
+
       def cfer_parameters
         {}
       end
@@ -48,11 +49,28 @@ module Stax
         Cfer.generate!(cfer_template, opts)
       end
 
+      ## generate method does puts, so steal stdout into a string
+      def cfer_generate_string
+        capture_stdout do
+          cfer_generate
+        end
+      end
+
       def cfer_tail
         Cfer.tail!(stack_name, follow: true, number: 1)
       rescue ::Aws::CloudFormation::Errors::ValidationError => e
         puts e.message
       end
+
+      ## temporarily grab stdout to a string
+      def capture_stdout
+        stdout, $stdout = $stdout, StringIO.new
+        yield
+        $stdout.string
+      ensure
+        $stdout = stdout
+      end
+
     end
 
   end

data/lib/stax/meta.rb

@@ -0,0 +1,39 @@
+module Stax
+  class Cli < Base
+
+    no_commands do
+      ## create order: default to stacks from Staxfile, override if needed
+      ## delete will be this, in reverse order
+      def stack_order
+        Stax.stack_list
+      end
+
+      def stack_objects
+        stack_order.map(&method(:stack))
+      end
+    end
+
+    desc 'create', 'meta create task'
+    def create
+      stack_objects.each do |s|
+        if s.exists?
+          say("Skipping: #{s.stack_name} exists", :yellow)
+        elsif y_or_n?("Create #{s.stack_name}?", :yellow)
+          s.create
+        end
+      end
+    end
+
+    desc 'delete', 'meta delete task'
+    def delete
+      stack_objects.reverse.each do |s|
+        if s.exists?
+          s.delete
+        else
+          say("#{s.stack_name} does not exist", :green)
+        end
+      end
+    end
+
+  end
+end

data/lib/stax/mixin/apigw.rb

@@ -0,0 +1,41 @@
+require 'stax/aws/apigw'
+
+module Stax
+  module Apigw
+    def self.included(thor)
+      thor.desc(:apigw, 'API Gateway subcommands')
+      thor.subcommand(:apigw, Cmd::Apigw)
+    end
+  end
+
+  module Cmd
+    class Apigw < SubCommand
+
+      no_commands do
+        def stack_apis
+          Aws::Cfn.resources_by_type(my.stack_name, 'AWS::ApiGateway::RestApi')
+        end
+      end
+
+      desc 'ls', 'list APIS'
+      def ls
+        print_table stack_apis.map { |r|
+          a = Aws::APIGateway.api(r.physical_resource_id)
+          [a.name, a.id, a.endpoint_configuration.types.join(','), a.created_date, a.description]
+        }
+      end
+
+      desc 'stages', 'list API stages'
+      def stages
+        stack_apis.each do |r|
+          api = Aws::APIGateway.api(r.physical_resource_id)
+          debug("Stages for API #{api.name} #{api.id}")
+          print_table Aws::APIGateway.stages(api.id).map { |s|
+            [s.stage_name, s.deployment_id, s.created_date, s.last_updated_date, s.description]
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/dynamodb.rb

@@ -1,4 +1,7 @@
+require 'yaml'
 require 'stax/aws/dynamodb'
+require_relative 'dynamodb/throughput'
+require_relative 'dynamodb/backup'
 
 module Stax
   module DynamoDB
@@ -12,16 +15,25 @@ module Stax
     class DynamoDB < SubCommand
 
       COLORS = {
-        CREATING: :yellow,
-        UPDATING: :yellow,
-        DELETING: :red,
-        ACTIVE:   :green,
+        CREATING:  :yellow,
+        UPDATING:  :yellow,
+        DELETING:  :red,
+        ACTIVE:    :green,
+        DELETED:   :red,
+        AVAILABLE: :green,
       }
 
       no_commands do
         def stack_tables
           Aws::Cfn.resources_by_type(my.stack_name, 'AWS::DynamoDB::Table')
         end
+
+        ## get table names from logical IDs, return all tables if nil
+        def stack_table_names(logical_ids)
+          stack_tables.tap do |tables|
+            tables.select! { |t| logical_ids.include?(t.logical_resource_id) } if logical_ids
+          end.map(&:physical_resource_id)
+        end
       end
 
       desc 'tables', 'list tables for stack'
@@ -52,9 +64,34 @@ module Stax
 
       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
-        }
+        print_table Aws::DynamoDB.keys(my.resource(id))
+      end
+
+      desc 'scan ID', 'scan table with given logical id from this stack'
+      def scan(id)
+        Aws::DynamoDB.scan(table_name: my.resource(id))
+      end
+
+      desc 'count ID', 'count items in table with given id'
+      def count(id)
+        puts Aws::DynamoDB.count(table_name: my.resource(id))
+      end
+
+      desc 'query ID HASH_VALUE [RANGE_VALUE]', 'query table with id'
+      def query(id, hash_value, range_value = nil)
+        name = my.resource(id)
+        k = Aws::DynamoDB.keys(name)
+        Aws::DynamoDB.query(
+          table_name: name,
+          expression_attribute_values: {
+            ':h' => hash_value,
+            ':r' => range_value,
+          }.compact,
+          key_condition_expression: [
+            "#{k[:hash]} = :h",
+            range_value ? "#{k[:range]} = :r" : nil,
+          ].compact.join(' and '),
+        )
       end
 
     end

data/lib/stax/mixin/dynamodb/backup.rb

@@ -0,0 +1,41 @@
+module Stax
+  module Cmd
+    class DynamoDB < SubCommand
+
+      no_commands do
+        def list_backups(name)
+          debug("Backups for #{name}")
+          print_table Aws::DynamoDB.list_backups(table_name: name).map { |b|
+            [b.backup_name, color(b.backup_status, COLORS), b.table_name, b.backup_creation_date_time, human_bytes(b.backup_size_bytes)]
+          }
+        end
+
+        def create_backup(table_name, backup_name)
+          backup_name = Time.now.utc.strftime("#{table_name}-%Y%m%d%H%M%S") if backup_name == 'create' # thor option empty
+          debug("Creating backup #{backup_name} from #{table_name}")
+          Aws::DynamoDB.create_backup(table_name, backup_name).tap do |b|
+            puts YAML.dump(stringify_keys(b.to_hash))
+          end
+        end
+      end
+
+      desc 'backup ID', 'table backups'
+      method_option :create, aliases: '-c', type: :string, default: nil, desc: 'create new backup from table'
+      def backup(id = nil)
+        name = my.resource(id)
+        if options[:create]
+          create_backup(name, options[:create])
+        else
+          list_backups(name)
+        end
+      end
+
+      desc 'restore ARN TABLE', 'restore backup to a new table'
+      def restore(arn, table)
+        debug("Creating table #{table} from backup #{arn}")
+        Aws::DynamoDB.restore_backup(table, arn)
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/dynamodb/throughput.rb

@@ -0,0 +1,67 @@
+module Stax
+  module Cmd
+    class DynamoDB < SubCommand
+
+      no_commands do
+        def print_throughput(ids)
+          output = [['NAME', 'INDEX NAME', 'READ CAPACITY', 'WRITE CAPACITY', 'DECREASES TODAY']]
+          stack_table_names(ids).each do |name|
+            table = Aws::DynamoDB.table(name)
+            t = table.provisioned_throughput
+            output << [table.table_name, nil, t.read_capacity_units, t.write_capacity_units, t.number_of_decreases_today]
+            (table.global_secondary_indexes || []).each do |gsi|
+              t = gsi.provisioned_throughput
+              output << [table.table_name, gsi.index_name, t.read_capacity_units, t.write_capacity_units, t.number_of_decreases_today]
+            end
+          end
+          print_table(output)
+        end
+
+        def update_throughput(ids, read, write)
+          debug("Updating throughput on #{ids ? ids.count : 'all'} tables")
+          stack_table_names(ids).each do |name|
+            puts name
+            table = Aws::DynamoDB.table(name)
+            begin
+              Aws::DynamoDB.client.update_table(
+                table_name: name,
+                provisioned_throughput: {
+                  read_capacity_units:  read  || table.provisioned_throughput.read_capacity_units,
+                  write_capacity_units: write || table.provisioned_throughput.write_capacity_units,
+                },
+                global_secondary_index_updates: table.global_secondary_indexes&.map do |gsi|
+                  {
+                    update: {
+                      index_name: gsi.index_name,
+                      provisioned_throughput: {
+                        read_capacity_units:  read  || gsi.provisioned_throughput.read_capacity_units,
+                        write_capacity_units: write || gsi.provisioned_throughput.write_capacity_units,
+                      }
+                    }
+                  }
+                end
+              )
+            rescue ::Aws::DynamoDB::Errors::ValidationException
+              puts 'no change'
+            rescue ::Aws::DynamoDB::Errors::ResourceInUseException => e
+              warn(e.message)
+            end
+          end
+        end
+      end
+
+      desc 'throughput ID', 'throughput'
+      method_option :tables, aliases: '-t', type: :array,   default: nil, desc: 'limit to given table IDs'
+      method_option :read,   aliases: '-r', type: :numeric, default: nil, desc: 'set read capacity units'
+      method_option :write,  aliases: '-w', type: :numeric, default: nil, desc: 'set write capacity units'
+      def throughput
+        if options[:write] || options[:read]
+          update_throughput(options[:tables], options[:read], options[:write])
+        else
+          print_throughput(options[:tables])
+        end
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/ecs.rb

@@ -6,6 +6,42 @@ module Stax
       thor.desc(:ecs, 'ECS subcommands')
       thor.subcommand(:ecs, Cmd::Ecs)
     end
+
+    def ecs_cluster_name
+      'default'
+    end
+
+    def ecs_services
+      @_ecs_services ||= Aws::Cfn.resources_by_type(stack_name, 'AWS::ECS::Service')
+    end
+
+    def ecs_task_definitions
+      @_ecs_task_definitions ||= Aws::Cfn.resources_by_type(stack_name, 'AWS::ECS::TaskDefinition')
+    end
+
+    def ecs_service_objects
+      Aws::Ecs.services(ecs_cluster_name, ecs_services.map(&:physical_resource_id))
+    end
+
+    ## register a new revision of existing task definition
+    def ecs_update_taskdef(id)
+      taskdef = Aws::Ecs.task_definition(resource(id))
+      debug("Registering new revision of #{taskdef.family}")
+      args = %i[family cpu memory requires_compatibilities task_role_arn execution_role_arn network_mode container_definitions volumes placement_constraints]
+      Aws::Ecs.client.register_task_definition(taskdef.to_hash.slice(*args)).task_definition.tap do |t|
+        puts t.task_definition_arn
+      end
+    end
+
+    ## update service to use a new task definition
+    def ecs_update_service(id, taskdef)
+      service_name = resource(id).split('/').last
+      taskdef_name = taskdef.task_definition_arn.split('/').last
+      debug("Updating #{service_name} to #{taskdef_name}")
+      Aws::Ecs.update_service(service: service_name, task_definition: taskdef_name).tap do |s|
+        puts s.task_definition
+      end
+    end
   end
 
   module Cmd
@@ -18,26 +54,14 @@ module Stax
       }
 
       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|
+        print_table Aws::Ecs.clusters(my.ecs_cluster_name).map { |c|
           [
             c.cluster_name,
             color(c.status, COLORS),
@@ -50,63 +74,119 @@ module Stax
 
       desc 'services', 'ECS services for stack'
       def services
-        print_table Aws::Ecs.services(ecs_cluster_name, ecs_services.map(&:physical_resource_id)).map { |s|
+        print_table my.ecs_service_objects.map { |s|
           [s.service_name, color(s.status, COLORS), s.task_definition.split('/').last, "#{s.running_count}/#{s.desired_count}"]
         }
       end
 
+      desc 'events', 'show service events'
+      method_option :number, aliases: '-n', type: :numeric, default: 10, desc: 'number of events to show'
+      def events
+        my.ecs_service_objects.each do |s|
+          debug("Events for #{s.service_name}")
+          print_table s.events.first(options[:number]).map { |e|
+            [set_color(e.created_at, :green), e.message]
+          }.reverse
+        end
+      end
+
+      desc 'deployments', 'show service deployments'
+      def deployments
+        my.ecs_service_objects.each do |s|
+          debug("Deployments for #{s.service_name}")
+          print_table s.deployments.map { |d|
+            count = "#{d.running_count}/#{d.desired_count} (#{d.pending_count})"
+            [d.id, d.status, count, d.created_at, d.updated_at, d.task_definition.split('/').last]
+          }
+        end
+      end
+
       desc 'definitions', 'ECS task definitions for stack'
       def definitions
-        print_table ecs_task_definitions.map { |r|
+        print_table my.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
+      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(my.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 'containers', 'containers for running tasks'
+      method_option :status, aliases: '-s', type: :string, default: 'RUNNING', desc: 'status to list'
+      def containers
+        debug("Containers for cluster #{my.ecs_cluster_name}")
+        print_table Aws::Ecs.tasks(my.ecs_cluster_name, options[:status].upcase).map { |task|
+          task_defn = task.task_definition_arn.split('/').last
+          task.containers.map { |c|
+            [
+              c.container_arn.split('/').last,
+              c.name,
+              color(c.last_status, COLORS),
+              c.network_interfaces.map(&:private_ipv_4_address).join(','),
+              task_defn,
+              c.exit_code,
+              c.reason,
+            ]
+          }
+        }.flatten(1)
+      end
+
+      desc 'instances', 'ECS instances'
+      def instances
+        print_table Aws::Ecs.instances(my.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(my.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(my.ecs_cluster_name, task).tap do |task|
+          puts task.container_instance_arn
+        end
+      end
+
+      desc 'scale', 'scale containers for service'
+      method_option :desired, aliases: '-d', type: :numeric, default: nil, desc: 'desired container count'
+      def scale
+        my.ecs_services.each do |s|
+          debug("Scaling service #{s.logical_resource_id}")
+          Aws::Ecs.update_service(
+            service: s.physical_resource_id,
+            desired_count: options[:desired],
+          ).tap do |s|
+            puts "desired: #{s.desired_count}"
+          end
+        end
+      end
 
     end
 

data/lib/stax/mixin/firehose.rb

@@ -0,0 +1,34 @@
+require 'stax/aws/firehose'
+
+module Stax
+  module Firehose
+    def self.included(thor)
+      thor.desc(:firehose, 'Firehose subcommands')
+      thor.subcommand(:firehose, Cmd::Firehose)
+
+      def stack_firehoses
+        Aws::Cfn.resources_by_type(stack_name,  'AWS::KinesisFirehose::DeliveryStream')
+      end
+    end
+  end
+
+  module Cmd
+    class Firehose < SubCommand
+
+      COLORS = {
+        ACTIVE:   :green,
+        CREATING: :yellow,
+        DELETING: :red,
+      }
+
+      desc 'ls', 'list stack firehoses'
+      def ls
+        print_table my.stack_firehoses.map { |r|
+          f = Aws::Firehose.describe(r.physical_resource_id)
+          [f.delivery_stream_name, color(f.delivery_stream_status, COLORS), f.create_timestamp, f.delivery_stream_type]
+        }
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/lambda.rb

@@ -18,6 +18,21 @@ module Stax
         def stack_lambdas
           Aws::Cfn.resources_by_type(my.stack_name, 'AWS::Lambda::Function')
         end
+
+        ## return zip file contents, make it if necessary
+        def zip_thing(thing)
+          if File.directory?(thing)
+            Dir.chdir(thing) do
+              %x[zip -q -r - .]      # zip dir contents
+            end
+          elsif thing.match(/\.zip$/i)
+            File.read(thing)         # raw zipfile contents
+          elsif File.file?(thing)
+            %x[zip -q -j - #{thing}] # zip a single file
+          else
+            nil
+          end
+        end
       end
 
       desc 'ls', 'list lambdas for stack'
@@ -52,6 +67,18 @@ module Stax
         end
       end
 
+      desc 'update ID FILE', 'update code for lambda function with ID'
+      method_option :publish, aliases: '-p', type: :boolean, default: false, desc: 'publish as a new version'
+      def update(id, file)
+        Aws::Lambda.update_code(
+          function_name: my.resource(id),
+          publish: options[:publish],
+          zip_file: zip_thing(file),
+        )&.version.tap do |v|
+          puts "version: #{v}"
+        end
+      end
+
       desc 'test ID', 'run lambda with ID'
       method_option :type,    type: :string,  default: nil,   desc: 'invocation type: RequestResponse, Event'
       method_option :tail,    type: :boolean, default: false, desc: 'tail log for RequestResponse'

data/lib/stax/mixin/logs.rb

@@ -89,6 +89,18 @@ module Stax
         end
       end
 
+      ## lambdas create their own log groups, and when we delete stack they are left behind;
+      ## this task looks up their names by stack prefix, and deletes them
+      desc 'cleanup', 'cleanup lambda log groups named for stack'
+      method_option :test, aliases: '-t', type: :boolean, default: false, desc: 'show group names without deleting'
+      def cleanup
+        debug("Cleaning up log groups for stack #{my.stack_name}")
+        Aws::Logs.groups("/aws/lambda/#{my.stack_name}").map(&:log_group_name).each do |name|
+          puts name
+          Aws::Logs.delete_group(name) unless options[:test]
+        end
+      end
+
     end
   end
 end

data/lib/stax/stack/crud.rb

@@ -75,6 +75,11 @@ module Stax
       cfer_tail
     end
 
+    desc 'generate', 'generate cloudformation template'
+    def generate
+      cfer_generate
+    end
+
     desc 'protection', 'show/set termination protection for stack'
     method_option :enable,  aliases: '-e', type: :boolean, default: nil, desc: 'enable termination protection'
     method_option :disable, aliases: '-d', type: :boolean, default: nil, desc: 'disable termination protection'

data/lib/stax/staxfile.rb

@@ -1,4 +1,9 @@
 module Stax
+  @@_stack_list = []
+
+  def self.stack_list
+    @@_stack_list
+  end
 
   ## search up the dir tree for nearest Staxfile
   def self.load_staxfile
@@ -14,6 +19,7 @@ module Stax
 
   ## add a stack by name, creates class as needed
   def self.add_stack(name, opt = {})
+    @@_stack_list << name
     c = name.capitalize
 
     ## create the class if it does not exist yet

data/lib/stax/version.rb

@@ -1,3 +1,3 @@
 module Stax
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stax
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Richard Lister
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-21 00:00:00.000000000 Z
+date: 2018-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -131,6 +131,7 @@ files:
 - lib/stax.rb
 - lib/stax/asg.rb
 - lib/stax/aws/alb.rb
+- lib/stax/aws/apigw.rb
 - lib/stax/aws/asg.rb
 - lib/stax/aws/cfn.rb
 - lib/stax/aws/dynamodb.rb
@@ -139,6 +140,7 @@ files:
 - lib/stax/aws/ecs.rb
 - lib/stax/aws/elb.rb
 - lib/stax/aws/emr.rb
+- lib/stax/aws/firehose.rb
 - lib/stax/aws/iam.rb
 - lib/stax/aws/keypair.rb
 - lib/stax/aws/kms.rb
@@ -159,13 +161,18 @@ files:
 - lib/stax/github.rb
 - lib/stax/iam.rb
 - lib/stax/keypair.rb
+- lib/stax/meta.rb
 - lib/stax/mixin/alb.rb
+- lib/stax/mixin/apigw.rb
 - lib/stax/mixin/asg.rb
 - lib/stax/mixin/dynamodb.rb
+- lib/stax/mixin/dynamodb/backup.rb
+- lib/stax/mixin/dynamodb/throughput.rb
 - lib/stax/mixin/ec2.rb
 - lib/stax/mixin/ecs.rb
 - lib/stax/mixin/elb.rb
 - lib/stax/mixin/emr.rb
+- lib/stax/mixin/firehose.rb
 - lib/stax/mixin/keypair.rb
 - lib/stax/mixin/kms.rb
 - lib/stax/mixin/lambda.rb