minke 1.10.0 → 1.11.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Mzg1Y2JlMzZhZmM1YjYwNjgzOGNmMjhiNDZkNTMyMGE0NGMzMGU1OA==
+    ZjYxZTYwNDkzZDQwOTQ0OTJhYjRjZjBmYzViNDE5OWQ0YmYxOTNhMg==
   data.tar.gz: !binary |-
-    NzZlMDAxMzNmN2E2NTJiZTA4ZGMyZGRhYjIyMzZkODBmYjZlYmYwYg==
+    NGFhMWY0MTY5MDBlMGQ1ZDM1YzVmNjUyNjQwYWE2MmI5ZjRkNzAyZA==
 SHA512:
   metadata.gz: !binary |-
-    YTY2ZDlmZTQyNzI5ZjAyOWM2ZmZkOWNlZWFhMGIzNGVkMDA5NWEyYzRkOTk3
-    NGIzMjdiYzk1NDFmOWViODQ3ZjQ4YWFmNzk2NzA3MWUyY2RhM2RiOWMyOTJh
-    YTAwZDlmYTY3ZjQ3NDEwMmRlMTMzOWVjODFjY2M0NzcyNzZlOWU=
+    NDRkZmEwNzMzZDI2MjM4ZmFiMDJjZjM4ZjEyMDI3MTkwMjE0NmUyMGYwYmU3
+    M2Y1NjU4NjRhMjllNDdlYTMyODJjM2NlNDQ5N2ZmNTQyODUxNzRhY2ViOGQ3
+    NDc3MGQ3NjA2YWMxYjg5NzQ5MWY0Mzc1NGI5NGE3MzhmYzBmZTA=
   data.tar.gz: !binary |-
-    MGEyZDMyNzc1MmQ5MzAwMTAxNTdhMWQ3MjVhNDZkYTZiZTdjZTlhMWY4NmI2
-    ZmViMTI5NGVmMmNjYjlhZGMxYTVkODAzNzY2OTMzODkyY2JmMmY0OWM2NWNm
-    YmI5YzE4NjMxYzA5ZTliZmQ4MDZlYjcxMmNiNDg2MzYzM2E1YjM=
+    YTExMTAzZDUxNmRmNjQ2MzZhODM2Y2UxMzQzZTY3MzQxZjEyN2E4ZmMxMDMz
+    ZjljNWFjNWRhOWRmZTY2YWUwMTFkZTRjMjczNDBiMGUxZDRlNzJiNmEzYmIw
+    MjJlM2E3ODVmODk4ZTE2ZTY4ZDBiMTVhYjJhYmQ3N2Y2MDRhZmQ=

data/lib/minke/config/config.rb

@@ -200,6 +200,20 @@ module Minke
     ##
     # Task encapsulates the configuration for the various rake tasks like build, run, etc.
     class Task
+      ##
+      # consul_loader will specify that the given config file is loaded into Consul.
+      # instance of Minke::Config::ConsulLoader
+      #
+      # [Optional]
+      attr_accessor :consul_loader
+
+      ##
+      # health_check is the string representation of a url to check before continuing with the rest of the
+      # task a successfull 200 response from the endpoint is required to contine.
+      #
+      # [Optional]
+      attr_accessor :health_check
+
       ##
       # pre tasks will run before the main task executes.
       # instance of Minke::Config::TaskRunSettings
@@ -239,20 +253,6 @@ module Minke
       # [Optional]
       attr_accessor :tasks
 
-      ##
-      # consul_loader will specify that the given config file is loaded into Consul.
-      # instance of Minke::Config::ConsulLoader
-      #
-      # [Optional]
-      attr_accessor :consul_loader
-
-      ##
-      # health_check is the string representation of a url to check before continuing with the rest of the
-      # task a successfull 200 response from the endpoint is required to contine.
-      #
-      # [Optional]
-      attr_accessor :health_check
-
       ##
       # copy is an array of Copy instances which will be copied before the task continues.
       # instance of Minke::Config::Copy

data/lib/minke/config/reader.rb

@@ -49,18 +49,18 @@ module Minke
 
       def read_task_section section, docker_config
         Task.new.tap do |t|
-          t.docker = read_docker_section section['docker'] unless section['docker'] == nil
-          t.pre    = read_pre_post_section section['pre']  unless section['pre'] == nil
-          t.post   = read_pre_post_section section['post'] unless section['post'] == nil
+          t.consul_loader = read_consul_loader_section section['consul_loader'] unless section['consul_loader'] == nil
+          t.health_check  = read_url section['health_check']  unless section['health_check'] == nil
+          t.docker        = read_docker_section section['docker'] unless section['docker'] == nil
+          t.pre           = read_pre_post_section section['pre']  unless section['pre'] == nil
+          t.post          = read_pre_post_section section['post'] unless section['post'] == nil
         end
       end
 
       def read_pre_post_section section
         TaskRunSettings.new.tap do |tr|
-          tr.tasks         = section['tasks']                                    unless section['tasks'] == nil
-          tr.copy          = read_copy_section section['copy']                   unless section['copy'] == nil
-          tr.consul_loader = read_consul_loader_section section['consul_loader'] unless section['consul_loader'] == nil
-          tr.health_check  = read_url section['health_check']                    unless section['health_check'] == nil
+          tr.tasks         = section['tasks']                  unless section['tasks'] == nil
+          tr.copy          = read_copy_section section['copy'] unless section['copy'] == nil
         end
       end
 

