stax 0.0.3 → 0.0.4

data/lib/stax/aws/dynamodb.rb

@@ -14,6 +14,12 @@ module Stax
           client.describe_table(table_name: name).table
         end
 
+        def global_table(name)
+          client.describe_global_table(global_table_name: name)&.global_table_description
+        rescue ::Aws::DynamoDB::Errors::GlobalTableNotFoundException
+          nil
+        end
+
         def gsi(name)
           client.describe_table(table_name: name).table.global_secondary_indexes || []
         end
@@ -71,6 +77,10 @@ module Stax
           end
         end
 
+        def put(opt)
+          client.put_item(opt)
+        end
+
         def list_backups(opt = {})
           last_arn = nil
           backups = []

data/lib/stax/aws/ec2.rb

@@ -16,7 +16,18 @@ module Stax
           end.map(&:instances).flatten
         end
 
+        ## list AMIs
+        def images(opt = {})
+          client.describe_images(opt).images.sort_by(&:creation_date)
+        end
+
+        ## tag AMIs
+        def create_tags(opt)
+          client.create_tags(opt)
+        end
+
       end
+
     end
   end
 end

data/lib/stax/aws/ecr.rb

@@ -14,10 +14,27 @@ module Stax
           client.get_authorization_token.authorization_data
         end
 
+        def repositories(opt = {})
+          paginate(:repositories) do |next_token|
+            client.describe_repositories(opt.merge(next_token: next_token))
+          end
+        end
+
         def exists?(repo, tag)
           !client.batch_get_image(repository_name: repo, image_ids: [{image_tag: tag}]).images.empty?
         end
 
+        def login(*registry_ids)
+          ids = registry_ids.empty? ? nil : Array(registry_ids)
+          client.get_authorization_token(registry_ids: ids).authorization_data
+        end
+
+        def images(opt = {})
+          paginate(:image_details) do |next_token|
+            client.describe_images(opt.merge(next_token: next_token))
+          end
+        end
+
       end
 
     end

data/lib/stax/aws/ecs.rb

@@ -24,18 +24,18 @@ module Stax
           client.describe_task_definition(task_definition: name).task_definition
         end
 
-        def list_tasks(cluster, status = :RUNNING)
+        def list_tasks(opt)
           paginate(:task_arns) do |token|
-            client.list_tasks(cluster: cluster, next_token: token, desired_status: status)
+            client.list_tasks(opt.merge(next_token: token))
           end
         end
 
-        def tasks(cluster, status = :RUNNING)
-          tasks = list_tasks(cluster, status)
+        def tasks(opt = {})
+          tasks = list_tasks(opt)
           if tasks.empty?
             []
           else
-            client.describe_tasks(cluster: cluster, tasks: tasks).tasks
+            client.describe_tasks(cluster: opt[:cluster], tasks: tasks).tasks
           end
         end
 

data/lib/stax/aws/route53.rb

@@ -0,0 +1,51 @@
+module Stax
+  module Aws
+    class Route53 < Sdk
+
+      class << self
+
+        def client
+          @_client ||= ::Aws::Route53::Client.new
+        end
+
+        ## list all zones
+        def zones
+          client.list_hosted_zones.hosted_zones
+        end
+
+        ## list limited number of zones, starting at named zone
+        def zones_by_name(name, max_items = nil)
+          client.list_hosted_zones_by_name(
+            dns_name: name,
+            max_items: max_items,
+          )&.hosted_zones
+        end
+
+        ## get single matching zone, or nil
+        def zone_by_name(name)
+          zones_by_name(name, 1).find do |zone|
+            zone.name == name
+          end
+        end
+
+        ## record sets for named zone
+        def record_sets(opt = {})
+          client.list_resource_record_sets(opt)&.resource_record_sets
+        end
+
+        def record(name, type = :A)
+          zone = name.split('.').last(2).join('.') + '.'
+          Aws::Route53.record_sets(
+            hosted_zone_id: zone_by_name(zone).id,
+            start_record_name: name,
+            start_record_type: type,
+          ).select do |record|
+            (record.name == name) && (record.type == type.to_s)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stax/base.rb

