broadside 2.0.0 → 3.0.0.pre.prerelease

data/lib/broadside/ecs/ecs_manager.rb

@@ -1,12 +1,9 @@
-require 'active_support/core_ext/hash'
-require 'active_support/core_ext/array'
-
 module Broadside
   class EcsManager
     DEFAULT_DESIRED_COUNT = 0
 
     class << self
-      include Utils
+      include LoggingUtils
 
       def ecs
         @ecs_client ||= Aws::ECS::Client.new(
@@ -15,14 +12,14 @@ module Broadside
         )
       end
 
-      def create_service(cluster, name, options = {})
+      def create_service(cluster, name, service_config = {})
         ecs.create_service(
           {
             cluster: cluster,
             desired_count: DEFAULT_DESIRED_COUNT,
             service_name: name,
             task_definition: name
-          }.deep_merge(options)
+          }.deep_merge(service_config)
         )
       end
 
@@ -35,42 +32,61 @@ module Broadside
       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
+        return nil unless (arn = get_latest_task_definition_arn(name))
+        ecs.describe_task_definition(task_definition: arn).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)
+        ips = get_running_instance_ips(cluster, family, task_arns)
+        raise Error, "No running tasks found for '#{family}' on cluster '#{cluster}'!" if ips.empty?
+        ips
+      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?
+        return [] 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: tasks.map(&:container_instance_arn)
         ).container_instances
-        ec2_instance_ids = container_instances.map(&:ec2_instance_id)
 
+        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)
+
+        reservations.map(&:instances).flatten.map(&:private_ip_address)
       end
 
-      def get_task_arns(cluster, family)
-        all_results(:list_tasks, :task_arns, { cluster: cluster, family: family })
+      def get_task_arns(cluster, family, filter = {})
+        options = {
+          cluster: cluster,
+          # Strange AWS restriction requires absence of family if service_name specified
+          family: filter[:service_name] ? nil : family,
+          desired_status: filter[:desired_status],
+          service_name: filter[:service_name],
+          started_by: filter[:started_by]
+        }.reject { |_, v| v.nil? }
+
+        all_results(:list_tasks, :task_arns, options)
       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
+      def get_task_exit_status(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
+
+        {
+          exit_code: container.exit_code,
+          reason: container.reason
+        }
       end
 
       def list_task_definition_families
@@ -81,10 +97,10 @@ module Broadside
         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)
+      def run_task(cluster, name, command, options = {})
+        raise ArgumentError, "command: '#{command}' must be an array" unless command.is_a?(Array)
 
-        ecs.run_task(
+        response = ecs.run_task(
           cluster: cluster,
           task_definition: get_latest_task_definition_arn(name),
           overrides: {
@@ -96,8 +112,14 @@ module Broadside
             ]
           },
           count: 1,
-          started_by: "before_deploy:#{command.join(' ')}"[0...36]
+          started_by: ((options[:started_by] ? "#{options[:started_by]}:" : '') + command.join(' '))[0...36]
         )
+
+        unless response.successful? && response.tasks.try(:[], 0)
+          raise EcsError, "Failed to run task '#{command.join(' ')}'\n#{response.pretty_inspect}"
+        end
+
+        response
       end
 
       def service_exists?(cluster, family)
@@ -105,6 +127,28 @@ module Broadside
         services.failures.empty? && services.services.any?
       end
 
+      def check_service_and_task_definition_state!(target)
+        check_task_definition_state!(target)
+        check_service_state!(target)
+      end
+
+      def check_task_definition_state!(target)
+        unless get_latest_task_definition_arn(target.family)
+          raise Error, "No task definition for '#{target.family}'! Please bootstrap or manually configure one."
+        end
+      end
+
+      def check_service_state!(target)
+        unless service_exists?(target.cluster, target.family)
+          raise Error, "No service for '#{target.family}'! Please bootstrap or manually configure one."
+        end
+      end
+
+      def current_service_scale(target)
+        check_service_state!(target)
+        EcsManager.ecs.describe_services(cluster: target.cluster, services: [target.family]).services.first[:desired_count]
+      end
+
       private
 
       def all_results(method, key, args = {})