data/lib/minke/docker/consul.rb

@@ -0,0 +1,57 @@
+module Minke
+  module Docker
+    class Consul
+      def initialize health_check, service_discovery, consul_loader, docker_runner, network, project_name
+        @health_check = health_check
+        @service_discovery = service_discovery
+        @consul_loader = consul_loader
+        @docker_runner = docker_runner
+        @network = network
+        @project_name = project_name
+      end
+
+      ##
+      # start_and_load_data config
+      def start_and_load_data consul_config
+        start
+        wait_for_startup consul_config.url
+        load_data consul_config.url, consul_config.config_file
+      end
+
+      ##
+      # stop consul
+      def stop
+        @docker_runner.stop_container @container
+        @docker_runner.delete_container @container
+      end
+
+      private
+      def start
+        @docker_runner.pull_image 'progrium/consul:latest' unless @docker_runner.find_image 'progrium/consul:latest'
+        @container, success = @docker_runner.create_and_run_container(
+          {
+            :image   => 'progrium/consul',
+            :network => @network,
+            :command => '-server -bootstrap -ui-dir /ui',
+            :name    => "/#{@project_name}_consul_1",
+            :deamon  => true
+          }
+        )
+
+        puts @container
+      end
+      
+      def wait_for_startup url
+        server = @service_discovery.build_address(url)
+        @health_check.wait_for_HTTPOK "#{server}/v1/status/leader"
+      end
+
+      ##
+      # Loads consul data into the given server
+      def load_data url, config_file
+        server = @service_discovery.build_address(url)
+        @consul_loader.load_config config_file, server
+      end
+    end
+  end
+end

data/lib/minke/docker/docker_compose.rb

@@ -1,23 +1,25 @@
 module Minke
   module Docker
     class DockerComposeFactory
-      def initialize system_runner, project_name
+      def initialize system_runner, project_name, docker_network = nil
         @project_name = project_name
         @system_runner = system_runner
+        @docker_network = docker_network
       end
 
       def create compose_file
-        Minke::Docker::DockerCompose.new compose_file, @system_runner, @project_name
+        Minke::Docker::DockerCompose.new compose_file, @system_runner, @project_name, @docker_network 
       end
     end
 
     class DockerCompose
       @compose_file = nil
 
-      def initialize compose_file, system_runner, project_name
+      def initialize compose_file, system_runner, project_name, docker_network = nil
         @project_name = project_name
         @compose_file = compose_file
         @system_runner = system_runner
+        @docker_network = docker_network ||= 'bridge'
       end
 
       ##
@@ -45,33 +47,44 @@ module Minke
         execute_command 'logs -f'
       end
 
-      ##
-      # return the local address and port of a containers private port
-      def public_address container, private_port
-        @system_runner.execute_and_return "docker-compose -f #{@compose_file} port #{container} #{private_port}"
-      end
-
       def execute_command command
-        unless ENV['DOCKER_NETWORK'].to_s.empty?
-          directory = create_compose_network_file
+        hash = create_compose
 
-          @system_runner.execute "docker-compose -f #{@compose_file} -f #{directory + '/docker-compose.yml'} -p #{@project_name} #{command}"
-          @system_runner.remove_entry_secure directory
-        else
-          @system_runner.execute "docker-compose -f #{@compose_file} -p #{@project_name} #{command}"
+        unless @docker_network == nil
+          hash.merge!(create_compose_network)
         end
-      end
-
-      def create_compose_network_file
-        content = { 'version' => '2'.to_s, 'networks' => {'default' => { 'external' => { 'name' => ENV['DOCKER_NETWORK'] } } } }
 
         directory = @system_runner.mktmpdir
 
         temp_file = directory + '/docker-compose.yml'
-        @system_runner.write_file temp_file, YAML.dump(content)
+        puts temp_file
+        @system_runner.write_file temp_file, YAML.dump(hash)
+
+        ex = "docker-compose -f #{temp_file} -p #{@project_name} #{command}"
+        puts ex
 
-        directory
+        @system_runner.execute ex
+        @system_runner.remove_entry_secure directory
       end
+
+      def create_compose_network
+        { 'networks' => {'default' => { 'external' => { 'name' => @docker_network } } } }
+      end
+
+      def create_compose
+        existing = YAML.load(File.read(@compose_file))
+        services = {}
+        
+        existing['services'].keys.each do |key|
+          newservice = existing['services'][key].merge({'external_links' => ["#{@project_name}_consul_1:consul"]})
+          services[key] = newservice
+        end
+
+        compose = { 'version' => 2.to_s, 'services' => services }
+        
+        compose
+      end
+
     end
   end
 end

data/lib/minke/docker/docker_runner.rb

@@ -1,6 +1,10 @@
 module Minke
   module Docker
     class DockerRunner
+      def initialize network = nil
+        @network = network ||= 'bridge'
+      end
+
       ##
       # returns the ip address that docker is running on
       def get_docker_ip_address
