ecs_compose 0.1.0.pre7 → 0.1.0.pre8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ae0188dc62e80cc71af5875294462deda6c5edd
-  data.tar.gz: 8e6f777891d855a5199eb117370be12596a4fb5a
+  metadata.gz: b1650cd5ac69bc7a05d43dfb153cecd2a399c3d6
+  data.tar.gz: 2ec1eabb033e0b12c7cb7a4c16b1b945913cf2cc
 SHA512:
-  metadata.gz: e14d979474af2e9a368b1a6973fff7b0571480c55da159fad7bdee7fc0b4cf311f8a720e8dfea12196c4a5c553ddf39804d08f503270997aaacce325c117fb59
-  data.tar.gz: e880db7381c14d238fd36c12d86f42704c552e540fab0088b018375bfd1d5bcf745d1842fb590bd7bd08081a58bfa4ee5eb60a54603b294f855dd8bf334bbedd
+  metadata.gz: b7528f64aac476b999b960c3baeaa93e86f9e17422e84e4a30c2e1d0f6fe8e5395b89948cdbfa8076bc94aed51e2d8d0c15d8d12cb2e3c55cd131688061483a3
+  data.tar.gz: 538236cee418cd6cb01a26dfded1d813a5dab847a63e03776bb34783c23123a9c9535c58f8b2028581f42670bb4d9d8e228e82b1d661a9ee1c707115f56a13c9

data/ecs_compose.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "thor", "~> 0.19.1"
+  spec.add_dependency "docopt", "~> 0.5.0"
   spec.add_dependency "colorize", "~> 0.7.7"
 
   spec.add_development_dependency "bundler", "~> 1.10"

data/exe/ecs-compose

@@ -1,5 +1,185 @@
 #!/usr/bin/env ruby
 
-require "ecs_compose/cli"
+require "docopt"
+require "ecs_compose"
 
