ufo 0.1.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47240674a8c9844d9abf4f3f7541f63afbfde413
-  data.tar.gz: 6bb1a923819cd3381e11843c9916410efb50ea7c
+  metadata.gz: dfca9e6d1cee650f151b4ad478f5fd3fb48ab840
+  data.tar.gz: 76d021b7c76d3215fe4fbddd07785c26d889c31c
 SHA512:
-  metadata.gz: 0efa6e8127ab99e3ba621f7edd3bf75bede2c4c64d4d2f80efa8bc82daec6ad45f69e9c9695a3014dc0e97408e5753911492a279226c74547fda74629713ef3f
-  data.tar.gz: a43d4e17f621b7ff18fe5c18c015a417dec30dd51dac9ed1ae07abbdffdb987b63a05c177d4c4271f528e377db3a45fd35f7164a11094725b38b61c36c12ac80
+  metadata.gz: 23b34f792eeff2b250a5215a2b44c99405aa04cc33bc985c1f5ccbc6ee66587b25bc98f869e4cc3f8c03a4710a38db5147457c606cdcafedc9ca700ea420cdee
+  data.tar.gz: 5eb6c95ab9839e658f9cd4dae7275d4d1bf0c6c784f92d169e4c036e85fd341b0a36d6412707dd0e681a7978c2f2553c12d6cd9b1644650896423326b8ee310a

data/CHANGELOG.md

@@ -3,6 +3,11 @@
 All notable changes to this project will be documented in this file.
 This project *tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
 
+## [1.0.0]
+
+* add `ufo task` command
+* been using in production for a while, ready for 1.0.0 release
+
 ## [0.1.6]
 
 * default wait for deployment to false

data/Gemfile

@@ -4,4 +4,3 @@ source 'https://rubygems.org'
 gemspec
 
 gem "codeclimate-test-reporter", group: :test, require: nil
-gem "byebug"

data/README.md