@@ -39,6 +43,7 @@ module Minke
       # pull_image pulls a new copy of the given image from the registry
       def pull_image image_name
       	puts "Pulling Image: #{image_name}"
+        ::Docker.options = {:chunk_size => 1, :read_timeout => 3600}
         ::Docker::Image.create('fromImage' => image_name)
       end
 
@@ -58,39 +63,42 @@ module Minke
       # Returns:
       # - Docker::Container
       # - sucess (true if command succeded without error)
-      def create_and_run_container image, volumes, environment, working_directory, cmd
+      def create_and_run_container args
       	# update the timeout for the Excon Http Client
       	# set the chunk size to enable streaming of log files
-        #puts working_directory
-        puts volumes
-        #puts environment
-
         ::Docker.options = {:chunk_size => 1, :read_timeout => 3600}
         container = ::Docker::Container.create(
-      		'Image' => image,
-      		'Cmd' => cmd,
-      		"Binds" => volumes,
-      		"Env" => environment,
-      		'WorkingDir' => working_directory)
+      		'Image'           => args[:image],
+      		'Cmd'             => args[:command],
+      		"Binds"           => args[:volumes],
+      		"Env"             => args[:environment],
+      		'WorkingDir'      => args[:working_directory],
+          'NetworkMode'     => @network,
+          'name'        => args[:name],
+          'PublishAllPorts' => true
+        )
 
         success = true
 
-        thread = Thread.new do
-          container.attach(:stream => true, :stdin => nil, :stdout => true, :stderr => true, :logs => false, :tty => false) do
-             |stream, chunk|
-              stream.to_s == 'stdout' ? color = :green : color  = :red
-              puts "#{chunk.strip}".colorize(color)
-
-              if stream.to_s == "stderr"
-                success = false
-              else
-                success = true
-              end
+        unless args[:deamon] == true 
+          thread = Thread.new do
+            container.attach(:stream => true, :stdin => nil, :stdout => true, :stderr => true, :logs => false, :tty => false) do
+              |stream, chunk|
+                stream.to_s == 'stdout' ? color = :green : color  = :red
+                puts "#{chunk.strip}".colorize(color)
+
+                if stream.to_s == "stderr"
+                  success = false
+                else
+                  success = true
+                end
+            end
           end
         end
 
         container.start
-        thread.join
+        
+        thread.join unless args[:deamon] == true
 
       	return container, success
       end
@@ -98,6 +106,8 @@ module Minke
       ##
       # build_image creates a new image from the given Dockerfile and name
       def build_image dockerfile_dir, name
+        puts dockerfile_dir
+        puts name
         ::Docker.options = {:read_timeout => 6200}
         begin
           ::Docker::Image.build_from_dir(dockerfile_dir, {:t => name}) do |v|
@@ -106,17 +116,22 @@ module Minke
             $stdout.puts data unless data == nil
           end
         rescue => e
+          puts e
           message = /.*{"message":"(.*?)"}/.match(e.to_s)
           puts "Error: #{message[1]}" unless message == nil || message.length < 1
         end
       end
 
+      def stop_container container 
+        container.stop()
+      end
+
       def delete_container container
         if container != nil
           begin
             container.delete()
           rescue => e
-            puts "Error: Unable to delete container"
+            puts "Error: Unable to delete container: #{e}"
           end
         end
       end

data/lib/minke/docker/health_check.rb

@@ -0,0 +1,61 @@
+module Minke
+  module Docker
+    ##
+    # HealthCheck checks health of a running container
+    class HealthCheck
+
+      def initialize count=nil, pause=nil
+        @count = count ||= 180
+        @pause = pause ||= 1
+        @successes = 2
+      end
+
+      ##
+      # waits until a 200 response is received from the given url
+      def wait_for_HTTPOK url
+        puts "Waiting for server #{url} to start #{@count} attempts left"
+
+        begin
+          response = RestClient.send('get', url)
+        rescue
+          puts 'Invalid response from server'
+        end
+
+        check_response response, url
+      end
+
+      private
+      def check_response response, url
+        if response == nil || !response.code.to_i == 200
+          check_failed url
+        else
+          check_success url
+        end
+      end
+
+      def check_failed url
+        @count -= 1
+        sleep @pause
+
+        if @count > 0
+          wait_for_HTTPOK url
+        else
+          raise 'Server failed to start'
+        end
+      end
+
+      def check_success url
+        if @successes > 0 
+          puts "Server: #{url} passed health check, #{@successes} checks to go..."
+
+          @successes -= 1
+          sleep @pause
+          wait_for_HTTPOK url
+        else
+          puts "Server: #{url} healthy"
+        end
+      end
+
+    end
+  end
+end

data/lib/minke/docker/network.rb

@@ -0,0 +1,23 @@
+module Minke
+  module Docker
+    class Network
+      def initialize network_name, shell_runner
+        @network_name = network_name
+        @shell_runner = shell_runner
+      end
+
+      def create
+        @shell_runner.execute("docker network create #{@network_name}") if find_network.to_s == ''
+      end
+
+      def remove
+        @shell_runner.execute("docker network rm #{@network_name}") unless find_network.to_s == ''
+      end
+
+      private 
+      def find_network
+        @shell_runner.execute_and_return("docker network ls | grep #{@network_name}")
+      end
+    end
+  end
+end

