kontena-cli 1.4.0.pre6 → 1.4.0.pre7

data/lib/kontena/cli/apps/build_command.rb

@@ -1,28 +0,0 @@
-require_relative 'common'
-require_relative 'docker_helper'
-
-module Kontena::Cli::Apps
-  class BuildCommand < Kontena::Command
-    include Kontena::Cli::Common
-    include Common
-    include DockerHelper
-
-    option ['-p', '--project-name'], 'NAME', 'Specify an alternate project name (default: directory name)'
-    option ['-f', '--file'], 'FILE', 'Specify an alternate Kontena compose file', attribute_name: :filename, default: 'kontena.yml'
-    option ['--no-cache'], :flag, 'Do not use cache when building the image', default: false
-    option '--skip-validation', :flag, 'Skip YAML file validation', default: false
-    parameter "[SERVICE] ...", "Services to build"
-
-    attr_reader :services
-
-    def execute
-      require_config_file(filename)
-      @services = services_from_yaml(filename, service_list, service_prefix, skip_validation?)
-      if services.none?{ |name, service| service['build'] }
-        error 'Not found any service with build option'
-        abort
-      end
-      process_docker_images(services, true, no_cache?)
-    end
-  end
-end

data/lib/kontena/cli/apps/common.rb

@@ -1,172 +0,0 @@
-require_relative '../services/services_helper'
-require_relative './service_generator'
-require_relative './service_generator_v2'
-require_relative './yaml/reader'
-require 'yaml'
-
-module Kontena::Cli::Apps
-  module Common
-    include Kontena::Cli::Services::ServicesHelper
-
-    def require_config_file(filename)
-      exit_with_error("File #{filename} does not exist") unless File.exists?(filename)
-    end
-
-    # @param [String] filename
-    # @param [Array<String>] service_list
-    # @param [String] prefix
-    # @param [TrueClass|FalseClass] skip_validation
-    # @return [Hash]
-    def services_from_yaml(filename, service_list, prefix, skip_validation = false)
-      set_env_variables(prefix, current_grid)
-      reader = YAML::Reader.new(filename, skip_validation)
-      outcome = reader.execute
-      hint_on_validation_notifications(outcome[:notifications]) if outcome[:notifications].size > 0
-      abort_on_validation_errors(outcome[:errors]) if outcome[:errors].size > 0
-      kontena_services = generate_services(outcome[:services], outcome[:version])
-      kontena_services.delete_if { |name, service| !service_list.include?(name)} unless service_list.empty?
-      kontena_services
-    end
-
-    ##
-    # @param [Hash] yaml
-    # @param [String] version
-    # @return [Hash]
-    def generate_services(yaml_services, version)
-      services = {}
-      if version.to_i == 2
-        generator_klass = ServiceGeneratorV2
-      else
-        generator_klass = ServiceGenerator
-      end
-      yaml_services.each do |service_name, config|
-        exit_with_error("Image is missing for #{service_name}. Aborting.") unless config['image']
-        services[service_name] = generator_klass.new(config).generate
-      end
-      services
-    end
-
-    def read_yaml(filename)
-      reader = YAML::Reader.new(filename)
-      outcome = reader.execute
-      outcome
-    end
-
-    def set_env_variables(project, grid)
-      ENV['project'] = project
-      ENV['grid'] = grid
-    end
-
-    def service_prefix
-      @service_prefix ||= project_name || project_name_from_yaml(filename) || current_dir
-    end
-
-    def project_name_from_yaml(file)
-      reader = YAML::Reader.new(file, true)
-      reader.stack_name
-    end
-
-    # @return [String]
-    def token
-      @token ||= require_token
-    end
-
-    # @param [String] name
-    # @return [String]
-    def prefixed_name(name)
-      return name if service_prefix.strip == ""
-      "#{service_prefix}-#{name}"
-    end
-
-    # @return [String]
-    def current_dir
-      File.basename(Dir.getwd)
-    end
-
-    # @param [String] name
-    # @return [Boolean]
-    def service_exists?(name)
-      get_service(token, prefixed_name(name)) rescue false
-    end
-
-    # @param [Hash] services
-    # @param [String] file
-    def create_yml(services, file = 'kontena.yml')
-      yml = File.new(file, 'w')
-      yml.puts services.to_yaml
-      yml.close
-    end
-
-    # @return [Hash]
-    def app_json
-      if !@app_json && File.exist?('app.json')
-        @app_json = JSON.parse(File.read('app.json'))
-      end
-      @app_json ||= {}
-    end
-
-    def display_notifications(messages, color = :yellow)
-      messages.each do |files|
-        files.each do |file, services|
-          $stderr.puts "#{file}:".colorize(color)
-          services.each do |service|
-            service.each do |name, errors|
-              $stderr.puts "  #{name}:".colorize(color)
-              if errors.is_a?(String)
-                $stderr.puts "    - #{errors}".colorize(color)
-              else
-                errors.each do |key, error|
-                  $stderr.puts "    - #{key}: #{error.to_json}".colorize(color)
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def hint_on_validation_notifications(errors)
-      $stderr.puts "YAML contains the following unsupported options and they were rejected:".colorize(:yellow)
-      display_notifications(errors)
-    end
-
-    def abort_on_validation_errors(errors)
-      $stderr.puts "YAML validation failed! Aborting.".colorize(:red)
-      display_notifications(errors, :red)
-      abort
-    end
-
-    def valid_addons(prefix=nil)
-      if prefix
-        prefix = "#{prefix}-"
-      end
-
-      {
-          'openredis' => {
-              'image' => 'redis:latest',
-              'environment' => ["REDIS_URL=redis://#{prefix}openredis:6379"]
-          },
-          'redis' => {
-              'image' => 'redis:latest',
-              'environment' => ["REDIS_URL=redis://#{prefix}redis:6379"]
-          },
-          'rediscloud' => {
-              'image' => 'redis:latest',
-              'environment' => ["REDISCLOUD_URL=redis://#{prefix}rediscloud:6379"]
-          },
-          'postgresql' => {
-              'image' => 'postgres:latest',
-              'environment' => ["DATABASE_URL=postgres://#{prefix}postgres:@postgresql:5432/postgres"]
-          },
-          'mongolab' => {
-              'image' => 'mongo:latest',
-              'environment' => ["MONGOLAB_URI=#{prefix}mongolab:27017"]
-          },
-          'memcachedcloud' => {
-              'image' => 'memcached:latest',
-              'environment' => ["MEMCACHEDCLOUD_SERVERS=#{prefix}memcachedcloud:11211"]
-          }
-      }
-    end
-  end
-end

