class Minke::Command

Attributes

args[RW]
config[RW]
generator_config[RW]
verbose[RW]

Public Class Methods

new(config, generator_config, verbose, args) click to toggle source
# File lib/minke/command.rb, line 5
def initialize(config, generator_config, verbose, args)
  self.config = config
  self.generator_config = generator_config
  self.verbose = verbose
  self.args = args
end

Public Instance Methods

build() click to toggle source
# File lib/minke/command.rb, line 85
def build
  if config.build != nil
    fetch
    tasks = create_tasks :build
    tasks[:build].run
  end
end
build_image() click to toggle source
# File lib/minke/command.rb, line 108
def build_image
  if config.build != nil
    test
    tasks = create_tasks :build
    tasks[:build_image].run
  end
end
create_dependencies(task) click to toggle source

Creates dependencies for minke

# File lib/minke/command.rb, line 13
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

  logger = Minke::Logging.create_logger(STDOUT, self.verbose)
  shell = Minke::Helpers::Shell.new(logger)

  task_runner = Minke::Tasks::TaskRunner.new ({
    :ruby_helper       => Minke::Helpers::Ruby.new,
    :copy_helper       => Minke::Helpers::Copy.new,
    :service_discovery => Minke::Docker::ServiceDiscovery.new(project_name, Minke::Docker::DockerRunner.new(logger), network_name),
    :logger_helper     => logger
  })

  consul = Minke::Docker::Consul.new(
    {
      :health_check => Minke::Docker::HealthCheck.new(logger),
      :service_discovery => Minke::Docker::ServiceDiscovery.new( project_name, Minke::Docker::DockerRunner.new(logger, network_name), network_name),
      :consul_loader => ConsulLoader::Loader.new(ConsulLoader::ConfigParser.new),
      :docker_runner => Minke::Docker::DockerRunner.new(logger, network_name),
      :network => network_name,
      :project_name => project_name,
      :logger_helper => logger
    }
  )

  network = Minke::Docker::Network.new(
    network_name,
    shell
  )

  return {
    :config                 => @config,
    :task_name              => task,
    :docker_runner          => Minke::Docker::DockerRunner.new(logger, network_name, project_name),
    :task_runner            => task_runner,
    :shell_helper           => shell,
    :logger_helper          => logger,
    :generator_config       => generator_config,
    :docker_compose_factory => Minke::Docker::DockerComposeFactory.new(shell, project_name, network_name),
    :consul                 => consul,
    :docker_network         => network,
    :health_check           => Minke::Docker::HealthCheck.new(logger),
    :service_discovery      => Minke::Docker::ServiceDiscovery.new(project_name, Minke::Docker::DockerRunner.new(logger), network_name)
  } 
end
create_tasks(task) click to toggle source
# File lib/minke/command.rb, line 62
def create_tasks task
  dependencies = create_dependencies(task)
  return {
    :bundler     => Minke::Tasks::Bundle.new(dependencies),
    :fetch       => Minke::Tasks::Fetch.new(dependencies),
    :build       => Minke::Tasks::Build.new(dependencies),
    :test        => Minke::Tasks::Test.new(dependencies),
    :run         => Minke::Tasks::Run.new(dependencies),
    :build_image => Minke::Tasks::BuildImage.new(dependencies),
    :cucumber    => Minke::Tasks::Cucumber.new(dependencies),
    :push        => Minke::Tasks::Push.new(dependencies),
    :shell       => Minke::Tasks::Shell.new(dependencies),
    :provision   => Minke::Tasks::Terraform.new(dependencies)
  }
end
cucumber() click to toggle source
# File lib/minke/command.rb, line 116
def cucumber
  if config.cucumber != nil
    tasks = create_tasks :cucumber
    tasks[:cucumber].run
  end
end
fetch() click to toggle source
# File lib/minke/command.rb, line 78
def fetch
  if config.fetch != nil
    tasks = create_tasks :fetch
    tasks[:fetch].run
  end
end
provision() click to toggle source
# File lib/minke/command.rb, line 135
def provision
  if config.provision != nil
    tasks = create_tasks :provision
    tasks[:provision].run self.args[:provision_mode]
  end
end
push() click to toggle source
# File lib/minke/command.rb, line 123
def push
  tasks = create_tasks :push
  tasks[:push].run
end
run() click to toggle source
# File lib/minke/command.rb, line 101
def run
  if config.run != nil
    tasks = create_tasks :run
    tasks[:run].run
  end
end
shell() click to toggle source
# File lib/minke/command.rb, line 128
def shell
  if config.shell != nil
    tasks = create_tasks :shell
    tasks[:shell].run
  end
end
test() click to toggle source
# File lib/minke/command.rb, line 93
def test
  if config.test != nil
    build
    tasks = create_tasks :test
    tasks[:test].run
  end
end