-EcsCompose::CLI.start(ARGV)
+USAGE = <<DOCOPT
+ecs-compose - Like docker-compose, but for AWS EC2 Container Service
+
+Usage:
+  ecs-compose --help
+  ecs-compose --version
+  ecs-compose [options] register [<task_def>...]
+  ecs-compose [options] up [<service>...]
+  ecs-compose [options] run [-e <name>=<value>]... [--entrypoint <entrypoint>] <task> [--] [<arg>...]
+  ecs-compose [options] json [<task_def>]
+
+Options:
+  -h, --help          Show this help message
+  --version           Print the version of this program
+  -m, --manifest <manifest>
+                      Path to an ecs-compose manifest (defaults to
+                      deploy/DEPLOY-MANIFEST.yml, takes precedence over --file)
+  -f, --file <file>   Path to docker-compose.yml file (defaults to
+                      docker-compose.yml)
+  -i, --file-info (task:<name> | service:<name>)
+                      Specify the task type and task name for a
+                      docker-compose.yml file
+  -e <name>=<value>   Set an environment variable
+  --entrypoint <entrypoint>
+                      Override the container's regular entrypoint
+
+Commands:
+  register  Registers the specified ECS task definitions (defaults to all)
+  up        Updates the specified ECS services (defaults to all)
+  run       Runs the specified task
+  json      Generate JSON for a specific task definition
+DOCOPT
+
+# Our command-line application.  Parses our rather complicated arguments,
+# then delegates all the real work to our usual internal classes.
+class App
+  include EcsCompose
+
+  DEFAULT_FILE = "docker-compose.yml"
+  DEFAULT_MANIFEST = "deploy/DEPLOY-MANIFEST.yml"
+
+  attr_reader :options, :manifest
+
+  def initialize
+    @options = Docopt::docopt(USAGE, version: EcsCompose::VERSION)
+    @manifest = load_manifest()
+
+    # Uncomment to dump the docopt parser output, which can be non-obvious.
+    #require "pp"
+    #pp(options)
+  end
+
+  # Figure out which subcommand was chosen, and run it.
+  def run
+    for command in %w{register up run json}
+      if options.fetch(command)
+        send("command_#{command}")
+        return
+      end
+    end
+    # We shouldn't ever get here.
+    raise "Unknown command: #{command}"
+  end
+
+  protected
+
+  def command_register
+    available = manifest.task_definitions
+    chosen = all_or_specified(available, options.fetch('<task_def>'))
+    chosen.each {|td| td.register }
+  end
+
+  def command_up
+    available = manifest.task_definitions.select {|td| td.type == :service }
+    chosen = all_or_specified(available, options.fetch('<service>'))
+    chosen.each {|td| td.up }
+  end
+
+  def command_run
+    available = manifest.task_definitions.select {|td| td.type == :task }
+    task_name = options.fetch('<task>')
+    task = available.find {|td| td.name == task_name } or
+      fatal_err("Cannot find task '#{task_name}'")
+
+    env = options.fetch('-e').flatten.inject({}) do |hsh, e_opt|
+      e_opt =~ /\A([^=]+)=(.*)/ or 
+        fatal_err "Can't parse '-e #{e_opt}'"
+      hsh[$1] = $2
+      hsh
+    end
+
+    command = options.fetch('<arg>')
+    command = nil if command.empty?
+
+    task.run(environment: env,
+             entrypoint: options.fetch('--entrypoint').flatten[0],
+             command: command)
+  end
+
+  def command_json
+    task_definition = options.fetch('<task_def>')[0]
+    if task_definition.nil?
+      choices = manifest.task_definitions.map {|td| td.name }
+      case choices.length
+      when 0
+        fatal_err("Please supply a manifest with at least one task definition")
+      when 1
+        task_definition = choices.first
+      else
+        fatal_err("Please choose one of: #{choices.join(', ')}")
+      end
+    end
+
+    found = manifest.task_definitions.find {|td| td.name } or
+      fatal_err("Can't find task definition: #{task_definition}")
+    puts found.to_json
+  end
+
+  # Choose either all items in `available`, or just those with the
+  # specified `names`.
+  def all_or_specified(available, names)
+    if names.empty?
+      available
+    else
+      available.select {|td| names.include?(td.name) }
+    end      
+  end
+
+  # Figure out whether we have a manifest or a docker-compose.yml.  We
+  # check supplied flags first, then defaults, and we prefer manifests
+  # when there's a tie.
+  def mode
+    if options.fetch('--manifest')
+      :manifest
+    elsif options.fetch('--file')
+      :file
+    elsif File.exist?(DEFAULT_MANIFEST)
+      :manifest
+    elsif File.exist?(DEFAULT_FILE)
+      :file
+    else
+      fatal_err("Unable to find either #{DEFAULT_FILE} or #{DEFAULT_MANIFEST}")
+    end
+  end
+
+  # Create a manifest, either by reading it in, or synthesizing it from a
+  # `docker-compose.yml` file and some extra arguments.
+  def load_manifest
+    case mode
+    when :manifest
+      Manifest.read_from_manifest(options.fetch('--manifest') || DEFAULT_MANIFEST)
+    when :file
+      info = options.fetch('--file-info')
+      if info.nil?
+        fatal_err("Must pass -i option when using docker-compose.yml")
+      end
+      unless info =~ /\A(service|task):([-_A-Za-z0-9\z]+)/
+        fatal_err("Incorrectly formatted -i option")
+      end
+      type, name = $1, $2
+      Manifest.read_from_file(options.fetch('--file') || DEFAULT_FILE,
+                              type.to_sym, name)
+    else raise "Unknown mode: #{mode}"
+    end
+  end
+
+  # Print an error and quit.
+  def fatal_err(msg)
+    STDERR.puts(msg.red)
+    exit(1)
+  end
+end
+
+# Run our application.
+begin
+  App.new.run
+rescue Docopt::Exit => e
+  puts e.message
+  exit(1)
+end

data/lib/ecs_compose/task_definition.rb

@@ -1,13 +1,52 @@
 module EcsCompose
 
-  # Information required to create an ECS task definition.
+  # Information required to create an ECS task definition, and commands to
+  # act upon it.
   class TaskDefinition
     attr_reader :type, :name, :yaml
 
+    # Create a new TaskDefinition.  The type should be either `:task` or
+    # `:service`, the name should be both the name of the ECS task
+    # definition and the corresponding ECS service (if any), and the YAML
+    # should be `docker-compose`-format YAML describing the containers
+    # associated with this task.
     def initialize(type, name, yaml)
       @name = name
       @type = type
       @yaml = yaml
     end
+
+    # Register this task definition with ECS.  Will create the task
+    # definition if it doesn't exist, and add a new version of the task.
+    def register
+      EcsCompose::Ecs.register_task_definition(to_json)
+    end
+
+    # Register this task definition with ECS, and update the corresponding
+    # service.
+    def up
+      EcsCompose::Ecs.update_service_with_json(name, to_json)
+    end
+
+    # Run this task definition as a one-shot ECS task, with the specified
+    # overrides.
+    def run(environment: {}, entrypoint: nil, command: nil)
+      puts "environment: #{environment.inspect}"
+      puts "entrypoint: #{entrypoint.inspect}"
+      puts "command: #{command.inspect}"
+      raise "Not yet implemented"
+    end
+
+    # Generate ECS task definition JSON for this instance.
+    def to_json
+      json_generator.json
+    end
+
+    protected
+
+    # Return a JSON generator for this task.
+    def json_generator
+      @json_generator ||= EcsCompose::JsonGenerator.new(name, yaml)
+    end
   end
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ecs_compose
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre7
+  version: 0.1.0.pre8
 platform: ruby
 authors:
 - Eric Kidd
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-07 00:00:00.000000000 Z
+date: 2015-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: docopt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.1
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.1
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -104,7 +104,6 @@ files:
 - exe/ecs-compose
 - go-publish.sh
 - lib/ecs_compose.rb
