docker-rails-app 0.3.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 89604320070bdd27a69e302b9ab8293462a8bbd7
+  data.tar.gz: 4e633b7d7f29fc3f07233be921023285f967178b
+SHA512:
+  metadata.gz: b0df7c6014209c36622f3845abdd89a8cff2c1f7f2b3f98773626795dafd9dc6713f0183eb336c5248aaee242591d7aaba1735bf4e1305841742f4542995dea1
+  data.tar.gz: 2a0ea6f57497d5702589e3fa8b7bde7a8d8094bc58c0ecfa2c58a6390f2e994c6586a5fb084039634c5a0090ce641275768163f361066a87eb464b459affa77e

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "docker_rails_app"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/docker_rails_app/import_gem_rake_tasks.rb

@@ -0,0 +1,9 @@
+require 'docker_rails_app'
+require 'rails'
+
+spec = Gem::Specification.find_by_name 'docker-rails-app'
+
+Dir.glob("#{spec.gem_dir}/lib/tasks/**/*.rake").each { |file|
+  load file
+}
+

data/lib/docker_rails_app/version.rb

@@ -0,0 +1,3 @@
+module DockerRailsApp
+  VERSION = "0.3.6"
+end

data/lib/docker_rails_app.rb

@@ -0,0 +1,5 @@
+require_relative "./support/docker_runner"
+require_relative "./support/docker_rails_app_creator"
+require "docker_rails_app/version"
+
+require "docker_rails_app/import_gem_rake_tasks"

data/lib/support/docker_api.rb

@@ -0,0 +1,81 @@
+# DOCKER_URL=tcp://qa2:4243 ruby lib/docker-api/docker_api_tests.rb 
+# DOCKER_URL=tcp://192.168.99.100:2376 ruby lib/docker-api/docker_api_tests.rb 
+require 'docker'
+
+raise "Remove this monkey patch when API library provides this stats method" if (Docker::Container.respond_to? "stats")
+class Docker::Container
+  # Non streaming stats
+  def stats(options = {})
+    path = path_for(:stats)
+    puts "Getting stats from: #{path}"
+    options[:stream] = false
+    container_stats = nil
+    begin
+      status = Timeout::timeout(5) {
+        container_stats = connection.get(path, options)
+      }
+    rescue Exception => e
+      return {error: e.message}
+    end
+    JSON.parse(container_stats)
+  end
+end
+
+class DockerApi
+  attr_accessor :connection
+  
+  # Build a connection to docker on a remote host.  Need a connection to be able to make multiple docker calls within the app to different hosts.
+  # host:   {address: "olex-qa2.openlogic.com", docker_port: 4245 }
+  def self.connection(host)
+    cert_path = ENV['DOCKER_CERT_PATH']
+    scheme = "http"
+    scheme = "https" if (ENV['DOCKER_TLS_VERIFY'] == "1")
+    
+    docker_connection_opts = {:client_cert=>"#{cert_path}/cert.pem", :client_key=>"#{cert_path}/key.pem",
+      :ssl_ca_file=>"#{cert_path}/ca.pem", :scheme => scheme}
+    
+    # docker_connection_opts = {:client_cert=>"/Users/mikemoore/.docker/machine/machines/dev/cert.pem", :client_key=>"/Users/mikemoore/.docker/machine/machines/dev/key.pem",
+    #   :ssl_ca_file=>"/Users/mikemoore/.docker/machine/machines/dev/ca.pem", :scheme=>"https"}
+    docker_connection_opts[:scheme] = "http" if (host[:ssl] == false)
+    docker_connection = Docker::Connection.new("tcp://#{host[:address]}:#{host[:docker_port]}", docker_connection_opts)
+    return docker_connection
+  end
+  
+  def initialize(url, secure = true)
+    # Docker.logger = Logger.new(STDOUT)
+    # Docker.logger.level = Logger::DEBUG
+    address = url.split("//").last.split(":").first
+    port = url.split(":").last
+    host = {address: address, docker_port: port, ssl: secure}
+    @connection = DockerApi.connection(host)
+  end
+
+  def find_container_with_name(wanted_name)
+    options = {
+      all: true
+    }
+    all_containers = Docker::Container.all(options, @connection)
+    all_containers.each do |container|
+      json = container.json
+      name = json['Name']
+      return container if (name == "/#{wanted_name}")
+    end
+    return nil
+  end
+end
+
+
+#
+# puts ""
+# puts "Here are Containers on #{docker_url}"
+# all_containers = Docker::Container.all
+# all_containers.each do |container|
+#   puts "#{container.json['Name']}"
+#   puts "   Running: #{container.json['State']['Running']}"
+#   puts "   Running: #{container.json['State']['ExitCode']}"
+#
+#   env_vars = container.json['Config']['Env']
+#   env_vars.each do |env|
+#     puts "       Env: #{env}"
+#   end
+# end

data/lib/support/docker_image_creator.rb