data/lib/minke/docker/service_discovery.rb

@@ -3,9 +3,10 @@ module Minke
     ##
     # ServiceDiscovery allows you to look up the publicly accessible address and port for a server
     class ServiceDiscovery
-      def initialize project_name, docker_runner
+      def initialize project_name, docker_runner, docker_network = nil
         @project_name = project_name
         @docker_runner = docker_runner
+        @docker_network = docker_network
       end
 
       ##
@@ -47,7 +48,21 @@ module Minke
         return "#{ip}:#{private_port}"
       end
 
-      :private
+      ##
+      # builds an address for the given url
+      def build_address url
+        if url.type == 'external'
+          "#{url.protocol}://#{url.address}:#{url.port}#{url.path}"
+        elsif url.type == 'bridge'
+          address = bridge_address_for @docker_network, url.address, url.port
+          "#{url.protocol}://#{address}#{url.path}"
+        elsif url.type == 'public'
+          address = public_address_for url.address, url.port
+          "#{url.protocol}://#{address}#{url.path}"
+        end
+      end
+
+      private
       def find_container_by_name name
         containers = @docker_runner.running_containers
         containers.select { |c| c.info['Names'].include?(name) }

data/lib/minke/helpers/copy.rb

@@ -0,0 +1,17 @@
+module Minke
+  module Helpers
+    class Copy
+      ##
+      # copy assets from one location to another
+      def copy_assets from, to
+        directory = to
+        if File.directory?(to)
+          directory = File.dirname(to)
+        end
+
+        Dir.mkdir directory unless Dir.exist? to
+        FileUtils.cp_r from, to
+      end
+    end
+  end
+end

data/lib/minke/helpers/error.rb

@@ -0,0 +1,12 @@
+module Minke
+  module Helpers
+    class Error
+      ##
+      # fatal_error aborts the current execute with the given message
+      def fatal_error message
+        abort message
+      end
+
+    end
+  end
+end

data/lib/minke/helpers/logger.rb

@@ -0,0 +1,17 @@
+module Minke
+  module Helpers
+    class Logger
+      def log message, level
+        ## implement logger implementation
+        case level
+        when :error
+          @logger.error message
+        when :info
+          @logger.info message
+        when :debug
+          @logger.debug message
+        end
+      end
+    end
+  end
+end

data/lib/minke/helpers/rake.rb

@@ -0,0 +1,11 @@
+module Minke
+  module Helpers
+    class Rake
+      ##
+      # invoke a rake task
+      def invoke_task task
+        Rake::Task[task].invoke
+      end
+    end
+  end
+end

data/lib/minke/{docker/system_runner.rb → helpers/shell.rb}

@@ -1,7 +1,8 @@
 module Minke
-  module Docker
-    class SystemRunner
-
+  module Helpers
+    class Shell
+      ##
+      # Executes a shell command and returns the return status
       def execute command
         system("#{command}")
       end
@@ -22,7 +23,6 @@ module Minke
       def write_file filename, data
         File.open(filename, 'w') { |file| file.write(data) }
       end
-
     end
   end
-end
+end

data/lib/minke/rake/app.rake

@@ -1,52 +1,46 @@
-namespace :app do
+require 'minke'
+
+reader = Minke::Config::Reader.new
+@config = reader.read './config.yml'
 
+namespace :app do
   desc "fetch dependent packages"
   task :fetch => ['config:set_docker_env'] do
-    create_dependencies
-
     if @config.fetch != nil
       puts 'run fetch'
-      runner = Minke::Tasks::Fetch.new @config, :fetch, @generator_config, @docker_runner, @docker_compose_factory, @service_discovery, @logger, @helper, @system_runner
+      runner = Minke::Tasks::Fetch.new create_dependencies :fetch
       runner.run
     end
   end
 
   desc "build application"
   task :build => [:fetch] do
-    create_dependencies
-
     if @config.build != nil
-      runner = Minke::Tasks::Build.new @config, :build, @generator_config, @docker_runner, @docker_compose_factory, @service_discovery, @logger, @helper, @system_runner
+      runner = Minke::Tasks::Build.new create_dependencies :build
       runner.run
     end
   end
 
   desc "run unit tests"
   task :test => [:build] do
-    create_dependencies
-
     if @config.test != nil
-      runner = Minke::Tasks::Test.new @config, :test, @generator_config, @docker_runner, @docker_compose_factory, @service_discovery, @logger, @helper, @system_runner
+      runner = Minke::Tasks::Test.new create_dependencies :test
       runner.run
     end
   end
 
   desc "build Docker image for application"
   task :build_image => [:test] do
-    create_dependencies
-
     if @config.build != nil
-      runner = Minke::Tasks::BuildImage.new @config, :build, @generator_config, @docker_runner, @docker_compose_factory, @service_discovery, @logger, @helper, @system_runner
+      runner = Minke::Tasks::BuildImage.new create_dependencies :build
       runner.run
     end
   end
 
   desc "run application with Docker Compose"
   task :run => ['config:set_docker_env'] do
-    create_dependencies
-
     if @config.run != nil