-- lib/ecs_compose/cli.rb
 - lib/ecs_compose/ecs.rb
 - lib/ecs_compose/json_generator.rb
 - lib/ecs_compose/manifest.rb

data/lib/ecs_compose/cli.rb

@@ -1,125 +0,0 @@
-require "ecs_compose"
-require "thor"
-
-module EcsCompose
-  # Our basic command-line interface.
-  class CLI < Thor
-    DEFAULT_FILE = "docker-compose.yml"
-    DEFAULT_MANIFEST = "deploy/DEPLOY-MANIFEST.yml"
-
-    # Force status 1 on exit. See: https://github.com/erikhuda/thor/issues/244
-    def self.exit_on_failure?
-      true
-    end
-
-    class_option(:manifest, type: :string,
-                 aliases: %w(-m),
-                 desc: "Manifest describing a set of tasks and services (takes precedence over --file) [default: #{DEFAULT_MANIFEST}]")
-    class_option(:file, type: :string,
-                 aliases: %w(-f),
-                 desc: "File describing a single task or service [default: #{DEFAULT_FILE}]")
-    class_option(:file_info, type: :string,
-                 aliases: %w(-i),
-                 desc: "Type and name for use with --file [ex: 'service:hello' or 'task:migrate']")
-
-    desc("up [SERVICES...]", "Register ECS task definitions and update services")
-    def up(*services)
-      available = manifest.task_definitions.select {|td| td.type == :service }
-      chosen = all_or_specified(available, services)
-
-      chosen.each do |service|
-        json = EcsCompose::JsonGenerator.new(service.name, service.yaml).json
-        EcsCompose::Ecs.update_service_with_json(service.name, json)
-      end
-    end
-
-    desc("register [TASK_DEFINITIONS...]", "Register ECS task definitions")
-    def register(*task_definitions)
-      available = manifest.task_definitions
-      chosen = all_or_specified(available, task_definitions)
-
-      chosen.each do |td|
-        json = EcsCompose::JsonGenerator.new(td.name, td.yaml).json
-        EcsCompose::Ecs.register_task_definition(json)
-      end
-    end
-
-    desc("json [TASK_DEFINITION]",
-         "Convert a task definition to ECS JSON format")
-    def json(task_definition=nil)
-      if task_definition.nil?
-        choices = manifest.task_definitions.map {|td| td.name }
-        case choices.length
-        when 0
-          fatal_err("Please supply a manifest with at least one task definition")
-        when 1
-          task_definition = choices.first
-        else
-          fatal_err("Please choose one of: #{choices.join(', ')}")
-        end
-      end
-
-      found = manifest.task_definitions.find {|td| td.name } or
-        fatal_err("Can't find task definition: #{task_definition}")
-      puts EcsCompose::JsonGenerator.new(found.name, found.yaml).json
-    end
-
-    protected
-
-    # Choose either all items in `available`, or just those with the
-    # specified `names`.
-    def all_or_specified(available, names)
-      if names.empty?
-        available
-      else
-        available.select {|td| names.include?(td.name) }
-      end      
-    end
-
-    # Figure out whether we have a manifest or a docker-compose.yml.  We
-    # check supplied flags first, then defaults, and we prefer manifests
-    # when there's a tie.
-    def mode
-      @mode ||=
-        if options.manifest
-          :manifest
-        elsif options.file
-          :file
-        elsif File.exist?(DEFAULT_MANIFEST)
-          :manifest
-        elsif File.exist?(DEFAULT_FILE)
-          :file
-        else
-          fatal_err("Unable to find either #{DEFAULT_FILE} or #{DEFAULT_MANIFEST}")
-        end
-    end
-
-    # Create a manifest, either by reading it in, or synthesizing it from a
-    # `docker-compose.yml` file and some extra arguments.
-    def manifest
-      @manifest ||=
-        case mode
-        when :manifest
-          Manifest.read_from_manifest(options.manifest || DEFAULT_MANIFEST)
-        when :file
-          info = options.file_info
-          if info.nil?
-            fatal_err("Must pass -i option when using docker-compose.yml")
-          end
-          unless info =~ /\A(service|task):([-_A-Za-z0-9\z]+)/
-            fatal_err("Incorrectly formatted -i option")
-          end
-          type, name = $1, $2
-          Manifest.read_from_file(options.file || DEFAULT_FILE,
-                                  type.to_sym, name)
-        else raise "Unknown mode: #{mode}"
-        end
-    end
-
-    # Print an error and quit.
-    def fatal_err(msg)
-      STDERR.puts(msg.red)
-      exit(1)
-    end
-  end
-end