central-cli 0.6.3

data/lib/central/cli/app_command.rb

@@ -0,0 +1,29 @@
+require_relative 'apps/init_command'
+require_relative 'apps/build_command'
+require_relative 'apps/deploy_command'
+require_relative 'apps/start_command'
+require_relative 'apps/stop_command'
+require_relative 'apps/restart_command'
+require_relative 'apps/remove_command'
+require_relative 'apps/list_command'
+require_relative 'apps/logs_command'
+require_relative 'apps/monitor_command'
+require_relative 'apps/show_command'
+require_relative 'apps/scale_command'
+
+class Central::Cli::AppCommand < Clamp::Command
+  subcommand 'init', 'Init Central application', Central::Cli::Apps::InitCommand
+  subcommand 'build', 'Build Central services', Central::Cli::Apps::BuildCommand
+  subcommand 'deploy', 'Deploy Central services', Central::Cli::Apps::DeployCommand
+  subcommand 'scale', 'Scale services', Central::Cli::Apps::ScaleCommand
+  subcommand 'start', 'Start services', Central::Cli::Apps::StartCommand
+  subcommand 'stop', 'Stop services', Central::Cli::Apps::StopCommand
+  subcommand 'restart', 'Restart services', Central::Cli::Apps::RestartCommand
+  subcommand 'show', 'Show service details', Central::Cli::Apps::ShowCommand
+  subcommand %w(ps list ls), 'List services', Central::Cli::Apps::ListCommand
+  subcommand ['logs'], 'Show service logs', Central::Cli::Apps::LogsCommand
+  subcommand 'monitor', 'Monitor services', Central::Cli::Apps::MonitorCommand
+  subcommand %w(remove rm), 'Remove services', Central::Cli::Apps::RemoveCommand
+  def execute
+  end
+end

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

@@ -0,0 +1,24 @@
+require_relative 'common'
+require_relative 'docker_helper'
+
+module Central::Cli::Apps
+  class BuildCommand < Clamp::Command
+    include Central::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 Central compose file', attribute_name: :filename, default: 'central.yml'
+    option ['--no-cache'], :flag, 'Do not use cache when building the image', default: false
+    parameter '[SERVICE] ...', 'Services to build'
+
+    attr_reader :services, :service_prefix
+
+    def execute
+      require_config_file(filename)
+      @service_prefix = project_name || current_dir
+      @services = load_services(filename, service_list, service_prefix)
+      process_docker_images(services, true, no_cache?)
+    end
+  end
+end

data/lib/central/cli/apps/central_yml_generator.rb

