ufo 0.0.6

data/lib/ufo/defaults.rb

@@ -0,0 +1,46 @@
+module Ufo
+  # To include this module must have this in initialize:
+  #
+  # def initialize(optiions, ...)
+  #   @options = options
+  #   ...
+  # end
+  #
+  # So @options must be set
+  module Defaults
+    # image: 123456789.dkr.ecr.us-east-1.amazonaws.com/sinatra
+    # # service to cluster mapping, overrides default cluster cli overrides this
+    # service_cluster:
+    #   default: prod-lo
+    #   hi-web-prod: prod-hi
+    #   hi-clock-prod: prod-lo
+    #   hi-worker-prod: prod-lo
+    #
+    # Assumes that @service is set in the class that the Defaults module is included in.
+    def default_cluster
+      service_cluster = settings.data["service_cluster"]
+      service_cluster[@service] || service_cluster["default"]
+    end
+
+    # These default service values only are used when a service is created by `ufo`
+    def default_maximum_percent
+      Integer(new_service_settings["maximum_percent"] || 200)
+    end
+
+    def default_minimum_healthy_percent
+      Integer(new_service_settings["minimum_healthy_percent"] || 100)
+    end
+
+    def default_desired_count
+      Integer(new_service_settings["desired_count"] || 1)
+    end
+
+    def new_service_settings
+      settings.data["new_service"] || {}
+    end
+
+    def settings
+      @settings ||= Settings.new(@options[:project_root])
+    end
+  end
+end

data/lib/ufo/destroy.rb

@@ -0,0 +1,60 @@
+module Ufo
+  class Destroy
+    include Defaults
+    include AwsServices
+
+    def initialize(service, options={})
+      @service = service
+      @options = options
+      @cluster = @options[:cluster] || default_cluster
+    end
+
+    def bye
+      unless are_you_sure?
+        puts "Phew, that was close"
+        exit
+      end
+
+      clusters = ecs.describe_clusters(clusters: [@cluster]).clusters
+      if clusters.size < 1
+        puts "The #{@cluster} cluster does not exist so there can be no service on that cluster to delete."
+        exit
+      end
+
+      services = ecs.describe_services(cluster: @cluster, services: [@service]).services
+      service = services.first
+      if service.nil?
+        puts "Unable to find #{@service} service to delete it."
+        exit
+      end
+      if service.status != "ACTIVE"
+        puts "The #{@service} service is not ACTIVE so no need to delete it."
+        exit
+      end
+
+      # changes desired size to 0
+      ecs.update_service(
+        desired_count: 0,
+        cluster: @cluster,
+        service: @service
+      )
+      # Cannot find all tasks scoped to a service.  Only scoped to a cluster.
+      # So will not try to stop the tasks.
+      # ask to stop them
+      #
+      resp = ecs.delete_service(
+        cluster: @cluster,
+        service: @service
+      )
+      puts "#{@service} service has been scaled down to 0 and destroyed." unless @options[:mute]
+    end
+
+    def are_you_sure?
+      return true if @options[:force]
+      puts "You are about to destroy #{@service} service on #{@cluster} cluster."
+      print "Are you sure you want to do this? (y/n) "
+      answer = $stdin.gets.strip
+      answer =~ /^y/
+    end
+  end
+end

data/lib/ufo/docker_builder.rb

