steam_donkey 0.3.0

data/lib/steam_donkey/aws.rb

@@ -0,0 +1,20 @@
+require 'aws-sdk'
+
+def client_options(options)
+  result = {}
+  result[:profile] = options[:profile] if !options[:profile].nil?
+  result[:region]  = options[:region] if !options[:region].nil?
+  result
+end
+
+def cf_client(options)
+  Aws::CloudFormation::Client.new(client_options(options))
+end
+
+def ec2_client(options)
+  Aws::EC2::Client.new(client_options(options))
+end
+
+def s3_client(options)
+  Aws::S3::Client.new(client_options(options))
+end

data/lib/steam_donkey/cli/output.rb

@@ -0,0 +1,62 @@
+require 'command_line_reporter'
+
+module SteamDonkey
+  module Cli
+    class Output
+      include CommandLineReporter
+
+      def initialize(render_headings, format)
+        @format = format
+        @render_headings = render_headings
+      end
+
+      def render(headings, rows)
+        case @format
+          when 'pretty'
+            table do
+              row :header => true  do
+                headings.each do |label|
+                  column label, :width => max_width(rows, label)+ 2, :color => 'blue'
+                end
+              end
+
+              rows.each do |result|
+                row do
+                  headings.each do |label|
+                    value = result.detect { |f| f[:label] == label }[:value]
+                    value = '-' if value.nil?
+                    if value.is_a? Time
+                      value = value.iso8601.to_s
+                    else
+                      value = '-' if value.methods.include? :empty? and value.empty?
+                    end
+                    column value
+                  end
+                end
+              end
+            end
+          else
+            puts headings.join(',') if @render_headings
+            rows.each do |result|
+              puts result.map { |c| c[:value] }.join(',')
+            end
+        end
+      end
+
+      def max_width(results, label)
+        width = results.map do |result|
+          value = result.detect { |f| f[:label] == label }[:value]
+          if value.nil?
+            0
+          elsif value.is_a? Time
+            value.iso8601.to_s.length
+          else
+            value.to_s.length
+          end
+        end
+        width << label.length
+        width.max
+      end
+    end
+  end
+end

data/lib/steam_donkey/cloudformation/deploy_stack.rb

@@ -0,0 +1,15 @@
+module SteamDonkey
+  module Cloudformation
+    class DeployStack
+
+        def initialize(client, options)
+          @client = client
+          @options = options
+        end
+
+        def deploy
+
+        end
+    end
+  end
+end

data/lib/steam_donkey/cloudformation/event_log.rb

