minke 0.16.0 → 1.0.0

data/lib/minke/helpers/helper.rb

@@ -0,0 +1,68 @@
+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 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 = 0
+        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

data/lib/minke/rake/app.rake

@@ -1,228 +1,80 @@
 namespace :app do
 
-  desc "get dependent packages"
-  task :get => ['config:set_docker_env', 'config:load_config', 'docker:fetch_images'] do
-    config = Minke::Helpers.config
-
-    if config[:build_config][:build][:get] != nil
-      puts "## Get dependent packages"
-      config[:build_config][:build][:get].each do |command|
-      	begin
-          container, ret = Minke::Docker.create_and_run_container config, command
-        ensure
-      		Minke::Docker.delete_container container
-      	end
-      end
-      puts ""
-    end
+  desc "fetch dependent packages"
+  task :fetch => ['config:set_docker_env', 'docker:fetch_images'] do
+    create_dependencies
+    runner = Minke::Tasks::Fetch.new @config, :fetch, @generator_config, @docker_runner, @docker_compose_factory, @logger, @helper
+    runner.run
   end
 
   desc "build application"
-  task :build => [:get] do
-  	puts "## Build for Linux"
-    config = Minke::Helpers.config
-
-    # do we need to build a custom build container
-    if config['docker']['build'] && config['docker']['build']['docker_file'] != nil
-      puts "## Building custom docker image"
-
-      docker_file = config['docker']['build']['docker_file']
-      image_name = config['application_name'] + "-buildimage"
-
-      Docker.options = {:read_timeout => 6200}
-    	image = Docker::Image.build_from_dir docker_file, {:t => image_name}
-      config[:build_config][:docker][:image] = image_name
-    end
-
-    if config['docker']['build'] && config['docker']['build']['image'] != nil
-      config[:build_config][:docker][:image] = config['docker']['build']['image']
-    end
-
-    if config['build'] != nil && config['build']['before'] != nil
-      config['build']['before'].each do |task|
-        puts "## Running before build task: #{task}"
-        Rake::Task[task].invoke
-
-        puts ""
-      end
-    end
-
-    config[:build_config][:build][:build].each do |command|
-    	begin
-    		# Build application
-        container, ret = Minke::Docker.create_and_run_container config, command
-        raise Exception, 'Error running command' unless ret == 0
-      ensure
-    		Minke::Docker.delete_container container
-    	end
-    end
-
-    puts ""
+  task :build => [:fetch] do
+    create_dependencies
+    runner = Minke::Tasks::Build.new @config, :build, @generator_config, @docker_runner, @docker_compose_factory, @logger, @helper
+    runner.run
   end
 
   desc "run unit tests"
   task :test => [:build] do
-    config = Minke::Helpers.config
-
-    if config['test'] != nil && config['test']['before'] != nil
-      config['test']['before'].each do |task|
-        puts "## Running before test task: #{task}"
-        Rake::Task[task].invoke
-
-        puts ""
-      end
-    end
-
-    puts "## Test application"
-    config[:build_config][:build][:test].each do |command|
-      begin
-  		  # Test application
-        container, ret = Minke::Docker.create_and_run_container config, command
-      	raise Exception, 'Error running command' unless ret == 0
-      ensure
-    		Minke::Docker.delete_container container
-    	end
-    end
-
-    puts ""
-  end
-
-  task :copy_assets do
-    puts "## Copy assets"
-
-    config = Minke::Helpers.config
-
-    if config['after_build'] != nil && config['after_build']['copy_assets'] != nil
-      Minke::Helpers.copy_files config['after_build']['copy_assets']
-    end
-
-    puts ""
+    create_dependencies
+    runner = Minke::Tasks::Test.new @config, :test, @generator_config, @docker_runner, @docker_compose_factory, @logger, @helper
+    runner.run
   end
 
   desc "build Docker image for application"
-  task :build_server => [:test, :copy_assets] do
-    config = Minke::Helpers.config
-
-  	puts "## Building Docker image"
-
-  	Docker.options = {:read_timeout => 6200}
-  	image = Docker::Image.build_from_dir config['docker']['docker_file'], {:t => config['application_name']}
-
-    puts ""
+  task :build_image => [:test] do
+    create_dependencies
+    runner = Minke::Tasks::BuildImage.new @config, :test, @generator_config, @docker_runner, @docker_compose_factory, @logger, @helper
+    runner.run
   end
 
   desc "run application with Docker Compose"
