broadside 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1de9e1e538f010d28635f3fa1729f4ea8325583f
-  data.tar.gz: c7c2c7d1a3dc580a76a9e4793509ad1eff6f9e68
+  metadata.gz: fc1d69217accd3c37cde3f4a27955021c62b7b75
+  data.tar.gz: 4806175370a4a5254a3da35d33bcd6cad2b7e504
 SHA512:
-  metadata.gz: 73310a4a5dbd7bd54cf6a9dfbd93933acd91ba8b050c947b1726d89f45ac19f4155f15e82cdd556416168919fd15336dbd6946b99ac24caaf1d82d69c49bf8f9
-  data.tar.gz: 3ab6ffad553c01486c59ce3e27fa7446ace9e9ec9a5124aad6c168049be839fe5e0ab0994e42a7841a4749aeb1e91516d3b07f05c84036023f5a0b07aeaf0549
+  metadata.gz: b123680b578397bc830e20099d47c364071ad2810f71594433fea4eef52280e23baa144c186cc166f9e13eff01799a3e0bc7efbaf39ccef9545efa65747c810f
+  data.tar.gz: fa3b8ee635ca551c74ee41e2f0f57198b8a97469f1c1298c2a2af827fdb4adaa06085f274faf8e9a82037930cacd97ef00b97223c9c8938f9953dfc83aad6ac6

data/CHANGELOG.md

@@ -1,5 +1,12 @@
+# 2.0.0
+- **BREAKING CHANGE** `rake db:migrate` is no longer the default `predeploy_command`
+- `Target` is a first class object
+- `Deploy` is composed of a `Target` plus command line options
+- There is no more `base` configuration - the main `Configuration` object holds all the `base` config.  You can still call `Broadside.config.base` though you will get a deprecation warning.
+- There is no more `deploy` configuration - most of that is handled in the main `Configuration` object and in `targets=`. You can still call `Broadside.config.deploy` though you will get a deprecation warning.
+
 # 1.4.0