data/lib/kontena/cli/apps/config_command.rb

@@ -1,25 +0,0 @@
-require_relative 'common'
-require 'yaml'
-
-module Kontena::Cli::Apps
-  class ConfigCommand < Kontena::Command
-    include Kontena::Cli::Common
-    include Common
-
-    option ['-f', '--file'], 'FILE', 'Specify an alternate Kontena compose file', attribute_name: :filename, default: 'kontena.yml'
-    option ['-p', '--project-name'], 'NAME', 'Specify an alternate project name (default: directory name)'
-    option '--skip-validation', :flag, 'Skip YAML file validation', default: false
-    parameter "[SERVICE] ...", "Services to view"
-
-    def execute
-      require_config_file(filename)
-      services = services_from_yaml(filename, service_list, service_prefix, skip_validation?)
-      services.each do |name, config|
-        config['cmd'] = config['cmd'].join(" ") if config['cmd']
-        config.delete_if {|key, value| value.nil? || (value.respond_to?(:empty?) && value.empty?) }
-      end
-      services = { 'services' => services }
-      puts services.to_yaml
-    end
-  end
-end

data/lib/kontena/cli/apps/deploy_command.rb

@@ -1,137 +0,0 @@
-require 'yaml'
-require_relative 'common'
-require_relative 'docker_helper'
-
-module Kontena::Cli::Apps
-  class DeployCommand < Kontena::Command
-    include Kontena::Cli::Common
-    include Kontena::Cli::GridOptions
-    include Common
-    include DockerHelper
-
-    option ['-f', '--file'], 'FILE', 'Specify an alternate Kontena compose file', attribute_name: :filename, default: 'kontena.yml'
-    option ['--no-build'], :flag, 'Don\'t build an image, even if it\'s missing', default: false
-    option ['-p', '--project-name'], 'NAME', 'Specify an alternate project name (default: directory name)'
-    option '--async', :flag, 'Run deploys async/parallel'
-    option '--force', :flag, 'Force deploy even if service does not have any changes'
-
-    option '--skip-validation', :flag, 'Skip YAML file validation', default: false
-    parameter "[SERVICE] ...", "Services to start"
-
-    attr_reader :services, :deploy_queue
-
-    def execute
-      require_api_url
-      require_token
-      require_config_file(filename)
-      @deploy_queue = []
-      @services = services_from_yaml(filename, service_list, service_prefix)
-      process_docker_images(services) if !no_build?
-      create_or_update_services(services)
-      deploy_services(deploy_queue)
-    end
-
-    private
-
-    # @param [Hash] services
-    def create_or_update_services(services)
-      services.each do |name, config|
-        create_or_update_service(name, config)
-      end
-    end
-
-    # @param [Array] queue
-    def deploy_services(queue)
-      queue.each do |service|
-        name = service['id'].split('/').last
-        options = {}
-        options[:force] = true if force?
-        spinner "Deploying #{unprefixed_name(name).colorize(:cyan)} " do
-          deployment = deploy_service(token, name, options)
-          unless async?
-            wait_for_deploy_to_finish(token, deployment)
-          end
-        end
-      end
-    end
-
-    # @param [String] name
-    # @param [Hash] options
-    def create_or_update_service(name, options)
-      # skip if service is already processed or it's not present
-      return nil if in_deploy_queue?(name) || !services.key?(name)
-
-      # create/update linked services recursively before continuing
-      unless options['links'].empty?
-        options['links'].each_with_index do |linked_service, index|
-          # change prefixed service name also to links options
-          linked_service_name = linked_service['name']
-          options['links'][index]['name'] = "#{prefixed_name(linked_service['name'])}"
-          create_or_update_service(linked_service_name, services[linked_service_name]) unless in_deploy_queue?(linked_service_name)
-        end
-      end
-
-      merge_external_links(options)
-
-      if service_exists?(name)
-        service = update(name, options)
-      else
-        service = create(name, options)
-      end
-
-      deploy_queue.push service
-    end
-
-    # @param [String] name
-    def find_service_by_name(name)
-      get_service(token, prefixed_name(name)) rescue nil
-    end
-
-    # @param [String] name
-    # @param [Hash] options
-    def create(name, options)
-      data = { 'name' => prefixed_name(name) }
-      data.merge!(options)
-      result = nil
-      spinner "Creating #{name.colorize(:cyan)} " do
-        result = create_service(token, current_grid, data)
-      end
-      result
-    end
-
-    # @param [String] name
-    # @param [Hash] options
-    def update(name, options)
-      prefixed_name = prefixed_name(name)
-      result = nil
-      spinner "Updating #{name.colorize(:cyan)} " do
-        result = update_service(token, prefixed_name, options)
-      end
-      result
-    end
-
-    # @param [String] name
-    def in_deploy_queue?(name)
-      deploy_queue.find {|service| service['name'] == prefixed_name(name)} != nil
-    end
-
-    #
-    # @param [String] name
-    def unprefixed_name(name)
-      if service_prefix.empty?
-        name
-      else
-        name.sub("#{service_prefix}-", '')
-      end
-    end
-
-    # @param [Hash] options
-    def merge_external_links(options)
-      if options['external_links']
-        options['links'] ||= []
-        options['links'] = options['links'] + options['external_links']
-        options.delete('external_links')
-      end
-    end
-  end
-end