-      runner = Minke::Tasks::Run.new @config, :run, @generator_config, @docker_runner, @docker_compose_factory, @service_discovery, @logger, @helper, @system_runner
+      runner = Minke::Tasks::Run.new create_dependencies :run
       runner.run
     end
   end
@@ -56,49 +50,69 @@ namespace :app do
 
   desc "run end to end Cucumber tests USAGE: rake app:cucumber[@tag]"
   task :cucumber, [:feature] => ['config:set_docker_env'] do |t, args|
-    create_dependencies
-
     if @config.cucumber != nil
-      runner = Minke::Tasks::Cucumber.new @config, :cucumber, @generator_config, @docker_runner, @docker_compose_factory, @service_discovery, @logger, @helper, @system_runner
+      runner = Minke::Tasks::Cucumber.new create_dependencies :cucumber
       runner.run
     end
   end
 
   desc "push built image to Docker registry"
   task :push  do
-    create_dependencies
-    runner = Minke::Tasks::Push.new @config, :cucumber, @generator_config, @docker_runner, @docker_compose_factory, @service_discovery, @logger, @helper, @system_runner
+    runner = Minke::Tasks::Push.new create_dependencies :push
     runner.run
   end
 
-  def create_dependencies
-    @project_name = "minke#{SecureRandom.urlsafe_base64(12)}".downcase.gsub('-', '')
-    ENV["DOCKER_PROJECT"] = @project_name
-
-    @system_runner = Minke::Docker::SystemRunner.new
-    @docker_compose_factory ||= Minke::Docker::DockerComposeFactory.new @system_runner, @project_name
-    @docker_runner ||= Minke::Docker::DockerRunner.new
-    @service_discovery ||= Minke::Docker::ServiceDiscovery.new @project_name, @docker_runner
-
-    if @config == nil
-      reader = Minke::Config::Reader.new
-      @config = reader.read './config.yml'
-    end
-
-    if @generator_config == nil
-      variables = Minke::Generators::ConfigVariables.new.tap do |v|
-        v.application_name = @config.application_name
-        v.namespace = @config.namespace
-        v.src_root = File.expand_path('../')
-      end
-
-      Minke::Generators::Processor.load_generators
-      processor = Minke::Generators::Processor.new variables, @docker_runner
+  def create_dependencies task
+    project_name = "minke#{SecureRandom.urlsafe_base64(12)}".downcase.gsub(/[^0-9a-z ]/i, '')
+    network_name = ENV['DOCKER_NETWORK'] ||= "#{project_name}_default"
+    ENV['DOCKER_PROJECT'] = project_name
+    ENV['DOCKER_NETWORK'] = network_name
 
-      @generator_config = processor.get_generator @config.generator_name
+    variables = Minke::Generators::ConfigVariables.new.tap do |v|
+      v.application_name = @config.application_name
+      v.namespace = @config.namespace
+      v.src_root = File.expand_path('../')
     end
 
-    @logger ||= Logger.new(STDOUT)
-    @helper ||= Minke::Helpers::Helper.new
+    Minke::Generators::Processor.load_generators
+    processor = Minke::Generators::Processor.new variables, @docker_runner
+
+    generator_config = processor.get_generator @config.generator_name
+
+    task_runner = Minke::Tasks::TaskRunner.new ({
+      :rake_helper       => Minke::Helpers::Rake.new,
+      :copy_helper       => Minke::Helpers::Copy.new,
+      :service_discovery => Minke::Docker::ServiceDiscovery.new(project_name, Minke::Docker::DockerRunner.new, network_name) 
+    })
+
+    consul = Minke::Docker::Consul.new( 
+      Minke::Docker::HealthCheck.new,
+      Minke::Docker::ServiceDiscovery.new( project_name, Minke::Docker::DockerRunner.new(network_name), network_name),
+      ConsulLoader::Loader.new(ConsulLoader::ConfigParser.new),
+      Minke::Docker::DockerRunner.new(network_name),
+      network_name,
+      project_name
+    )
+
+    network = Minke::Docker::Network.new(
+      network_name,
+      Minke::Helpers::Shell.new
+    )
+
+    return {
+      :config                 => @config,
+      :task_name              => task,
+      :docker_runner          => Minke::Docker::DockerRunner.new(network_name),
+      :task_runner            => task_runner,
+      :error_helper           => Minke::Helpers::Error.new,
+      :shell_helper           => Minke::Helpers::Shell.new,
+      :logger_helper          => Minke::Helpers::Logger.new,
+      :generator_config       => generator_config,
+      :docker_compose_factory => Minke::Docker::DockerComposeFactory.new(Minke::Helpers::Shell.new, project_name, network_name),
+      :consul                 => consul,
+      :docker_network         => network,
+      :health_check           => Minke::Docker::HealthCheck.new,
+      :service_discovery      => Minke::Docker::ServiceDiscovery.new(project_name, Minke::Docker::DockerRunner.new, network_name)
+    }
   end
 end

data/lib/minke/rake/config.rake

@@ -1,6 +1,6 @@
 namespace :config do
   task :set_docker_env do
-    DOCKER_IP = Minke::Docker::DockerRunner.new.get_docker_ip_address
+    DOCKER_IP = Minke::Docker::DockerRunner.new(nil).get_docker_ip_address
     ENV['DOCKER_IP'] = DOCKER_IP
   end
 end