-= [#42](https://github.com/lumoslabs/broadside/pull/42/files): Update the task definition when running bootstrap
+- [#42](https://github.com/lumoslabs/broadside/pull/42/files): Update the task definition when running bootstrap
 
 # 1.3.0
 - [#41](https://github.com/lumoslabs/broadside/pull/41/files): Introduce the concept of bootstrap commands, which are designed to be run when setting up a new server or environment.

data/README.md

@@ -11,9 +11,9 @@ Broadside offers a simple command-line interface to perform deployments on ECS.
 
 ```ruby
 Broadside.configure do |config|
-  config.base.application = 'hello_world'
-  config.base.docker_image = 'lumoslabs/hello_world'
-  config.deploy.type = 'ecs'
+  config.application = 'hello_world'
+  config.docker_image = 'lumoslabs/hello_world'
+  config.type = 'ecs'
   config.ecs.cluster = 'micro-cluster'
   config.deploy.targets = {
     production_web: {
@@ -21,7 +21,7 @@ Broadside.configure do |config|
       command: ['bundle', 'exec', 'unicorn', '-c', 'config/unicorn.conf.rb'],
       env_file: '../.env.production'
       predeploy_commands: [
-        ['bundle', 'exec', 'rake', 'db:migrate'],
+        Broadside::Predeploy::RAKE_DB_MIGRATE,     # RAKE_DB_MIGRATE is just a constant for your convenience
         ['bundle', 'exec', 'rake', 'data:migrate']
       ]
     },
@@ -31,6 +31,7 @@ Broadside.configure do |config|
       env_file: '../.env.production'
     },
     staging_web: {
+      cluster: 'staging-cluster', # Overrides config.ecs.cluster
       scale: 1,
       command: ['bundle', 'exec', 'puma'],
       env_file: '../.env.staging'
@@ -68,13 +69,16 @@ end
 ```
 
 From here, developers can use broadside's command-line interface to initiate a basic deployment:
-```
+
+```bash
 broadside deploy short --target production_web --tag $GIT_SHA
 ```
 or run
-```
+
+```bash
 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.
@@ -84,12 +88,12 @@ See the complete command-line reference in the wiki.
 
 ## Setup
 First, install broadside by adding it to your application gemfile:
-```
+```ruby
 gem 'broadside'
 ```
 
 Then run
-```
+```bash
 bundle install
 bundle binstubs broadside
 ```
@@ -97,7 +101,7 @@ 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:
-```
+```bash
 bin/broadside --help
 ```
 

data/bin/broadside

@@ -26,8 +26,10 @@ def add_shared_deploy_configs(subcmd)
   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).public_send(subcmd.name)
+    _DeployObj = Kernel.const_get("Broadside::#{Broadside.config.type.capitalize}Deploy")
+    _target = Broadside.config.targets.select { |t| t.name == options[:target] }.first
+    raise "Bad target: #{options[:target]}" unless _target
+    _DeployObj.new(_target, options).public_send(subcmd.name)
   end
 end
 
@@ -44,9 +46,9 @@ end
 
 desc 'Bootstrap your service and task definition from the configured definition.'
 command :bootstrap do |b|
-  subcmd.desc 'Docker tag for application container'
-  subcmd.arg_name 'TAG'
-  subcmd.flag [:tag]
+  b.desc 'Docker tag for application container'
+  b.arg_name 'TAG'
+  b.flag [:tag]
 
   add_shared_deploy_configs(b)
 end
@@ -144,7 +146,8 @@ command :deploy do |d|
 end
 
 def call_hook(type, command)
-  hook = Broadside.config.base.send(type)
+  hook = Broadside.config.send(type)
+
   if hook.is_a?(Proc)
     hook_args =
       if command.parent.is_a?(GLI::Command)

data/broadside.gemspec

@@ -6,7 +6,7 @@ require 'broadside/version'
 Gem::Specification.new do |spec|
   spec.name          = 'broadside'
   spec.version       = Broadside::VERSION
-  spec.authors       = ['Matthew Leung']
+  spec.authors       = ['Matthew Leung', 'Lumos Labs, Inc.']
   spec.email         = ['leung.mattp@gmail.com']
 
   spec.summary       = 'A command-line tool for EC2 Container Service deployment.'
@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'gli', '~> 2.13'
   spec.add_dependency 'rainbow', '~> 2.1'
 
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
   spec.add_development_dependency 'bundler', '~> 1.9'
   spec.add_development_dependency 'fakefs'
 end

data/lib/broadside.rb

@@ -1,14 +1,14 @@
 require 'broadside/error'
 require 'broadside/utils'
+require 'broadside/configuration/verify_instance_variables'
 require 'broadside/configuration'
-require 'broadside/configuration/config_struct'
 require 'broadside/configuration/aws_config'
-require 'broadside/configuration/base_config'
-require 'broadside/configuration/deploy_config'
 require 'broadside/configuration/ecs_config'
+require 'broadside/target'
 require 'broadside/deploy'
-require 'broadside/deploy/ecs_deploy'
-require 'broadside/deploy/ecs_manager'
+require 'broadside/predeploy_commands'
+require 'broadside/ecs/ecs_deploy'
+require 'broadside/ecs/ecs_manager'
 require 'broadside/version'
 
 module Broadside
@@ -29,8 +29,8 @@ module Broadside
     end
 
     begin
-      load config_file
       config.file = config_file
+      load config_file
     rescue LoadError => e
       error "Encountered an error loading required configuration file '#{config_file}' !"
       raise e

data/lib/broadside/configuration.rb

@@ -1,15 +1,30 @@
+require 'logger'
+
 module Broadside
   class Configuration
+    extend Gem::Deprecate
+    include VerifyInstanceVariables
     include Utils
 
-    attr_accessor :base, :deploy, :ecs, :aws, :file
+    attr_accessor(
+      :application,
+      :docker_image,
+      :file,
+      :git_repo,
+      :logger,
+      :prehook,
+      :posthook,
+      :ssh,
+      :timeout,
+      :type
+    )
+    attr_reader :targets
 
     def initialize
-      @base = BaseConfig.new
-    end
-
-    def deploy
-      @deploy ||= DeployConfig.new
+      @logger = ::Logger.new(STDOUT)
+      @logger.level = ::Logger::DEBUG
+      @logger.datetime_format = '%Y-%m-%d_%H:%M:%S'
+      @timeout = 600
     end
 
     def aws
@@ -20,13 +35,24 @@ module Broadside
       @ecs ||= EcsConfig.new
     end
 
-    def verify
-      @base.verify(:application, :docker_image)
+    def targets=(_targets)
+      raise ArgumentError, "Targets must be a hash" unless _targets.is_a?(Hash)
+      @targets = _targets.map { |name, config| Target.new(name, config) }
+    end
+
+    def verify(*args)
+      super(*([:application, :docker_image] + args))
+    end
+
+    # Maintain backward compatibility
+    def deploy
+      self
     end
+    deprecate :deploy, 'config.deploy.option should be configured directly as config.option', 2017, 4
 
-    def method_missing(m, *args, &block)
-      warn "Unknown configuration '#{m}' provided, ignoring. Check your version of broadside?"
-      ConfigStruct.new
+    def base
+      self
     end
+    deprecate :base, 'config.base.option should be configured directly as config.option', 2017, 4
   end
 end

data/lib/broadside/configuration/aws_config.rb

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

data/lib/broadside/configuration/ecs_config.rb

@@ -1,12 +1,13 @@
 module Broadside
-  class Configuration
-    class EcsConfig < ConfigStruct
-      attr_accessor :cluster, :poll_frequency
+  class EcsConfig
+    include VerifyInstanceVariables
 
-      def initialize
-        @cluster = nil
-        @poll_frequency = 2
-      end
+    # Cluster can be overridden in a Target
+    attr_accessor :cluster, :poll_frequency
+
+    def initialize
+      @cluster = nil
+      @poll_frequency = 2
     end
   end
 end

data/lib/broadside/configuration/verify_instance_variables.rb

@@ -0,0 +1,11 @@
+module Broadside
+  module VerifyInstanceVariables
+    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
+  end
+end

data/lib/broadside/deploy.rb

@@ -1,21 +1,24 @@
 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
-      @deploy_config.lines = opts[:lines]       || @deploy_config.lines
+    include VerifyInstanceVariables
+
+    attr_reader(
+      :command,
+      :instance,
+      :lines,
+      :tag,
+      :target
+    )
+
+    def initialize(target, opts = {})
+      @target   = target
+      @command  = opts[:command]  || @target.command
+      @instance = opts[:instance] || @target.instance
+      @lines    = opts[:lines]    || 10
+      @rollback = opts[:rollback] || 1
+      @scale    = opts[:scale]    || @target.scale
+      @tag      = opts[:tag]
     end
 
     def short
@@ -23,44 +26,44 @@ module Broadside
     end
 
     def full
-      run_predeploy
+      config.verify(:ssh)
+      verify(:tag)
+
+      info "Running predeploy commands for #{family}..."
+      run_commands(@target.predeploy_commands)
+      info 'Predeploy complete.'
+
       deploy
     end
 
     def deploy
-      @deploy_config.verify(:tag)
+      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}..."
+    def rollback(count = @rollback)
+      info "Rolling back #{count} release for #{family}..."
       yield
       info 'Rollback complete.'
     end
 
     def scale
-      info "Rescaling #{family} with scale=#{@deploy_config.scale}"
+      info "Rescaling #{family} with scale=#{@scale}"
       yield
       info 'Rescaling complete.'
     end
 
     def run
-      @deploy_config.verify(:tag, :ssh, :command)
-      info "Running command [#{@deploy_config.command}] for #{family}..."
+      config.verify(:ssh)
+      verify(:tag, :command)
+      info "Running command [#{@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
@@ -68,32 +71,33 @@ module Broadside
     end
 
     def logtail
-      @deploy_config.verify(:instance)
+      verify(:instance)
       yield
     end
 
     def ssh
-      @deploy_config.verify(:instance)
+      verify(:instance)
       yield
     end
 
     def bash
-      @deploy_config.verify(:instance)
+      verify(:instance)
       yield
     end
 
-    protected
+    private
 
     def family
-      "#{config.base.application}_#{@deploy_config.target}"
+      "#{config.application}_#{@target.name}"
     end
 
     def image_tag
-      "#{config.base.docker_image}:#{@deploy_config.tag}"
+      raise ArgumentError, "Missing tag" unless @tag
+      "#{config.docker_image}:#{@tag}"
     end
 
     def gen_ssh_cmd(ip, options = { tty: false })
-      opts = @deploy_config.ssh || {}
+      opts = config.ssh || {}
       cmd = 'ssh -o StrictHostKeyChecking=no'
       cmd << ' -t -t' if options[:tty]
       cmd << " -i #{opts[:keyfile]}" if opts[:keyfile]

data/lib/broadside/{deploy → ecs}/ecs_deploy.rb

@@ -12,14 +12,14 @@ module Broadside
       memory: 1000
     }
 