@@ -0,0 +1,108 @@
+module SteamDonkey
+  module Cloudformation
+    class EventLog
+
+        def initialize(client, options)
+          @client = client
+          @options = options
+          @events_seen = []
+        end
+
+        BOLD     = "[1m"
+        BLACK    = "[30m"
+        RED      = "[31m"
+        GREEN    = "[32m"
+        YELLOW   = "[33m"
+        BLUE     = "[34m"
+        MAGENTA  = "[35m"
+        CYAN     = "[36m"
+        WHITE    = "[37m"
+
+        def status_colors
+          {
+            "REVIEW_IN_PROGRESS"                           => "\033" + YELLOW,
+
+            "CREATE_IN_PROGRESS"                           => "\033" + YELLOW,
+            "CREATE_FAILED"                                => "\033" + RED,
+            "CREATE_COMPLETE"                              => "\033" + GREEN,
+            
+            "DELETE_IN_PROGRESS"                           => "\033" + RED,
+            "DELETE_FAILED"                                => "\033" + RED,
+            "DELETE_COMPLETE"                              => "\033" + BOLD,
+            "DELETE_SKIPPED"                               => "\033" + BOLD,
+
+            "UPDATE_IN_PROGRESS"                           => "\033" + YELLOW,
+            "UPDATE_FAILED"                                => "\033" + RED,
+            "UPDATE_COMPLETE"                              => "\033" + GREEN,
+            "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"          => "\033" + YELLOW,
+
+            "UPDATE_ROLLBACK_IN_PROGRESS"                  => "\033" + RED,
+            "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS" => "\033" + RED,
+            "UPDATE_ROLLBACK_COMPLETE"                     => "\033" + GREEN
+          }
+        end
+
+        def list
+          printf("%s%-20s  %-44s  %-26s  %s%s\n",
+            "\033[1m", 
+            "Timestamp",
+            "Status",
+            "Resource Type",
+            "Logical Id",
+            "\033[0m"
+          )
+
+          trap("SIGINT") { throw :ctrl_c }
+          catch :ctrl_c do
+            begin
+              events = []
+              stack_events.each do |response|
+                new_events(response).each do |event|
+                  @events_seen << event.event_id
+                  if after_desired_time(event)
+                    events.unshift event
+                  end
+                end
+              end
+              print_events(events)
+              sleep 5 if @options[:follow]
+            end while @options[:follow]
+          end
+        end
+
+        def after_desired_time(event)
+          event.timestamp > @options[:since]
+        end
+
+        def stack_name
+          @options[:stack_name]
+        end
+
+        def stack_events
+          @client.describe_stack_events(:stack_name => stack_name)
+        end
+
+        def new_events(response)
+          response.stack_events.select(&self.method(:is_new?))
+        end
+
+        def is_new?(event) 
+          !@events_seen.include? event.event_id
+        end
+
+        def print_events(events)
+          events.each do |event|
+            # puts "#{event.timestamp.iso8601}"
+            printf("%-20s  %s%-44s%s  %-26s  %s\n",
+                event.timestamp.iso8601,
+                status_colors[event.resource_status], event.resource_status, "\033[0m",
+                event.resource_type,
+                event.logical_resource_id
+            )
+          end
+          STDOUT.flush
+        end
+      
+    end
+  end
+end

data/lib/steam_donkey/cloudformation/exports_listing.rb

@@ -0,0 +1,49 @@
+require 'aws-sdk'
+
+module SteamDonkey
+  module Cloudformation
+    class ExportsListing
+      include SteamDonkey::ResourceListing
+
+      def initialize(client, options = {})
+        @client = client
+        init(options[:sort], options[:filters], options[:columns])
+      end
+
+      def aliases
+        [
+          { test: /^StackId$/i, value: 'ExportingStackId' }
+        ]
+      end
+
+      def search
+        result     = []
+        exports    = @client.list_exports
+        begin
+          last_token = exports.next_token
+          exports.exports.map do |export|
+            result << export
+          end
+          exports = @client.list_exports({ :next_token => exports.next_token })
+        end while last_token != exports.next_token
+
+        result
+      end
+
+      def select_column(column, stack)
+        begin
+          c = column.clone
+          case column[:name]
+            when 'nil'
+            else
+              c[:value] = stack.send(column[:name].underscore)
+          end
+          c
+        rescue
+          raise "Unknown column #{column[:name]}"
+        end
+      end
+
+    end
+  end
+end

data/lib/steam_donkey/cloudformation/package.rb