data/lib/minke/scripts/minke.sh

@@ -4,6 +4,7 @@ RVM_COMMAND="source /usr/local/rvm/scripts/rvm"
 ERROR="Please specify a command e.g. ./minke.sh rake app:test"
 COMMAND=""
 NEW_UUID=$(base64 /dev/urandom | tr -d '/+' | head -c 32 | tr '[:upper:]' '[:lower:]')
+NETWORK
 GEMSET='minkegems'
 GEMSETFOLDER="/usr/local/rvm/gems/ruby-2.3.1@${GEMSET}"
 
@@ -29,5 +30,4 @@ if [[ $1 != \ -g* ]]; then
 
   eval "docker network create minke_${NEW_UUID}"
   eval "${DOCKER_RUN}"
-  eval "docker network rm minke_${NEW_UUID}"
 fi

data/lib/minke/tasks/build.rb

@@ -4,14 +4,12 @@ module Minke
 
       def run args = nil
         puts "## Build application"
-        run_with_block do
-          if  @generator_settings.build_settings.build_commands.build != nil
-
-            @generator_settings.build_settings.build_commands.build.each do |command|
+        if  @generator_config.build_settings.build_commands.build != nil
+          run_with_block do
+            @generator_config.build_settings.build_commands.build.each do |command|
               puts command.to_s
-            	run_command_in_container command
+              run_command_in_container command
             end
-            
           end
         end
       end

data/lib/minke/tasks/cucumber.rb

@@ -5,18 +5,22 @@ module Minke
       def run args = nil
       	puts "## Running cucumber with tags #{args}"
 
-      	begin
-          status = 0
-      	  @compose.up
+        compose_file = @config.compose_file_for(@task_name)
+        compose_file = File.expand_path(compose_file)
+        compose = @docker_compose_factory.create compose_file unless compose_file == nil
 
-          run_with_block do
-            status = @helper.execute_shell_command "cucumber --color -f pretty #{get_features args}"
+        run_with_block do
+          status = false
+          begin
+            compose.up
+            server_address = @service_discovery.build_address(@task_settings.health_check) 
+            @health_check.wait_for_HTTPOK(server_address) unless @task_settings.health_check == nil
+            
+            status = @shell_helper.execute "cucumber --color -f pretty #{get_features args}"
+          ensure
+            compose.down
+            @error_helper.fatal_error("Cucumber steps failed") unless status == true
           end
-
-      	ensure
-      		@compose.down
-
-          @helper.fatal_error "Cucumber steps failed" unless status == 0
       	end
       end
 

data/lib/minke/tasks/fetch.rb

@@ -6,12 +6,13 @@ module Minke
         puts "## Update dependencies"
 
         puts '### Install gems'
-        @system_runner.execute('bundle install -j3 && bundle update')
+        @shell_helper.execute('bundle install -j3 && bundle update')
 
         puts '### Install generator dependencies'
-        run_with_block do
-          if @generator_settings.build_settings.build_commands.fetch != nil
-            @generator_settings.build_settings.build_commands.fetch.each do |command|
+        
+        if @generator_config.build_settings.build_commands.fetch != nil
+          run_with_block do
+            @generator_config.build_settings.build_commands.fetch.each do |command|
               run_command_in_container command
             end
           end

data/lib/minke/tasks/run.rb

@@ -5,16 +5,18 @@ module Minke
       def run args = nil
         puts "## Run application with docker compose"
 
-      	begin
-          @compose.up
+        compose_file = @config.compose_file_for(@task_name)
+        compose_file = File.expand_path(compose_file)
+        compose = @docker_compose_factory.create compose_file unless compose_file == nil
 
-          run_with_block do
-            @compose.logs
+        run_with_block do
+          begin
+            compose.up
+            compose.logs
+          ensure
+            compose.down
           end
-
-      	ensure
-      		@compose.down
-      	end
+        end
       end
 
     end

data/lib/minke/tasks/task.rb

@@ -4,109 +4,83 @@ module Minke
     # Task is a base implementation of a rake task such as fetch, build, etc
     class Task
 
-      def initialize config, task, generator_settings, docker_runner, docker_compose_factory, service_discovery, logger, helper, system_runner
-        @config = config
-        @task = task
-        @generator_settings = generator_settings
-        @docker_runner = docker_runner
-        @service_discovery = service_discovery
-        @logger = logger
-        @helper = helper
-        @task_settings = config.send(task)
-        @system_runner = system_runner
-
-        @build_image = @generator_settings.build_settings.docker_settings.image
-        @build_image = config.build_image_for(task) unless config.build_image_for(task) == nil
-
-        @build_file = config.build_docker_file_for(task)
-
-        @compose_file = config.compose_file_for(task)
-
-        @compose = docker_compose_factory.create @compose_file unless @compose_file == nil
+      def initialize args
+        @config                 = args[:config]
+        @task_name              = args[:task_name]
+        @docker_runner          = args[:docker_runner]
+        @task_runner            = args[:task_runner]
+        @error_helper           = args[:error_helper]
+        @shell_helper           = args[:shell_helper]
+        @logger_helper          = args[:logger_helper]
+        @generator_config       = args[:generator_config]
+        @docker_compose_factory = args[:docker_compose_factory]
+        @consul                 = args[:consul]
+        @docker_network         = args[:docker_network]
+        @health_check           = args[:health_check]
+        @service_discovery      = args[:service_discovery]
+        @task_settings          = @config.send(@task_name)
       end
 
       ##
       # run_with_config executes the task steps for the given
       # - block containing custom actions
       def run_with_block