@@ -1,3 +1,5 @@
+require 'stax/aws/sts'
+
 module Stax
   class Base < Thor
 
@@ -14,6 +16,14 @@ module Stax
         @_stack_prefix ||= [app_name, branch_name].compact.join('-') + '-'
       end
 
+      def aws_account_id
+        @_aws_account_id ||= Aws::Sts.id.account
+      end
+
+      def aws_region
+        @_aws_region ||= ENV['AWS_REGION']
+      end
+
       ## find or create a stack object
       def stack(id)
         object = Stax.const_get(id.to_s.capitalize)
@@ -104,6 +114,14 @@ module Stax
         timestamp.nil? ? '-' : Time.at(timestamp.to_i/1000)
       end
 
+      ## convert a diff in seconds to d h m s
+      def human_time_diff(t, n = 5)
+        mm, ss = t.divmod(60)
+        hh, mm = mm.divmod(60)
+        dd, hh = hh.divmod(24)
+        {d: dd, h: hh, m: mm, s: ss}.reject{ |_,v| v == 0 }.map{ |k,v| "#{v.round}#{k}" }.first(n).join
+      end
+
       ## convert bytes to nearest unit
       def human_bytes(bytes, precision = 0)
         return 0.to_s if bytes < 1

data/lib/stax/cfer.rb

@@ -1,18 +1,45 @@
 require 'cfer'
 
+## TODO: remove these hacks once merged and released in upstream cfer
+## see cfer PRs: #52, #54
+module Cfer::Core::Functions
+  def get_azs(region = '')
+    {"Fn::GetAZs" => region}
+  end
+
+  def cidr(ip_block, count, size_mask)
+    {"Fn::Cidr" => [ip_block, count, size_mask]}
+  end
+
+  def import_value(value)
+    {"Fn::ImportValue" => value}
+  end
+
+  def split(*args)
+    {"Fn::Split" => [ *args ].flatten }
+  end
+end
+
+## see cfer PR: #56
+module Cfer::Core
+  class Stack < Cfer::Block
+    def output(name, value, options = {})
+      opt = options.each_with_object({}) { |(k,v),h| h[k.to_s.capitalize] = v } # capitalize all keys
+      export = opt.has_key?('Export') ? {'Name' => opt['Export']} : nil
+      self[:Outputs][name] = opt.merge('Value' => value, 'Export' => export).compact
+    end
+  end
+end
+
 module Stax
   class Stack < Base
     class_option :use_previous_value, aliases: '-u', type: :array, default: [], desc: 'params to use previous value'
 
     no_commands do
 
+      ## backward-compatibility
       def cfer_parameters
-        {}
-      end
-
-      ## location of cfer template file
-      def cfer_template
-        File.join('cf', "#{class_name}.rb")
+        cfn_parameters
       end
 
       ## override with S3 bucket for upload of large templates as needed
@@ -29,37 +56,20 @@ module Stax
         false
       end
 
-      ## create/update the stack
-      def cfer_converge(args = {})
-        opts = {
-          parameters: stringify_keys(cfer_parameters).except(*options[:use_previous_value]),
-          template:   cfer_template,
-          follow:     true,
-          number:     1,
-          s3_path:    cfer_s3_path,
-          notification_arns: cfer_notification_arns,
-          enable_termination_protection: cfer_termination_protection,
-        }
-        Cfer.converge!(stack_name, opts.merge(args))
-      end
-
-      ## generate JSON for stack without sending to cloudformation
-      def cfer_generate
-        opts = {parameters: stringify_keys(cfer_parameters)}
-        Cfer.generate!(cfer_template, opts)
+      ## location of template file
+      def cfn_template_path
+        File.join('cf', "#{class_name}.rb")
       end
 