@@ -0,0 +1,100 @@
+require 'pathname'
+
+module SteamDonkey
+  module Cloudformation
+
+
+    class Template
+
+      def initialize(dirname, filename)
+        @dirname = dirname
+        @filename = filename
+      end
+
+      def path
+        File.join(@dirname, @filename)
+      end
+
+      def name
+        @filename
+      end
+
+      def contains_child_templates?
+        !templates.empty?
+      end
+
+      def templates
+        @child_references ||= scan_for_child_templates path
+      end
+
+      def relative_path(root)
+        template_path = Pathname.new(path)
+        root_path = Pathname.new(root)
+        template_path.relative_path_from(root_path)
+      end
+
+      def packaged_template(bucket, prefix, root_path)
+        lines = []
+        File.readlines(path).each do |line|
+          new_line = line
+          line.scan /\.\/(.+)$/ do |child_path|
+            unless child_path.empty?
+              new_line = line.gsub(/\.\/.+$/, "https://s3-eu-west-1.amazonaws.com/#{bucket}/#{prefix}/#{child_path.first}")
+            end
+          end
+          lines << new_line
+        end
+        lines.join
+      end
+
+    private
+
+      def scan_for_child_templates(template)
+        child_templates = []
+        child_templates << self
+        File.readlines(template).each do |line|
+          line.scan /\.\/(.+)$/ do |child_path|
+            unless child_path.empty?
+              child = create_child_template(child_path.first) 
+              child_templates << child
+              child_templates.push(*(child.templates))
+            end
+          end
+        end
+        child_templates.uniq
+      end
+
+      def create_child_template(path)
+        child_path = File.join(@dirname, path)
+        Template.new File.dirname(child_path), File.basename(child_path)
+      end
+    end
+
+    class Package
+      def initialize(client, quiet, dry_run)
+        @client = client
+        @quiet = quiet || false 
+        @dry_run = dry_run || false
+      end
+
+      def package(path, bucket, prefix)
+        template_dir = File.dirname(File.absolute_path(path))
+        template_name = File.basename(path)
+        
+        root_template = Template.new(template_dir, template_name)
+
+        root_template.templates.each do |template|
+          puts "Uploading s3://#{bucket}/#{prefix}/#{template.relative_path(template_dir)}" unless @quiet
+          @client.put_object({
+            body: template.packaged_template(bucket, prefix, template_dir),
+            bucket: bucket,
+            key: "#{prefix}/#{template.relative_path(template_dir)}"
+          }) unless @dry_run
+        end
+
+        "https://s3-eu-west-1.amazonaws.com/#{bucket}/#{prefix}/#{root_template.name}"
+      end
+
+    end
+  end
+end

data/lib/steam_donkey/cloudformation/stack_listing.rb

@@ -0,0 +1,47 @@
+require 'aws-sdk'
+
+module SteamDonkey
+  module Cloudformation
+    class StackListing
+      include SteamDonkey::ResourceListing
+
+      def initialize(client, options = {})
+        @client = client
+        init(options[:sort], options[:filters], options[:columns])
+      end
+
+      def aliases
+          [
+              { test: /^Id$/i, value: 'StackId' },
+              { test: /^Name$/i, value: 'StackName' },
+              { test: /^Status/i, value: 'StackStatus' },
+              { test: /^StatusReason/i, value: 'StackStatusReason' },
+          ]
+        end
+
+        def search
+          @client.list_stacks.map do |response|
+            response.stack_summaries.map do |stack|
+              stack
+            end
+          end.flatten
+        end
+
+        def select_column(column, stack)
+          begin
+            c = column.clone
+            case column[:name]
+              when /^Tags\./i
+                c[:value] = find_tag(stack, column[:name].split('.').last)
+              else
+                c[:value] = stack.send(column[:name].underscore)
+            end
+            c
+          rescue
+            raise "Unknown column,#{column[:name]}"
+          end
+        end
+      
+    end
+  end
+end

data/lib/steam_donkey/commands/cf.rb