@@ -0,0 +1,88 @@
+require 'yaml'
+require_relative 'common'
+
+module Central::Cli::Apps
+  class CentralYmlGenerator
+    include Common
+
+    attr_reader :image_name, :service_prefix
+
+    def initialize(image_name, service_prefix)
+      @image_name = image_name
+      @service_prefix = service_prefix
+    end
+
+    def generate_from_compose_file(docker_compose_file)
+      services = {}
+      # extend services from docker-compose.yml
+      file = File.read(docker_compose_file)
+      compose_services = YAML.load(file)
+      compose_services.each do |name, options|
+        services[name] = { 'extends' => { 'file' => 'docker-compose.yml', 'service' => name } }
+        if options.key?('build')
+          image = image_name || "registry.central.local/#{File.basename(Dir.getwd)}:latest"
+          services[name]['image'] = image
+        end
+
+        # set Heroku addon service as stateful by default
+        services[name]['stateful'] = true if valid_addons.key?(name)
+
+        # we have to generate Central urls to env vars for Heroku addons
+        # redis://openredis:6379 -> redis://project-name-openredis:6379
+        next unless options['links']
+        options['links'].each do |link|
+          service_link = link.split(':').first
+          if valid_addons.key?(service_link)
+            services[name]['environment'] ||= []
+            services[name]['environment'] += valid_addons(service_prefix)[service_link]['environment']
+          end
+        end
+      end
+      create_yml(services, 'central.yml')
+    end
+
+    def generate(procfile, addons, env_file)
+      image = image_name || "registry.central.local/#{File.basename(Dir.getwd)}:latest"
+      if procfile.keys.size > 0
+        # generate services found in Procfile
+        services = {}
+        procfile.keys.each do |name|
+          services[name] = { 'image' => image }
+          services[name]['environment'] = ['PORT=5000'] if app_json && name == 'web' # Heroku generates PORT env variable so should we do too
+          services[name]['command'] = "/start #{name}" if name != 'web'
+          services[name]['env_file'] = env_file if env_file
+
+          # generate addon services
+          addons.each do |addon|
+            addon_service = addon.split(':')[0]
+            addon_service.slice!('heroku-')
+            next unless valid_addons.key?(addon_service)
+            services[name]['links'] ||= []
+            services[name]['links'] << "#{addon_service}:#{addon_service}"
+            services[name]['environment'] ||= []
+            services[name]['environment'] += valid_addons(service_prefix)[addon_service]['environment']
+            services[addon_service] = { 'image' => valid_addons[addon_service]['image'], 'stateful' => true }
+          end
+        end
+      else
+        # no Procfile found, create dummy web service
+        services = { 'web' => { 'image' => image } }
+        services['web']['env_file'] = env_file if env_file
+      end
+      # create central.yml file
+      create_yml(services, 'central.yml')
+    end
+
+    def create_yml(services, filename)
+      if File.exist?(filename)
+        central_services = YAML.load(File.read(filename))
+        services.each do |name, _options|
+          if central_services[name]
+            services[name].merge!(central_services[name])
+          end
+        end
+      end
+      super(services, filename)
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+require 'yaml'
+require_relative '../services/services_helper'
+
+module Central::Cli::Apps
+  module Common
+    include Central::Cli::Services::ServicesHelper
+
+    def require_config_file(filename)
+      abort("File #{filename} does not exist") unless File.exist?(filename)
+    end
+
+    # @param [String] filename
+    # @param [Array<String>] service_list
+    # @param [String] prefix
+    # @return [Hash]
+    def load_services(filename, service_list, prefix)
+      services = parse_services(filename, nil, prefix)
+      services.delete_if { |name, _service| !service_list.include?(name) } unless service_list.empty?
+      services
+    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 [String] file
+    # @param [String,NilClass] name
+    # @param [String] prefix
+    # @return [Hash]
+    def parse_services(file, name = nil, prefix = '')
+      services = YAML.load(File.read(File.expand_path(file)) % { project: prefix, stack: current_stack })
+      Dir.chdir(File.dirname(File.expand_path(file))) do
+        services.each do |name, options|
+          normalize_env_vars(options)
+          next unless options.key?('extends')
+          extension_file = options['extends']['file']
+          service_name = options['extends']['service']
+          options.delete('extends')
+          services[name] = extend_options(options, extension_file, service_name, prefix)
+        end
+      end
+      if name.nil?
+        services
+      else
+        abort("Service #{name} not found in #{file}") unless services.key?(name)
+        services[name]
+      end
+    end
+
+    # @param [Hash] options
+    # @param [String] file
+    # @param [String] service_name
+    # @param [String] prefix
+    # @return [Hash]
+    def extend_options(options, file, service_name, prefix)
+      parent_options = parse_services(file, service_name, prefix)
+      options['environment'] = extend_env_vars(parent_options['environment'], options['environment'])
+      options['secrets'] = extend_secrets(parent_options['secrets'], options['secrets'])
+      parent_options.merge(options)
+    end
+
+    # @param [Hash] options
+    def normalize_env_vars(options)
+      if options['environment'].is_a?(Hash)
+        options['environment'] = options['environment'].map { |k, v| "#{k}=#{v}" }
+      end
+    end
+
+    # @param [Array] from
+    # @param [Array] to
+    # @return [Array]
+    def extend_env_vars(from, to)
+      env_vars = to || []
+      if from
+        from.each do |env|
+          env_vars << env unless to && to.find { |key| key.split('=').first == env.split('=').first }
+        end
+      end
+      env_vars
+    end
+
+    # @param [Array] from
+    # @param [Array] to
+    # @return [Array]
+    def extend_secrets(from, to)
+      secrets = to || []
+      if from
+        from.each do |from_secret|
+          secrets << from_secret unless to && to.any? { |to_secret| to_secret['secret'] == from_secret['secret'] }
+        end
+      end
+      secrets
+    end
+
+    # @param [Hash] services
+    # @param [String] file
+    def create_yml(services, file = 'central.yml')
+      yml = File.new(file, 'w')
+      yml.puts services.to_yaml
+      yml.close
+    end
+
+    # @return [Hash]
+    def app_json
+      @app_json = if !@app_json && File.exist?('app.json')
+                    JSON.parse(File.read('app.json'))
+                  else
+                    {}
+      end
+      @app_json
+    end
+
+    def valid_addons(prefix = nil)
+      prefix = "#{prefix}-" if prefix
+
+      {
+        '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/central/cli/apps/deploy_command.rb

@@ -0,0 +1,191 @@
+require 'yaml'
+require_relative 'common'
+require_relative 'docker_helper'
+
+module Central::Cli::Apps
+  class DeployCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Common
+    include DockerHelper
+
+    option ['-f', '--file'], 'FILE', 'Specify an alternate Central compose file', attribute_name: :filename, default: 'central.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-deploy', :flag, 'Force deploy even if service does not have any changes'
+
+    parameter '[SERVICE] ...', 'Services to start'
+
+    attr_reader :services, :service_prefix, :deploy_queue
+
+    def execute
+      require_api_url
+      require_token
+      require_config_file(filename)
+      @deploy_queue = []
+      @service_prefix = project_name || current_dir
+      @services = load_services(filename, service_list, service_prefix)
+      process_docker_images(services) unless 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_deploy?
+        deploy_service(token, name, options)
+        print "deploying #{name.sub("#{service_prefix}-", '').colorize(:cyan)}"
+        unless async?
+          wait_for_deploy_to_finish(token, service['id'])
+        else
+          puts ''
+        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.keys.include?(name)
+
+      # create/update linked services recursively before continuing
+      unless options['links'].nil?
+        parse_links(options['links']).each_with_index do |linked_service, index|
+          # change prefixed service name also to links options
+          options['links'][index] = "#{prefixed_name(linked_service[:name])}:#{linked_service[:alias]}"
+          create_or_update_service(linked_service[:name], services[linked_service[:name]]) unless in_deploy_queue?(linked_service[:name])
+        end
+      end
+
+      merge_external_links(options)
+      merge_env_vars(options)
+
+      service = if service_exists?(name)
+                  update(name, options)
+                else
+                  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)
+      puts "creating #{name.colorize(:cyan)}"
+      name = prefixed_name(name)
+      data = { name: name }
+      data.merge!(parse_data(options))
+      create_service(token, current_stack, data)
+    end
+
+    # @param [String] id
+    # @param [Hash] options
+    def update(id, options)
+      puts "updating #{id.colorize(:cyan)}"
+      id = prefixed_name(id)
+      data = parse_data(options)
+      update_service(token, id, data)
+    end
+
+    # @param [String] name
+    def in_deploy_queue?(name)
+      deploy_queue.find { |service| service['name'] == prefixed_name(name) } != nil
+    end
+
+    # @param [Hash] options
+    def merge_env_vars(options)
+      return unless options['env_file']
+
+      options['env_file'] = [options['env_file']] if options['env_file'].is_a?(String)
+      options['environment'] = [] unless options['environment']
+
+      options['env_file'].each do |env_file|
+        options['environment'].concat(read_env_file(env_file))
+      end
+
+      options['environment'].uniq! { |s| s.split('=').first }
+    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
+
+    # @param [String] path
+    def read_env_file(path)
+      File.readlines(path).delete_if { |line| line.start_with?('#') || line.empty? }
+    end
+
+    ##
+    # @param [Hash] options
+    def parse_data(options)
+      data = {}
+      data[:image] = parse_image(options['image'])
+      data[:env] = options['environment']
+      data[:container_count] = options['instances']
+      data[:links] = parse_links(options['links'] || [])
+      data[:ports] = parse_ports(options['ports'] || [])
+      data[:memory] = parse_memory(options['mem_limit'].to_s) if options['mem_limit']
+      data[:memory_swap] = parse_memory(options['memswap_limit'].to_s) if options['memswap_limit']
+      data[:cpu_shares] = options['cpu_shares'] if options['cpu_shares']
+      data[:volumes] = options['volumes'] || []
+      data[:volumes_from] = options['volumes_from'] || []
+      data[:cmd] = options['command'].split(' ') if options['command']
+      data[:affinity] = options['affinity'] || []
+      data[:user] = options['user'] if options['user']
+      data[:stateful] = options['stateful'] == true
+      data[:privileged] = options['privileged'] unless options['privileged'].nil?
+      data[:cap_add] = options['cap_add'] if options['cap_add']
+      data[:cap_drop] = options['cap_drop'] if options['cap_drop']
+      data[:net] = options['net'] if options['net']
+      data[:pid] = options['pid'] if options['pid']
+      data[:log_driver] = options['log_driver'] if options['log_driver']
+      data[:log_opts] = options['log_opt'] if options['log_opt'] && !options['log_opt'].empty?
+
+      deploy_opts = options['deploy'] || {}
+      data[:strategy] = deploy_opts['strategy'] if deploy_opts['strategy']
+      deploy = {}
+      if deploy_opts.key?('wait_for_port')
+        deploy[:wait_for_port] = deploy_opts['wait_for_port']
+      end
+      if deploy_opts.key?('min_health')
+        deploy[:min_health] = deploy_opts['min_health']
+      end
+      if deploy_opts.key?('interval')
+        deploy[:interval] = parse_relative_time(deploy_opts['interval'])
+      end
+      data[:deploy_opts] = deploy unless deploy.empty?
+
+      data[:hooks] = options['hooks'] || {}
+      data[:secrets] = options['secrets'] if options['secrets']
+
+      data
+    end
+  end
+end