broadside 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 419c835965bd07e3dc7b0ea768d9c627862e8499
-  data.tar.gz: ee3747f4a5e54723d804f29421059cdef842afb8
+  metadata.gz: 06c6097999d33e216468be90c482378b894496aa
+  data.tar.gz: e34ca4894bd642e4ea163f81f34f1b660b9689ba
 SHA512:
-  metadata.gz: 2e3072860cf4b3c6c4329a125fd0727a02375269d6c4e08acd5bef4ab135d7fa4de7da3cd5012b0e71e01afc3844819f10c29ee8cc8b7a891a68c86dd51cfcd9
-  data.tar.gz: d1bfa94f90f463704cdda69f51df19576759eb25fa1ad584ba466527959775542f9823821c6ae2cfb9f6a13ae1ec5cc96994f1a0f291f77c407f03e50f6196aa
+  metadata.gz: b583cb598536cd02b403d929ff237ea9632d124126b7f7abd03ab481f76de155a4ec489f83cfab771acc1bbf67f67fdee1112e3a1c462c6e2c1341890fae4161
+  data.tar.gz: aebd8291a1c8b21f7ada0f827834250aa601d7e0d0f199394d6a5523ee6905cde8b8b32f70e5bef1871333f3459dd9698165544d81f6fe86a360c194ecd65bb2

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 1.2.0
+- [#32](https://github.com/lumoslabs/broadside/pull/32): Deploys will also update service configs defined in a deploy target (see full list in the [AWS Docs](https://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#create_service-instance_method))
+- Updates additional container definition configs like cpu, memory. See full list in the [AWS Docs](https://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method)
+- [#24](https://github.com/lumoslabs/broadside/pull/24): Refactored most ECS-specific utility methods into a separate class
+
 # 1.1.1
 - [#25](https://github.com/lumoslabs/broadside/issues/25): Fix issue with undefined local variable 'ecs'
 

data/README.md

@@ -41,7 +41,10 @@ Broadside.configure do |config|
       env_file: '../.env.staging'
     },
     # Example with a task_definition and service configuration which you use to bootstrap a service and
-    # initial task definition
+    # initial task definition.  Accepts all the options AWS does - read their documentation for details:
+    #
+    # Service config: https://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#create_service-instance_method
+    # Task Definition Config: https://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method
     game_save_as_json_blob_stream: {
       scale: 1,
       command: ['java', '-cp', '*:.', 'path.to.MyClass'],

data/bin/broadside

@@ -27,7 +27,7 @@ def add_shared_deploy_configs(subcmd)
 
   subcmd.action do |global_options, options, args|
     _DeployObj = Kernel.const_get("Broadside::#{Broadside.config.deploy.type.capitalize}Deploy")
-    _DeployObj.new(options).send(subcmd.name)
+    _DeployObj.new(options).public_send(subcmd.name)
   end
 end
 
@@ -42,7 +42,7 @@ accept Fixnum do |val|
   val.to_i
 end
 
-desc 'Bootstrap your service and task definition.'
+desc 'Bootstrap your service and task definition from the configured definition.'
 command :bootstrap do |b|
   add_shared_deploy_configs(b)
 end
@@ -168,7 +168,7 @@ 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."
+    error exception.message, "Run your last command with --help for more information."
     false
   else
     true

data/lib/broadside.rb

@@ -1,13 +1,14 @@
 require 'broadside/error'
 require 'broadside/utils'
 require 'broadside/configuration'
-require 'broadside/configuration/struct'
-require 'broadside/configuration/aws'
-require 'broadside/configuration/base'
+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/deploy'
 require 'broadside/deploy/ecs_deploy'
+require 'broadside/deploy/ecs_manager'
 require 'broadside/version'
 
 module Broadside

data/lib/broadside/configuration/deploy_config.rb

@@ -31,7 +31,7 @@ module Broadside
         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) },
+        predeploy_commands: ->(target_attribute) { validate_predeploy_commands(target_attribute) },
         service_config: ->(target_attribute) { validate_types([Hash, NilClass], target_attribute) },
         task_definition_config: ->(target_attribute) { validate_types([Hash, NilClass], target_attribute) }
       }
@@ -57,24 +57,24 @@ module Broadside
       # Checks existence of provided target
       def validate_targets!
         @targets.each do |target, configuration|
-          TARGET_ATTRIBUTE_VALIDATIONS.each do |var, validation|
+          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 message.nil?
-              exception "Deploy target '#{@target}' parameter '#{var}' is invalid: #{message}"
-            end
+          unless invalid_messages.empty?
+            raise ArgumentError, invalid_messages.join("\n")
           end
         end
 
         unless @targets.has_key?(@target)
-          exception "Could not find deploy target #{@target} in configuration !"
+          raise ArgumentError, "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?
@@ -84,13 +84,14 @@ module Broadside
 
         if env_file.exist?
           vars = Dotenv.load(env_file)
-          @env_vars = vars.map { |k,v| {'name'=> k, 'value' => v } }
+          @env_vars = vars.map { |k, v| { 'name'=> k, 'value' => v } }
         else
-          exception "Could not find file '#{env_file}' for loading environment variables !"
+          raise ArgumentError, "Could not find file '#{env_file}' for loading environment variables !"
         end
 
         @scale ||= @targets[@target][:scale]
         @command = @targets[@target][:command]
+        # TODO: what's up with predeploy_commands.  ||= []?
         @predeploy_commands = @targets[@target][:predeploy_commands] if @targets[@target][:predeploy_commands]
         @service_config = @targets[@target][:service_config]
         @task_definition_config = @targets[@target][:task_definition_config]
@@ -99,18 +100,18 @@ module Broadside
       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}' !"