@@ -121,8 +165,8 @@ module Broadside
 
       def ec2_client
         @ec2_client ||= Aws::EC2::Client.new(
-          region: config.aws.region,
-          credentials: config.aws.credentials
+          region: Broadside.config.aws.region,
+          credentials: Broadside.config.aws.credentials
         )
       end
     end

data/lib/broadside/error.rb

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

data/lib/broadside/gli/commands.rb

@@ -0,0 +1,147 @@
+def add_tag_flag(cmd)
+  cmd.desc 'Docker tag for application container'
+  cmd.arg_name 'TAG'
+  cmd.flag [:tag]
+end
+
+def add_target_flag(cmd)
+  cmd.desc 'Deployment target to use, e.g. production_web'
+  cmd.arg_name 'TARGET'
+  cmd.flag [:t, :target], type: Symbol, required: true
+end
+
+def add_instance_flag(cmd)
+  cmd.desc '0-based index into the array of running instances'
+  cmd.default_value 0
+  cmd.arg_name 'INSTANCE'
+  cmd.flag [:n, :instance], type: Fixnum
+end
+
+def add_command_flags(cmd)
+  add_instance_flag(cmd)
+  add_target_flag(cmd)
+end
+
+desc 'Bootstrap your service and task definition from the configured definition.'
+command :bootstrap do |bootstrap|
+  add_tag_flag(bootstrap)
+  add_target_flag(bootstrap)
+
+  bootstrap.action do |_, options, _|
+    Broadside::EcsDeploy.new(options).bootstrap
+  end
+end
+
+desc 'Gives an overview of all of the deploy targets'
+command :targets do |targets|
+  targets.action do |_, options, _|
+    Broadside::Command.targets
+  end
+end
+
+desc 'Gets information about what is currently deployed.'
+command :status do |status|
+  status.desc 'Additionally displays service and task information'
+  status.switch :verbose, negatable: false
+
+  add_target_flag(status)
+
+  status.action do |_, options, _|
+    Broadside::Command.status(options)
+  end
+end
+
+desc 'Creates a single instance of the application to run a command.'
+command :run do |run|
+  run.desc 'Broadside::Command to run (wrap argument in quotes)'
+  run.arg_name 'COMMAND'
+  run.flag [:command], type: Array
+
+  add_tag_flag(run)
+  add_command_flags(run)
+
+  run.action do |_, options, _|
+    EcsDeploy.new(options).run_commands([options[:command]], started_by: 'run')
+  end
+end
+
+desc 'Tail the logs inside a running container.'
+command :logtail do |logtail|
+  logtail.desc 'Number of lines to tail'
+  logtail.default_value Broadside::Command::DEFAULT_TAIL_LINES
+  logtail.arg_name 'TAIL_LINES'
+  logtail.flag [:l, :lines], type: Fixnum
+
+  add_command_flags(logtail)
+
+  logtail.action do |_, options, _|
+    Broadside::Command.logtail(options)
+  end
+end
+
+desc 'Establish a secure shell on an instance running the container.'
+command :ssh do |ssh|
+  add_command_flags(ssh)
+
+  ssh.action do |_, options, _|
+    Broadside::Command.ssh(options)
+  end
+end
+
+desc 'Establish a shell inside a running container.'
+command :bash do |bash|
+  add_command_flags(bash)
+
+  bash.action do |_, options, _|
+    Broadside::Command.bash(options)
+  end
+end
+
+desc 'Deploy your application.'
+command :deploy do |d|
+  d.desc 'Deploys WITHOUT running predeploy commands'
+  d.command :short do |short|
+    add_tag_flag(short)
+    add_target_flag(short)
+
+    short.action do |_, options, _|
+      Broadside::EcsDeploy.new(options).short
+    end
+  end
+
+  d.desc 'Deploys WITH running predeploy commands'
+  d.command :full do |full|
+    add_tag_flag(full)
+    add_target_flag(full)
+
+    full.action do |_, options, _|
+      Broadside::EcsDeploy.new(options).full
+    end
+  end
+
+  d.desc 'Scales application to a given count'
+  d.command :scale do |scale|
+    scale.desc 'Specify a new scale for application'
+    scale.arg_name 'NUM'
+    scale.flag [:s, :scale], type: Fixnum
+
+    add_target_flag(scale)
+
+    scale.action do |_, options, _|
+      Broadside::EcsDeploy.new(options).scale(options)
+    end
+  end
+
+  d.desc 'Rolls back n releases and deploys'
+  d.command :rollback do |rollback|
+    rollback.desc 'Number of releases to rollback'
+    rollback.arg_name 'COUNT'
+    rollback.flag [:r, :rollback], type: Fixnum
+
+    add_target_flag(rollback)
+
+    rollback.action do |_, options, _|
+      Broadside::EcsDeploy.new(options).rollback(options)
+    end
+  end
+end