@@ -0,0 +1,102 @@
+require 'chronic'
+
+desc 'Manage and view cloudformation stacks and templates'
+command [:cf] do |cf|
+
+  cf.desc 'List cloudformation stacks'
+  cf.command [:list, :ls] do |list|
+
+  	list.switch [:raw,      :r], :default_value => false, :negatable => false, :desc => "Output unformatted, useful when piping results to other commands"
+  	list.switch [:headings, :h], :default_value => false, :desc => "Toggle column headings"
+
+    list.flag [:filters, :f], :default_value => 'Status=!/DELETE_COMPLETE/', :desc => ""
+    list.flag [:columns, :c], :default_value => 'Name,CreationTime,Status', :desc => ""
+  	list.flag [:sort,    :s], :default_value => 'CreationTime=desc,Name', :desc => ""
+
+    list.flag [:output, :o], :default_value => 'pretty', :must_match => { "pretty"  => :pretty, "raw" => :raw }
+
+    list.action do |global_options, options, args|
+      listing_options = {
+        :filters => options[:filters],
+        :columns => options[:columns],
+        :sort    => options[:sort]
+      }
+
+      stack_listing = SteamDonkey::Cloudformation::StackListing.new(cf_client(global_options), listing_options)
+
+      output = SteamDonkey::Cli::Output.new true, options[:output]
+      output.render stack_listing.column_labels, stack_listing.list
+    end
+  end
+
+  cf.desc 'List stack events'
+  cf.command [:events] do |events|
+
+    events.flag ['stack-name', :s], :arg_name => 'STACK_NAME', :required => true,  :desc => "Stack name"
+    events.switch ['follow', :f],   :default_value => false,   :negatable => false
+
+    events.action do |global_options, options, args|  
+      list_options = {
+        :follow     => options[:follow],
+        :stack_name => options[:'stack-name'],
+        :since      => Chronic.parse("2 years ago")
+      }
+
+      event_log = SteamDonkey::Cloudformation::EventLog.new(cf_client(global_options), list_options)
+      event_log.list
+    end
+  end
+
+  cf.desc 'List cloudformation exports'
+  cf.command [:exports] do |exports|
+
+    exports.switch [:raw,      :r], :default_value => false, :negatable => false, :desc => "Output unformatted, useful when piping results to other commands"
+    exports.switch [:headings, :h], :default_value => false, :desc => "Toggle column headings"
+
+    exports.flag [:filters, :f], :default_value => '', :desc => ""
+    exports.flag [:columns, :c], :default_value => 'Name,Value', :desc => ""
+    exports.flag [:sort,    :s], :default_value => 'Name', :desc => ""
+
+    exports.flag [:output, :o], :default_value => 'pretty', :must_match => { "pretty"  => :pretty, "raw" => :raw }
+
+    exports.action do |global_options, options, args|
+      listing_options = {
+        :filters => options[:filters],
+        :columns => options[:columns],
+        :sort    => options[:sort]
+      }
+
+      exports_listing = SteamDonkey::Cloudformation::ExportsListing.new(cf_client(global_options), listing_options)
+
+      output = SteamDonkey::Cli::Output.new true, options[:output]
+      output.render exports_listing.column_labels, exports_listing.list
+    end
+  end
+
+  cf.desc 'Package cloudformation template and upload to S3'
+  cf.command [:package] do |p|
+
+    p.flag [:template, :t], :required => true, :desc => "Path to template to package and upload"
+    p.flag [:bucket, :b], :desc => "Name of the S3 bucket to upload packaged templates to"
+    p.flag [:prefix, :p], :desc => "Prefix to prepend to uploaded templates"
+    p.switch ['launch-console', :l], :default_value => false, :negatable => false, :desc => "Launch CloudFormation console with uploaded template"
+    p.switch ['dry-run', :d], :default_value => false, :negatable => false
+    p.switch [:quiet, :q], :default_value => false, :negatable => false
+
+    p.action do |global_options, options, args|
+      bucket_name = options[:bucket] || global_options[:rc][:cloudformation][:package]["bucketName"]
+      bucket_path_prefix = options[:prefix] || global_options[:rc][:cloudformation][:package]["bucketPathPrefix"]
+
+      package = SteamDonkey::Cloudformation::Package.new(s3_client(global_options), options[:quiet], options['dry-run'])
+
+      template_url = package.package options[:template], bucket_name, bucket_path_prefix
+
+      puts template_url unless options[:quiet]
+
+      if options['launch-console']
+        `open https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=#{template_url}`
+      end
+    end
+  end
+end
+