data/lib/kontena/cli/apps/docker_compose_generator.rb

@@ -1,61 +0,0 @@
-require 'yaml'
-require_relative 'common'
-
-module Kontena::Cli::Apps
-  class DockerComposeGenerator
-    include Common
-
-    attr_reader :docker_compose_file
-
-    def initialize(filename)
-      @docker_compose_file = filename
-    end
-
-    def generate(procfile, addons, env_file)
-      if procfile.keys.size > 0
-        # generate services found in Procfile
-        docker_compose = {
-          'version' => '2'
-        }
-        services = {}
-        procfile.each do |service, command|
-          services[service] = {'build' => '.' }
-          if app_json && service == 'web' # Heroku generates PORT env variable so should we do too
-            services[service]['environment'] = ['PORT=5000']
-            services[service]['ports'] = ['5000:5000']
-          end
-          services[service]['command'] =  "/start #{service}" if service != 'web'
-          services[service]['env_file'] = env_file if env_file
-
-          # generate addon services
-          addons.each do |addon|
-            addon_service = addon.split(":")[0]
-            addon_service.slice!('heroku-')
-            if valid_addons.has_key?(addon_service)
-              services[service]['links'] = [] unless services[service]['links']
-              services[service]['links'] << "#{addon_service}:#{addon_service}"
-              services[service]['environment'] = [] unless services[service]['environment']
-              services[service]['environment'] += valid_addons[addon_service]['environment']
-              services[addon_service] = {'image' => valid_addons[addon_service]['image']}
-            end
-          end
-        end
-        docker_compose['services'] = services
-      else
-        # no Procfile found, create dummy web service
-        docker_compose = {
-          'version' => '2',
-          'services' => {
-            'web' => {
-              'build' => '.'
-            }
-          }
-        }
-
-        docker_compose['services']['web']['env_file'] = env_file if env_file
-      end
-      # create docker-compose.yml file
-      create_yml(docker_compose, docker_compose_file)
-    end
-  end
-end