@@ -0,0 +1,244 @@
+require_relative "./docker_runner"
+require_relative "./docker_registry"
+
+class DockerImageCreator
+  attr_accessor :use_date_as_version
+  
+  REMOVE_INTERMEDIATE_FLAG = "--rm=true"
+  DAEMON_OPTIONS = " -d -t -P"
+  INTERACT_OPTIONS = " -a stdin -a stdout -i -t -P"
+  DOCKER_DIR = Dir.pwd + "/lib"
+  
+  attr_accessor :version_forced, :image_name_forced, :docker_host, :docker_host_secure
+  attr_reader :definition
+
+  def initialize(definition)
+    raise "Definition is nil" if definition == nil
+    @definition = definition
+    @home = FileUtils.pwd
+    @version = nil
+    @docker_host = nil
+    @docker_host_secure = nil
+  end
+
+  def use_date_as_version?
+    false
+  end
+  
+  def image_name
+    return (@image_name_forced) if (@image_name_forced)
+    build_def = @definition[:build]
+    name = @definition[:run][:image_name] if (@definition[:run])
+    name = build_def[:name] if (build_def)
+    return name
+  end 
+  
+  def docker_api
+    @docker_host = @docker_host || ENV['DOCKER_HOST']
+    @docker_host_secure = @docker_host_secure || (ENV['DOCKER_TLS_VERIFY'].to_s == '1')
+    raise "Need to define DOCKER_HOST env variable" if (!@docker_host)
+    raise "Need to define DOCKER_TLS_VERIFY env variable" if (@docker_host_secure == nil)
+    docker_api = DockerApi.new(@docker_host, @docker_host_secure)
+  end
+  
+  def build_it()
+    docker_connection = docker_api.connection
+    build_def = @definition[:build]
+    if (build_def == nil)
+      puts "Warning: build not defined for #{definition[:code]} - ignoring request"
+    else
+      begin
+        before_build(@definition)
+        remove_intermediate = REMOVE_INTERMEDIATE_FLAG
+    
+        volume_path = build_def[:volume_path]
+        build_command = nil
+      
+        image_and_version = image_name()
+        image_and_version += ":#{version()}" if (version() != nil)
+
+        opts = build_def[:api_options] || {}
+        opts[:t] = "#{image_and_version}"
+        opts[:rm] = true
+
+        Excon.defaults[:write_timeout] = 1000
+        Excon.defaults[:read_timeout] = 1000
+        puts "Building image.  Docker dir: #{docker_dir} ..."
+        
+        image = Docker::Image.build_from_dir(docker_dir, opts, docker_connection) do |v|
+          begin
+            if (log = JSON.parse(v)) && log.has_key?("stream")
+              $stdout.puts log["stream"]
+            end
+          rescue Exception => ex
+            puts "#{v}"
+          end
+        end
+      rescue Exception => ex
+        puts"Exception: #{ex.message}"
+        puts ex.backtrace
+        debugger
+        raise "Exception building image.  #{ex.message}\nCheck connection to: #{docker_connection}"
+      ensure
+        after_build(@definition)
+      end
+    end
+  end
+
+  def version
+    return (@version_forced) if (@version_forced)
+    build_def = @definition[:build]
+    raise "No build definition for: #{@definition[:code]}" if (!build_def)
+    version = 'latest'
+    version = build_def[:version] if (build_def[:version] != nil)
+    return version
+  end
+
+  def tag_it(registry)
+    raise "DOCKER_REGISTRY environment variable not defined for push operation" if registry == nil
+    do_tag(registry)
+  end
+  
+  #def do_tag(image_name, version, registry)
+  def do_tag(registry)
+    docker_connection = docker_api.connection
+    image = Docker::Image.get("#{image_name}:#{version}", {}, docker_connection)
+    puts "Tagging image: #{image_name}"
+    image.tag('repo' => "#{registry}/#{image_name()}", 'image' => 'unicorn', 'tag' => version(), force: true)
+  end
+  
+  def push_it(registry)
+    raise "DOCKER_REGISTRY environment variable not defined for push operation" if registry == nil
+    build_def = @definition[:build]
+    do_push(registry)
+  end
+  
+  def api_image(registry, docker_connection)
+    full_name = "#{registry}/#{image_name}"
+    full_name += ":#{version()}" if (version() != nil)
+    image = Docker::Image.get(full_name, {}, docker_connection)
+    puts "Pushing Image: #{full_name} ..."
+    return image
+  end
+  
+  def do_push(registry)
+    if (registry)
+      Excon.defaults[:write_timeout] = 1000
+      Excon.defaults[:read_timeout] = 1000
+    
+      docker_connection = docker_api.connection
+  
+      image = api_image(registry, docker_connection)
+
+      credentials = nil
+      result = image.push(credentials, {tag: version, repo: registry}) 
+      puts "Done pushing Image: #{registry}/#{image_name}"
+      the_registry = DockerRegistry.new(registry)
+      
+      if (the_registry.has_image_with_version?("#{image_name}", version) == false) 
+        raise "After push, image doesn't appear in registry.  Image: #{image_name}:#{version}.  Push result: #{result}"
+      end
+    else
+      puts "No registry specified for pushing"
+    end
+  end
+  
+  def run_it(host, host_ssl, interact, run_instance_count, registry = nil)
+    @docker_host = host
+    @docker_host_secure = host_ssl
+    puts "Warning:  registry not defined, assuming run is local" if registry == nil
+    run_def = @definition[:run]
+    build_def = @definition[:build]
+    if (run_def == nil)
+      puts "No run definition for: #{@definition[:code]}" 
+    else
+      (1..run_instance_count).each do |instance_index|
+        use_extension = (run_instance_count > 1)
+        run_with_extension(:next, registry, interact, use_extension)
+      end
+    end
+  end
+  
+  def run_with_extension(instance_index, registry, interact, use_extension)
+    @docker_api = DockerApi.new(@docker_host)
+    docker_runner = DockerRunner.new(self, nil)
+    docker_runner.registry = registry
+    docker_runner.instance_index = instance_index
+    docker_runner.use_extension = use_extension
+    docker_runner.interact =  interact
+    docker_runner.image_name = image_name
+    docker_runner.code = @definition[:code]
+    docker_runner.remote_address = @docker_host
+    docker_runner.secure_docker_api = @docker_host_secure
+    docker_runner.run_with_extension
+  end
+  
+  def add_it(host, host_ssl, run_instance_count, registry)
+    @docker_host = host
+    @docker_host_secure = host_ssl
+    number_added = 0
+    while (number_added < run_instance_count)
+      run_def = @definition[:run]
+      run_name = run_def[:name]
+      extension = 1
+      run_with_extension(:next, registry, false, true)
+      number_added += 1
+    end
+  end
+  
+  def kill_all(host, host_ssl)
+    docker_runner = DockerRunner.new(self, nil)
+    docker_runner.registry = nil
+    docker_runner.use_extension = true
+    docker_runner.interact =  false
+    docker_runner.remote_address = host
+    docker_runner.secure_docker_api = host_ssl
+
+    run_def = @definition[:run]
+    run_name = run_def[:name]
+    docker_runner.kill_all(run_name)
+  end
+  
+  def subtract(host, host_ssl, count)
+    docker_runner = DockerRunner.new(self, nil)
+    docker_runner.registry = nil
+    docker_runner.use_extension = true
+    docker_runner.interact =  false
+    docker_runner.remote_address = host
+    docker_runner.secure_docker_api = host_ssl
+
+    run_def = @definition[:run]
+    run_name = run_def[:name]
+    docker_runner.kill(run_name, count)
+  end
+  
+  def openlogic_home()
+    @openlogic_home = @openlogic_home[0..(@openlogic_home.length - 2)] if (@openlogic_home.end_with? "/")
+    return @openlogic_home
+  end
+
+  def before_build(definition)
+    delete_image_support_from_stage()
+    copy_image_support_to_stage()
+  end
+  
+  def after_build(definition)
+    delete_image_support_from_stage()
+  end
+  
+  def delete_image_support_from_stage()
+    FileUtils.remove_dir("#{docker_dir}image_support", true)
+  end
+  
+  def docker_dir
+    return @definition[:build][:docker_directory] + "/"
+  end
+  
+  def copy_image_support_to_stage
+    raise "Definition nil" if @definition == nil
+    raise "Build Definition nil" if @definition[:build] == nil
+    image_support_dir = "#{FileUtils.pwd}/lib/support/image_support/"
+    FileUtils.cp_r(image_support_dir, docker_dir())
+  end
+  
+end