@@ -1,4 +1,6 @@
-# Ufo - Build Docker Containers and Ship Them to AWS ECS
+# Ufo - A Easy Way to Build and Ship Docker Images AWS ECS
+
+[![CircleCI](https://circleci.com/gh/tongueroo/ufo.svg?style=svg)](https://circleci.com/gh/tongueroo/ufo)
 
 ## Quick Introduction
 
@@ -7,11 +9,11 @@ Ufo is a simple tool that makes building and shipping Docker containers to [AWS
 * This blog post provides an introduction to the tool: [Ufo - Build Docker Containers and Ship Them to AWS ECS](https://medium.com/@tongueroo/ufo-easily-build-docker-containers-and-ship-them-to-aws-ecs-15556a2b39f#.qqu8o4wal).
 * This presentation covers ufo also: [Ufo Ship on AWS ECS](http://www.slideshare.net/tongueroo/ufo-ship-for-aws-ecs-70885296)
 
-A summary of steps `ufo ship` takes:
+A summary of what `ufo ship` does:
 
-1. builds a docker image. 
-2. generates and registers the ECS template definition. 
-3. deploys the ECS template definition to the specified service.
+1. Builds a docker image. 
+2. Generates and registers the ECS template definition. 
+3. Deploys the ECS template definition to the specified service.
 
 Ufo deploys a task definition that is created via a template generator which is fully controllable.
 
@@ -20,13 +22,46 @@ Ufo deploys a task definition that is created via a template generator which is
 
     $ gem install ufo
 
-You will need a working version of docker installed as ufo calls the docker command.
+Dependencies: You will need a working version of docker installed as ufo shells out and calls the `docker` command.
+
+## Quick Usage
+
+### ufo ship
 
-## Usage
+To execute the ship process run:
 
-When using ufo if the ECS service does not yet exist, it will automatically be created for you.  If you are relying on this tool to create the cluster, you still need to associate ECS Container Instances to the cluster yourself.
+```bash
+ufo ship hi-web-prod--cluster mycluster
+```
 
-First initialize ufo files within your project.  Let's say you have an `hi` app.
+Note, if you have configured `ufo/settings.yml` to map hi-web-prod to the `mycluster` cluster using the service_cluster option the command becomes simply:
+
+```bash
+ufo ship hi-web-prod
+```
+
+When you run `ufo ship hi-web-prod`:
+
+1. It builds the docker image.
+2. Generates a task definition and registers it.
+3. Updates the ECS service to use it.
+
+If the ECS service hi-web-prod does not yet exist, ufo will create the service for you.
+
+By convention, if the service has a container name web, you'll get prompted to create an ELB and specify a target group arn.  The ELB and target group must already exist.
+
+You can bypass the prompt and specify the target group arn as part of the command.  The elb target group can only be associated when the service gets created for the first time.  If the service already exists then the `--target-group` parameter just gets ignored and the ECS task simply gets updated.  Example:
+
+
+```bash
+ufo ship hi-web-prod --target-group=arn:aws:elasticloadbalancing:us-east-1:12345689:targetgroup/hi-web-prod/12345
+```
+
+When using ufo if the ECS service does not yet exist, it will automatically be created for you.  Ufo will also automatically create the ECS cluster. If you are relying on this tool to create the cluster, you still need to associate ECS Container Instances to the cluster yourself.
+
+## Detailed Usage
+
+First initialize ufo files within your project.  Let's say you have an example `hi` app.
 
 ```
 $ git clone https://github.com/tongueroo/hi
@@ -43,30 +78,30 @@ Starter ufo files created.
 $
 ```
 
-Take a look at the `ufo/settings.yml` file to see that it holds some default configuration settings so you don't have to type out these options every single time.
+Take a look at the `ufo/settings.yml` file and notice that it contains some default configuration settings so you do not have to type out these options repeatedly for some of the ufo commands.
 
 ```yaml
 image: tongueroo/hi
 service_cluster:
-  default: stag # default cluster
-  hi-web: stag
-  hi-clock: stag
-  hi-worker: stag
+  default: prod # default cluster
+  hi-web-prod: blue
+  hi-clock-prod: blue
+  hi-worker-prod: blue
 ```
 
 The `image` value is the name that ufo will use for the Docker image name.
 
-The `service_cluster` mapping provides a way to set default service to cluster mappings so that you do not have to specify the `--cluster` repeatedly.  Example:
+The `service_cluster` mapping provides a way to set default service-to-cluster mappings so that you do not have to specify the `--cluster` repeatedly.  This is very helpful. For example:
 
 ```
-ufo ship hi-web --cluster hi-cluster
-ufo ship hi-web # same as above because it is configured in ufo/settings.yml
-ufo ship hi-web --cluster special-cluster # overrides any setting default fallback.
+ufo ship hi-web-prod --cluster hi-cluster
+ufo ship hi-web-prod # same as above because it is configured in ufo/settings.yml
+ufo ship hi-web-prod --cluster special-cluster # overrides the default setting in `ufo/settings.yml`.
 ```
 
-## Task Definition ERB Template and DSL Generator
+### Task Definition ERB Template and DSL Generator
 
-Ufo task definitions are is written in a template generator DSL to provide full control of the task definition that gets uploaded for each service.  We'll go over a simple example.  Here is the ERB template for `ufo/templates/main.json.erb`:
+Ufo task definitions are written as an ERB template that makes it every easily accessible and configurable to your requirements.  Here is is an example of an ERB template `ufo/templates/main.json.erb` that shows how easy it is to modfied the task definition you want to be uploaded by ufo:
 
 ```json
 {
@@ -110,16 +145,16 @@ Ufo task definitions are is written in a template generator DSL to provide full
 }
 ```
 
-The instance variable values are specified in `ufo/task_definitions.rb`.  Here's the 
+The instance variable values are specified in `ufo/task_definitions.rb` via a DSL.  Here's the
 
 
 ```ruby
-task_definition "hi-web" do
+task_definition "hi-web-prod" do
   source "main" # will use ufo/templates/main.json.erb
   variables(
     family: task_definition_name,
     # image: tongueroo/hi:ufo-[timestamp]=[sha]
-    image: helper.full_image_name, 
+    image: helper.full_image_name,
     environment: env_file('.env.prod')
     name: "web",
     container_port: helper.dockerfile_port,
@@ -128,53 +163,15 @@ task_definition "hi-web" do
 end
 ```
 
-As you can see above, the task\_definitions.rb file has some special variables and helper methods available. These helper methods provide useful contextual information about the project. For example, one of the variable provides the exposed port in the Dockerfile of the project. Here is a list of the important ones:
+The task\_definitions.rb file has some special variables and helper methods available. These helper methods provide useful contextual information about the project. For example, one of the variable provides the exposed port in the Dockerfile of the project. This why if someone changes the exported port in the Dockerfile, he will not "forgot" to also update the ufo variable as it is automatically referenced. Here is a list of the important helpers:
 
-* **helper.full\_image\_name** — The full docker image name that ufo builds. The “base” portion of the docker image name is defined in ufo/settings.yml. For example, the base portion is "tongueroo/hi" and the full image name is tongueroo/hi:ufo-[timestamp]-[sha]. So the base does not include the Docker tag and the full image name does include the tag.
+* **helper.full\_image\_name** — The full docker image name that ufo builds. The “base” portion of the docker image name is defined in ufo/settings.yml. For example, the base portion is `tongueroo/hi` and the full image name is `tongueroo/hi:ufo-[timestamp]-[sha]`. The base name does not include the generated Docker tag, which contains a timestamp and git sha of the Dockerfile that is used.
 * **helper.dockerfile\_port** — Exposed port extracted from the Dockerfile of the project. 
-* **env_file** — This method takes an .env file which contains a simple key value list of environment variables and converts the list to the proper task definition json format.
+* **env_vars(text)** — This method takes a block of text that contains the env values in key=value format and converts that block of text to the proper task definition json format.
+* **env_file(path)** — This method takes an `.env` file which contains a simple key value list of environment variables and converts the list to the proper task definition json format.
 
 The 2 classes which provide these special helper methods are in [ufo/dsl.rb](https://github.com/tongueroo/ufo/blob/master/lib/ufo/dsl.rb) and [ufo/dsl/helper.rb](https://github.com/tongueroo/ufo/blob/master/lib/ufo/dsl/helper.rb). Refer to these classes for the full list of the special variables and methods.
 
-### Customizing Templates
-
-If you want to change the template then you can follow the example in the generated ufo files. For example, if you want to create a template for the worker service.
-
-1. Create a new template under ufo/templates/worker.json.erb.
-2. Change the source in the `task_definition` using "worker" as the source.
-3. Add variables.
-
-### ufo ship
-
-Ufo uses the aforementioned files to build task definitions and then ship to them to AWS ECS.  To execute the ship process run:
-
-```bash
-ufo ship hi-web --cluster stag
-```
-
-Note, if you have configured `ufo/settings.yml` to map hi-web to the stag cluster using the service_cluster option the command becomes simply:
-
-```bash
-ufo ship hi-web
-```
-
-When you run `ufo ship hi-web`:
-
-1. It builds the docker image.
-2. Generates a task definition and registers it.
-3. Updates the ECS service to use it.
-
-If the ECS service hi-web does not yet exist, ufo will create the service for you.
-
-If the service has a container name web, you'll get prompted to create an ELB and specify a target group arn.  The ELB and target group must already exist.
-
-You can bypass the prompt and specify the target group arn as part of the command.  The elb target group can only be associated when the service gets created for the first time.  If the service already exists then the `--target-group` parameter just gets ignored and the ECS task simply gets updated.  Example:
-
-
-```bash
-ufo ship hi-web --target-group=arn:aws:elasticloadbalancing:us-east-1:12345689:targetgroup/hi-web/jdisljflsdkjl
-```
-
 ### Shipping Multiple Services with bin/deploy
 
 A common pattern is to have 3 processes: web, worker, and clock.  This is very common in rails applcations. The web process handles web traffic, the worker process handles background job processing that would be too slow and potentially block web requests, and a clock process is typically used to schedule recurring jobs. These processes use the same codebase, or same docker image, but have slightly different run time settings.  For example, the docker run command for a web process could be [puma](http://puma.io/) and the command for a worker process could be [sidekiq](http://sidekiq.org/).  Environment variables are sometimes different also.  The important key is that the same docker image is used for all 3 services but the task definition for each service is different.
@@ -186,7 +183,7 @@ This is easily accomplished with the `bin/deploy` wrapper script that the `ufo i
 
 ufo ship hi-worker --cluster stag --no-wait
 ufo ship hi-clock --cluster stag --no-wait --no-docker
-ufo ship hi-web --cluster stag --no-docker
+ufo ship hi-web-prod--cluster stag --no-docker
 ```
 
 The first `ufo ship hi-worker` command build and ships docker image to ECS, but the following two `ufo ship` commands use the `--no-docker` flag to skip the `docker build` step.  `ufo ship` will use the last built docker image as the image to be shipped.  For those curious, this is stored in `ufo/docker_image_name_ufo.txt`.
@@ -196,7 +193,7 @@ The first `ufo ship hi-worker` command build and ships docker image to ECS, but
 Ufo assumes a convention that service\_name and the task\_name are the same.  If you would like to override this convention then you can specify the task name.
 
 ```
-ufo ship hi-web --task my-task
+ufo ship hi-web-prod--task my-task
 ```
 
 This means that in the task_definition.rb you will also defined it with `my-task`.  For example:
@@ -233,21 +230,40 @@ ufo tasks register # will register all genreated task definitinos in the ufo/out
 Skips all the build docker phases of a deploy sequence and only update the service with the task definitions.
 
 ```bash
-ufo ship hi-web --no-docker
+ufo ship hi-web-prod--no-docker
 ```
 Note if you use the `--no-docker` option you should ensure that you have already push a docker image to your docker register.  Or else the task will not be able to spin up because the docker image does not exist.  I recommend that you normally use `ufo ship` most of the time.
 
 
-## Automated Docker Images Clean Up
+### Automated Docker Images Clean Up
 
 Ufo can be configured to automatically clean old images from the ECR registry after the deploy completes.  I normally set `~/.ufo/settings.yml` like so:
 
 ```yaml
-ecr_keep: 3
+ecr_keep: 30
 ```
 
 Automated Docker images clean up only works if you are using ECR registry.
 
+## Running a single task
+
+Sometimes you do not want to run a long running `service` but a one time task. Running Rails migrations are a good example of a one off task.  Here is an example of how you would run a one time task.
+
+```
+ufo task hi-migrate-prod
+```
+
+You will need to define a task definition for the migrate command also in `ufo/task_definitions.rb`.  If you only need to override the Docker command and can re-use an existing task definition like `hi-web-prod`.  You can use the `--override-command` option:
+
+```
+ufo task hi-web-prod --override-command '["bin/migrate"]'
+ufo task hi-web-prod --override-command bin/migrate
+ufo task hi-web-prod --override-command "bin/with_env bundle exec rake db:migrate:redo VERSION=xxx"
+ufo task hi-web-prod --override-command '["bin/with_env", "bundle", "exec", "rake", "db:migrate:redo", "VERSION=xxx"]''
+```
+
+The `--override-command` option takes a string. If the string has brackets in it then it will be evaluated as an Array but the option must be a string.
+
 ## Scale
 
 There is a convenience wrapper that simple executes `aws ecs update-service --service [SERVICE] --desired-count [COUNT]`

data/lib/starter_project/ufo/task_definitions.rb

@@ -13,6 +13,11 @@ common = {
   cpu: 128,
   memory_reservation: 256,
   environment: helper.env_file(".env")
+  # another example
+  # environment: helper.env_vars(%Q{
+  #   RAILS_ENV=production
+  #   SECRET_KEY_BASE=secret
+  # })
 }
 
 task_definition "<%= @app %>-web" do

data/lib/ufo.rb

@@ -17,6 +17,7 @@ module Ufo
   autoload :TasksBuilder, 'ufo/tasks_builder'
   autoload :TasksRegister, 'ufo/tasks_register'
   autoload :Ship, 'ufo/ship'
+  autoload :Task, 'ufo/task'
   autoload :EcrCleaner, 'ufo/ecr_cleaner'
   autoload :Destroy, 'ufo/destroy'
   autoload :Scale, 'ufo/scale'

data/lib/ufo/cli.rb

@@ -95,23 +95,12 @@ module Ufo
     option :ecr_keep, type: :numeric, desc: "ECR specific cleanup of old images.  Specifies how many images to keep.  Only runs if the images are ECR images. Defaults to keeping all the images."
     long_desc Help.ship
     def ship(service)
-      builder = DockerBuilder.new(options) # outside if because it need docker.full_image_name
-      if options[:docker]
-        builder.build
-        builder.push
-      end
-
-      # task definition and deploy logic are coupled in the Ship class.
-      # Example: We need to know if the task defintion is a web service to see if we need to
-      # add the elb target group.  The web service information is in the TasksBuilder
-      # and the elb target group gets set in the Ship class.
-      # So we always call these together.
-      TasksBuilder.new(options).build
+      builder = build_docker(options)
       task_definition = options[:task] || service # convention
-      TasksRegister.register(task_definition, options)
-      ship = Ship.new(service, task_definition, options)
+      register_task(task_definition, options)
+      return if ENV['TEST'] # allows quick testing of the ship CLI portion only
 
-      return if ENV['TEST'] # to allow me to quickly test most of the ship CLI portion only
+      ship = Ship.new(service, task_definition, options)
       ship.deploy
       if options[:docker]
         DockerCleaner.new(builder.image_name, options).cleanup
@@ -120,6 +109,16 @@ module Ufo
       puts "Docker image shipped: #{builder.full_image_name.green}"
     end
 
+    desc "task [TASK_DEFINITION]", "runs a one time task"
+    long_desc Help.task
+    option :docker, type: :boolean, desc: "Enable docker build and push", default: true
+    option :command, desc: "Override the command used for the container"
+    def task(task_definition)
+      build_docker(options)
+      register_task(task_definition, options)
+      Task.new(task_definition, options).run
+    end
+
     desc "destroy [SERVICE]", "destroys the ECS service"
     long_desc Help.destroy
     option :force, type: :boolean, desc: "By pass are you sure prompt."
@@ -133,5 +132,31 @@ module Ufo
     def scale(service, count)
       Scale.new(service, count, options).update
     end
+
+    desc "version", "Prints version number of installed ufo"
+    def version
+      puts Ufo::VERSION
+    end
+
+    no_tasks do
+      def build_docker(options)
+        builder = DockerBuilder.new(options) # outside if because it need docker.full_image_name
+        if options[:docker]
+          builder.build
+          builder.push
+        end
+        builder
+      end
+
+      def register_task(task_definition, options)
+        # task definition and deploy logic are coupled in the Ship class.
+        # Example: We need to know if the task defintion is a web service to see if we need to
+        # add the elb target group.  The web service information is in the TasksBuilder
+        # and the elb target group gets set in the Ship class.
+        # So we always call these together.
+        TasksBuilder.new(options).build
+        TasksRegister.register(task_definition, options)
+      end
+    end
   end
 end

data/lib/ufo/cli/help.rb

@@ -137,6 +137,28 @@ $ ufo ship hi-web-prod --no-elb-prompt
 EOL
         end
 
+        def task
+<<-EOL
+Examples:
+
+To run a one time task with ECS:
+
+$ ufo task hi-migrate-prod
+
+You can also override the command used by the Docker container in the task definitions via override-command.
+
+ufo task hi-web-prod --override-command bin/migrate
+
+ufo task hi-web-prod --override-command '["bin/migrate"]'
+
+ufo task hi-web-prod --override-command "bin/with_env bundle exec rake db:migrate:redo VERSION=xxx"
+
+ufo task hi-web-prod --override-command '["bin/with_env","bundle","exec","rake","db:migrate:redo","VERSION=xxx"]''
+
+The `--override-command` option takes a string. If the string has brackets in it then it will be evaluated as an Array but the optoin must be a string.  Also there can be no spaces in the string.
+EOL
+        end
+
         def destroy
 <<-EOL
 Examples:

data/lib/ufo/settings.rb

@@ -15,7 +15,7 @@ module Ufo
         @data = YAML.load_file(settings_path)
         @data = user_settings.merge(@data)
       else
-        puts "ERROR: No settings file file at #{settings_path}"
+        puts "ERROR: No settings file at #{settings_path}"
         puts "Please create a settings file via: ufo init"
         exit 1
       end

data/lib/ufo/ship.rb

@@ -75,23 +75,6 @@ module Ufo
       stop_old_task(deployed_service) if @stop_old_tasks
     end
 
-    def process_multiple_services
-      puts "Multi services mode" unless @options[:mute]
-      services_to_deploy = []
-      find_all_ecs_services do |ecs_service|
-        if service_pattern_match?(ecs_service.service_name)
-          services_to_deploy << ecs_service
-        end
-      end
-
-      deployed_services = services_to_deploy.map do |ecs_service|
-        update_service(ecs_service)
-      end
-
-      wait_for_all_deployments(deployed_services) if @wait_for_deployment && !@options[:noop]
-      stop_old_tasks(deployed_services) if @stop_old_tasks
-    end
-
     def service_tasks(cluster, service)
       all_task_arns = ecs.list_tasks(cluster: cluster, service_name: service).task_arns
       return [] if all_task_arns.empty?
@@ -367,19 +350,6 @@ module Ufo
       }
     end
 
-    def service_exact_match?(service_name)
-      service_name == @service
-    end
-
-    # @service is changed to a pattern to be search with.
-    #
-    # Examples:
-    #   @service == "hi-.*-prod"
-    def service_pattern_match?(service_name)
-      service_patttern = Regexp.new(@service)
-      service_name =~ service_patttern
-    end
-
     def find_ecs_service
       find_all_ecs_services.find { |ecs_service| ecs_service.service_name == @service }
     end

data/lib/ufo/task.rb

@@ -0,0 +1,53 @@
+module Ufo
+  class Task
+    include Defaults
+    include AwsServices
+
+    def initialize(task_definition, options)
+      @task_definition = task_definition
+      @options = options
+      @cluster = @options[:cluster] || default_cluster
+    end
+
+    def run
+      puts "Running task_definition: #{@task_definition}".colorize(:green) unless @options[:mute]
+      return if @options[:noop]
+      task_options = {
+        cluster: @cluster,
+        task_definition: @task_definition
+      }
+      task_options.merge!(overrides: overrides) if @options[:command]
+      resp = ecs.run_task(task_options)
+      puts "Task ARN: #{resp.tasks[0].task_arn}" unless @options[:mute]
+    end
+
+  private
+    # only using the overrides to override the container command
+    def overrides
+      command = @options[:command]
+      command = eval(command) if command.include?('[') # command is in Array form
+      container_definition = get_original_container_definition
+      {
+        container_overrides: [
+          {
+            name: container_definition[:name],
+            command: command,
+            environment: container_definition[:environment],
+          },
+        ]
+      }
+    end
+
+    def get_original_container_definition
+      resp = ecs.list_task_definitions(
+        family_prefix: @task_definition,
+        sort: "DESC"
+      )
+      # "arn:aws:ecs:us-east-1:<aws_account_id>:task-definition/wordpress:6",
+      last_definition_arn = resp.task_definition_arns.first
+      task_name = last_definition_arn.split("/").last
+      resp = ecs.describe_task_definition(task_definition: task_name)
+      container_definition = resp.task_definition.container_definitions[0].to_h
+    end
+  end
+end

data/lib/ufo/version.rb

@@ -1,3 +1,3 @@
 module Ufo
-  VERSION = "0.1.6"
+  VERSION = "1.0.0"
 end

data/spec/lib/cli_spec.rb

@@ -46,5 +46,12 @@ describe Ufo::CLI do
         expect(out).to include("Task Definitions built")
       end
     end
+
+    context "task" do
+      it "runs one time task" do
+        out = execute("bin/ufo task hi-migrate-prod #{@args}")
+        expect(out).to include("Running task_definition")
+      end
+    end
   end
 end

data/spec/lib/ecr_cleaner_spec.rb

@@ -3,7 +3,13 @@ require 'spec_helper'
 describe Ufo::EcrCleaner do
   let(:docker_image_name) { "123456789.dkr.ecr.us-east-1.amazonaws.com/my-name" }
   let(:repo_domain) { "https://123456789.dkr.ecr.us-east-1.amazonaws.com" }
-  let(:cleaner) { Ufo::EcrCleaner.new(docker_image_name, mute: true) }
+  let(:cleaner) do
+    Ufo::EcrCleaner.new(docker_image_name,
+      project_root: "spec/fixtures/hi",
+      ecr_keep: 3, # using 3 to test, default is 30
+      mute: true
+    )
+  end
   before(:each) do
     allow(cleaner).to receive(:update_auth_token).and_return(:whatever)
   end

data/spec/lib/ship_spec.rb

@@ -11,14 +11,20 @@ describe Ufo::Ship do
       stop_old_tasks: false,
     }
   end
+  let(:service) { "hi-web-prod" }
   let(:task_definition) { service }
-  let(:ship) { Ufo::Ship.new(service, task_definition, options) }
+  let(:ship) do
+    ship = Ufo::Ship.new(service, task_definition, options)
+    allow(ship).to receive(:ecs).and_return(ecs_client)
+    ship
+  end
 
-  context "single service id" do
-    let(:service) { "hi-web-prod" }
-    it "should create or update single service" do
+  context "hi-web-prod service" do
+    it "should create or update service" do
       allow(ship).to receive(:process_single_service)
+
       ship.deploy
+
       expect(ship).to have_received(:process_single_service)
     end
 
@@ -26,49 +32,37 @@ describe Ufo::Ship do
       it "should create service on first cluster" do
         allow(ship).to receive(:find_ecs_service)
         allow(ship).to receive(:create_service)
+
         ship.deploy
+
         expect(ship).to have_received(:create_service)
       end
     end
 
     context "1 services found" do
-      it "should call update service 3 times" do
+      it "should call update service" do
         allow(ship).to receive(:find_ecs_service).and_return(ecs_service("hi-web-prod"))
         allow(ship).to receive(:update_service)
+
         ship.deploy
+
         expect(ship).to have_received(:update_service).exactly(1).times
       end
     end
   end
 
-  context "multiple service pattern" do
-    let(:service) { "hi-.*-prod" }
-    it "should update multiple service that are found" do
-      allow(ship).to receive(:process_multiple_services)
-      ship.deploy
-      expect(ship).to have_received(:process_multiple_services)
-    end
-
-    context "0 services found" do
-      it "should not call update_service" do
-        allow(ship).to receive(:find_all_ecs_services)
-        allow(ship).to receive(:update_service)
-        ship.deploy
-        expect(ship).to_not have_received(:update_service)
-      end
-    end
+  # mocks
+  def ecs_client
+    ecs = double("ecs")
+    allow(ecs).to receive(:describe_clusters).and_return(ecs_describe_clusters)
+    ecs
+  end
 
-    context "3 services found" do
-      it "should call update service 3 times" do
-        allow(ship).to receive(:find_all_ecs_services).
-                          and_yield(ecs_service("hi-web-prod")).
-                          and_yield(ecs_service("hi-worker-prod")).
-                          and_yield(ecs_service("hi-clock-prod"))
-        allow(ship).to receive(:update_service)
-        ship.deploy
-        expect(ship).to have_received(:update_service).exactly(3).times
-      end
-    end
+  # ensure_cluster_exist calls this and this makes sure that the cluster 'exists'
+  def ecs_describe_clusters
+    describe_clusters = double("ecs-describe-clusters")
+    allow(describe_clusters).to receive(:clusters).and_return(["cluster1"])
+    describe_clusters
   end
 
   def ecs_service(name)

data/spec/lib/task_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Ufo::Ship do
+  let(:project_root) { File.expand_path("../../fixtures/hi", __FILE__) }
+  let(:options) do
+    {
+      project_root: project_root,
+      mute: true
+    }
+  end
+  let(:task_definition) { "hi-migrate-prod" }
+  let(:task) do
+    task = Ufo::Task.new(task_definition, options)
+    allow(task).to receive(:ecs).and_return(ecs_client)
+    task
+  end
+
+  context "hi-migrate-prod" do
+    it "should migrate the database" do
+      task.run
+
+      expect(task.ecs).to have_received(:run_task)
+    end
+  end
+
+  # mocks
+  def ecs_client
+    ecs = double("ecs")
+    fake_response = double('fake-response').as_null_object
+    allow(ecs).to receive(:run_task).and_return(fake_response)
+    ecs
+  end
+end

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ require "#{root}/lib/ufo"
 
 module Helpers
   def execute(cmd)
-    puts "Running: #{cmd}" if ENV['DEBUG']
+    puts "Running: #{cmd.colorize(:magenta)}" if ENV['DEBUG']
     out = `#{cmd}`
     puts out if ENV['DEBUG']
     out
@@ -25,4 +25,9 @@ end
 
 RSpec.configure do |c|
   c.include Helpers
+
+  c.before(:each) do
+    # ensures we never called real aws api since the fixture home folder does not have ~/.aws/credentails setup
+    ENV['HOME'] = "spec/fixtures/home"
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ufo
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 1.0.0
 platform: ruby
 authors:
 - Tung Nguyen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-28 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -223,6 +223,7 @@ files:
 - lib/ufo/scale.rb
 - lib/ufo/settings.rb
 - lib/ufo/ship.rb
+- lib/ufo/task.rb
 - lib/ufo/tasks_builder.rb
 - lib/ufo/tasks_register.rb
 - lib/ufo/templates/default.json.erb
@@ -232,6 +233,7 @@ files:
 - spec/lib/ecr_auth_spec.rb
 - spec/lib/ecr_cleaner_spec.rb
 - spec/lib/ship_spec.rb
+- spec/lib/task_spec.rb
 - spec/spec_helper.rb
 - ufo.gemspec
 homepage: https://github.com/tongueroo/ufo
@@ -254,7 +256,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Build Docker Containers and Ship Them to AWS ECS
@@ -264,4 +266,5 @@ test_files:
 - spec/lib/ecr_auth_spec.rb
 - spec/lib/ecr_cleaner_spec.rb
 - spec/lib/ship_spec.rb
+- spec/lib/task_spec.rb
 - spec/spec_helper.rb