-  task :run => ['config:set_docker_env', 'config:load_config'] do
-    puts "## Run application with docker compose"
-
-    config = Minke::Helpers.config
-
-    if config['run']['docker'] != nil && config['run']['docker']['compose_file'] != nil
-      config_file = config['run']['docker']['compose_file']
-    else
-      config_file = config['docker']['compose_file']
-    end
-
-    compose = Minke::DockerCompose.new config_file
-
-  	begin
-      compose.up
-
-      # do we need to run any tasks after the server starts?
-      if config['run']['after_start'] != nil
-        config['run']['after_start'].each do |task|
-          puts "## Running after_start task: #{task}"
-          Rake::Task[task].invoke
-
-          puts ""
-        end
-      end
-
-      if config['run']['consul_loader']['enabled']
-        Minke::Helpers.wait_until_server_running "#{config['run']['consul_loader']['url']}/v1/status/leader", 0
-        loader = ConsulLoader::Loader.new(ConsulLoader::ConfigParser.new)
-        loader.load_config config['run']['consul_loader']['config_file'], config['run']['consul_loader']['url']
-
-        puts ""
-      end
-
-      compose.logs
-  	rescue SystemExit, Interrupt
-  		compose.stop
-  		compose.rm unless Docker.info["Driver"] == "btrfs"
-  	end
+  task :run => ['config:set_docker_env'] do
+    create_dependencies
+    runner = Minke::Tasks::Run.new @config, :run, @generator_config, @docker_runner, @docker_compose_factory, @logger, @helper
+    runner.run
   end
 
   desc "build and run application with Docker Compose"
-  task :build_and_run => [:build_server, :run]
+  task :build_and_run => [:build_image, :run]
 
   desc "run end to end Cucumber tests USAGE: rake app:cucumber[@tag]"
-  task :cucumber, [:feature] => ['config:set_docker_env', 'config:load_config'] do |t, args|
-    config = Minke::Helpers.config
-
-  	puts "## Running cucumber with tags #{args[:feature]}"
-
-  	if args[:feature] != nil
-  		feature = "--tags #{args[:feature]}"
-  	else
-  		feature = ""
-  	end
+  task :cucumber, [:feature] => ['config:set_docker_env'] do |t, args|
+    create_dependencies
+    runner = Minke::Tasks::Cucumber.new @config, :cucumber, @generator_config, @docker_runner, @docker_compose_factory, @logger, @helper
+    runner.run
+  end
 
-  	status = 0
+  desc "push built image to Docker registry"
+  task :push  do
+    create_dependencies
+    runner = Minke::Tasks::Push.new
+    runner.run
+  end
 
-    config = Minke::Helpers.config
+  def create_dependencies
+    @system_runner = Minke::Docker::SystemRunner.new
+    @docker_compose_factory ||= Minke::Docker::DockerComposeFactory.new @system_runner
 
-    if config['cucumber']['docker'] != nil && config['cucumber']['docker']['compose_file'] != nil
-      config_file = config['cucumber']['docker']['compose_file']
-    else
-      config_file = config['docker']['compose_file']
+    if @config == nil
+      reader = Minke::Config::Reader.new
+      @config = reader.read './config.yml'
     end
 
-    compose = Minke::DockerCompose.new config_file
-
-  	begin
-  	  compose.up
-
-      # do we need to run any tasks after the server starts?
-      if config['cucumber']['after_start'] != nil
-        config['cucumber']['after_start'].each do |task|
-          puts "## Running after_start task: #{task}"
-
-          begin
-            Rake::Task[task].invoke
-          rescue Exception => msg
-            puts "Error running rake task: #{msg}"
-            raise msg
-          end
-          puts ""
-        end
-      end
-
-      if config['cucumber']['consul_loader']['enabled']
-        Minke::Helpers.wait_until_server_running "#{config['cucumber']['consul_loader']['url']}/v1/status/leader", 0
-        loader = ConsulLoader::Loader.new(ConsulLoader::ConfigParser.new)
-        loader.load_config config['cucumber']['consul_loader']['config_file'], config['cucumber']['consul_loader']['url']
+    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('../', __FILE__)
       end
 
-      if config['cucumber']['health_check']['enabled']
-        Minke::Helpers.wait_until_server_running config['cucumber']['health_check']['url'], 0, 3
-      end
-
-  		sh "cucumber --color -f pretty #{feature}"
-      status = $?.exitstatus
-  	ensure
-  		compose.stop
-  		compose.rm unless Docker.info["Driver"] == "btrfs"
-
-      abort "Cucumber steps failed" unless status == 0
-  	end
-  end
-
-  desc "push built image to Docker registry"
-  task :push => ['config:load_config'] do
-  	puts "## Push image to registry"
+      processor = Minke::Generators::Processor.new variables
+      processor.load_generators
+      @generator_config = processor.get_generator @config.generator_name
+    end
 
-    config = Minke::Helpers.config
-  	Minke::GoDocker.tag_and_push config
+    @docker_runner ||= Minke::Docker::DockerRunner.new
+    @logger ||= Logger.new(STDOUT)
+    @helper ||= Minke::Helpers::Helper.new
   end
 end

data/lib/minke/rake/config.rake

@@ -1,10 +1,6 @@
 namespace :config do
-  task :load_config do
-    Minke::Helpers.load_config './config.yml'
-  end
-
   task :set_docker_env do
-    DOCKER_IP = Minke::Docker.get_docker_ip_address
+    DOCKER_IP = Minke::Docker::DockerRunner.new.get_docker_ip_address
     ENV['DOCKER_IP'] = DOCKER_IP
   end
 end

data/lib/minke/rake/docker.rake

@@ -1,20 +1,22 @@
 namespace :docker do
   desc "updates build images for swagger and golang will overwrite existing images"
   task :update_images do