-        #TODO: Need to add some tests for this stuff
-        run_steps @task_settings.pre unless @task_settings == nil || @task_settings.pre == nil
-
-        yield if block_given?
-
-        run_steps @task_settings.post unless @task_settings == nil || @task_settings.post == nil
-      end
+        puts "Starting Consul"
+        begin
+          @docker_network.create
+          @consul.start_and_load_data @task_settings.consul_loader unless @task_settings.consul_loader == nil
+          @task_runner.run_steps(@task_settings.pre) unless @task_settings == nil || @task_settings.pre == nil
 
-      ##
-      # execute the defined steps in the given Minke::Config::TaskRunSettings
-      def run_steps steps
-        execute_rake_tasks steps.tasks unless steps.tasks == nil
-        load_consul_data steps.consul_loader unless steps.consul_loader == nil
-        wait_for_health_check steps.health_check unless steps.health_check == nil
-        copy_assets steps.copy unless steps.copy == nil
-      end
+          yield if block_given?
 
-      ##
-      # execute an array of rake tasks
-      def execute_rake_tasks tasks
-        tasks.each { |t| @helper.invoke_task t }
+          @task_runner.run_steps(@task_settings.post) unless @task_settings == nil || @task_settings.post == nil
+        ensure
+          puts "Stopping Consul"
+          @consul.stop unless @task_settings.consul_loader == nil
+          @docker_network.remove
+        end
       end
 
       ##
-      # load consul config
-      def load_consul_data config
-        @helper.load_consul_data build_address(config.url), config.config_file
-      end
-
-      def wait_for_health_check url
-        @helper.wait_for_HTTPOK build_address(url), 0, 3
-      end
-
-      def copy_assets assets
-        assets.each { |a| @helper.copy_assets a.from, a.to }
-      end
-
+      # runs the given command in a docker container
       def run_command_in_container command
         begin
-          settings = @generator_settings.build_settings.docker_settings
-          if @build_file != nil
-            @build_image = "#{@config.application_name}-buildimage"
-            @docker_runner.build_image @build_file, @build_image
-          else
-            @docker_runner.pull_image @build_image unless @docker_runner.find_image @build_image
-          end
-
-          container, success = @docker_runner.create_and_run_container @build_image, settings.binds, settings.env, settings.working_directory, command
+          settings = @generator_config.build_settings.docker_settings
+          build_image = create_container_image
+
+          args = {
+            :image             => build_image,
+            :command           => command,
+            :volumes           => settings.binds,
+            :environment       => settings.env,
+            :working_directory => settings.working_directory
+          }
+          container, success = @docker_runner.create_and_run_container args
 
           # throw exception if failed
-          @helper.fatal_error "Unable to run command #{command}" unless success
+          @error_helper.fatal_error "Unable to run command #{command}" unless success
         ensure
           @docker_runner.delete_container container
         end
       end
 
-      def build_address url
-        if url.type == 'external'
-          "#{url.protocol}://#{url.address}:#{url.port}#{url.path}"
-        elsif url.type == 'bridge'
-          address = @service_discovery.bridge_address_for ENV['DOCKER_NETWORK'], url.address, url.port
-          "#{url.protocol}://#{address}#{url.path}"
-        elsif url.type == 'public'
-          address = @service_discovery.public_address_for url.address, url.port
-          "#{url.protocol}://#{address}#{url.path}"
+      ##
+      # Pulls the build image for the container from the registry if one is supplied,
+      # if a build file is specified an image is built. 
+      def create_container_image
+        build_image = @generator_config.build_settings.docker_settings.image
+        build_image = @config.build_image_for(@task_name) unless @config.build_image_for(@task_name) == nil
+
+        build_file = @config.build_docker_file_for(@task_name)
+
+        if build_file != nil
+          build_image = "#{@config.application_name}-buildimage"
+          @docker_runner.build_image build_file, build_image
+        else
+          @docker_runner.pull_image build_image unless @docker_runner.find_image build_image
         end
-      end
 
-      def log message, level
-        ## implement logger implementation
-        case level
-        when :error
-          @logger.error message
-        when :info
-          @logger.info message
-        when :debug
-          @logger.debug message
-        end
+        build_image
       end
 
     end

data/lib/minke/tasks/task_runner.rb

@@ -0,0 +1,33 @@
+module Minke
+  module Tasks
+    class TaskRunner
+
+      def initialize args
+        @rake_helper       = args[:rake_helper]
+        @copy_helper       = args[:copy_helper]
+        @service_discovery = args[:service_discovery]
+      end
+
+      ##
+      # execute the defined steps in the given Minke::Config::TaskRunSettings
+      def run_steps steps
+        execute_rake_tasks steps.tasks unless steps.tasks == nil
+        copy_assets steps.copy unless steps.copy == nil
+      end
+
+      private
+      ##
+      # execute an array of rake tasks
+      def execute_rake_tasks tasks
+        tasks.each { |t| @rake_helper.invoke_task t }
+      end
+
+      ##
+      # copys the assets defined in the step
+      def copy_assets assets
+        assets.each { |a| @copy_helper.copy_assets a.from, a.to }
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/test.rb

