broadside 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf7af1a3d95745e8c208d866da7936dcffbc66b9
-  data.tar.gz: db5d5c03f60d77464b536f8505ec5ba1904aaeb2
+  metadata.gz: 3693defb94dc9f5396cf5d5ad907eecd49032c77
+  data.tar.gz: 2dc28e92eb875b2bae69cc4a3a25896eacfe79c7
 SHA512:
-  metadata.gz: 0f06d8a671d93309450ff17b3f289980cde9fbd5374d372656ba954d7036dec2b6f4119994491c72e048b4d5ed26c76a6329f931c439fb05f09689740605f837
-  data.tar.gz: 301976eb3eeec7da29da54a875feec0673c3daabb2883c81001766ba0caa4efb4bfdf4351e2419e6be140deeb686293cf58484ccd35010348c638529923d2c87
+  metadata.gz: 81e4d4e8e4d1afb13f49e0e822119b102a8489c69626e22930e7a160590c328c4f110f910790cca1513a7d18a73748ee0abe8797d60fea12d81ee6e991e4c960
+  data.tar.gz: db75a3e185c21492bb78641e288079e59aa4a602666f513ea0aaabfd7d6245c5e8704ae4f21c3f1f44f628605597a0990d23a329722f97f9c47aba8d60cdedec

data/.gitignore

@@ -0,0 +1,9 @@
+.bundle/
+*.log
+pkg/
+*~
+.env
+.DS_Store
+
+*.gem
+Gemfile.lock

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "broadside.wiki"]
+	path = broadside.wiki
+	url = git@github.com:lumoslabs/broadside.wiki.git

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,13 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.1.6
+cache: bundler
+script:
+  - bundle exec rspec
+branches:
+  except:
+    - /^production_release_\d+$/
+    - /^staging_release_\d+$/
+notifications:
+  email: false

data/AUTHORS