+        if types.include?(target_attribute.class)
+          nil
+        else
+          "'#{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)
+      def self.validate_predeploy_commands(commands)
+        return nil if commands.nil?
+        return 'predeploy_commands must be an array' unless commands.is_a?(Array)
 
-        messages = target_attribute.reject { |cmd| cmd.is_a?(Array) }.map do |command|
+        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(', ')

data/lib/broadside/deploy/ecs_deploy.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/hash'
 require 'aws-sdk'
 require 'open3'
 require 'pp'
@@ -7,8 +6,6 @@ require 'shellwords'
 
 module Broadside
   class EcsDeploy < Deploy
-
-    DEFAULT_DESIRED_COUNT = 0
     DEFAULT_CONTAINER_DEFINITION = {
       cpu: 1,
       essential: true,
@@ -22,7 +19,13 @@ module Broadside
 
     def deploy
       super do
-        exception "Service #{family} does not exist!" unless service_exists?
+        unless EcsManager.service_exists?(config.ecs.cluster, family)
+          exception "No service for #{family}! Please bootstrap or manually configure the service."
+        end
+        unless EcsManager.get_latest_task_definition_arn(family)
+          exception "No task definition for '#{family}'! Please bootstrap or manually configure the task definition."
+        end
+
         update_task_revision
 
         begin
@@ -37,36 +40,49 @@ module Broadside
           error 'Deploy failed! Rolling back...'
           rollback(1)
           error 'Deployment did not finish successfully.'
-          raise
+          raise e
         end
       end
     end
 
     def bootstrap
-      unless get_latest_task_def_id
-        # Right now this creates a useless first revision and then update_task_revision will create a 2nd one
-        raise ArgumentError, "No first task definition and cannot create one" unless @deploy_config.task_definition_config
+      if EcsManager.get_latest_task_definition_arn(family)
+        info("Task definition for #{family} already exists.")
+      else
+        unless @deploy_config.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..."
-        create_task_definition(family, @deploy_config.task_definition_config)
+
+        EcsManager.ecs.register_task_definition(
+          @deploy_config.task_definition_config.merge(
+            family: family,
+            container_definitions: [DEFAULT_CONTAINER_DEFINITION.merge(container_definition)]
+          )
+        )
       end
 
-      unless service_exists?
-        raise ArgumentError, "Service doesn't exist and cannot be created" unless @deploy_config.service_config
+      if EcsManager.service_exists?(config.ecs.cluster, family)
+        info("Service for #{family} already exists.")
+      else
+        unless @deploy_config.service_config
+          raise ArgumentError, "Service doesn't exist and no :service_config in '#{family}' configuration"
+        end
 
         info "Service '#{family}' doesn't exist, creating..."
-        create_service(family, @deploy_config.service_config)
+        EcsManager.create_service(config.ecs.cluster, family, @deploy_config.service_config)
       end
     end
 
     def rollback(count = @deploy_config.rollback)
       super do
         begin
-          deregister_tasks(count)
+          EcsManager.deregister_last_n_tasks_definitions(family, count)
           update_service
-        rescue StandardError => e
+        rescue StandardError
           error 'Rollback failed to complete!'
-          raise e
+          raise
         end
       end
     end
@@ -84,7 +100,7 @@ module Broadside
         begin
           run_command(@deploy_config.command)
         ensure
-          deregister_tasks(1)
+          EcsManager.deregister_last_n_tasks_definitions(family, 1)
         end
       end
     end
@@ -95,22 +111,19 @@ module Broadside
         update_task_revision
 
         begin
-          @deploy_config.predeploy_commands.each do |command|
-            run_command(command)
-          end
+          @deploy_config.predeploy_commands.each { |command| run_command(command) }
         ensure
-          deregister_tasks(1)
+          EcsManager.deregister_last_n_tasks_definitions(family, 1)
         end
       end
     end
 
     def status
       super do
-        td = get_latest_task_def
-        ips = get_running_instance_ips
+        ips = EcsManager.get_running_instance_ips(config.ecs.cluster, family)
         info "\n---------------",
           "\nDeployed task definition information:\n",
-          Rainbow(PP.pp(td, '')).blue,
+          Rainbow(PP.pp(EcsManager.get_latest_task_definition(family), '')).blue,
           "\nPrivate ips of instances running containers:\n",
           Rainbow(ips.join(' ')).blue,
           "\n\nssh command:\n#{Rainbow(gen_ssh_cmd(ips.first)).cyan}",
@@ -120,7 +133,7 @@ module Broadside
 
     def logtail
       super do
-        ip = get_running_instance_ips.fetch(@deploy_config.instance)
+        ip = get_running_instance_ip
         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}`"
@@ -131,7 +144,7 @@ module Broadside
 
     def ssh
       super do
-        ip = get_running_instance_ips.fetch(@deploy_config.instance)
+        ip = get_running_instance_ip
         debug "Establishing an SSH connection to ip #{ip}..."
         exec gen_ssh_cmd(ip)
       end
@@ -139,7 +152,7 @@ module Broadside
 
     def bash
       super do
-        ip = get_running_instance_ips.fetch(@deploy_config.instance)
+        ip = get_running_instance_ip
         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"
@@ -150,141 +163,100 @@ module Broadside
 
     private
 
-    # removes latest n task definitions
-    def deregister_tasks(count)
-      get_task_definition_arns.last(count).each do |td_id|
-        ecs_client.deregister_task_definition({task_definition: td_id})
-        debug "Deregistered #{td_id}"
-      end
+    def get_running_instance_ip
+      EcsManager.get_running_instance_ips(config.ecs.cluster, family).fetch(@deploy_config.instance)
     end
 
-    # creates a new task revision using current directory's env vars and provided tag
+    # Creates a new task revision using current directory's env vars, provided tag, and configured options.
+    # Currently can only handle a single container definition.
     def update_task_revision
-      new_task_def = create_new_task_revision
-
-      new_task_def[:container_definitions].select { |c| c[:name] == family }.first.tap do |container_def|
-        container_def[:environment] = @deploy_config.env_vars
-        container_def[:image] = image_tag
-        container_def[:command] = @deploy_config.command
-      end
-
-      debug "Creating a new task definition..."
-      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
-
-    def create_service(name, options = {})
-      ecs_client.create_service(
-        {
-          cluster: config.ecs.cluster,
-          desired_count: DEFAULT_DESIRED_COUNT,
-          service_name: name,
-          task_definition: name
-        }.deep_merge(options)
+      revision = EcsManager.get_latest_task_definition(family).except(
+        :requires_attributes,
+        :revision,
+        :status,
+        :task_definition_arn
       )
-    end
+      updatable_container_definitions = revision[:container_definitions].select { |c| c[:name] == family }
+      exception "Can only update one container definition!" if updatable_container_definitions.size != 1
 
-    def create_task_definition(name, options = {})
-      # Deep merge doesn't work with arrays, so build the hash and merge later
-      container_definitions = DEFAULT_CONTAINER_DEFINITION.merge(
-        name: name,
-        command: @deploy_config.command,
-        environment: @deploy_config.env_vars,
-        image: image_tag,
-      ).merge(options[:container_definitions].first || {})
+      # 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))
 
-      ecs_client.register_task_definition(
-        { family: name }.deep_merge(options).merge(container_definitions: [container_definitions])
-      )
+      task_definition = EcsManager.ecs.register_task_definition(revision).task_definition
+      debug "Successfully created #{task_definition.task_definition_arn}"
     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({
+      task_definition_arn = EcsManager.get_latest_task_definition_arn(family)
+      debug "Updating #{family} with scale=#{@deploy_config.scale} using task #{task_definition_arn}..."
+
+      update_service_response = EcsManager.ecs.update_service({
         cluster: config.ecs.cluster,
+        desired_count: @deploy_config.scale,
         service: family,
-        task_definition: get_latest_task_def_id,
-        desired_count: @deploy_config.scale
-      })
+        task_definition: task_definition_arn
+      }.deep_merge(@deploy_config.service_config || {}))
 
-      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
+      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
+        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
-        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}!"
+      run_task_response = EcsManager.run_task(config.ecs.cluster, family, command)
+
+      unless run_task_response.successful? && run_task_response.tasks.try(:[], 0)
+        exception("Failed to run #{command_name} task.", run_task_response.pretty_inspect)
+      end
+
+      task_arn = run_task_response.tasks[0].task_arn
+      debug "Launched #{command_name} task #{task_arn}, waiting for completion..."
+
+      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
+
+      info "#{command_name} task container logs:\n#{get_container_logs(task_arn)}"
+
+      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
-        raise "Failed to run #{command_name} task."
+        exception "#{command_name} task #{task_arn} exited with a non-zero status code #{code}!"
       end
     end
 
-    def get_container_logs(task_id)
-      ip = get_running_instance_ips(task_id).first
+    def get_container_logs(task_arn)
+      ip = EcsManager.get_running_instance_ips(config.ecs.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_id}'\""
+      find_container_id_cmd = "#{gen_ssh_cmd(ip)} \"docker ps -aqf 'label=com.amazonaws.ecs.task-arn=#{task_arn}'\""
       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}"
+      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, _|
@@ -293,99 +265,18 @@ module Broadside
       logs
     end
 
-    def get_task_exit_code(task_id)
-      task = ecs_client.describe_tasks({cluster: config.ecs.cluster, tasks: [task_id]}).tasks.first
-      container = task.containers.select { |c| c.name == family }.first
-      container.exit_code
-    end
-
-    def get_running_instance_ips(task_ids = nil)
-      task_arns = nil
-      if task_ids.nil?
-        task_arns = get_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
-
-      instances.map { |i| i.private_ip_address }
-    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_task_arns
-      all_results(:list_tasks, :task_arns, { cluster: config.ecs.cluster, family: family })
-    end
-
-    def get_task_definition_arns
-      all_results(:list_task_definitions, :task_definition_arns, { family_prefix: family })
-    end
-
-    def list_task_definition_families
-      all_results(:list_task_definition_families, :families)
-    end
-
-    def list_services
-      all_results(:list_services, :service_arns, { cluster: config.ecs.cluster })
-    end
-
-    def get_latest_task_def_id
-      get_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 service_exists?
-      services = ecs_client.describe_services({ cluster: config.ecs.cluster, services: [family] })
-      services.failures.empty? && !services.services.empty?
-    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 all_results(method, key, args = {})
-      page = ecs_client.public_send(method, args)
-      results = page.send(key)
-
-      while page.next_token
-        page = ecs_client.public_send(method, args.merge(next_token: page.next_token))
-        results += page.send(key)
+    def container_definition
+      configured_containers = (@deploy_config.task_definition_config || {})[:container_definitions]
+      if configured_containers && configured_containers.size > 1
+        raise ArgumentError, 'Creating > 1 container definition not supported yet'
       end
 
-      results
+      (configured_containers.try(:first) || {}).merge(
+        name: family,
+        command: @deploy_config.command,
+        environment: @deploy_config.env_vars,
+        image: image_tag
+      )
     end
   end
-end
+end

data/lib/broadside/deploy/ecs_manager.rb

@@ -0,0 +1,130 @@
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/array'
+
+module Broadside
+  class EcsManager
+    DEFAULT_DESIRED_COUNT = 0
+
+    class << self
+      include Utils
+
+      def ecs
+        @ecs_client ||= Aws::ECS::Client.new(
+          region: Broadside.config.aws.region,
+          credentials: Broadside.config.aws.credentials
+        )
+      end
+
+      def create_service(cluster, name, options = {})
+        ecs.create_service(
+          {
+            cluster: cluster,
+            desired_count: DEFAULT_DESIRED_COUNT,
+            service_name: name,
+            task_definition: name
+          }.deep_merge(options)
+        )
+      end
+
+      # removes latest n task definitions
+      def deregister_last_n_tasks_definitions(name, count)
+        get_task_definition_arns(name).last(count).each do |arn|
+          ecs.deregister_task_definition(task_definition: arn)
+          debug "Deregistered #{arn}"
+        end
+      end
+
+      def get_latest_task_definition(name)
+        return nil unless get_latest_task_definition_arn(name)
+        ecs.describe_task_definition(task_definition: get_latest_task_definition_arn(name)).task_definition.to_h
+      end
+
+      def get_latest_task_definition_arn(name)
+        get_task_definition_arns(name).last
+      end
+
+      def get_running_instance_ips(cluster, family, task_arns = nil)
+        task_arns = task_arns ? Array.wrap(task_arns) : get_task_arns(cluster, family)
+        exception "No running tasks found for '#{family}' on cluster '#{cluster}'!" if task_arns.empty?
+
+        tasks = ecs.describe_tasks(cluster: cluster, tasks: task_arns).tasks
+        container_instances = ecs.describe_container_instances(
+          cluster: cluster,
+          container_instances: tasks.map(&:container_instance_arn),
+        ).container_instances
+        ec2_instance_ids = container_instances.map(&:ec2_instance_id)
+
+        reservations = ec2_client.describe_instances(instance_ids: ec2_instance_ids).reservations
+        instances = reservations.map(&:instances).flatten
+        instances.map(&:private_ip_address)
+      end
+
+      def get_task_arns(cluster, family)
+        all_results(:list_tasks, :task_arns, { cluster: cluster, family: family })
+      end
+
+      def get_task_definition_arns(family)
+        all_results(:list_task_definitions, :task_definition_arns, { family_prefix: family })
+      end
+
+      def get_task_exit_code(cluster, task_arn, name)
+        task = ecs.describe_tasks({ cluster: cluster, tasks: [task_arn] }).tasks.first
+        container = task.containers.select { |c| c.name == name }.first
+        container.exit_code
+      end
+
+      def list_task_definition_families
+        all_results(:list_task_definition_families, :families)
+      end
+
+      def list_services(cluster)
+        all_results(:list_services, :service_arns, { cluster: cluster })
+      end
+
+      def run_task(cluster, name, command)
+        fail ArgumentError, "#{command} must be an array" unless command.is_a?(Array)
+
+        ecs.run_task(
+          cluster: cluster,
+          task_definition: get_latest_task_definition_arn(name),
+          overrides: {
+            container_overrides: [
+              {
+                name: name,
+                command: command
+              }
+            ]
+          },
+          count: 1,
+          started_by: "before_deploy:#{command.join(' ')}"[0...36]
+        )
+      end
+
+      def service_exists?(cluster, family)
+        services = ecs.describe_services(cluster: cluster, services: [family])
+        services.failures.empty? && services.services.any?
+      end
+
+      private
+
+      def all_results(method, key, args = {})
+        page = ecs.public_send(method, args)
+        results = page.public_send(key)
+
+        while page.next_token
+          page = ecs.public_send(method, args.merge(next_token: page.next_token))
+          results += page.public_send(key)
+        end
+
+        results
+      end
+
+      def ec2_client
+        @ec2_client ||= Aws::EC2::Client.new(
+          region: config.aws.region,
+          credentials: config.aws.credentials
+        )
+      end
+    end
+  end
+end

data/lib/broadside/utils.rb

@@ -17,7 +17,7 @@ module Broadside
     end
 
     def exception(*args)
-      raise Broadside::Error, args.join(' ')
+      raise Broadside::Error, args.join("\n")
     end
 
     def config

data/lib/broadside/version.rb

@@ -1,3 +1,3 @@
 module Broadside
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: broadside
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Matthew Leung
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-03 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -149,13 +149,14 @@ files:
 - broadside.gemspec
 - lib/broadside.rb
 - lib/broadside/configuration.rb
-- lib/broadside/configuration/aws.rb
-- lib/broadside/configuration/base.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/struct.rb
 - lib/broadside/deploy.rb
 - lib/broadside/deploy/ecs_deploy.rb
+- lib/broadside/deploy/ecs_manager.rb
 - lib/broadside/error.rb
 - lib/broadside/utils.rb
 - lib/broadside/version.rb