-      ## generate method does puts, so steal stdout into a string
-      def cfer_generate_string
-        capture_stdout do
-          cfer_generate
-        end
+      def cfer_client
+        @_cfer_client ||= Cfer::Cfn::Client.new({})
       end
 
-      def cfer_tail
-        Cfer.tail!(stack_name, follow: true, number: 1)
-      rescue ::Aws::CloudFormation::Errors::ValidationError => e
-        puts e.message
+      ## generate JSON for stack without sending to cloudformation
+      def cfer_generate
+        Cfer::stack_from_file(cfn_template_path, client: cfer_client, parameters: stringify_keys(cfn_parameters)).to_json
+      rescue Cfer::Util::FileDoesNotExistError => e
+        fail_task(e.message)
       end
 
       ## temporarily grab stdout to a string

data/lib/stax/cli.rb

@@ -2,8 +2,6 @@ require 'stax/aws/cfn'
 
 module Stax
   class Cli < Base
-    include Aws
-
     class_option :branch, type: :string, default: Git.branch, desc: 'git branch to use'
     class_option :app,    type: :string, default: File.basename(Git.toplevel), desc: 'application name'
 
@@ -14,11 +12,11 @@ module Stax
 
     desc 'ls', 'list stacks for this branch'
     def ls
-      print_table Cfn.stacks.select { |s|
+      print_table Aws::Cfn.stacks.select { |s|
         s.stack_name.start_with?(stack_prefix)
       }.map { |s|
-        [s.stack_name, s.creation_time, color(s.stack_status, Cfn::COLORS), s.template_description]
-      }
+        [s.stack_name, s.creation_time, color(s.stack_status, Aws::Cfn::COLORS), s.template_description]
+      }.sort
     end
 
   end

data/lib/stax/meta.rb

@@ -24,6 +24,24 @@ module Stax
       end
     end
 
+    desc 'update', 'meta update task'
+    def update
+      stack_objects.each do |s|
+        if s.exists? && y_or_n?("Update #{s.stack_name}?", :yellow)
+          s.update
+        end
+      end
+    end
+
+    desc 'change', 'meta change task'
+    def change
+      stack_objects.each do |s|
+        if s.exists?
+          s.change
+        end
+      end
+    end
+
     desc 'delete', 'meta delete task'
     def delete
       stack_objects.reverse.each do |s|

data/lib/stax/mixin/asg.rb

@@ -102,7 +102,7 @@ module Stax
       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)