-    def initialize(opts)
-      super(opts)
+    def initialize(target, opts = {})
+      super
       config.ecs.verify(:cluster, :poll_frequency)
     end
 
     def deploy
       super do
-        unless EcsManager.service_exists?(config.ecs.cluster, family)
+        unless EcsManager.service_exists?(@target.cluster, family)
           exception "No service for #{family}! Please bootstrap or manually configure the service."
         end
         unless EcsManager.get_latest_task_definition_arn(family)
@@ -46,49 +46,36 @@ module Broadside
     end
 
     def bootstrap
-      if EcsManager.get_latest_task_definition_arn(family)
-        info("Task definition for #{family} already exists.")
-        run_bootstrap_commands
-      else
-        unless @deploy_config.task_definition_config
+      unless EcsManager.get_latest_task_definition_arn(family)
+        unless @target.task_definition_config
           raise ArgumentError, "No first task definition and no :task_definition_config in '#{family}' configuration"
         end
 
         info "Creating an initial task definition for '#{family}' from the config..."
 
         EcsManager.ecs.register_task_definition(
-          @deploy_config.task_definition_config.merge(
+          @target.task_definition_config.merge(
             family: family,
             container_definitions: [DEFAULT_CONTAINER_DEFINITION.merge(container_definition)]
           )
         )
-
-        run_bootstrap_commands
       end
 
-      if EcsManager.service_exists?(config.ecs.cluster, family)
+      run_commands(@target.bootstrap_commands)
+
+      if EcsManager.service_exists?(@target.cluster, family)
         info("Service for #{family} already exists.")
       else
-        unless @deploy_config.service_config
+        unless @target.service_config
           raise ArgumentError, "Service doesn't exist and no :service_config in '#{family}' configuration"
         end
 
         info "Service '#{family}' doesn't exist, creating..."
-        EcsManager.create_service(config.ecs.cluster, family, @deploy_config.service_config)
+        EcsManager.create_service(@target.cluster, family, @target.service_config)
       end
     end
 
-    def run_bootstrap_commands
-      update_task_revision
-
-      begin
-        @deploy_config.bootstrap_commands.each { |command| run_command(command) }
-      ensure
-        EcsManager.deregister_last_n_tasks_definitions(family, 1)
-      end
-    end
-
-    def rollback(count = @deploy_config.rollback)
+    def rollback(count = @rollback)
       super do
         begin
           EcsManager.deregister_last_n_tasks_definitions(family, count)
@@ -108,32 +95,13 @@ module Broadside
 
     def run
       super do
-        update_task_revision
-
-        begin
-          run_command(@deploy_config.command)
-        ensure
-          EcsManager.deregister_last_n_tasks_definitions(family, 1)
-        end
-      end
-    end
-
-    # runs before deploy commands using the latest task definition
-    def run_predeploy
-      super do
-        update_task_revision
-
-        begin
-          @deploy_config.predeploy_commands.each { |command| run_command(command) }
-        ensure
-          EcsManager.deregister_last_n_tasks_definitions(family, 1)
-        end
+        run_commands(@command)
       end
     end
 
     def status
       super do
-        ips = EcsManager.get_running_instance_ips(config.ecs.cluster, family)
+        ips = EcsManager.get_running_instance_ips(@target.cluster, family)
         info "\n---------------",
           "\nDeployed task definition information:\n",
           Rainbow(PP.pp(EcsManager.get_latest_task_definition(family), '')).blue,
@@ -149,7 +117,7 @@ module Broadside
         ip = get_running_instance_ip
         debug "Tailing logs for running container at ip #{ip}..."
         search_pattern = Shellwords.shellescape(family)
-        cmd = "docker logs -f --tail=#{@deploy_config.lines} `docker ps -n 1 --quiet --filter name=#{search_pattern}`"
+        cmd = "docker logs -f --tail=#{@lines} `docker ps -n 1 --quiet --filter name=#{search_pattern}`"
         tail_cmd = gen_ssh_cmd(ip) + " '#{cmd}'"
         exec tail_cmd
       end
@@ -177,7 +145,7 @@ module Broadside
     private
 
     def get_running_instance_ip
-      EcsManager.get_running_instance_ips(config.ecs.cluster, family).fetch(@deploy_config.instance)
+      EcsManager.get_running_instance_ips(@target.cluster, family).fetch(@target.instance)
     end
 
     # Creates a new task revision using current directory's env vars, provided tag, and configured options.
@@ -194,7 +162,7 @@ module Broadside
 
       # Deep merge doesn't work well with arrays (e.g. :container_definitions), so build the container first.
       updatable_container_definitions.first.merge!(container_definition)
-      revision.deep_merge!((@deploy_config.task_definition_config || {}).except(:container_definitions))
+      revision.deep_merge!((@target.task_definition_config || {}).except(:container_definitions))
 
       task_definition = EcsManager.ecs.register_task_definition(revision).task_definition
       debug "Successfully created #{task_definition.task_definition_arn}"
@@ -203,21 +171,21 @@ module Broadside
     # reloads the service using the latest task definition
     def update_service
       task_definition_arn = EcsManager.get_latest_task_definition_arn(family)
-      debug "Updating #{family} with scale=#{@deploy_config.scale} using task #{task_definition_arn}..."
+      debug "Updating #{family} with scale=#{@target.scale} using task #{task_definition_arn}..."
 
       update_service_response = EcsManager.ecs.update_service({
-        cluster: config.ecs.cluster,
-        desired_count: @deploy_config.scale,
+        cluster: @target.cluster,
+        desired_count: @target.scale,
         service: family,
         task_definition: task_definition_arn
-      }.deep_merge(@deploy_config.service_config || {}))
+      }.deep_merge(@target.service_config || {}))
 
       unless update_service_response.successful?
         exception('Failed to update service during deploy.', update_service_response.pretty_inspect)
       end
 
