minke 0.16.0 → 1.0.0

data/lib/minke/config/reader.rb

@@ -0,0 +1,94 @@
+module Minke
+  module Config
+    ##
+    # Reader reads a yaml based configuration and processes it into a Minke::Config::Config instance
+    class Reader
+      ##
+      # read yaml config file and return Minke::Config::Config instance
+      def read config_file
+        b = binding
+
+        config = Config.new
+        file   = ERB.new(File.read(config_file)).result b
+        file   = YAML.load(file)
+
+        config.namespace        = file['namespace']
+        config.application_name = file['application_name']
+        config.generator_name   = file['generator_name']
+
+        config.docker_registry = read_docker_registry file['docker_registry'] unless file['docker_registry'] == nil
+        config.docker          = read_docker_section file['docker']           unless file['docker'] == nil
+
+        config.fetch    = read_task_section file['fetch'], config.docker    unless file['fetch'] == nil
+        config.build    = read_task_section file['build'], config.docker    unless file['build'] == nil
+        config.run      = read_task_section file['run'], config.docker      unless file['run'] == nil
+        config.cucumber = read_task_section file['cucumber'], config.docker unless file['cucumber'] == nil
+
+        return config
+      end
+
+      def read_docker_registry section
+        DockerRegistrySettings.new.tap do |d|
+          d.url       = section['url']
+          d.user      = section['user']
+          d.password  = section['password']
+          d.email     = section['email']
+          d.namespace = section['namespace']
+        end
+      end
+
+      def read_docker_section section
+        DockerSettings.new.tap do |d|
+          d.build_image              = section['build_image']              unless section['build_image'] == nil
+          d.build_docker_file        = section['build_docker_file']        unless section['build_docker_file'] == nil
+          d.application_docker_file  = section['application_docker_file']  unless section['application_docker_file'] == nil
+          d.application_compose_file = section['application_compose_file'] unless section['application_compose_file'] == nil
+        end
+      end
+
+      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
+        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
+        end
+      end
+
+      def read_copy_section section
+        section.map do |s|
+          Copy.new.tap do |c|
+            c.from = s['from']
+            c.to   = s['to']
+          end
+        end
+      end
+
+      def read_consul_loader_section section
+        ConsulLoader.new.tap do |c|
+          c.config_file = section['config_file']
+          c.url         = read_url section['url']
+        end
+      end
+
+      def read_url section
+        URL.new.tap do |url|
+          url.address  = section['address']
+          url.port     = section['port']     != nil ? section['port'].to_s : '80'
+          url.path     = section['path']     != nil ? section['path'] : ''
+          url.protocol = section['protocol'] != nil ? section['protocol'] : 'http'
+          url.type     = section['type']
+        end
+      end
+
+    end
+  end
+end

data/lib/minke/docker/docker_compose.rb

@@ -0,0 +1,53 @@
+module Minke
+  module Docker
+    class DockerComposeFactory
+      def initialize system_runner
+        @system_runner = system_runner
+      end
+
+      def create compose_file
+        Minke::Docker::DockerCompose.new compose_file, @system_runner
+      end
+    end
+
+    class DockerCompose
+      @compose_file = nil
+
+      def initialize compose_file, system_runner
+        @compose_file = compose_file
+        @system_runner = system_runner
+      end
+
+      ##
+      # start the containers in a stack defined by the docker compose file
+      def up
+        @system_runner.execute "docker-compose -f #{@compose_file} up -d"
+        sleep 2
+      end
+
+      ##
+      # stop the containers in a stack defined by the docker compose file
+      def stop
+        @system_runner.execute "docker-compose -f #{@compose_file} stop"
+      end
+
+      ##
+      # remove the containers started in a stack defined by the docker compose file
+      def rm
+        @system_runner.execute "echo y | docker-compose -f #{@compose_file} rm -v" unless ::Docker.info["Driver"] == "btrfs"
+      end
+
+      ##
+      # stream the logs for the current running stack
+      def logs
+        @system_runner.execute "docker-compose -f #{@compose_file} 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
+    end
+  end
+end

data/lib/minke/docker/docker_runner.rb