@@ -0,0 +1,4 @@
+Cameron Dutro <camertron@gmail.com>
+Jay O'Connor <jay@jayoconnor.com>
+Matthew Leung <leung.mattp@gmail.com>
+Rob Froetscher <rfroetscher@lumoslabs.com>

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 1.0.0
+- Initial release.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in broadside.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Lumos Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Broadside
+A command-line tool for deploying applications on AWS EC2 Container Service (ECS)
+
+This tool is primarily intended for use with ruby applications.
+
+
+## Overview
+Amazon ECS presents a low barrier to entry for production-level docker applications. Combined with ECS's built-in blue-green deployment, Elastic Load Balancers, Autoscale Groups, and CloudWatch, one can set up a robust cluster that can scale to serve any number of applications in a short amount of time. Broadside seeks to leverage these benefits and improve the deployment process for developers.
+
+Broadside offers a simple command-line interface to perform deployments on ECS. It does not attempt to handle operational tasks like infrastructure setup and configuration, which are better suited for tools like [terraform](https://www.terraform.io/). This allows applications using broadside to employ a clean configuration file that looks something like:
+
+```ruby
+Broadside.configure do |config|
+  config.base.application = 'hello_world'
+  config.base.docker_image = 'lumoslabs/hello_world'
+  config.deploy.type = 'ecs'
+  config.ecs.cluster = 'micro-cluster'
+  config.deploy.targets = {
+    production_web: {
+      scale: 7,
+      command: ['bundle', 'exec', 'unicorn', '-c', 'config/unicorn.conf.rb'],
+      env_file: '../.env.production'
+      predeploy_commands: [
+        ['bundle', 'exec', 'rake', 'db:migrate'],
+        ['bundle', 'exec', 'rake', 'data:migrate']
+      ]
+    },
+    production_worker: {
+      scale: 15,
+      command: ['bundle', 'exec', 'rake', 'resque:work'],
+      env_file: '../.env.production'
+    }
+    staging_web: {
+      scale: 1,
+      command: ['bundle', 'exec', 'puma'],
+      env_file: '../.env.staging'
+    }
+    staging_worker: {
+      scale: 1,
+      command: ['bundle', 'exec', 'rake', 'resque:work'],
+      env_file: '../.env.staging'
+    }
+  }
+end
+```
+
+From here, developers can use broadside's command-line interface to initiate a basic deployment:
+```
+broadside deploy short --target production_web --tag $GIT_SHA
+```
+or run
+```
+broadside deploy full --target production_web --tag $GIT_SHA
+```
+which will run the listed `predeploy_commands` listed in the config above prior to the deployment.
+
+In the case of an error or timeout during a deploy, broadside will automatically rollback to the latest stable version. You can perform manual rollbacks as well through the command-line.
+
+See the complete command-line reference in the wiki.
+
+
+## Setup
+First, install broadside by adding it to your application gemfile:
+```
+gem 'broadside'
+```
+
+Then run
+```
+bundle install
+bundle binstubs broadside
+```
+
+It's recommended that you specify broadside as a development gem so it doesn't inflate your production image.
+
+You can now run the executable in your app directory:
+```
+bin/broadside --help
+```
+
+For a full application setup, see the detailed instructions in the wiki.
+
+
+## Contributing
+Pull requests, bug reports, and feature suggestions are welcome! Before starting on a contribution, I recommend opening an issue or replying to an existing one to give others some initial context on the work needing to be done.
+
+1. Create your feature branch (`git checkout -b my-new-feature`)
+2. Commit your changes (`git commit -am 'Add some feature'`)
+3. Push to the branch (`git push origin my-new-feature`)
+4. Create a new Pull Request

data/bin/broadside

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+
+require 'gli'
+require 'broadside'
+
+include GLI::App
+include Broadside::Utils
+
+program_desc 'A command-line tool for deployment and development of docker applications.'
+
+version Broadside::VERSION
+
+subcommand_option_handling :normal
+arguments :strict
+synopsis_format :full
+
+desc 'Configuration file to use.'
+default_value 'config/broadside.conf.rb'
+arg_name 'FILE'
+flag [:c, :config]
+
+def add_shared_deploy_configs(subcmd)
+  # deployment always requires target
+  subcmd.desc 'Deployment target to use, e.g. production_web'
+  subcmd.arg_name 'TARGET'
+  subcmd.flag [:t, :target], type: Symbol
+
+  subcmd.action do |global_options, options, args|
+    _DeployObj = Kernel.const_get("Broadside::#{Broadside.config.deploy.type.capitalize}Deploy")
+    _DeployObj.new(options).send(subcmd.name)
+  end
+end
+
+# GLI type coercions
+accept Symbol do |val|
+  val.to_sym
+end
+accept Array do |val|
+  val.split(' ')
+end
+accept Fixnum do |val|
+  val.to_i
+end
+
+desc 'Deploy your application.'
+command :deploy do |d|
+  d.desc 'Deploys without running migrations'
+  d.command :short do |subcmd|
+    subcmd.desc 'Docker tag for application container'
+    subcmd.arg_name 'TAG'
+    subcmd.flag [:tag]
+
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Performs a full deployment (with migration)'
+  d.command :full do |subcmd|
+    subcmd.desc 'Docker tag for application container'
+    subcmd.arg_name 'TAG'
+    subcmd.flag [:tag]
+
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Scales application to a given count'
+  d.command :scale do |subcmd|
+    subcmd.desc 'Specify a new scale for application'
+    subcmd.arg_name 'NUM'
+    subcmd.flag [:s, :scale], type: Fixnum
+
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Creates a single instance of the application to run a command.'
+  d.command :run do |subcmd|
+    subcmd.desc 'Docker tag for application container'
+    subcmd.arg_name 'TAG'
+    subcmd.flag [:tag]
+
+    subcmd.desc 'Command to run (wrap argument in quotes)'
+    subcmd.arg_name 'COMMAND'
+    subcmd.flag [:command], type: Array
+
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Rolls back n releases and deploys'
+  d.command :rollback do |subcmd|
+    subcmd.desc 'Number of releases to rollback'
+    subcmd.arg_name 'COUNT'
+    subcmd.flag [:r, :rollback], type: Fixnum
+
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Gets information about what is currently deployed.'
+  d.command :status do |subcmd|
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Tail the logs inside the running container.'
+  d.command :logtail do |subcmd|
+    subcmd.desc '0-based instance index'
+    subcmd.default_value '0'
+    subcmd.arg_name 'INSTANCE'
+    subcmd.flag [:n, :instance], type: Fixnum
+
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Establish a secure shell on the instance running the container.'
+  d.command :ssh do |subcmd|
+    subcmd.desc '0-based instance index'
+    subcmd.default_value '0'
+    subcmd.arg_name 'INSTANCE'
+    subcmd.flag [:n, :instance], type: Fixnum
+
+    add_shared_deploy_configs(subcmd)
+  end
+
+  d.desc 'Establish a shell inside the running container.'
+  d.command :bash do |subcmd|
+    subcmd.desc '0-based instance index'
+    subcmd.default_value '0'
+    subcmd.arg_name 'INSTANCE'
+    subcmd.flag [:n, :instance], type: Fixnum
+
+    add_shared_deploy_configs(subcmd)
+  end
+end
+
+def call_hook(type, command)
+  hook = Broadside.config.base.send(type)
+  if hook.is_a?(Proc)
+    hook_args =
+      if command.parent.is_a?(GLI::Command)
+        {
+          command: command.parent.name,
+          subcommand: command.name
+        }
+      else
+        { command: command.name }
+      end
+    debug "Calling", type, "with args", hook_args
+    hook.call(hook_args)
+  end
+end
+
+pre do |global, command, options, args|
+  Broadside.load_config(global[:config])
+
+  call_hook(:prehook, command)
+  true
+end
+
+post do |global, command, options, args|
+  call_hook(:posthook, command)
+  true
+end
+
+
+on_error do |exception|
+  # false skips default error handling
+  case exception
+  when Broadside::MissingVariableError
+    error exception.message, "\nRun your last command with --help for more information."
+    false
+  else
+    true
+  end
+end
+
+exit run(ARGV)

data/broadside.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'broadside/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'broadside'
+  spec.version       = Broadside::VERSION
+  spec.authors       = ['Matthew Leung']
+  spec.email         = ['leung.mattp@gmail.com']
+
+  spec.summary       = 'A command-line tool for EC2 Container Service deployment.'
+  spec.homepage      = 'https://github.com/lumoslabs/broadside'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = ['broadside']
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'aws-sdk', '~> 2.2.7'
+  spec.add_dependency 'rainbow', '~> 2.1'
+  spec.add_dependency 'gli', '~> 2.13'
+  spec.add_dependency 'dotenv', '>= 0.9.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'fakefs'
+end

data/lib/broadside.rb

@@ -0,0 +1,48 @@
+require 'broadside/error'
+require 'broadside/utils'
+require 'broadside/configuration'
+require 'broadside/configuration/struct'
+require 'broadside/configuration/aws'
+require 'broadside/configuration/base'
+require 'broadside/configuration/deploy'
+require 'broadside/configuration/ecs'
+require 'broadside/deploy'
+require 'broadside/deploy/ecs'
+require 'broadside/version'
+
+module Broadside
+  extend Utils
+
+  SYSTEM_CONFIG_FILE = "#{Dir.home}/.broadside/config.rb"
+
+  def self.configure
+    yield config
+  end
+
+  def self.load_config(config_file)
+    begin
+      load SYSTEM_CONFIG_FILE if File.exists?(SYSTEM_CONFIG_FILE)
+    rescue LoadError => e
+      error "Encountered an error loading system configuration file '#{SYSTEM_CONFIG_FILE}' !"
+      raise e
+    end
+
+    begin
+      load config_file
+      config.file = config_file
+    rescue LoadError => e
+      error "Encountered an error loading required configuration file '#{config_file}' !"
+      raise e
+    end
+
+    config.verify
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.reset!
+    @config = nil
+  end
+end

data/lib/broadside/configuration.rb

@@ -0,0 +1,32 @@
+module Broadside
+  class Configuration
+    include Utils
+
+    attr_accessor :base, :deploy, :ecs, :aws, :file
+
+    def initialize
+      @base = BaseConfig.new
+    end
+
+    def deploy
+      @deploy ||= DeployConfig.new
+    end
+
+    def aws
+      @aws ||= AwsConfig.new
+    end
+
+    def ecs
+      @ecs ||= EcsConfig.new
+    end
+
+    def verify
+      @base.verify(:application, :docker_image)
+    end
+
+    def method_missing(m, *args, &block)
+      warn "Unknown configuration '#{m}' provided, ignoring. Check your version of broadside?"
+      ConfigStruct.new
+    end
+  end
+end

data/lib/broadside/configuration/aws.rb

@@ -0,0 +1,14 @@
+require 'aws-sdk'
+
+module Broadside
+  class Configuration
+    class AwsConfig < ConfigStruct
+      attr_accessor :region, :credentials
+
+      def initialize
+        @region = 'us-east-1'
+        @credentials = Aws::SharedCredentials.new.credentials
+      end
+    end
+  end
+end

data/lib/broadside/configuration/base.rb

@@ -0,0 +1,19 @@
+require 'logger'
+
+module Broadside
+  class Configuration
+    class BaseConfig < ConfigStruct
+      attr_accessor :application, :git_repo, :docker_image, :logger, :loglevel, :prehook, :posthook
+
+      def initialize
+        @application = nil
+        @docker_image = nil
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::DEBUG
+        @logger.datetime_format = '%Y-%m-%d_%H:%M:%S'
+        @prehook = nil
+        @posthook = nil
+      end
+    end
+  end
+end

data/lib/broadside/configuration/deploy.rb

@@ -0,0 +1,114 @@
+require 'dotenv'
+require 'pathname'
+
+module Broadside
+  class Configuration
+    class DeployConfig < ConfigStruct
+      include Utils
+
+      DEFAULT_PREDEPLOY_COMMANDS = [
+        ['bundle', 'exec', 'rake', '--trace', 'db:migrate']
+      ]
+
+      attr_accessor(
+        :type,
+        :tag,
+        :ssh,
+        :rollback,
+        :timeout,
+        :target,
+        :targets,
+        :scale,
+        :env_vars,
+        :command,
+        :instance,
+        :predeploy_commands
+      )
+
+      TARGET_ATTRIBUTE_VALIDATIONS = {
+        scale: ->(target_attribute) { validate_types([Fixnum], target_attribute) },
+        env_file: ->(target_attribute) { validate_types([String], target_attribute) },
+        command: ->(target_attribute) { validate_types([Array, NilClass], target_attribute) },
+        predeploy_commands: ->(target_attribute) { validate_predeploy(target_attribute) }
+      }
+
+      def initialize
+        @type = 'ecs'
+        @ssh = nil
+        @tag = nil
+        @rollback = 1
+        @timeout = 600
+        @target = nil
+        @targets = nil
+        @scale = nil
+        @env_vars = nil
+        @command = nil
+        @predeploy_commands = DEFAULT_PREDEPLOY_COMMANDS
+        @instance = 0
+      end
+
+      # Validates format of deploy targets
+      # Checks existence of provided target
+      def validate_targets!
+        @targets.each do |target, configuration|
+          TARGET_ATTRIBUTE_VALIDATIONS.each do |var, validation|
+            message = validation.call(configuration[var])
+
+            unless message.nil?
+              exception "Deploy target '#{@target}' parameter '#{var}' is invalid: #{message}"
+            end
+          end
+        end
+
+        unless @targets.has_key?(@target)
+          exception "Could not find deploy target #{@target} in configuration !"
+        end
+      end
+
+      # Loads deploy target data using provided target
+      def load_target!
+        validate_targets!
+
+        env_file = Pathname.new(@targets[@target][:env_file])
+
+        unless env_file.absolute?
+          dir = config.file.nil? ? Dir.pwd : Pathname.new(config.file).dirname
+          env_file = env_file.expand_path(dir)
+        end
+
+        if env_file.exist?
+          vars = Dotenv.load(env_file)
+          @env_vars = vars.map { |k,v| {'name'=> k, 'value' => v } }
+        else
+          exception "Could not find file '#{env_file}' for loading environment variables !"
+        end
+
+        @scale ||= @targets[@target][:scale]
+        @command = @targets[@target][:command]
+        @predeploy_commands = @targets[@target][:predeploy_commands] if @targets[@target][:predeploy_commands]
+      end
+
+      private
+
+      def self.validate_types(types, target_attribute)
+        unless types.include?(target_attribute.class)
+          return "'#{target_attribute}' must be of type [#{types.join('|')}], got '#{target_attribute.class}' !"
+        end
+
+        nil
+      end
+
+      def self.validate_predeploy(target_attribute)
+        return nil if target_attribute.nil?
+
+        return 'predeploy_commands must be an array' unless target_attribute.is_a?(Array)
+
+        target_attribute.each do |command|
+          return "predeploy_command '#{command}' must be an array" unless command.is_a?(Array)
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/broadside/configuration/ecs.rb

@@ -0,0 +1,12 @@
+module Broadside
+  class Configuration
+    class EcsConfig < ConfigStruct
+      attr_accessor :cluster, :poll_frequency
+
+      def initialize
+        @cluster = nil
+        @poll_frequency = 2
+      end
+    end
+  end
+end

data/lib/broadside/configuration/struct.rb

@@ -0,0 +1,24 @@
+module Broadside
+  class Configuration
+    class ConfigStruct
+      def verify(*args)
+        args.each do |var|
+          if self.send(var).nil?
+            raise Broadside::MissingVariableError, "Missing required #{self.class.to_s.split("::").last} variable '#{var}' !"
+          end
+        end
+      end
+
+      def to_h
+        self.instance_variables.inject({}) do |h, var|
+          h[var] = self.instance_variable_get(var)
+          h
+        end
+      end
+
+      def method_missing(m, *args, &block)
+        warn "Unknown configuration '#{m}' provided, ignoring. Check your version of broadside?"
+      end
+    end
+  end
+end

data/lib/broadside/deploy.rb

@@ -0,0 +1,106 @@
+module Broadside
+  class Deploy
+    include Utils
+
+    attr_accessor :deploy_config
+
+    def initialize(opts)
+      @deploy_config = Broadside.config.deploy.dup
+      @deploy_config.tag = opts[:tag]           || @deploy_config.tag
+      @deploy_config.target = opts[:target]     || @deploy_config.target
+      @deploy_config.verify(:target, :targets)
+      @deploy_config.load_target!
+
+      @deploy_config.scale = opts[:scale]       || @deploy_config.scale
+      @deploy_config.rollback = opts[:rollback] || @deploy_config.rollback
+      @deploy_config.instance = opts[:instance] || @deploy_config.instance
+      @deploy_config.command = opts[:command]   || @deploy_config.command
+    end
+
+    def short
+      deploy
+    end
+
+    def full
+      run_predeploy
+      deploy
+    end
+
+    def deploy
+      @deploy_config.verify(:tag)
+      info "Deploying #{image_tag} to #{family}..."
+      yield
+      info 'Deployment complete.'
+    end
+
+    def rollback(count = @deploy_config.rollback)
+      @deploy_config.verify(:rollback)
+      info "Rolling back #{@deploy_config.rollback} release for #{family}..."
+      yield
+      info 'Rollback complete.'
+    end
+
+    def scale
+      info "Rescaling #{family} with scale=#{@deploy_config.scale}"
+      yield
+      info 'Rescaling complete.'
+    end
+
+    def run
+      @deploy_config.verify(:tag, :ssh, :command)
+      info "Running command [#{@deploy_config.command}] for #{family}..."
+      yield
+      info 'Complete.'
+    end
+
+    def run_predeploy
+      @deploy_config.verify(:tag, :ssh)
+      info "Running predeploy commands for #{family}..."
+      yield
+      info 'Predeploy complete.'
+    end
+
+    def status
+      info "Getting status information about #{family}"
+      yield
+      info 'Complete.'
+    end
+
+    def logtail
+      @deploy_config.verify(:instance)
+      yield
+    end
+
+    def ssh
+      @deploy_config.verify(:instance)
+      yield
+    end
+
+    def bash
+      @deploy_config.verify(:instance)
+      yield
+    end
+
+    protected
+
+    def family
+      "#{config.base.application}_#{@deploy_config.target}"
+    end
+
+    def image_tag
+      "#{config.base.docker_image}:#{@deploy_config.tag}"
+    end
+
+    def gen_ssh_cmd(ip, options = { tty: false })
+      opts = @deploy_config.ssh
+      cmd = 'ssh -o StrictHostKeyChecking=no'
+      cmd << ' -t -t' if options[:tty]
+      cmd << " -i #{opts[:keyfile]}" if opts[:keyfile]
+      if opts[:proxy]
+        cmd << " -o ProxyCommand=\"ssh #{opts[:proxy][:host]} nc #{ip} #{opts[:proxy][:port]}\""
+      end
+      cmd << " #{opts[:user]}@#{ip}"
+      cmd
+    end
+  end
+end

data/lib/broadside/deploy/ecs.rb

@@ -0,0 +1,322 @@
+require 'aws-sdk'
+require 'open3'
+require 'pp'
+require 'rainbow'
+require 'shellwords'
+
+module Broadside
+  class EcsDeploy < Deploy
+    def initialize(opts)
+      super(opts)
+      config.ecs.verify(:cluster, :poll_frequency)
+      check_service_existence
+    end
+
+    def deploy
+      super do
+        update_task
+
+        begin
+          update_service
+        rescue SignalException::Interrupt
+          error 'Caught interrupt signal, rolling back...'
+          rollback(1)
+          error 'Deployment did not finish successfully.'
+          abort
+        rescue StandardError => e
+          error e.inspect, "\n", e.backtrace.join("\n")
+          error 'Deploy failed! Rolling back...'
+          rollback(1)
+          error 'Deployment did not finish successfully.'
+          abort
+        end
+      end
+    end
+
+    def rollback(count = @deploy_config.rollback)
+      super do
+        begin
+          deregister_tasks(count)
+          update_service
+        rescue StandardError => e
+          error 'Rollback failed to complete!'
+          raise e
+        end
+      end
+    end
+
+    def scale
+      super do
+        update_service
+      end
+    end
+
+    def run
+      super do
+        update_task
+
+        begin
+          run_command(@deploy_config.command)
+        ensure
+          deregister_tasks(1)
+        end
+      end
+    end
+
+    # runs before deploy commands using the latest task definition
+    def run_predeploy
+      super do
+        update_task
+
+        begin
+          @deploy_config.predeploy_commands.each do |command|
+            run_command(command)
+          end
+        ensure
+          deregister_tasks(1)
+        end
+      end
+    end
+
+    def status
+      super do
+        td = get_latest_task_def
+        ips = get_running_instance_ips
+        info "\n---------------",
+          "\nDeployed task definition information:\n",
+          Rainbow(PP.pp(td, '')).blue,
+          "\nPrivate ips of instances running containers:\n",
+          Rainbow(ips.join(' ')).blue,
+          "\n\nssh command:\n#{Rainbow(gen_ssh_cmd(ips.first)).cyan}",
+          "\n---------------\n"
+      end
+    end
+
+    def logtail
+      super do
+        ip = get_running_instance_ip_at_index!(@deploy_config.instance)
+        debug "Tailing logs for running container at ip #{ip}..."
+        search_pattern = Shellwords.shellescape(family)
+        cmd = "docker logs -f --tail=10 `docker ps -n 1 --quiet --filter name=#{search_pattern}`"
+        tail_cmd = gen_ssh_cmd(ip) + " '#{cmd}'"
+        exec tail_cmd
+      end
+    end
+
+    def ssh
+      super do
+        ip = get_running_instance_ip_at_index!(@deploy_config.instance)
+        debug "Establishing an SSH connection to ip #{ip}..."
+        exec gen_ssh_cmd(ip)
+      end
+    end
+
+    def bash
+      super do
+        ip = get_running_instance_ip_at_index!(@deploy_config.instance)
+        debug "Running bash for running container at ip #{ip}..."
+        search_pattern = Shellwords.shellescape(family)
+        cmd = "docker exec -i -t `docker ps -n 1 --quiet --filter name=#{search_pattern}` bash"
+        bash_cmd = gen_ssh_cmd(ip, tty: true) + " '#{cmd}'"
+        exec bash_cmd
+      end
+    end
+
+    private
+
+    def get_running_instance_ip_at_index(index)
+      ips = get_running_instance_ips
+      ips.size > index ? ips[index] : false
+    end
+
+    def get_running_instance_ip_at_index!(index)
+      ip = get_running_instance_ip_at_index(index)
+      return ip if ip
+      exception 'Instance index greater than available instance count.'
+    end
+
+    # removes latest n task definitions
+    def deregister_tasks(count)
+      task_definition_ids = ecs_client.list_task_definitions({family_prefix: family}).task_definition_arns
+      task_definition_ids.last(count).each do |td_id|
+        ecs_client.deregister_task_definition({task_definition: td_id})
+        debug "Deregistered #{td_id}"
+      end
+    end
+
+    # creates a new task revision using current directory's env vars and provided tag
+    def update_task
+      debug "Creating a new task definition..."
+      new_task_def = create_new_task_revision
+
+      #TODO instead of first, use select to cover task defs w multiple containers
+      new_task_def[:container_definitions].first[:environment] = @deploy_config.env_vars
+      new_task_def[:container_definitions].first[:image] = image_tag
+      new_task_def[:container_definitions].first[:command] = @deploy_config.command
+      new_task_def_id = ecs_client.register_task_definition(new_task_def).task_definition.task_definition_arn
+      debug "Successfully created #{new_task_def_id}"
+    end
+
+    # reloads the service using the latest task definition
+    def update_service
+      td = get_latest_task_def_id
+      debug "Updating #{family} with scale=#{@deploy_config.scale} using task #{td}..."
+      resp =  ecs_client.update_service({
+        cluster: config.ecs.cluster,
+        service: family,
+        task_definition: get_latest_task_def_id,
+        desired_count: @deploy_config.scale
+      })
+      if resp.successful?
+        begin
+          ecs_client.wait_until(:services_stable, {cluster: config.ecs.cluster, services: [family]}) do |w|
+            w.max_attempts = @deploy_config.timeout.nil? ? @deploy_config.timeout : @deploy_config.timeout / config.ecs.poll_frequency
+            w.delay = config.ecs.poll_frequency
+            seen_event = nil
+            w.before_wait do |attempt, response|
+              debug "(#{attempt}/#{w.max_attempts}) Polling ECS for events..."
+              # skip first event since it doesn't apply to current request
+              if response.services[0].events.first &&
+                  response.services[0].events.first.id != seen_event &&
+                  attempt > 1
+                seen_event = response.services[0].events.first.id
+                debug(response.services[0].events.first.message)
+              end
+            end
+          end
+        rescue Aws::Waiters::Errors::TooManyAttemptsError
+          exception 'Deploy did not finish in the expected amount of time.'
+        end
+      else
+        exception 'Failed to update service during deploy.'
+      end
+    end
+
+    def run_command(command)
+      command_name = command.join(' ')
+      resp = ecs_client.run_task({
+        cluster: config.ecs.cluster,
+        task_definition: get_latest_task_def_id,
+        overrides: {
+          container_overrides: [
+            {
+              name: family,
+              command: command
+            },
+          ],
+        },
+        count: 1,
+        started_by: "before_deploy:#{command_name}"[0...36]
+      })
+      if resp.successful?
+        task_id = resp.tasks[0].task_arn
+        debug "Launched #{command_name} task #{task_id}"
+        debug "Waiting for #{command_name} to complete..."
+        ecs_client.wait_until(:tasks_stopped, {cluster: config.ecs.cluster, tasks: [task_id]}) do |w|
+          w.max_attempts = nil
+          w.delay = config.ecs.poll_frequency
+          w.before_attempt do |attempt|
+            debug "Attempt #{attempt}: waiting for #{command_name} to complete..."
+          end
+        end
+        debug 'Task finished running, getting logs...'
+        info "#{command_name} task container logs:\n#{get_container_logs(task_id)}"
+        if(code = get_task_exit_code(task_id)) == 0
+          debug "#{command_name} task #{task_id} exited with status code 0"
+        else
+          exception "#{command_name} task #{task_id} exited with a non-zero status code #{code}!"
+        end
+      else
+        raise "Failed to run #{command_name} task."
+      end
+    end
+
+    def get_container_logs(task_id)
+      ip = get_running_instance_ips(task_id).first
+      debug "Found ip of container instance: #{ip}"
+
+      find_container_id_cmd = "#{gen_ssh_cmd(ip)} \"docker ps -aqf 'label=com.amazonaws.ecs.task-arn=#{task_id}'\""
+      debug "Running command to find container id:\n#{find_container_id_cmd}"
+      container_id = `#{find_container_id_cmd}`.strip
+
+      get_container_logs_cmd = "#{gen_ssh_cmd(ip)} \"docker logs #{container_id}\""
+      debug "Running command to get logs of container #{container_id}:",
+        "\n#{get_container_logs_cmd}"
+
+      logs = nil
+      Open3.popen3(get_container_logs_cmd) do |_, stdout, stderr, _|
+        logs = "STDOUT:--\n#{stdout.read}\nSTDERR:--\n#{stderr.read}"
+      end
+      logs
+    end
+
+    def get_task_exit_code(task_id)
+      task = ecs_client.describe_tasks({cluster: config.ecs.cluster, tasks: [task_id]}).tasks.first
+      task.containers.first.exit_code
+    end
+
+    def get_running_instance_ips(task_ids = nil)
+      task_arns = nil
+      if task_ids.nil?
+        task_arns = ecs_client.list_tasks({cluster: config.ecs.cluster, family: family}).task_arns
+        if task_arns.empty?
+          exception "No running tasks found for '#{family}' on cluster '#{config.ecs.cluster}' !"
+        end
+      elsif task_ids.class == String
+        task_arns = [task_ids]
+      else
+        task_arns = task_ids
+      end
+
+      tasks = ecs_client.describe_tasks({cluster: config.ecs.cluster, tasks: task_arns}).tasks
+      container_instance_arns = tasks.map { |t| t.container_instance_arn }
+      container_instances = ecs_client.describe_container_instances({
+        cluster: config.ecs.cluster, container_instances: container_instance_arns
+      }).container_instances
+      ec2_instance_ids = container_instances.map { |ci| ci.ec2_instance_id }
+      reservations = ec2_client.describe_instances({instance_ids: ec2_instance_ids}).reservations
+      instances = reservations.map { |r| r.instances }.flatten
+      private_ips = instances.map { |i| i.private_ip_address }
+      private_ips
+    end
+
+    def get_latest_task_def
+      ecs_client.describe_task_definition({task_definition: get_latest_task_def_id}).task_definition.to_h
+    end
+
+    def get_latest_task_def_id
+      task_defs = ecs_client.list_task_definitions({family_prefix: family})
+      task_defs.task_definition_arns.last
+    end
+
+    def create_new_task_revision
+      task_def = get_latest_task_def
+      task_def.delete(:task_definition_arn)
+      task_def.delete(:requires_attributes)
+      task_def.delete(:revision)
+      task_def.delete(:status)
+      task_def
+    end
+
+    def ecs_client
+      @ecs_client ||= Aws::ECS::Client.new({
+        region: config.aws.region,
+        credentials: config.aws.credentials
+      })
+    end
+
+    def ec2_client
+      @ec2_client ||= Aws::EC2::Client.new({
+        region: config.aws.region,
+        credentials: config.aws.credentials
+      })
+    end
+
+    def check_service_existence
+      resp = ecs_client.describe_services({cluster: config.ecs.cluster, services: [family]})
+      unless resp.failures.empty?
+        exception "Could not find ECS service '#{family}' in cluster '#{config.ecs.cluster}' !"
+      end
+    end
+  end
+end

data/lib/broadside/error.rb

@@ -0,0 +1,10 @@
+module Broadside
+  class MissingVariableError < StandardError
+  end
+
+  class Error < StandardError
+    def initialize(msg = 'Broadside encountered an error !')
+      super
+    end
+  end
+end

data/lib/broadside/utils.rb

@@ -0,0 +1,27 @@
+module Broadside
+  module Utils
+    def debug(*args)
+      config.base.logger.debug(args.join(' '))
+    end
+
+    def info(*args)
+      config.base.logger.info(args.join(' '))
+    end
+
+    def warn(*args)
+      config.base.logger.warn(args.join(' '))
+    end
+
+    def error(*args)
+      config.base.logger.error(args.join(' '))
+    end
+
+    def exception(*args)
+      raise Broadside::Error, args.join(' ')
+    end
+
+    def config
+      Broadside.config
+    end
+  end
+end

data/lib/broadside/version.rb

@@ -0,0 +1,3 @@
+module Broadside
+  VERSION = '1.0.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: broadside
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
-- matl33t
+- Matthew Leung
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-22 00:00:00.000000000 Z
+date: 2016-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.2.7
 - !ruby/object:Gem::Dependency
-  name: colorize
+  name: rainbow
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.7
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.7
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: gli
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,13 +94,51 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
-- mleung@lumoslabs.com
-executables: []
+- leung.mattp@gmail.com
+executables:
+- broadside
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".rspec"
+- ".travis.yml"
+- AUTHORS
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- bin/broadside
+- broadside.gemspec
+- lib/broadside.rb
+- lib/broadside/configuration.rb
+- lib/broadside/configuration/aws.rb
+- lib/broadside/configuration/base.rb
+- lib/broadside/configuration/deploy.rb
+- lib/broadside/configuration/ecs.rb
+- lib/broadside/configuration/struct.rb
+- lib/broadside/deploy.rb
+- lib/broadside/deploy/ecs.rb
+- lib/broadside/error.rb
+- lib/broadside/utils.rb
+- lib/broadside/version.rb
 homepage: https://github.com/lumoslabs/broadside
 licenses:
 - MIT
@@ -110,5 +162,5 @@ rubyforge_project:
 rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
-summary: A command-line tool for deployment using docker. Coming soon.
+summary: A command-line tool for EC2 Container Service deployment.
 test_files: []