-      EcsManager.ecs.wait_until(:services_stable, { cluster: config.ecs.cluster, services: [family] }) do |w|
-        w.max_attempts = @deploy_config.timeout ? @deploy_config.timeout / config.ecs.poll_frequency : nil
+      EcsManager.ecs.wait_until(:services_stable, { cluster: @target.cluster, services: [family] }) do |w|
+        w.max_attempts = config.timeout ? config.timeout / config.ecs.poll_frequency : nil
         w.delay = config.ecs.poll_frequency
         seen_event = nil
 
@@ -232,36 +200,46 @@ module Broadside
       end
     end
 
-    def run_command(command)
-      command_name = command.join(' ')
-      run_task_response = EcsManager.run_task(config.ecs.cluster, family, command)
+    def run_commands(commands)
+      return if commands.nil? || commands.empty?
 
-      unless run_task_response.successful? && run_task_response.tasks.try(:[], 0)
-        exception("Failed to run #{command_name} task.", run_task_response.pretty_inspect)
-      end
+      update_task_revision
 
-      task_arn = run_task_response.tasks[0].task_arn
-      debug "Launched #{command_name} task #{task_arn}, waiting for completion..."
+      begin
+        Array.wrap(commands).each do |command|
+          command_name = command.join(' ')
+          run_task_response = EcsManager.run_task(@target.cluster, family, command)
 