@@ -6,7 +6,7 @@ module Minke
         puts "## Test application"
 
         run_with_block do
-          @generator_settings.build_settings.build_commands.test.each do |command|
+          @generator_config.build_settings.build_commands.test.each do |command|
           	run_command_in_container command
           end
         end

data/lib/minke/version.rb

@@ -1,3 +1,3 @@
 module Minke
-  VERSION = "1.10.0"
+  VERSION = "1.11.0"
 end

data/lib/minke.rb

@@ -17,16 +17,23 @@ require 'sshkey'
 
 require 'minke/version'
 
-require 'minke/helpers/helper'
+require 'minke/helpers/copy'
+require 'minke/helpers/error'
+require 'minke/helpers/logger'
+require 'minke/helpers/rake'
+require 'minke/helpers/shell'
 
 require 'minke/docker/docker_compose'
 require 'minke/docker/docker_runner'
-require 'minke/docker/system_runner'
 require 'minke/docker/service_discovery'
+require 'minke/docker/health_check'
+require 'minke/docker/consul'
+require 'minke/docker/network'
 
 require 'minke/config/config'
 require 'minke/config/reader'
 
+require 'minke/tasks/task_runner'
 require 'minke/tasks/task'
 require 'minke/tasks/build'
 require 'minke/tasks/cucumber'

data/minke.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'guard'
   spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'webmock'
 
   spec.add_runtime_dependency 'sshkey'
   spec.add_runtime_dependency 'colorize'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minke
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Nic Jackson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-08 00:00:00.000000000 Z
+date: 2016-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sshkey
   requirement: !ruby/object:Gem::Requirement
@@ -209,10 +223,12 @@ files:
 - lib/minke.rb
 - lib/minke/config/config.rb
 - lib/minke/config/reader.rb
+- lib/minke/docker/consul.rb
 - lib/minke/docker/docker_compose.rb
 - lib/minke/docker/docker_runner.rb
+- lib/minke/docker/health_check.rb
+- lib/minke/docker/network.rb
 - lib/minke/docker/service_discovery.rb
-- lib/minke/docker/system_runner.rb
 - lib/minke/encryption/encryption.rb
 - lib/minke/encryption/key_locator.rb
 - lib/minke/generators/config.rb
@@ -221,7 +237,11 @@ files:
 - lib/minke/generators/processor.rb
 - lib/minke/generators/register.rb
 - lib/minke/generators/shell_script.rb
-- lib/minke/helpers/helper.rb
+- lib/minke/helpers/copy.rb
+- lib/minke/helpers/error.rb
+- lib/minke/helpers/logger.rb
+- lib/minke/helpers/rake.rb
+- lib/minke/helpers/shell.rb
 - lib/minke/rake/app.rake
 - lib/minke/rake/config.rake
 - lib/minke/rake/docker.rake
@@ -233,6 +253,7 @@ files:
 - lib/minke/tasks/push.rb
 - lib/minke/tasks/run.rb
 - lib/minke/tasks/task.rb
+- lib/minke/tasks/task_runner.rb
 - lib/minke/tasks/test.rb
 - lib/minke/version.rb
 - minke.gemspec

data/lib/minke/helpers/helper.rb

@@ -1,68 +0,0 @@
-module Minke
-  module Helpers
-    class Helper
-      ##
-      # copy assets from one location to another
-      def copy_assets from, to
-        directory = to
-        if File.directory?(to)
-          directory = File.dirname(to)
-        end
-
-        Dir.mkdir directory unless Dir.exist? to
-        FileUtils.cp_r from, to
-      end
-
-      ##
-      # invoke a rake task
-      def invoke_task task
-        Rake::Task[task].invoke
-      end
-
-      def load_consul_data server, config_file
-        wait_for_HTTPOK "#{server}/v1/status/leader", 0, 1
-        loader = ConsulLoader::Loader.new(ConsulLoader::ConfigParser.new)
-        puts config_file
-        loader.load_config config_file, server
-      end
-
-      def execute_shell_command command
-        puts `#{command}`
-        $?.exitstatus
-      end
-
-      def fatal_error message
-        abort message
-      end
-
-      ##
-      # waits until a 200 response is received from the given url
-      def wait_for_HTTPOK url, count, successes = 3
-        begin
-          response = RestClient.send("get", url)
-        rescue
-
-        end
-
-        if response == nil || !response.code.to_i == 200
-          puts "Waiting for server #{url} to start"
-          sleep 1
-          if count < 180
-            wait_for_HTTPOK url, count + 1
-          else
-            raise 'Server failed to start'
-          end
-        else
-          if successes > 0
-            puts "Server: #{url} passed health check, #{successes} checks to go..."
-            sleep 1
-            wait_for_HTTPOK url, count + 1, successes - 1
-          else
-            puts "Server: #{url} healthy"
-          end
-        end
-      end
-
-    end
-  end
-end