data/lib/broadside/gli/global.rb

@@ -0,0 +1,72 @@
+# 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 'Configuration file to use.'
+default_value 'config/broadside.conf.rb'
+arg_name 'FILE'
+flag [:c, :config]
+
+desc 'Enables debug mode'
+switch [:D, :debug], negatable: false
+
+desc 'Log level output'
+arg_name 'LOGLEVEL'
+flag [:l, :loglevel], must_match: %w(debug info warn error fatal)
+
+def call_hook(type, command, options, args)
+  hook = Broadside.config.public_send(type)
+  return if hook.nil?
+  raise "#{type} hook is not a callable proc" unless hook.is_a?(Proc)
+
+  hook_args = {
+    options: options,
+    args: args
+  }
+
+  if command.parent.is_a?(GLI::Command)
+    hook_args[:command] = command.parent.name
+    hook_args[:subcommand] = command.name
+  else
+    hook_args[:command] = command.name
+  end
+
+  debug "Calling #{type} with args '#{hook_args}'"
+  hook.call(hook_args)
+end
+
+pre do |global, command, options, args|
+  Broadside.load_config_file(global[:config])
+
+  if global[:debug]
+    Broadside.config.logger.level = ::Logger::DEBUG
+    ENV['GLI_DEBUG'] = 'true'
+  elsif global[:loglevel]
+    Broadside.config.logger.level = ::Logger.const_get(global[:loglevel].upcase)
+  end
+
+  call_hook(:prehook, command, options, args)
+  true
+end
+
+post do |global, command, options, args|
+  call_hook(:posthook, command, options, args)
+  true
+end
+
+on_error do |exception|
+  case exception
+  when Broadside::ConfigurationError
+    error exception.message, "Run your last command with --help for more information."
+    false # false skips default error handling
+  else
+    true
+  end
+end

data/lib/broadside/logging_utils.rb

@@ -0,0 +1,9 @@
+module Broadside
+  module LoggingUtils
+    %w(debug info warn error fatal).each do |log_level|
+      define_method(log_level) do |*args|
+        Broadside.config.logger.public_send(log_level.to_sym, args.join(' '))
+      end
+    end
+  end
+end

data/lib/broadside/target.rb

@@ -3,15 +3,14 @@ require 'pathname'
 
 module Broadside
   class Target
-    include VerifyInstanceVariables
-    include Utils
+    include ActiveModel::Model
+    include LoggingUtils
 