-      EcsManager.ecs.wait_until(:tasks_stopped, { cluster: config.ecs.cluster, tasks: [task_arn] }) 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
+          unless run_task_response.successful? && run_task_response.tasks.try(:[], 0)
+            exception("Failed to run #{command_name} task.", run_task_response.pretty_inspect)
+          end
 
-      info "#{command_name} task container logs:\n#{get_container_logs(task_arn)}"
+          task_arn = run_task_response.tasks[0].task_arn
+          debug "Launched #{command_name} task #{task_arn}, waiting for completion..."
 
-      if (code = EcsManager.get_task_exit_code(config.ecs.cluster, task_arn, family)) == 0
-        debug "#{command_name} task #{task_arn} exited with status code 0"
-      else
-        exception "#{command_name} task #{task_arn} exited with a non-zero status code #{code}!"
+          EcsManager.ecs.wait_until(:tasks_stopped, { cluster: @target.cluster, tasks: [task_arn] }) 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
+
+          info "#{command_name} task container logs:\n#{get_container_logs(task_arn)}"
+
+          if (code = EcsManager.get_task_exit_code(@target.cluster, task_arn, family)) == 0
+            debug "#{command_name} task #{task_arn} exited with status code 0"
+          else
+            exception "#{command_name} task #{task_arn} exited with a non-zero status code #{code}!"
+          end
+        end
+      ensure
+        EcsManager.deregister_last_n_tasks_definitions(family, 1)
       end
     end
 
     def get_container_logs(task_arn)