data/lib/support/docker_rails_app_creator.rb

@@ -0,0 +1,60 @@
+require_relative "./docker_image_creator"
+require 'fileutils'
+
+class DockerRailsAppCreator < DockerImageCreator
+  ARCHIVE_TMP_FILE = "/tmp/rails_application.tar.gz"
+  
+  def docker_dir
+    dir = definition['build']['docker_dir'] || "#{FileUtils.pwd}/docker"
+  end
+  
+  def before_build(definition)
+    build_from_current_dir = true
+    stage_files_dir = docker_dir() + "/files"
+    FileUtils.rm_rf stage_files_dir
+    FileUtils.mkdir_p stage_files_dir
+
+    archive_file = ARCHIVE_TMP_FILE
+    `rm -rf #{archive_file}`
+    `tar -czf #{archive_file} --exclude=tmp/* --exclude .git --exclude "*.log" *`
+    FileUtils.mv(archive_file, stage_files_dir)
+    
+    create_database_config_file(definition, stage_files_dir)
+  end
+  
+  def create_database_config_file(definition, directory)
+    db_host_name = definition['run']['name'] + "-db"
+    File.open("#{directory}/database.yml", "w") do |file|
+      content = "
+#This file generated by Docker Rails when building docker image
+production:
+  adapter: mysql2
+  database: application_db
+  pool: 5
+  timeout: 5000
+  host: #{db_host_name}
+  port: 3306
+  user: root
+  password: password
+  persistence: :db
+      "
+      file.write(content)
+    end
+  end
+  
+  def prepare_for_git_pull
+    ssh_staging_dir = stage_files_dir + "/ssh/"
+    FileUtils.mkdir_p ssh_staging_dir
+    FileUtils.cp "#{ENV['HOME']}/.ssh/id_rsa", ssh_staging_dir
+    FileUtils.cp "#{ENV['HOME']}/.ssh/id_rsa.pub", ssh_staging_dir
+  end
+  
+  def after_build(definiton)
+    if (build_source == :current)
+      stage_files_dir = docker_dir() + "/files"
+      FileUtils.rm_f stage_files_dir
+    end
+  end
+
+  
+end