-    attr_accessor(
+    attr_reader(
       :bootstrap_commands,
+      :cluster,
       :command,
-      :env_files,
-      :env_vars,
-      :instance,
+      :docker_image,
       :name,
       :predeploy_commands,
       :scale,
@@ -20,91 +19,78 @@ module Broadside
       :task_definition_config
     )
 
-    DEFAULT_INSTANCE = 0
+    validates :cluster, :docker_image, :name, presence: true
+    validates :scale, numericality: { only_integer: true }
 
-    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!
+    validates_each(:bootstrap_commands, :predeploy_commands, allow_nil: true) do |record, attr, val|
+      record.errors.add(attr, 'is not array of arrays') unless val.is_a?(Array) && val.all? { |v| v.is_a?(Array) }
     end
 
-    def cluster
-      @cluster || config.ecs.cluster
+    validates_each(:service_config, allow_nil: true) do |record, attr, val|
+      record.errors.add(attr, 'is not a hash') unless val.is_a?(Hash)
     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")
+    validates_each(:task_definition_config, allow_nil: true) do |record, attr, val|
+      if val.is_a?(Hash)
+        if val[:container_definitions] && val[:container_definitions].size > 1
+          record.errors.add(attr, 'specifies > 1 container definition but this is not supported yet')
+        end
+      else
+        record.errors.add(attr, 'is not a hash')
       end
     end
 
-    def load_env_vars!
-      @env_files.flatten.each do |env_path|
-        env_file = Pathname.new(env_path)
+    validates_each(:command, allow_nil: true) do |record, attr, val|
+      record.errors.add(attr, 'is not an array of strings') unless val.is_a?(Array) && val.all? { |v| v.is_a?(String) }
+    end
 
-        unless env_file.absolute?
-          dir = config.file.nil? ? Dir.pwd : Pathname.new(config.file).dirname
-          env_file = env_file.expand_path(dir)
-        end
+    def initialize(name, options = {})
+      @name = name
 
-        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
+      config = options.deep_dup
+      @bootstrap_commands     = config.delete(:bootstrap_commands)
+      @cluster                = config.delete(:cluster) || Broadside.config.aws.ecs_default_cluster
+      @command                = config.delete(:command)
+      @docker_image           = config.delete(:docker_image) || Broadside.config.default_docker_image
+      @predeploy_commands     = config.delete(:predeploy_commands)
+      @scale                  = config.delete(:scale)
+      @service_config         = config.delete(:service_config)
+      @task_definition_config = config.delete(:task_definition_config)
+
+      @env_files = Array.wrap(config.delete(:env_files) || config.delete(:env_file)).map do |env_path|
+        env_file = Pathname.new(env_path)
+        next env_file if env_file.absolute?
+
+        dir = Broadside.config.config_file ? Pathname.new(Broadside.config.config_file).dirname : Dir.pwd
+        env_file.expand_path(dir)
       end
 
-      # convert env vars to format ecs expects
-      @env_vars = @env_vars.map { |k, v| { 'name' => k, 'value' => v } }
+      raise ConfigurationError, errors.full_messages unless valid?
+      warn "Target #{@name} was configured with invalid/unused options: #{config}" unless config.empty?
     end
 
-    def self.validate_types(types, target_attribute)
-      return nil if types.any? { |type| target_attribute.is_a?(type) }
+    def ecs_env_vars
+      @env_vars ||= @env_files.inject({}) do |env_variables, env_file|
+        raise ConfigurationError, "Specified env_file: '#{env_file}' does not exist!" unless env_file.exist?
 
-      "'#{target_attribute}' must be of type [#{types.join('|')}], got '#{target_attribute.class}' !"
+        begin
+          env_variables.merge(Dotenv.load(env_file))
+        rescue Dotenv::FormatError => e
+          raise e.class, "Error parsing #{env_file}: #{e.message}", e.backtrace
+        end
+      end.map { |k, v| { 'name' => k, 'value' => v } }
     end
 
-    def self.validate_commands(commands)
-      return nil if commands.nil?
-      return 'predeploy_commands must be an array' unless commands.is_a?(Array)
+    def family
+      "#{Broadside.config.application}_#{@name}"
+    end
 
-      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(', ')
+    def to_h
+      {
+        Target: @name,
+        Image: "#{@docker_image}:#{@tag || 'no_tag_configured'}",
+        Cluster: @cluster
+      }
     end
   end
 end