-      ip = EcsManager.get_running_instance_ips(config.ecs.cluster, family, task_arn).first
+      ip = EcsManager.get_running_instance_ips(@target.cluster, family, task_arn).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_arn}'\""
@@ -279,15 +257,15 @@ module Broadside
     end
 
     def container_definition
-      configured_containers = (@deploy_config.task_definition_config || {})[:container_definitions]
+      configured_containers = (@target.task_definition_config || {})[:container_definitions]
       if configured_containers && configured_containers.size > 1
         raise ArgumentError, 'Creating > 1 container definition not supported yet'
       end
 
       (configured_containers.try(:first) || {}).merge(
         name: family,
-        command: @deploy_config.command,
-        environment: @deploy_config.env_vars,
+        command: @command,
+        environment: @target.env_vars,
         image: image_tag
       )
     end

data/lib/broadside/predeploy_commands.rb

@@ -0,0 +1,7 @@
+# Here rest some commonly used predeploy commands, so they can be included by constant name instead of
+# having to retype them in every config file.
+module Broadside
+  module PredeployCommands
+    RAKE_DB_MIGRATE = ['bundle', 'exec', 'rake', '--trace', 'db:migrate']
+  end
+end

data/lib/broadside/target.rb

@@ -0,0 +1,110 @@
+require 'dotenv'
+require 'pathname'
+
+module Broadside
+  class Target
+    include VerifyInstanceVariables
+    include Utils
+
+    attr_accessor(
+      :bootstrap_commands,
+      :command,
+      :env_files,
+      :env_vars,
+      :instance,
+      :name,
+      :predeploy_commands,
+      :scale,
+      :service_config,
+      :tag,
+      :task_definition_config
+    )
+
+    DEFAULT_INSTANCE = 0
+
+    TARGET_ATTRIBUTE_VALIDATIONS = {
+      bootstrap_commands:     ->(target_attribute) { validate_commands(target_attribute) },
+      command:                ->(target_attribute) { validate_types([Array, NilClass], target_attribute) },
+      env_files:              ->(target_attribute) { validate_types([String, Array], target_attribute) },
+      predeploy_commands:     ->(target_attribute) { validate_commands(target_attribute) },
+      scale:                  ->(target_attribute) { validate_types([Integer], target_attribute) },
+      service_config:         ->(target_attribute) { validate_types([Hash, NilClass], target_attribute) },
+      task_definition_config: ->(target_attribute) { validate_types([Hash, NilClass], target_attribute) }
+    }
+
+    def initialize(name, options = {})
+      @name = name
+      @config = options
+
+      @bootstrap_commands = @config[:bootstrap_commands] || []
+      @cluster = @config[:cluster]
+      @command = @config[:command]
+      _env_files = @config[:env_files] || @config[:env_file]
+      @env_files = _env_files ? [*_env_files] : nil
+      @env_vars = {}
+      @instance = DEFAULT_INSTANCE || @config[:instance]
+      @predeploy_commands = @config[:predeploy_commands]
+      @scale = @config[:scale]
+      @service_config = @config[:service_config]
+      @tag = @config[:tag]
+      @task_definition_config = @config[:task_definition_config]
+
+      validate!
+      load_env_vars!
+    end
+
+    def cluster
+      @cluster || config.ecs.cluster
+    end
+
+    private
+
+    def validate!
+      invalid_messages = TARGET_ATTRIBUTE_VALIDATIONS.map do |var, validation|
+        message = validation.call(instance_variable_get('@' + var.to_s))
+        message.nil? ? nil : "Deploy target '#{@name}' parameter '#{var}' is invalid: #{message}"
+      end.compact
+
+      unless invalid_messages.empty?
+        raise ArgumentError, invalid_messages.join("\n")
+      end
+    end
+
+    def load_env_vars!
+      @env_files.flatten.each do |env_path|
+        env_file = Pathname.new(env_path)
+
+        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.merge!(vars)
+        else
+          raise ArgumentError, "Could not find file '#{env_file}' for loading environment variables !"
+        end
+      end
+
+      # convert env vars to format ecs expects
+      @env_vars = @env_vars.map { |k, v| { 'name' => k, 'value' => v } }
+    end
+
+    def self.validate_types(types, target_attribute)
+      return nil if types.any? { |type| target_attribute.is_a?(type) }
+
+      "'#{target_attribute}' must be of type [#{types.join('|')}], got '#{target_attribute.class}' !"
+    end
+
+    def self.validate_commands(commands)
+      return nil if commands.nil?
+      return 'predeploy_commands must be an array' unless commands.is_a?(Array)
+
+      messages = commands.reject { |cmd| cmd.is_a?(Array) }.map do |command|
+        "predeploy_command '#{command}' must be an array" unless command.is_a?(Array)
+      end
+      messages.empty? ? nil : messages.join(', ')
+    end
+  end
+end