@@ -0,0 +1,123 @@
+module Minke
+  module Docker
+    class DockerRunner
+      ##
+      # returns the ip address that docker is running on
+      def get_docker_ip_address
+        if ENV['DOCKER_IP'] == nil
+          if ENV['DOCKER_HOST']
+        		# dockerhost set
+        		host = ENV['DOCKER_HOST'].dup
+        		host.gsub!(/tcp:\/\//, '')
+        		host.gsub!(/:\d+/,'')
+
+        		return host
+          else
+            return '127.0.0.1'
+        	end
+        end
+      end
+
+      ##
+      # find_image finds a docker image in the local registry
+      # Returns
+      #
+      # Docker::Image
+      def find_image image_name
+      	found = nil
+      	::Docker::Image.all.each do | image |
+      		found = image if image.info["RepoTags"].include? image_name
+      	end
+
+      	return found
+      end
+
+      ##
+      # pull_image pulls a new copy of the given image from the registry
+      def pull_image image_name
+      	puts "Pulling Image: #{image_name}"
+      	puts `docker pull #{image_name}`
+      end
+
+      ##
+      # create_and_run_container starts a conatainer of the given image name and executes a command
+      #
+      # Returns:
+      # - Docker::Container
+      # - sucess (true if command succeded without error)
+      def create_and_run_container image, volumes, environment, working_directory, cmd
+      	# update the timeout for the Excon Http Client
+      	# set the chunk size to enable streaming of log files
+        ::Docker.options = {:chunk_size => 1, :read_timeout => 3600}
+        container = ::Docker::Container.create(
+      		'Image' => image,
+      		'Cmd' => cmd,
+      		"Binds" => volumes,
+      		"Env" => environment,
+      		'WorkingDir' => working_directory)
+
+        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
+          end
+        end
+
+        container.start
+        thread.join
+
+      	return container, success
+      end
+
+      ##
+      # build_image creates a new image from the given Dockerfile and name
+      def build_image dockerfile_dir, name
+        ::Docker.options = {:read_timeout => 6200}
+        begin
+          ::Docker::Image.build_from_dir(dockerfile_dir, {:t => name}) do |v|
+            data = /{"stream.*:"(.*)".*/.match(v)
+            data = data[1].encode(Encoding.find('UTF-8'), {invalid: :replace, undef: :replace, replace: ''}) unless data == nil || data.length < 1
+            $stdout.puts data unless data == nil
+          end
+        rescue => e
+          message = /.*{"message":"(.*?)"}/.match(e.to_s)
+          puts "Error: #{message[1]}" unless message == nil || message.length < 1
+        end
+      end
+
+      def delete_container container
+        if container != nil
+          begin
+            container.delete()
+          rescue => e
+            puts "Error: Unable to delete container"
+          end
+        end
+      end
+
+      def login_registry url, user, password, email
+        system("docker login -u #{user} -p #{password} -e #{email} #{url}")
+        $?.exitstatus
+      end
+
+      def tag_image image_name, tag
+        image =  self.find_image "#{image_name}:latest"
+      	image.tag('repo' => tag, 'force' => true) unless image.info["RepoTags"].include? "#{tag}:latest"
+      end
+
+      def push_image image_name
+      	system("docker push #{image_name}:latest")
+        $?.exitstatus ==  0
+      end
+    end
+  end
+end

data/lib/minke/docker/service_discovery.rb

@@ -0,0 +1,24 @@
+module Minke
+  module Docker
+    ##
+    # ServiceDiscovery allows you to look up the publicly accessible address and port for a server
+    class ServiceDiscovery
+      def initialize config
+        reader = Minke::Config::Reader.new
+        @config = reader.read config
+      end
+
+      ##
+      # Will attempt to locate the public details for a running container given
+      # its name and private port
+      # Parameters:
+      # - container_name: the name of the running container
+      # - private_port: the private port which you wish to retrieve an address for
+      # - task: :run, :cucumber search either the run or cucumber section of the config
+      def public_address_for container_name, private_port, task
+        compose = Minke::Docker::DockerCompose.new @config.compose_file_for(task), Minke::Docker::SystemRunner.new
+        compose.public_address container_name, private_port
+      end
+    end
+  end
+end

data/lib/minke/docker/system_runner.rb

@@ -0,0 +1,16 @@
+module Minke
+  module Docker
+    class SystemRunner
+
+      def execute command
+        system("#{command}")
+      end
+
+      def execute_and_return command
+        log = `#{command}`
+        return log.strip
+      end
+
+    end
+  end
+end

data/lib/minke/generators/config.rb

@@ -0,0 +1,106 @@
+module Minke
+  module Generators
+
+    ##
+    # This class encapsulates the config required by the generator.
+    class Config
+      ##
+      # Name of the generator.
+      attr_accessor :name
+
+      ##
+      # Location of the ERB template files
+      attr_accessor :template_location
+
+      ##
+      # Instance of Minke::Generators::GenerateSettings
+      attr_accessor :generate_settings
+
+      ##
+      # Instance of Minke::Generators::BuildSettings
+      attr_accessor :build_settings
+    end
+
+    ##
+    # This class encapsulates the settings required to generate a new template.
+    class GenerateSettings
+      ##
+      # [OPTIONAL]
+      # A command to execute when generating a new template.
+      #
+      # Using this attribute it is possible to delegate reponsibility for generation of part of the codebase
+      # to an external command.
+      # For example you could execute rails new... to generate a new rails project as part of the template
+      # generation.
+      attr_accessor :command
+
+      ##
+      # The name of a docker image to run the commands inside.
+      #
+      # All commands are run inside a docker container to remove the dependency on installed software
+      # on the build machine.
+      attr_accessor :docker_image
+
+      ##
+      # The folder location of a docker file from which an image will be build before running commands inside it.
+      #
+      # This option can be used as an alternative to providing a docker image, Dockerfiles can be bundled with the
+      # template.
+      # Minke will attempt to create an image from this Dockerfile before executing the generate commands.
+      attr_accessor :docker_file
+    end
+
+    ##
+    # BuildSettings contains the commands and settings used to build and test your code, these are not
+    # related to template generation but when Minke is used to build source created from a template.
+    class BuildSettings
+      ##
+      # Instance of Minke::Generators::BuildCommands
+      attr_accessor :build_commands
+
+      ##
+      # Instance of Minke::Generators::DockerSettings
+      attr_accessor :docker_settings
+    end
+
+    ##
+    # BuildCommands define the command that will be executed in the docker container for each
+    # of the build steps.
+    class BuildCommands
+
+      ##
+      # An array of commands to execute for the fetch step.
+      attr_accessor :fetch
+
+      ##
+      # An array of commands to execute for the build step.
+      attr_accessor :build
+
+      ##
+      # An array of commands to execute for the test step.
+      attr_accessor :test
+    end
+
+    ##
+    # DockerSettings encapsulates the settings required for the Docker container
+    # within which the commands will execute.
+    class DockerSettings
+
+      ##
+      # Docker image used to execute commands
+      attr_accessor :image
+
+      ##
+      # Docker environment to set on running container
+      attr_accessor :env
+
+      ##
+      # Volume mapping information for Docker container, must be fully qualified path
+      attr_accessor :binds
+
+      ##
+      # Workging directory for executed commands
+      attr_accessor :working_directory
+    end
+  end
+end

data/lib/minke/generators/config_processor.rb

@@ -0,0 +1,47 @@
+module Minke
+  module Generators
+
+    ##
+    # ConfigProcessor replaces variable placeholders in the config object
+    # with the values specified in the initialize method
+    class ConfigProcessor
+
+      ##
+      # initialize takes a single parameter of Minke::Generators::ConfigVariables
+      def initialize variables
+        @variables = variables
+      end
+
+      ##
+      # process a Minke::Generators::Config object and replace given variables
+      def process config
+        replace_variables config.template_location
+
+        replace_variables config.generate_settings.command unless config.generate_settings == nil || config.generate_settings.command == nil
+        replace_variables config.generate_settings.docker_file unless config.generate_settings == nil || config.generate_settings.docker_file == nil
+
+        replace_variables config.build_settings.build_commands.fetch unless config.build_settings == nil || config.build_settings.build_commands.fetch == nil
+        replace_variables config.build_settings.build_commands.build unless config.build_settings == nil || config.build_settings.build_commands.build == nil
+        replace_variables config.build_settings.build_commands.test unless config.build_settings == nil || config.build_settings.build_commands.test == nil
+
+        replace_variables config.build_settings.docker_settings.image unless config.build_settings == nil || config.build_settings.docker_settings.image == nil
+        replace_variables config.build_settings.docker_settings.env unless config.build_settings == nil || config.build_settings.docker_settings.env == nil
+        replace_variables config.build_settings.docker_settings.binds unless config.build_settings == nil || config.build_settings.docker_settings.binds == nil
+        replace_variables config.build_settings.docker_settings.working_directory unless config.build_settings == nil || config.build_settings.docker_settings.working_directory == nil
+
+        return config
+      end
+
+      def replace_variables section
+        if section.is_a?(Array)
+          section.each { |a| replace_variables a }
+        else
+          section.gsub! '<%= application_name %>', @variables.application_name
+          section.gsub! '<%= namespace %>', @variables.namespace
+          section.gsub! '<%= src_root %>', @variables.src_root
+        end
+      end
+    end
+
+  end
+end

data/lib/minke/generators/config_variables.rb

@@ -0,0 +1,23 @@
+module Minke
+  module Generators
+
+    ##
+    # ConfigVariables encapsulates the variables that are evaluated at runtime when
+    # a template is loaded.
+    class ConfigVariables
+
+      ##
+      # src_root is the absolute path where the src files will be generated
+      attr_accessor :src_root
+
+      ##
+      # namespace is the namespace of the application
+      attr_accessor :namespace
+
+      ##
+      # application_name is the name of the application
+      attr_accessor :application_name
+    end
+
+  end
+end

data/lib/minke/generators/processor.rb

@@ -0,0 +1,131 @@
+module Minke
+  module Generators
+    ##
+    # Process handles the creation of new projects from a generator template.
+    class Processor
+
+      def initialize variables
+        @variables = variables
+      end
+
+      def process generator_name, output_folder
+        generator = get_generator generator_name
+
+        # process the files
+        puts '# Modifiying templates'
+        puts "#{generator.template_location}"
+
+        process_directory generator.template_location, '**/*', output_folder, @variables.application_name
+        process_directory generator.template_location, '**/.*', output_folder, @variables.application_name
+
+        # run generate command if present
+        if generator.generate_settings != nil && generator.generate_settings.command
+          build_image unless generator.generate_settings.command.docker_file == nil
+          fetch_image unless generator.generate_settings.command.docker_image == nil
+
+          #run_command_in_container
+        end
+      end
+
+      def build_image
+        puts "## Building custom docker image"
+
+        image_name = APPLICATION_NAME + "-buildimage"
+        Docker.options = {:read_timeout => 6200}
+        image = Docker::Image.build_from_dir generator.generate_command_docker_file, {:t => image}
+      end
+
+      def fetch_image
+        Minke::Docker.pull_image generator.generate_command_docker_image unless Minke::Docker.find_image generator.generate_command_docker_image
+        image_name = generator.generate_command_docker_image
+      end
+
+      def run_command_in_container
+        begin
+          config = {
+            :build_config => {
+              :docker => {
+                :image => image_name,
+                :binds => ["#{File.expand_path(options[:output])}:/src"],
+                :working_directory => "/src"
+              }
+            }
+          }
+
+          #command = Minke::Helpers.replace_vars_in_section generator.generate_command, '##SERVICE_NAME##', APPLICATION_NAME
+          #container, ret = Minke::Docker.create_and_run_container config, command
+        ensure
+        #  Minke::Docker.delete_container container
+        end
+      end
+
+      def process_directory template_location, folder, output_folder, service_name
+        Dir.glob("#{template_location}/#{folder}").each do |file_name|
+          puts "## Processing #{file_name}"
+          process_file template_location, file_name, output_folder, service_name
+        end
+      end
+
+      def process_file template_location, original, output_folder, service_name
+        new_filename = create_new_filename template_location, original, output_folder, service_name
+
+        dirname = File.dirname(new_filename)
+        unless File.directory?(dirname)
+          FileUtils.mkdir_p(dirname)
+        end
+
+        if !File.directory?(original)
+          if File.extname(original) == ".erb"
+            render_erb original, new_filename
+          elsif
+            FileUtils.cp(original, new_filename)
+          end
+        end
+      end
+
+      def render_erb original, new_filename
+        b = binding
+        b.local_variable_set(:application_name, @variables.application_name)
+        b.local_variable_set(:namespace, @variables.namespace)
+        b.local_variable_set(:src_root, @variables.src_root)
+
+        renderer = ERB.new(File.read(original))
+        File.open(new_filename, 'w') {|f| f.write renderer.result(b) }
+      end
+
+      def create_new_filename template_location, original, output_folder, service_name
+        new_filename = original.sub(template_location + '/', '')
+        new_filename.sub!('.erb', '')
+        new_filename.sub!('<%= application_name %>', service_name)
+
+        output_folder + '/' + new_filename
+      end
+
+      ##
+      #
+      def local_gems
+         Gem::Specification.sort_by{ |g| [g.name.downcase, g.version] }.group_by{ |g| g.name }
+      end
+
+      def load_generators
+        puts '# Loading installed generators'
+        Gem::Specification.find_all.each do |spec|
+          if spec.metadata != nil && spec.metadata['entrypoint'] != nil
+            require spec.metadata['entrypoint']
+          end
+        end
+      end
+
+      def get_generator generator
+        config = Minke::Generators.get_registrations.select { |c| c.name == generator}.first
+        if config == nil
+          puts "Generator not installed please select from the above list of installed generators or install the required gem"
+          exit 1
+        end
+        processor = Minke::Generators::ConfigProcessor.new @variables
+        return processor.process config
+      end
+
+    end
+  end
+end

data/lib/minke/generators/register.rb

@@ -0,0 +1,19 @@
+module Minke
+  module Generators
+    @@registrations = []
+
+    def register config
+      puts "registered #{config.name}"
+
+      @@registrations.push(config)
+      #puts "registered #{config.template_location}"
+    end
+
+    def get_registrations
+      @@registrations
+    end
+
+    module_function :register
+    module_function :get_registrations
+  end
+end