-    config = Minke::Helpers.config
+    config = Minke::Config::Reader.new.read './config.yml'
 
     puts "## Updating Docker images"
-  	Minke::Docker.pull_image config[:build_config][:docker][:image]
+    runner = Minke::Docker::DockerRunner.new
+  	runner.pull_image config.docker.build_image
 
     puts ""
   end
 
   desc "pull images for golang from Docker registry if not already downloaded"
   task :fetch_images do
-    config = Minke::Helpers.config
-    
+    config = Minke::Config::Reader.new.read './config.yml'
+
     puts "## Pulling Docker images"
-  	Minke::Docker.pull_image config[:build_config][:docker][:image] unless Minke::Docker.find_image config[:build_config][:docker][:image]
+    runner = Minke::Docker::DockerRunner.new
+  	runner.pull_image config.docker.build_image unless runner.find_image config.docker.build_image
 
     puts ""
   end

data/lib/minke/tasks/build.rb

@@ -0,0 +1,17 @@
+module Minke
+  module Tasks
+    class Build < Task
+
+      def run args = nil
+        puts "## Build application"
+        run_with_block do
+          @generator_settings.build_settings.build_commands.build.each do |command|
+            puts command
+          	run_command_in_container command
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/build_image.rb

@@ -0,0 +1,13 @@
+module Minke
+  module Tasks
+    class BuildImage < Task
+
+      def run args = nil
+        puts "## Build image"
+
+        @docker_runner.build_image @config.docker.application_docker_file, @config.application_name
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/cucumber.rb

@@ -0,0 +1,34 @@
+module Minke
+  module Tasks
+    class Cucumber < Task
+
+      def run args = nil
+      	puts "## Running cucumber with tags #{args}"
+
+      	begin
+          status = 0
+      	  @compose.up
+
+          run_with_block do
+            status = @helper.execute_shell_command "cucumber --color -f pretty #{get_features args}"
+          end
+
+      	ensure
+      		@compose.stop
+      		@compose.rm
+
+          @helper.fatal_error "Cucumber steps failed" unless status == 0
+      	end
+      end
+
+      def get_features args
+        if args != nil && args[:feature] != nil
+      		feature = "--tags #{args[:feature]}"
+      	else
+      		feature = ""
+      	end
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/fetch.rb

@@ -0,0 +1,16 @@
+module Minke
+  module Tasks
+    class Fetch < Task
+
+      def run args = nil
+        puts "## Update dependencies"
+        run_with_block do
+          @generator_settings.build_settings.build_commands.fetch.each do |command|
+            run_command_in_container command
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/push.rb

@@ -0,0 +1,22 @@
+module Minke
+  module Tasks
+    class Push < Task
+
+      def run args = nil
+        puts "## Push image to registry"
+
+        url = @config.docker_registry.url
+        user = @config.docker_registry.user
+        password = @config.docker_registry.password
+        email = @config.docker_registry.email
+        namespace = @config.docker_registry.namespace
+        image_tag = "#{namespace}/#{@config.application_name}"
+
+        @docker_runner.login_registry url, user, password, email
+        @docker_runner.tag_image @config.application_name, image_tag
+        @docker_runner.push_image image_tag
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/run.rb

@@ -0,0 +1,23 @@
+module Minke
+  module Tasks
+    class Run < Task
+
+      def run args = nil
+        puts "## Run application with docker compose"
+
+      	begin
+          @compose.up
+
+          run_with_block do
+            @compose.logs
+          end
+
+      	ensure
+      		@compose.stop
+      		@compose.rm
+      	end
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/task.rb

@@ -0,0 +1,107 @@
+module Minke
+  module Tasks
+    ##
+    # 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, logger, helper
+        @config = config
+        @task = task
+        @generator_settings = generator_settings
+        @docker_runner = docker_runner
+        @logger = logger
+        @helper = helper
+        @task_settings = config.send(task)
+
+        @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
+      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
+
+      ##
+      # 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
+
+      ##
+      # execute an array of rake tasks
+      def execute_rake_tasks tasks
+        tasks.each { |t| @helper.invoke_task t }
+      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), 3, 0
+      end
+
+      def copy_assets assets
+        assets.each { |a| @helper.copy_assets a.from, a.to }
+      end
+
+      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
+          end
+
+          container, success = @docker_runner.create_and_run_container @build_image, settings.binds, settings.env, settings.working_directory, command
+
+          # throw exception if failed
+          @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 == 'public'
+          "#{url.protocol}://#{url.address}:#{url.port}#{url.path}"
+        else
+          public_address = @compose.public_address url.address, url.port
+          "#{url.protocol}://#{public_address}#{url.path}"
+        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
+      end
+
+    end
+  end
+end

data/lib/minke/tasks/test.rb

@@ -0,0 +1,17 @@
+module Minke
+  module Tasks
+    class Test < Task
+
+      def run args = nil
+        puts "## Test application"
+
+        run_with_block do
+          @generator_settings.build_settings.build_commands.test.each do |command|
+          	run_command_in_container command
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/minke/version.rb

@@ -1,3 +1,3 @@
 module Minke
-  VERSION = "0.16.0"
+  VERSION = "1.0.0"
 end