data/lib/support/docker_rails_config_reader.rb

@@ -0,0 +1,26 @@
+
+class DockerRailsConfigReader
+  attr_accessor :definitions
+  
+  def initialize
+    @definitions = nil
+    config_file = "#{FileUtils.pwd}/docker/docker-rails.json"
+    raise "Could not find your project config at: #{config_file} .  Did you run: 'rake docker:install' ?" if (!File.exist?(config_file))
+    File.open(config_file, "r") do |file|
+      str = file.read
+      @definitions = JSON.parse(str)
+    end
+  end
+  
+  def rails_app_configuration
+    @definitions.each do |definition|
+      name = definition.keys.first
+      if (name == "rails_app")
+        return definition
+      end
+    end
+    return nil
+  end
+  
+  
+end

data/lib/support/docker_registry.rb

@@ -0,0 +1,58 @@
+require 'json'
+
+class DockerRegistry
+
+  def initialize(registry_url)
+    @server = registry_url
+    if (!registry_url.include? "://")
+      registry_url = "https://#{registry_url}"
+    end
+    @connection = connection(registry_url)
+  end
+
+  def find_images()
+    response = @connection.get "/v2/_catalog"
+    raise "catalog retrieval return error: #{response.status} #{response.body}" if (response.status != 200)
+    json = JSON.parse(response.body)
+    return json['repositories']
+  end
+  
+  def find_tags(image_name)
+    response = @connection.get "/v2/#{image_name}/tags/list"
+    raise "Querying tags returned error code: #{response.status}" if (response.status != 200)
+    json = JSON.parse(response.body)
+    return json['tags']
+  end
+  
+  def has_image_with_version?(image, commit_id) 
+    tags = self.find_tags(image)
+    if (tags != nil)
+      tags.each do |tag|
+        return true if (tag == commit_id)
+      end
+    end
+    return false
+  end
+  
+  def images_and_versions
+    hash = {}
+    images = find_images()
+    images.each do |image|
+      tags = find_tags(image)
+      hash[image] = tags
+    end
+    return hash
+  end
+  
+  private 
+  
+  def connection(address)
+    if (!@service_connection)
+      @service_connection = Faraday.new address, :ssl => {:verify => false}
+    end
+    return @service_connection
+  end
+  
+  
+
+end

data/lib/support/docker_runner.rb