data/lib/kontena/cli/apps/docker_helper.rb

@@ -1,80 +0,0 @@
-module Kontena::Cli::Apps
-  module DockerHelper
-
-    # @param [Hash] services
-    # @param [Boolean] force_build
-    # @param [Boolean] no_cache
-    def process_docker_images(services, force_build = false, no_cache = false)
-      services.each do |name, service|
-        if service['build'] && (!image_exist?(service['image']) || force_build)
-          dockerfile = service['build']['dockerfile'] || 'Dockerfile'
-          raise ("'#{service['image']}' is not valid Docker image name") unless validate_image_name(service['image'])
-          raise ("'#{service['build']['context']}' does not have #{dockerfile}") unless dockerfile_exist?(service['build']['context'], dockerfile)
-          if service['hooks'] && service['hooks']['pre_build']
-            puts "Running pre_build hook".colorize(:cyan)
-            run_pre_build_hook(service['hooks']['pre_build'])
-          end
-          puts "Building image #{service['image'].colorize(:cyan)}"
-          build_docker_image(service, no_cache)
-          puts "Pushing image #{service['image'].colorize(:cyan)} to registry"
-          push_docker_image(service['image'])
-        end
-      end
-    end
-
-    # @param [String] name
-    # @return [Boolean]
-    def validate_image_name(name)
-      !(/^[\w.\/\-:]+:?+[\w+.]+$/ =~ name).nil?
-    end
-
-    # @param [Hash] service
-    # @param [Boolean] no_cache
-    # @return [Integer]
-    def build_docker_image(service, no_cache = false)
-      dockerfile = dockerfile = service['build']['dockerfile'] || 'Dockerfile'
-      build_context = service['build']['context']
-      cmd = ['docker', 'build', '-t', service['image']]
-      cmd << ['-f', File.join(File.expand_path(build_context), dockerfile)] if dockerfile != "Dockerfile"
-      cmd << '--no-cache' if no_cache
-      args = service['build']['args'] || {}
-      args.each do |k, v|
-        cmd << "--build-arg=#{k}=#{v}"
-      end
-      cmd << build_context
-      ret = system(*cmd.flatten)
-      raise ("Failed to build image #{service['image'].colorize(:cyan)}") unless ret
-      ret
-    end
-
-    # @param [String] image
-    # @return [Integer]
-    def push_docker_image(image)
-      ret = system('docker', 'push', image)
-      raise ("Failed to push image #{image.colorize(:cyan)}") unless ret
-      ret
-    end
-
-    # @param [String] image
-    # @return [Boolean]
-    def image_exist?(image)
-      system("docker history '#{image}' >/dev/null 2>/dev/null")
-    end
-
-    # @param [String] path
-    # @param [String] dockerfile
-    # @return [Boolean]
-    def dockerfile_exist?(path, dockerfile)
-      file = File.join(File.expand_path(path), dockerfile)
-      File.exist?(file)
-    end
-
-    # @param [Hash] hook
-    def run_pre_build_hook(hook)
-      hook.each do |h|
-        ret = system(h['cmd'])
-        raise ("Failed to run pre_build hook: #{h['name']}!") unless ret
-      end
-    end
-  end
-end