@@ -0,0 +1,120 @@
+module Ufo
+  class DockerBuilder
+    include PrettyTime
+    include Execute
+
+    def initialize(options={})
+      @options = options
+      @project_root = options[:project_root] || '.'
+      @dockerfile = options[:dockerfile] || 'Dockerfile'
+      @image_namespace = options[:image_namespace] || 'ufo'
+    end
+
+    def build
+      start_time = Time.now
+      store_full_image_name
+      update_auth_token # call after store_full_image_name
+
+      command = "docker build -t #{full_image_name} -f #{@dockerfile} ."
+      say "Building docker image with:".green
+      say "  #{command}".green
+      check_dockerfile_exists
+      command = "cd #{@project_root} && #{command}"
+      success = execute(command, use_system: true)
+      unless success
+        puts "The docker image fail to build.  Are you sure the docker daemon is available?  Try running: docker version"
+        exit 1
+      end
+
+      took = Time.now - start_time
+      say "Docker image #{full_image_name} built.  " + "Took #{pretty_time(took)}.".green
+    end
+
+    def push
+      update_auth_token
+      start_time = Time.now
+      message = "Pushed #{full_image_name} docker image."
+      if @options[:noop]
+        message = "NOOP #{message}"
+      else
+        execute("docker push #{full_image_name}", use_system: true)
+      end
+      took = Time.now - start_time
+      message << " Took #{pretty_time(took)}.".green
+      puts message unless @options[:mute]
+    end
+
+    def check_dockerfile_exists
+      unless File.exist?("#{@project_root}/#{@dockerfile}")
+        puts "#{@dockerfile} does not exist.  Are you sure it exists?"
+        exit 1
+      end
+    end
+
+    def update_auth_token
+      return unless ecr_image?
+      repo_domain = "https://#{image_name.split('/').first}"
+      auth = EcrAuth.new(repo_domain)
+      auth.update
+    end
+
+    def ecr_image?
+      full_image_name =~ /\.amazonaws\.com/
+    end
+
+    # full_image - does not include the tag
+    def image_name
+      settings.data["image"]
+    end
+
+    # full_image - includes the tag
+    def full_image_name
+      unless File.exist?(docker_name_path)
+        puts "Unable to find #{docker_name_path} which contains the last docker image name that was used as a part of `ufo docker build`.  Please run `ufo docker build` first."
+        exit 1
+      end
+      IO.read(docker_name_path).strip
+    end
+
+    # Store this in a file because this name gets reference in other tasks later
+    # and we want the image name to stay the same when the commands are run separate
+    # in different processes.  So we store the state in a file.
+    # Only when a new docker build command gets run will the image name state be updated.
+    def store_full_image_name
+      dirname = File.dirname(docker_name_path)
+      FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+      full_image_name = "#{image_name}:#{@image_namespace}-#{timestamp}-#{git_sha}"
+      IO.write(docker_name_path, full_image_name)
+      IO.write("#{@project_root}/ufo/version", full_image_name)
+    end
+
+    def docker_name_path
+      # output gets entirely wiped by tasks builder so dotn use that folder
+      "#{@project_root}/ufo/docker_image_name_#{@image_namespace}.txt"
+    end
+
+    def timestamp
+      @timestamp ||= Time.now.strftime('%Y-%m-%dT%H-%M-%S')
+    end
+
+    def git_sha
+      return @git_sha if @git_sha
+      # always call this and dont use the execute method because of the noop option
+      @git_sha = `cd #{@project_root} && git rev-parse --short HEAD`
+      @git_sha.strip!
+    end
+
+    def settings
+      @settings ||= Settings.new(@project_root)
+    end
+
+    def update_dockerfile
+      updater = DockerfileUpdater.new(full_image_name, @options)
+      updater.update
+    end
+
+    def say(msg)
+      puts msg unless @options[:mute]
+    end
+  end
+end

data/lib/ufo/docker_cleaner.rb

@@ -0,0 +1,52 @@
+module Ufo
+  class DockerCleaner
+    include Execute
+
+    def initialize(docker_image_name, options)
+      # docker_image_name does not containg the tag
+      # Example: 123456789.dkr.ecr.us-east-1.amazonaws.com/image
+      @docker_image_name = docker_image_name
+      @options = options
+      @keep = options[:keep] || 3
+      @tag_prefix = options[:tag_prefix] || "ufo"
+    end
+
+    def cleanup
+      return if delete_list.empty?
+      command = "docker rmi #{delete_list}"
+      say "Cleaning up docker images...".green
+      say "Running: #{"docker rmi #{delete_list}"}"
+      return if @options[:noop]
+      execute(command, use_system: false) # to use_system: false silence output
+    end
+
+    def delete_list
+      return @delete_list if @delete_list
+
+      out = execute("docker images", live: true) # live to override the noop cli options
+      name_regexp = Regexp.new(@docker_image_name)
+      # Example tag: ufo-2016-10-19T00-36-47-211b63a
+      tag_string = "#{@tag_prefix}-\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-.{7}"
+      tag_regexp = Regexp.new(tag_string)
+      filtered_out = out.split("\n").select do |line|
+        name,tag = line.split(' ')
+        name =~ name_regexp && tag =~ tag_regexp
+      end
+
+      tags = filtered_out.map { |l| l.split(' ')[1] } # 2nd column is tag
+      tags = tags.sort.reverse  # ordered by most recent images first
+      delete_tags = tags[@keep..-1]
+      if delete_tags.nil?
+        say "No images found that matched #{@docker_image_name}:#{tag_string}"
+        @delete_list = []
+      else
+        @delete_list = delete_tags.map { |t| "#{@docker_image_name}:#{t}" }.join(' ')
+      end
+    end
+
+    def say(msg)
+      msg = "NOOP #{msg}" if @options[:noop]
+      puts msg unless @options[:mute]
+    end
+  end
+end

data/lib/ufo/dockerfile_updater.rb