@@ -0,0 +1,263 @@
+require_relative "launch_support"
+require_relative "./docker_api"
+require 'pp'
+
+class DockerRunner
+  include LaunchSupport
+  attr_accessor :instance_index, :registry, :use_extension, :interact, :image_name, :code
+  attr_accessor :host, :user, :deployment_id, :version, :secure_docker_api, :remote_address
+  attr_accessor :docker_host, :docker_host_secure, :run_untagged
+  
+
+  def initialize(config)
+    @config = config
+    @run_config = config['run']
+    @build_config = config['build']
+    @run_untagged = false
+    
+    @image_name = @run_config['image_name']
+    if (!@image_name) 
+      if (@build_config)
+        @image_name = @build_config['name']
+        raise "Build config does not have 'name'" if (@image_name == nil)
+      else
+        raise "Can't find an image name.  Either specify 'name' in build config or 'image_name' in run config."
+      end
+    end
+    
+    @registry = @config['registry'] 
+    
+    @instance_index = 0
+    @use_extension = false
+    @interact = false
+    @remote_address = nil
+    @api_container = nil
+    @version = nil
+    @secure_docker_api = true
+    @build_args = nil
+  end
+  
+  def find_machine_apis
+    @run_on_apis = []
+    @all_docker_apis_in_cluster = []
+    if (@deploy_config != nil) && (@deploy_config[:hosts] != nil)
+      @deploy_config[:hosts].each do |host_key|
+        host = Hosts::HOSTS[host_key]
+        address = "tcp://#{host[:address]}:#{host[:docker_port]}"
+        docker_api = DockerApi.new(address, host[:ssl])
+        @all_docker_apis_in_cluster << docker_api
+        @run_on_apis << docker_api if (address == @remote_address) || ( @deploy_config[:targets][run_name] == :all)
+      end
+    else
+      # Config not given, we need to create api from remote address and ssl setting.  This is the only api for this class.
+      @docker_host = @docker_host || ENV['DOCKER_HOST']
+      @docker_host_secure = @docker_host_secure || (ENV['DOCKER_TLS_VERIFY'].to_s == '1')
+      docker_api = DockerApi.new(@docker_host, @docker_host_secure)
+      
+      @all_docker_apis_in_cluster << docker_api
+      @run_on_apis << docker_api
+    end
+  end
+  
+  def run_name
+    return @run_config['name']
+  end
+  
+  def image_version
+    return @version if (@version != nil)
+    the_version = 'latest'
+    the_version = @build_config['version'] if (@build_config) && (@build_config['version'] != nil)
+    return the_version
+  end
+  
+  def kill_all(name_prefix)
+    find_machine_apis
+    @all_docker_apis_in_cluster.each do |api|
+      #options = {filters: {status: [:running, :exited, :paused, :restarting]}}
+      options = {}
+      containers = Docker::Container.all(options.to_json, api.connection)
+      containers.each do |container|
+        if (container.json["Name"].start_with?("/#{name_prefix}"))
+          pp "Killing and removing: #{container.json["Name"]}"
+          container.kill() if (container.json["State"]["Running"])
+          container.remove() if (container != nil)
+        else
+          pp " * Container didn't match: #{container.json["Name"]}"
+        end
+      end
+    end
+  end
+  
+  
+  def run
+    find_machine_apis
+    raise "No run on apis" if (@run_on_apis.count == 0)
+
+    code = @code
+    instance_index = 1
+    if (@instance_index == :next)
+      options = {filters: {status: [:running]}}
+      @active_container_names = []
+      containers = Docker::Container.all(options.to_json, @run_on_apis.first.connection)
+      containers.each do |container|
+        container_json = container.json
+        container_name = container_json["Name"]
+        @active_container_names << container_name
+      end
+      
+      instance_index = 1
+      container_name_taken = true
+      while (true)
+        instance_ext = "_#{instance_index}"
+        instance_name = "/#{run_name}#{instance_ext}"
+        if (!@active_container_names.include? instance_name)
+          @instance_index = instance_index
+          break
+        else
+          instance_index += 1
+        end
+      end
+    end
+    
+    instance_ext = ""
+    instance_ext = "_#{@instance_index}" if (@use_extension)
+    instance_name = "#{run_name}#{instance_ext}"
+
+    @all_docker_apis_in_cluster.each do |docker_api|
+      kill_previous_containers_in_cluster(docker_api, instance_name)
+    end
+    image_name = image_name_with_registry()
+
+    @run_on_apis.each do |docker_api|
+      if (!@run_untagged)
+        pull_image_to_host(docker_api, registry)
+      end
+      run_container(docker_api, instance_name)
+    end
+  end
+  
+  
+  private
+
+  def pull_image_to_host(docker_api, registry)
+    return if (registry == nil)  || (@run_untagged)
+    Excon.defaults[:write_timeout] = 500
+    Excon.defaults[:read_timeout] = 500
+    options = {}
+    options[:repo] = registry
+    options[:fromImage] = "#{image_name_with_registry}:#{image_version}"
+    pp "See if Host needs to pull image (#{options[:fromImage]}).  Host: #{docker_api.connection}"
+    
+    image = Docker::Image.create(options, nil, docker_api.connection)
+  end  
+
+  def run_container(docker_api, instance_name)
+    create_options = @run_config['options'] || {}
+
+    if (!image_name_with_registry.include? ":")
+      create_options['Image'] = "#{image_name_with_registry}:#{image_version}" 
+    else
+      create_options['Image'] = image_name_with_registry 
+    end
+    create_options['name'] = instance_name
+    create_options['Labels'] = { deployer: @user, deploy_id: @deployment_id }
+    create_options['Tty'] = true if (@interact == true)
+    create_options['Entrypoint'] = ["/bin/bash"] if (@interact == true)
+      
+    pp "Running container: #{instance_name}\nOptions: #{create_options}"
+    cli_command = "docker run --name #{instance_name}"
+    if (create_options['Env'] != nil)
+      create_options['Env'].each do |env|
+        cli_command += " -e #{env}"
+      end
+    end
+    if (create_options['HostConfig'] != nil)
+      host_config = create_options['HostConfig']
+      binds = host_config['Binds']
+      if (binds != nil) 
+        binds.each do |bind|
+          cli_command += " -v #{bind}"
+        end
+      end
+      links = host_config['Links']
+      if (links != nil)
+        links.each do |link|
+          cli_command += " --link #{link}"
+        end
+      end
+      ports = host_config['PortBindings']
+      ports.keys.each do |port|
+        container_port = port.split("/").first
+        host_port = container_port
+        port_binds = ports[port]
+        port_binds.each do |bind|
+          host_port = bind['HostPort']  if (bind['HostPort'] != nil)
+          cli_command += " -p #{host_port}:#{container_port}"
+        end
+        if (port_binds.length == 0)
+          cli_command += " -p #{host_port}:#{container_port}"
+        end
+      end
+    end
+    cli_command += " -d"
+    cli_command += " #{create_options['Image']}"
+    cli_command += " #{create_options['Entrypoint']}" if (create_options['Entrypoint'] != nil)
+    puts "CLI Command: #{cli_command}"
+    
+    @api_container = Docker::Container.create(create_options, docker_api.connection)
+    puts @api_container.start
+    if (@interact)
+      pp "=================================================================="
+      pp "CONTAINER STARTED FOR INTERACTION - ENTRYPOINT NOT CALLED"
+      pp "To attach:  docker exec -it '#{instance_name}' bash"
+      pp "=================================================================="
+    end
+  end
+
+  
+  def kill_previous_containers_in_cluster(docker_api, instance_name)
+    pp "Killing and removing containers with same name: #{instance_name}"
+    @api_container = nil
+    begin
+      @api_container = Docker::Container.get(instance_name, {}, docker_api.connection)
+      puts "Killing and removing container: #{instance_name} in #{docker_api.connection}"
+      @api_container.kill()
+    rescue Docker::Error::NotFoundError => not_found_error
+      puts "No container with name \"#{instance_name}\" running.  No need to kill."    
+    end
+    
+    if (@api_container)
+      begin
+        pp "Removing container: #{instance_name}"
+        @api_container.remove() if (@api_container != nil)
+      rescue Docker::Error::NotFoundError => remove_error
+        puts "Didn't find image to remove: #{instance_name}"
+      end
+    end
+  end
+
+
+  def image_name_with_registry
+    image_name = @image_name
+    if (registry != nil) && (!@run_untagged)
+      registry_without_protocol = registry.split("://").last
+      image_name = "#{registry_without_protocol}/#{@image_name}"
+    end
+    return image_name
+  end
+
+  def container_state
+    return @api_container.json['State']
+  end
+
+  def wait_for_completion 
+    while (container_state()["Running"] == true)
+      sleep 1
+      puts "Waiting for container #{run_name} to finish."
+    end
+    exit_code = container_state()['ExitCode']
+    raise "Container failed (#{image_name_with_registry()}) Exit code: #{exit_code}" if (exit_code != 0) 
+  end
+
+  
+end