+        opt = options.slice(*%w[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}")

data/lib/stax/mixin/codebuild.rb

@@ -0,0 +1,98 @@
+require 'stax/aws/codebuild'
+
+module Stax
+  module Codebuild
+    def self.included(thor)
+      thor.desc(:codebuild, 'Codebuild subcommands')
+      thor.subcommand(:codebuild, Cmd::Codebuild)
+    end
+
+    def stack_projects
+      @_stack_projects ||= Aws::Cfn.resources_by_type(stack_name, 'AWS::CodeBuild::Project')
+    end
+
+    def stack_project_names
+      @_stack_project_names ||= stack_projects.map(&:physical_resource_id)
+    end
+  end
+
+  module Cmd
+    class Codebuild < SubCommand
+      COLORS = {
+        SUCCEEDED:    :green,
+        FAILED:       :red,
+        FAULT:        :red,
+        CLIENT_ERROR: :red,
+        STOPPED:      :red,
+      }
+
+      no_commands do
+        def print_phase(p)
+          duration = (d = p.duration_in_seconds) ? "#{d}s" : ''
+          status = p.phase_status || (p.phase_type == 'COMPLETED' ? '' : 'in progress')
+          puts "%-16s  %-12s  %4s  %s" % [p.phase_type, color(status, COLORS), duration, p.end_time]
+        end
+      end
+
+      desc 'projects', 'list projects'
+      def projects
+        print_table Aws::Codebuild.projects(my.stack_project_names).map { |p|
+          [p.name, p.source.location, p.environment.image, p.environment.compute_type, p.last_modified]
+        }
+      end
+
+      desc 'builds', 'list builds for stack projects'
+      method_option :number, aliases: '-n', type: :numeric, default: 10, desc: 'number of builds to list'
+      def builds
+        my.stack_project_names.each do |project|
+          debug("Builds for #{project}")
+          ids = Aws::Codebuild.builds_for_project(project, options[:number])
+          print_table Aws::Codebuild.builds(ids).map { |b|
+            duration = human_time_diff(b.end_time - b.start_time)
+            [b.id, b.initiator, color(b.build_status, COLORS), duration, b.end_time]
+          }
+        end
+      end
+
+      desc 'phases [ID]', 'show build phases for given or most recent build'
+      def phases(id = nil)
+        id ||= Aws::Codebuild.builds_for_project(my.stack_project_names.first, 1).first
+        debug("Phases for build #{id}")
+        Aws::Codebuild.builds([id]).first.phases.each(&method(:print_phase))
+      end
+
+      desc 'tail [ID]', 'tail build phases for build'
+      def tail(id = nil)
+        trap('SIGINT', 'EXIT')    # clean exit with ctrl-c
+        id ||= Aws::Codebuild.builds_for_project(my.stack_project_names.first, 1).first
+        debug("Phases for build #{id}")
+        seen = {}
+        loop do
+          (Aws::Codebuild.builds([id]).first.phases || []).each do |p|
+            i = p.phase_type + p.phase_status.to_s
+            print_phase(p) unless seen[i]
+            seen[i] = true
+          end
+          break if seen['COMPLETED']
+          sleep(3)
+        end
+      end
+
+      desc 'start', 'start a build'
+      method_option :project, type: :string, default: nil, desc: 'project to build'
+      method_option :version, type: :string, default: nil, desc: 'source version to build (sha/branch/tag)'
+      def start
+        project = options[:project] || my.stack_project_names.first
+        version = options[:version] || Git.sha
+        debug("Starting build for #{project} #{version}")
+        build = Aws::Codebuild.start(
+          project_name: project,
+          source_version: version,
+        )
+        puts build.id
+        tail build.id
+      end
+
+    end
+  end
+end

data/lib/stax/mixin/codepipeline.rb

@@ -0,0 +1,125 @@
+require 'stax/aws/codepipeline'
+
+module Stax
+  module Codepipeline
+    def self.included(thor)
+      thor.desc(:codepipeline, 'Codepipeline subcommands')
+      thor.subcommand(:codepipeline, Cmd::Codepipeline)
+    end
+
+    def stack_pipelines
+      @_stack_pipelines ||= Aws::Cfn.resources_by_type(stack_name, 'AWS::CodePipeline::Pipeline')
+    end
+
+    def stack_pipeline_names
+      @_stack_pipeline_names ||= stack_pipelines.map(&:physical_resource_id)
+    end
+  end
+
+  module Cmd
+    class Codepipeline < SubCommand
+      COLORS = {
+        Succeeded: :green,
+        Failed:    :red,
+      }
+
+      desc 'stages', 'list pipeline stages'
+      def stages
+        my.stack_pipeline_names.each do |name|
+          debug("Stages for #{name}")
+          print_table Aws::Codepipeline.stages(name).map { |s|
+            actions = s.actions.map{ |a| a&.action_type_id&.provider }.join(' ')
+            [s.name, actions]
+          }
+        end
+      end
+
+      desc 'history', 'pipeline execution history'
+      method_option :number, aliases: '-n', type: :numeric, default: 10, desc: 'number of items'
+      def history
+        my.stack_pipeline_names.each do |name|
+          debug("Execution history for #{name}")
+          print_table Aws::Codepipeline.executions(name, options[:number]).map { |e|
+            r = Aws::Codepipeline.execution(name, e.pipeline_execution_id)&.artifact_revisions&.first
+            age = human_time_diff(Time.now - e.last_update_time, 1)
+            duration = human_time_diff(e.last_update_time - e.start_time)
+            [e.pipeline_execution_id, color(e.status, COLORS), "#{age} ago", duration, r&.revision_id&.slice(0,7) + ':' + r&.revision_summary]
+          }
+        end
+      end
+
+      desc 'state', 'pipeline state'
+      def state
+        my.stack_pipeline_names.each do |name|
+          state = Aws::Codepipeline.state(name)
+          debug("State for #{name} at #{state.updated}")
+          print_table state.stage_states.map { |s|
+            s.action_states.map { |a|
+              l = a.latest_execution
+              percent = (l&.percent_complete || 100).to_s + '%'
+              sha = a.current_revision&.revision_id&.slice(0,7)
+              ago = (t = l&.last_status_change) ? human_time_diff(Time.now - t, 1) : '?'
+              [s.stage_name, a.action_name, color(l&.status || '', COLORS), percent, "#{ago} ago", (sha || l&.token), l&.error_details&.message]
+            }
+          }.flatten(1)
+        end
+      end
+
+      desc 'approvals', 'approve or reject pending approvals'
+      method_option :approved, type: :boolean, default: false, desc: 'approve the request'
+      method_option :rejected, type: :boolean, default: false, desc: 'reject the request'
+      def approvals
+        my.stack_pipeline_names.each do |name|
+          debug("Pending approvals for #{name}")
+          Aws::Codepipeline.state(name).stage_states.each do |s|
+            s.action_states.each do |a|
+              next unless (a.latest_execution&.token && a.latest_execution&.status == 'InProgress')
+              l = a.latest_execution
+              ago = (t = l&.last_status_change) ? human_time_diff(Time.now - t, 1) : '?'
+              puts "#{a.action_name} #{l&.token} #{ago} ago"
+              resp = (options[:approved] && :approved) || (options[:rejected] && :rejected) || ask('approved,rejected,[skip]?', :yellow)
+              status = resp.to_s.capitalize
+              if (status == 'Rejected') || (status == 'Approved')
+                Aws::Codepipeline.client.put_approval_result(
+                  pipeline_name: name,
+                  stage_name: s.stage_name,
+                  action_name: a.action_name,
+                  token: l.token,
+                  result: {status: status, summary: "#{status} by #{ENV['USER']}"},
+                ).tap { |r| puts "#{status} at #{r&.approved_at}" }
+              end
+            end
+          end
+        end
+      end
+
+      desc 'start [NAME]', 'start execution for pipeline'
+      def start(name = nil)
+        name ||= my.stack_pipeline_names.first
+        debug("Starting execution for #{name}")
+        puts Aws::Codepipeline.start(name)
+        tail name
+      end
+
+      desc 'tail [NAME]', 'tail pipeline state changes'
+      def tail(name = nil)
+        trap('SIGINT', 'EXIT')    # clean exit with ctrl-c
+        name ||= my.stack_pipeline_names.first
+        last_seen = nil
+        loop do
+          state = Aws::Codepipeline.state(name)
+          now = Time.now
+          stages = state.stage_states.map do |s|
+            last_change = s.action_states.map { |a| a&.latest_execution&.last_status_change }.compact.max
+            revisions = s.action_states.map { |a| a.current_revision&.revision_id&.slice(0,7) }.join(' ')
+            ago = last_change ? human_time_diff(now - last_change, 1) : '?'
+            [s.stage_name, color(s&.latest_execution&.status || '', COLORS), "#{ago} ago", revisions].join(' ')
+          end
+          puts [set_color(now, :blue), stages].flatten.join('  ')
+          sleep 5
+        end
+      end
+
+    end
+  end
+end