@@ -0,0 +1,42 @@
+module Ufo
+  class DockerfileUpdater
+    def initialize(full_image_name, options={})
+      @full_image_name = full_image_name
+      @options = options
+      @project_root = options[:project_root] || '.'
+    end
+
+    def update
+      write_new_dockerfile
+    end
+
+    def current_dockerfile
+      @current_dockerfile ||= IO.read(dockerfile_path)
+    end
+
+    def dockerfile_path
+      "#{@project_root}/Dockerfile"
+    end
+
+    def new_dockerfile
+      lines = current_dockerfile.split("\n")
+      # replace FROM line
+      new_lines = lines.map do |line|
+                    if line =~ /^FROM /
+                      "FROM #{@full_image_name}"
+                    else
+                      line
+                    end
+                  end
+      new_lines.join("\n") + "\n"
+    end
+
+    def write_new_dockerfile
+      IO.write(dockerfile_path, new_dockerfile)
+      unless @options[:mute]
+        puts "The Dockerfile FROM statement has been updated with the latest base image:".green
+        puts "  #{@full_image_name}".green
+      end
+    end
+  end
+end

data/lib/ufo/dsl.rb

@@ -0,0 +1,93 @@
+require 'ostruct'
+
+module Ufo
+  autoload :TaskDefinition, 'ufo/dsl/task_definition'
+  autoload :Outputter, 'ufo/dsl/outputter'
+  autoload :Helper, 'ufo/dsl/helper'
+
+  class DSL
+    def initialize(template_definitions_path, options={})
+      @template_definitions_path = template_definitions_path
+      @options = options
+      @project_root = options[:project_root] || '.'
+      @task_definitions = []
+      @outputters = []
+    end
+
+    def run
+      evaluate_template_definitions
+      build_task_definitions
+      write_outputs
+    end
+
+    # All we're doing at this point is saving blocks of code into memory
+    # The instance_eval provides the task_definition and helper methods as they are part
+    # of this class.
+    def evaluate_template_definitions
+      source_code = IO.read(@template_definitions_path)
+      instance_eval(source_code, @template_definitions_path)
+    end
+
+    def build_task_definitions
+      puts "Generating Task Definitions:" unless @options[:quiet]
+      clean_existing_task_definitions
+      @task_definitions.each do |task|
+        erb_result = task.build
+        @outputters << Outputter.new(task.task_definition_name, erb_result, @options)
+      end
+    end
+
+    def clean_existing_task_definitions
+      # removing 1 file a a time instead of recursing removing the directory to be safe
+      Dir.glob("#{@options[:project_root]}/ufo/output/*").each do |path|
+        FileUtils.rm_f(path)
+      end
+    end
+
+    def write_outputs
+      @outputters.each do |outputter|
+        outputter.write
+      end
+    end
+
+    # methods available in task_definitionintions
+    def task_definition(name, &block)
+      @task_definitions << TaskDefinition.new(self, name, @options, &block)
+    end
+
+    def env_vars(text)
+      lines = filtered_lines(text)
+      lines.map do |line|
+        key,value = line.strip.split("=").map {|x| x.strip}
+        {
+          name: key,
+          value: value,
+        }
+      end
+    end
+
+    def env_file(path)
+      full_path = "#{@project_root}/#{path}"
+      unless File.exist?(full_path)
+        puts "The #{full_path} env file could not be found.  Are you sure it exists?"
+        exit 1
+      end
+      text = IO.read(full_path)
+      env_vars(text)
+    end
+
+    def filtered_lines(text)
+      lines = text.split("\n")
+      # remove comment at the end of the line
+      lines.map! { |l| l.sub(/#.*/,'').strip }
+      # filter out commented lines
+      lines = lines.reject { |l| l =~ /(^|\s)#/i }
+      # filter out empty lines
+      lines = lines.reject { |l| l.strip.empty? }
+    end
+
+    def helper
+      Helper.new(@options)
+    end
+  end
+end

data/lib/ufo/dsl/helper.rb

@@ -0,0 +1,47 @@
+# Some of variables are from the Dockerfile and some are from other places.
+#
+# * helper.full_image_name - Docker image name to be used when a the docker image is build. This is defined in ufo/settings.yml.
+# * helper.dockerfile_port - Expose port in the Dockerfile.  Only supports one exposed port, the first one that is encountered.
+
+# Simply aggregates a bunch of variables that is useful for the task_definition.
+module Ufo
+  class DSL
+    # provides some helperally context variables
+    class Helper
+      def initialize(options={})
+        @options = options
+        @project_root = options[:project_root] || '.'
+      end
+
+      ##############
+      # helper variables
+      def dockerfile_port
+        dockerfile_path = "#{@project_root}/Dockerfile"
+        if File.exist?(dockerfile_path)
+          parse_for_dockerfile_port(dockerfile_path)
+        end
+      end
+
+      def full_image_name
+        DockerBuilder.new(@options).full_image_name
+      end
+
+      #############
+      # helper methods
+      def settings
+        @settings ||= Settings.new(@project_root)
+      end
+
+      def parse_for_dockerfile_port(dockerfile_path)
+        lines = IO.read(dockerfile_path).split("\n")
+        expose_line = lines.find { |l| l =~ /^EXPOSE / }
+        if expose_line
+          md = expose_line.match(/EXPOSE (\d+)/)
+          port = md[1] if md
+        end
+        port.to_i if port
+      end
+
+    end
+  end
+end