data/lib/support/image_files/DockerfileRepo

@@ -0,0 +1,49 @@
+FROM ruby:2.1.5
+
+
+ENV GIT_REPO_ADDRESS <<GIT_REPO_ADDRESS>>
+ENV DOCKER_IMAGE true
+ENV APP_HOME /application
+ENV RAILS_ENV production
+
+
+RUN apt-get update && apt-get install -y --force-yes \
+  autoconf \
+  build-essential \
+  cmake \
+  pkg-config \
+  libssl-dev \
+  libyaml-dev \
+  libreadline6-dev \
+  zlib1g-dev \
+  libffi-dev \
+  libncurses5-dev \
+  libgdbm3 \
+  libgdbm-dev \
+  libsqlite3-dev \
+  libmysqlclient-dev \
+  libv8-dev \
+#  telnet \
+  mysql-client \
+  git \
+  netcat \
+  wget && \
+  gem install --no-document bundler && \
+  echo "Set up ssh credentials for gitlab, so we can clone olex at docker image run time." && \
+  mkdir /root/.ssh
+
+
+# COPY files/rails_application.tar.gz /application
+COPY files/ssh/* /root/.ssh/
+
+ RUN  echo "RUNNING CONTAINER ENTRYPOINT" && \
+      rm -rf "$APP_HOME" && \
+      git clone "$GIT_REPO_ADDRESS" "$APP_HOME" &&\
+      cd "$APP_HOME" && \
+      bundle install --without test development
+    
+EXPOSE 3000
+
+# COPY entrypoint.sh /entrypoint.sh
+# ENTRYPOINT ["/entrypoint.sh"]
+# CMD ["/application/rails","s"]

data/lib/support/image_files/DockerfileSelf

@@ -0,0 +1,46 @@
+FROM ruby:2.1.5
+
+ENV SQL_HOST <<SQL_HOST>>
+ENV SQL_HOST_PORT 3306
+
+ENV DOCKER_IMAGE true
+ENV APP_HOME /application
+ENV RAILS_ENV production
+
+
+RUN apt-get update && apt-get install -y --force-yes \
+  autoconf \
+  build-essential \
+  cmake \
+  pkg-config \
+  libssl-dev \
+  libyaml-dev \
+  libreadline6-dev \
+  zlib1g-dev \
+  libffi-dev \
+  libncurses5-dev \
+  libgdbm3 \
+  libgdbm-dev \
+  libsqlite3-dev \
+  libmysqlclient-dev \
+  libv8-dev \
+  mysql-client \
+  netcat \
+  wget && \
+  gem install --no-document bundler &&\
+  mkdir -p "$APP_HOME" &&\
+  gem install puma
+
+COPY files/rails_application.tar.gz "$APP_HOME"
+
+RUN  echo "PREPARING APPLICATION" && \
+      cd "$APP_HOME" &&\
+      tar xzf rails_application.tar.gz && \
+      bundle install --without test development
+      
+COPY files/database.yml "$APP_HOME/config"
+    
+EXPOSE 3000
+COPY wait_for_port.sh /wait_for_port.sh
+COPY entrypoint.sh /entrypoint.sh
+ENTRYPOINT ["/entrypoint.sh"]

data/lib/support/image_files/entrypoint.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+cd "$APP_HOME"
+
+echo "================ Waiting for MySQL's port to respond"
+
+/bin/bash /wait_for_port.sh "$SQL_HOST" "$SQL_HOST_PORT"
+
+echo "================ Migrating Openlogic database"
+rake db:create db:migrate
+
+# echo "================ Starting memcache - oh no, two long running processes in the same container."
+# memcached -d -uroot
+
+
+rails s -d Puma -b 0.0.0.0 -p 3000
+tail -100f ./log/production.log

data/lib/support/image_files/wait_for_file.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+file=$1
+
+while ! exit | [ -e "$file" ]; 
+  do echo "Waiting for file: $file" && sleep 3; 
+done
+echo ""
+echo "File found: $file"

data/lib/support/image_files/wait_for_port.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+host=$1
+port=$2
+
+echo "Waiting for port to respond: $host:$port"
+while ! exit | nc -q 1 "$host" "$port"; 
+  do echo "Waiting for: $host Port: $port" && sleep 3; 
+done
+echo ""
+echo "Port responding: $host:$port"

data/lib/support/initialize_project.rb

@@ -0,0 +1,131 @@
+require 'fileutils'
+
+class InitializeProject
+  def app_docker_path
+    project_dir = FileUtils.pwd
+    docker_dir = "#{project_dir}/docker"
+    FileUtils.mkdir_p("#{docker_dir}/files")
+    return docker_dir
+  end
+  
+  def fill_in_file_param(file_path, param_name, param_value)
+    new_content = nil
+    File.open(file_path, "r") do |file|
+      content = file.read
+      search_str = "<<#{param_name}>>"
+      index = content.index(search_str)
+      content_start = content[0..(index - 1)]
+      content_end = content[(index + search_str.length), content.length]
+      new_content = content_start + param_value + content_end
+    end
+    File.open(file_path, "w") do |file|
+      file.write(new_content)
+    end
+  end
+
+  def create_configuration
+    #Use directory name as default for image name.
+    default_image_name = FileUtils.pwd.split('/').last
+    default_image_name = default_image_name.split('_').join("-")
+    default_image_name = default_image_name.split(' ').join("-")
+    
+    puts "Creating configurations."
+    puts "Enter image name of rails app (#{default_image_name}):"
+    image_name = STDIN.gets.chomp
+    if (image_name.length == 0)
+      image_name = default_image_name
+    end
+    
+    db_run_time_name = image_name + "-db"
+    
+    docker_dir = app_docker_path()
+    FileUtils.mkdir_p("#{docker_dir}/files")
+    
+    this_dir = File.dirname(__FILE__)
+    docker_file_path = "#{docker_dir}/Dockerfile"
+    copy_docker_file = true
+    if (File.exist?(docker_file_path))
+      puts "Dockerfile already exists in #{docker_dir}.  Overwrite? (y/n)"
+      overwrite = STDIN.gets.chomp
+      if (overwrite.downcase == "n")
+        copy_docker_file = false
+      end
+    end
+    
+    if (copy_docker_file)
+      FileUtils.cp("#{this_dir}/image_files/DockerfileSelf", docker_file_path)
+      fill_in_file_param(docker_file_path, 'SQL_HOST', db_run_time_name)
+      puts "Copied standard Dockerfile to: #{docker_dir}"
+    end
+    
+    
+    copy_entry_file = true
+    entry_file_path = "#{docker_dir}/entrypoint.sh"
+    if (File.exist?(entry_file_path))
+      puts "Entrypoint.sh already exists in #{docker_dir}.  Overwrite? (y/n)"
+      overwrite = STDIN.gets.chomp
+      if (overwrite.downcase == "n")
+        copy_entry_file = false
+      end
+    end
+    
+    if (copy_entry_file)
+      FileUtils.cp("#{this_dir}/image_files/entrypoint.sh", "#{docker_dir}/entrypoint.sh")
+      puts "Copied entry point file to: #{docker_dir}"
+    end
+
+    FileUtils.cp("#{this_dir}/image_files/wait_for_port.sh", "#{docker_dir}/wait_for_port.sh")
+    
+    
+    main_configuration = {
+      registry: "https://my.registry.com:5000",
+      build: {
+        name: image_name
+      },
+      run: {
+        name: image_name,
+        options: {
+          "Env" => [
+            "IS_DOCKER=true"
+          ],
+          "HostConfig" => {
+            "Links" => ["#{db_run_time_name}:#{db_run_time_name}"],
+            "PortBindings" => {
+              "3000/tcp" => [
+                      {"HostIp" => "", "HostPort" => "3000"}
+              ]
+            }
+          }
+        }
+      }
+    }
+    
+    sql_configuration = {
+      run: {
+        name: db_run_time_name,
+        image_name: "percona:5.6",
+        options: {
+          "Env" => [
+            "MYSQL_ROOT_PASSWORD=password"
+          ],
+          "HostConfig" => {
+            "PortBindings" => {
+              "3306/tcp" => []
+            }
+          }
+        }
+      }
+    }
+    
+    
+    configs = [{sql: sql_configuration}, {rails_app: main_configuration}]
+    
+    output = JSON.pretty_generate(configs)
+    config_file_path = "#{app_docker_path}/docker-rails.json"
+    File.open(config_file_path, "w") do |f|
+      f.write(output)
+    end
+    
+  end
+
+end

data/lib/support/launch_support.rb

@@ -0,0 +1,62 @@
+module LaunchSupport
+
+  def is_port_open?(ip, port)
+    begin
+      Timeout::timeout(1) do
+        begin
+          puts "Connecting to #{ip}: #{port}"
+          s = TCPSocket.new(ip, port)
+          s.close
+          return true
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          return false
+        end
+      end
+    rescue Timeout::Error
+    end
+    return false
+  end
+
+
+  def wait_for_short_lived_image_to_complete(image_run_name)
+    done = false
+    while (!done)
+      #puts "Inspecting image: #{image_run_name}"
+      output = `docker inspect #{image_run_name}`
+      #puts "Output: #{output}"
+      json = JSON.parse(output)
+      state = json.first['State']
+      is_running = state['Running']
+      exit_code =  state['ExitCode']
+      puts "Waiting for short-lived container to complete: \"#{image_run_name}\""
+      if (exit_code == 0) && (is_running == false)
+        done = true
+      elsif (exit_code != 0)
+        raise "Container failed: #{image_run_name}  - Run: docker logs -f #{image_run_name}"
+      else
+        sleep 3
+      end
+    end
+  end
+
+  def wait_for_port(ip, port)
+    while (!is_port_open?(ip, port))
+      puts "Port not ready: #{ip}:#{port}"
+      sleep 3
+    end
+  end
+
+
+  def host
+    output = `boot2docker ip`
+    if (output.strip.length == 0) || (output.include?("command not found")) || (output.include?("is not running"))
+      docker_machine_active = `docker-machine active`
+      docker_machine_active = docker_machine_active[0..(docker_machine_active.length - 2)]
+      output = `docker-machine url #{docker_machine_active}`
+      address = output.split("//")[1].split(":").first
+      return address
+    else
+      return output.strip
+    end
+  end
+end

data/lib/tasks/deploy.rake

@@ -0,0 +1,45 @@
+require_relative "../support/docker_rails_config_reader"
+require_relative "../support/docker_rails_app_creator"
+
+
+namespace :docker do 
+
+  
+  desc "Build docker image of this project"
+  task :build => :environment do 
+    config_reader = DockerRailsConfigReader.new
+    config_reader.definitions.each do |definition|
+      definition_name = definition.keys.first
+      definition_value = definition[definition_name]
+      if (definition_value['build'])
+        builder = DockerRailsAppCreator.new(definition_value)
+        builder.docker_host = "tcp://127.0.0.1:2375"
+        builder.docker_host_secure = true
+        builder.build_it
+      end
+    end
+  end
+
+  desc "Push docker image to repo"
+  task :push => :environment do 
+    config_reader = DockerRailsConfigReader.new
+    config_reader.definitions.each do |definition|
+      definition_name = definition.keys.first
+      definition_value = definition[definition_name]
+      if (definition_value['build'])
+        builder = DockerRailsAppCreator.new(definition_value)
+        builder.docker_host = "tcp://127.0.0.1:2375"
+        builder.docker_host_secure = true
+        registry = definition_value['registry']
+        if (registry)
+          builder.tag_it(registry)
+          builder.push_it(registry)
+        else
+          puts "No registry definited.  Ignoring push command."
+        end
+      end
+    end
+  end
+  
+  
+end

data/lib/tasks/initialize.rake

@@ -0,0 +1,13 @@
+require_relative "../support/docker_rails_app_creator"
+require_relative "../support/initialize_project"
+
+
+namespace :docker do 
+  
+  desc "Build docker image of this project"
+  task :install => :environment do 
+    initializer = InitializeProject.new
+    initializer.create_configuration()
+  end
+  
+end

data/lib/tasks/run.rake

@@ -0,0 +1,38 @@
+require_relative "../support/docker_rails_app_creator"
+
+namespace :docker do 
+
+  desc "Run Docker image"
+  task :run => :environment do 
+    config_reader = DockerRailsConfigReader.new
+    config_reader.definitions.each do |definition|
+      definition_name = definition.keys.first
+      definition_value = definition[definition_name]
+      if (definition_value['run'])
+        docker_runner = DockerRunner.new(definition_value)
+        docker_runner.docker_host = "tcp://127.0.0.1:2375"
+        docker_runner.docker_host_secure = true
+        docker_runner.run
+      end
+    end
+  end
+  
+
+  desc "Run Local Docker image"
+  task :run_local => :environment do 
+    config_reader = DockerRailsConfigReader.new
+    config_reader.definitions.each do |definition|
+      definition_name = definition.keys.first
+      definition_value = definition[definition_name]
+      if (definition_value['run'])
+        docker_runner = DockerRunner.new(definition_value)
+        docker_runner.docker_host = "tcp://127.0.0.1:2375"
+        docker_runner.docker_host_secure = true
+        docker_runner.run_untagged = true
+        docker_runner.run
+      end
+    end
+  end
+
+  
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: docker-rails-app
+version: !ruby/object:Gem::Version
+  version: 0.3.6
+platform: ruby
+authors:
+- Mike Moore
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.31'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.31'
+description: Puts your rails app into a Docker image
+email:
+- m.moore.denver@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup
+- lib/docker_rails_app.rb
+- lib/docker_rails_app/import_gem_rake_tasks.rb
+- lib/docker_rails_app/version.rb
+- lib/support/docker_api.rb
+- lib/support/docker_image_creator.rb
+- lib/support/docker_rails_app_creator.rb
+- lib/support/docker_rails_config_reader.rb
+- lib/support/docker_registry.rb
+- lib/support/docker_runner.rb
+- lib/support/image_files/DockerfileRepo
+- lib/support/image_files/DockerfileSelf
+- lib/support/image_files/entrypoint.sh
+- lib/support/image_files/wait_for_file.sh
+- lib/support/image_files/wait_for_port.sh
+- lib/support/initialize_project.rb
+- lib/support/launch_support.rb
+- lib/tasks/deploy.rake
+- lib/tasks/initialize.rake
+- lib/tasks/run.rake
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/docker_rails_app
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Puts your rails app into a Docker image
+test_files: []