data/lib/broadside/utils.rb

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

data/lib/broadside/version.rb

@@ -1,3 +1,3 @@
 module Broadside
-  VERSION = '1.4.0'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: broadside
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Matthew Leung
+- Lumos Labs, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-09 00:00:00.000000000 Z
+date: 2017-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -90,16 +91,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.4.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -150,14 +151,14 @@ files:
 - lib/broadside.rb
 - lib/broadside/configuration.rb
 - lib/broadside/configuration/aws_config.rb
-- lib/broadside/configuration/base_config.rb
-- lib/broadside/configuration/config_struct.rb
-- lib/broadside/configuration/deploy_config.rb
 - lib/broadside/configuration/ecs_config.rb
+- lib/broadside/configuration/verify_instance_variables.rb
 - lib/broadside/deploy.rb
-- lib/broadside/deploy/ecs_deploy.rb
-- lib/broadside/deploy/ecs_manager.rb
+- lib/broadside/ecs/ecs_deploy.rb
+- lib/broadside/ecs/ecs_manager.rb
 - lib/broadside/error.rb
+- lib/broadside/predeploy_commands.rb
+- lib/broadside/target.rb
 - lib/broadside/utils.rb
 - lib/broadside/version.rb
 homepage: https://github.com/lumoslabs/broadside
@@ -180,9 +181,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: A command-line tool for EC2 Container Service deployment.
 test_files: []
-has_rdoc: 

data/lib/broadside/configuration/base_config.rb

@@ -1,19 +0,0 @@
-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/config_struct.rb

@@ -1,24 +0,0 @@
-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/configuration/deploy_config.rb

@@ -1,148 +0,0 @@
-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,
-        :lines,
-        :predeploy_commands,
-        :bootstrap_commands,
-        :service_config,
-        :task_definition_config
-      )
-
-      TARGET_ATTRIBUTE_VALIDATIONS = {
-        scale: ->(target_attribute) { validate_types([Fixnum], target_attribute) },
-        env_file: ->(target_attribute) { validate_types([String, Array], target_attribute) },
-        command: ->(target_attribute) { validate_types([Array, NilClass], target_attribute) },
-        predeploy_commands: ->(target_attribute) { validate_predeploy_commands(target_attribute) },
-        bootstrap_commands: ->(target_attribute) { validate_bootstrap_commands(target_attribute) },
-        service_config: ->(target_attribute) { validate_types([Hash, NilClass], target_attribute) },
-        task_definition_config: ->(target_attribute) { validate_types([Hash, NilClass], 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
-        @bootstrap_commands = []
-        @instance = 0
-        @service_config = nil
-        @task_definition_config = nil
-        @lines = 10
-      end
-
-      # Validates format of deploy targets
-      # Checks existence of provided target
-      def validate_targets!
-        @targets.each do |target, configuration|
-          invalid_messages = TARGET_ATTRIBUTE_VALIDATIONS.map do |var, validation|
-            message = validation.call(configuration[var])
-            message.nil? ? nil : "Deploy target '#{@target}' parameter '#{var}' is invalid: #{message}"
-          end.compact
-
-          unless invalid_messages.empty?
-            raise ArgumentError, invalid_messages.join("\n")
-          end
-        end
-
-        unless @targets.has_key?(@target)
-          raise ArgumentError, "Could not find deploy target #{@target} in configuration !"
-        end
-      end
-
-      # Loads deploy target data using provided target
-      def load_target!
-        validate_targets!
-        load_env_vars!
-
-        @scale ||= @targets[@target][:scale]
-        @command = @targets[@target][:command]
-        @predeploy_commands = @targets[@target][:predeploy_commands] if @targets[@target][:predeploy_commands]
-        @bootstrap_commands = @targets[@target][:bootstrap_commands] if @targets[@target][:bootstrap_commands]
-        @service_config = @targets[@target][:service_config]
-        @task_definition_config = @targets[@target][:task_definition_config]
-      end
-
-      def load_env_vars!
-        @env_vars ||= {}
-
-        [@targets[@target][:env_file]].flatten.each do |env_path|
-          env_file = Pathname.new(env_path)
-
-          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.merge!(vars)
-          else
-            raise ArgumentError, "Could not find file '#{env_file}' for loading environment variables !"
-          end
-        end
-
-        # convert env vars to format ecs expects
-        @env_vars = @env_vars.map { |k, v| { 'name' => k, 'value' => v } }
-      end
-
-      private
-
-      class << self
-        def validate_types(types, target_attribute)
-          if types.include?(target_attribute.class)
-            nil
-          else
-            "'#{target_attribute}' must be of type [#{types.join('|')}], got '#{target_attribute.class}' !"
-          end
-        end
-
-        def validate_predeploy_commands(commands)
-          validate_commands(commands, 'predeploy_commands')
-        end
-
-        def validate_bootstrap_commands(commands)
-          validate_commands(commands, 'bootstrap_commands')
-        end
-
-        def validate_commands(commands, attribute_name)
-          return nil if commands.nil?
-          return "#{attribute_name} must be an array" unless commands.is_a?(Array)
-
-          messages = commands.reject { |cmd| cmd.is_a?(Array) }.map do |command|
-            "#{attribute_name} '#{command}' must be an array" unless command.is_a?(Array)
-          end
-
-          messages.empty? ? nil : messages.join(', ')
-        end
-      end
-    end
-  end
-end