central-cli 0.6.3

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

@@ -0,0 +1,48 @@
+require 'yaml'
+require_relative 'common'
+
+module Central::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 = {}
+        procfile.keys.each do |service|
+          docker_compose[service] = { 'build' => '.' }
+          if app_json && service == 'web' # Heroku generates PORT env variable so should we do too
+            docker_compose[service]['environment'] = ['PORT=5000']
+            docker_compose[service]['ports'] = ['5000:5000']
+          end
+          docker_compose[service]['command'] = "/start #{service}" if service != 'web'
+          docker_compose[service]['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)
+            docker_compose[service]['links'] = [] unless docker_compose[service]['links']
+            docker_compose[service]['links'] << "#{addon_service}:#{addon_service}"
+            docker_compose[service]['environment'] = [] unless docker_compose[service]['environment']
+            docker_compose[service]['environment'] += valid_addons[addon_service]['environment']
+            docker_compose[addon_service] = { 'image' => valid_addons[addon_service]['image'] }
+          end
+        end
+      else
+        # no Procfile found, create dummy web service
+        docker_compose = { 'web' => { 'build' => '.' } }
+        docker_compose['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/central/cli/apps/docker_helper.rb

@@ -0,0 +1,85 @@
+module Central::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)
+      if services.none? { |_name, service| service['build'] }
+        puts 'Not found any service with build option'
+        return
+      end
+
+      services.each do |_name, service|
+        next unless service['build'] && (!image_exist?(service['image']) || force_build)
+        dockerfile = service['dockerfile'] || 'Dockerfile'
+        unless validate_image_name(service['image'])
+          abort("'#{service['image']}' is not valid Docker image name")
+        end
+        unless dockerfile_exist?(service['build'], dockerfile)
+          abort("'#{service['build']}' does not have #{dockerfile}")
+        end
+        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['image'], service['build'], dockerfile, no_cache)
+        puts "Pushing image #{service['image'].colorize(:cyan)} to registry"
+        push_docker_image(service['image'])
+      end
+    end
+
+    # @param [String] name
+    # @return [Boolean]
+    def validate_image_name(name)
+      !(/^[\w.\/\-:]+:?+[\w+.]+$/ =~ name).nil?
+    end
+
+    # @param [String] name
+    # @param [String] path
+    # @param [String] dockerfile
+    # @param [Boolean] no_cache
+    # @return [Integer]
+    def build_docker_image(name, path, dockerfile, no_cache = false)
+      cmd = ["docker build -t #{name}"]
+      if dockerfile != 'Dockerfile'
+        cmd << "-f #{File.join(File.expand_path(path), dockerfile)}"
+      end
+      cmd << '--no-cache' if no_cache
+      cmd << path
+      ret = system(cmd.join(' '))
+      abort("Failed to build image #{name.colorize(:cyan)}") unless ret
+      ret
+    end
+
+    # @param [String] image
+    # @return [Integer]
+    def push_docker_image(image)
+      ret = system("docker push #{image}")
+      abort("Failed to push image #{image.colorize(:cyan)}") unless ret
+      ret
+    end
+
+    # @param [String] image
+    # @return [Boolean]
+    def image_exist?(image)
+      `docker history #{image} 2>&1`; $CHILD_STATUS.success?
+    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'])
+        abort("Failed to run pre_build hook: #{h['name']}!".colorize(:red)) unless ret
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'yaml'
+require_relative 'common'
+
+module Central::Cli::Apps
+  class DockerfileGenerator
+    include Common
+
+    def generate(base_image)
+      dockerfile = File.new('Dockerfile', 'w')
+      dockerfile.puts "FROM #{base_image}"
+      dockerfile.puts 'CMD ["/start", "web"]'
+      dockerfile.close
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'securerandom'
+require_relative 'common'
+require_relative 'dockerfile_generator'
+require_relative 'docker_compose_generator'
+require_relative 'central_yml_generator'
+
+module Central::Cli::Apps
+  class InitCommand < Clamp::Command
+    include Central::Cli::Common
+    include Common
+
+    option ['-f', '--file'], 'FILE', 'Specify a docker-compose file', attribute_name: :docker_compose_file, default: 'docker-compose.yml'
+    option ['-i', '--image-name'], 'IMAGE_NAME', 'Specify a docker image name'
+    option ['-b', '--base-image'], 'BASE_IMAGE_NAME', 'Specify a docker base image name', default: 'central/buildstep'
+    option ['-p', '--project-name'], 'NAME', 'Specify an alternate project name (default: directory name)'
+
+    attr_reader :service_prefix
+
+    def execute
+      require 'highline/import'
+
+      @service_prefix = project_name || File.basename(Dir.getwd)
+
+      if File.exist?('Dockerfile')
+        puts 'Found Dockerfile'
+      elsif create_dockerfile?
+        puts "Creating #{'Dockerfile'.colorize(:cyan)}"
+        DockerfileGenerator.new.generate(base_image)
+      end
+
+      procfile = if File.exist?('Procfile')
+                   YAML.load(File.read('Procfile'))
+                 else
+                   {}
+      end
+
+      app_env = create_env_file(app_json)
+      addons = app_json['addons'] || []
+
+      if File.exist?(docker_compose_file)
+        puts "Found #{docker_compose_file}."
+      elsif create_docker_compose_yml?
+        puts "Creating #{docker_compose_file.colorize(:cyan)}"
+        docker_compose_generator = DockerComposeGenerator.new(docker_compose_file)
+        docker_compose_generator.generate(procfile, addons, app_env)
+      end
+
+      if File.exist?('central.yml')
+        puts "Updating #{'central.yml'.colorize(:cyan)}"
+      else
+        puts "Creating #{'central.yml'.colorize(:cyan)}"
+      end
+
+      central_yml_generator = CentralYmlGenerator.new(image_name, service_prefix)
+      if File.exist?(docker_compose_file)
+        central_yml_generator.generate_from_compose_file(docker_compose_file)
+      else
+        central_yml_generator.generate(procfile, addons, app_env)
+      end
+
+      puts "Your app is ready! Deploy with 'cm app deploy'.".colorize(:green)
+    end
+
+    protected
+
+    def create_dockerfile?
+      ['', 'y', 'yes'].include? ask('Dockerfile not found. Do you want to create it? [Yn]: ').downcase
+    end
+
+    def create_env_file(app_json)
+      if app_json['env']
+        app_env = File.new('.env', 'w')
+        app_json['env'].each do |key, env|
+          value = if env['generator'] == 'secret'
+                    SecureRandom.hex(64)
+                  else
+                    env['value']
+          end
+          app_env.puts "#{key}=#{value}"
+        end
+        app_env.close
+        return '.env'
+      end
+      nil
+    end
+
+    def create_docker_compose_yml?
+      ['', 'y', 'yes'].include? ask("#{docker_compose_file} not found. Do you want to create it? [Yn]: ").downcase
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require_relative 'common'
+require 'tty'
+
+module Central::Cli::Apps
+  class ListCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Common
+
+    option ['-f', '--file'], 'FILE', 'Specify an alternate Central compose file', attribute_name: :filename, default: 'central.yml'
+    option ['-p', '--project-name'], 'NAME', 'Specify an alternate project name (default: directory name)'
+
+    parameter '[SERVICE] ...', 'Services to start'
+
+    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)
+      if services.size > 0
+        show_services(services)
+      elsif !service_list.empty?
+        puts "No such service: #{service_list.join(', ')}".colorize(:red)
+      end
+    end
+
+    def show_services(services)
+      header = %w(Name Images Instances Stateful State Ports)
+      rows = []
+
+      services.each do |service_name, _opts|
+        service = begin
+                    get_service(token, prefixed_name(service_name))
+                  rescue
+                    false
+                  end
+        if service
+          name = service['name'].sub("#{@service_prefix}-", '')
+          state = service['stateful'] ? 'yes' : 'no'
+          ports = service['ports'].map do|p|
+            "#{p['ip']}:#{p['node_port']}->#{p['container_port']}/#{p['protocol']}"
+          end.join(', ')
+          running = service['instances']['running']
+          desired = service['container_count']
+          instances = "#{running} / #{desired}"
+          rows << [
+            name,
+            service['image'],
+            instances,
+            state,
+            (service['state'] ? ' ✓ '.colorize(:green) : ' ✘ '.colorize(:red)),
+            ports
+          ]
+        else
+          rows << [service_name.colorize(:yellow), '-', '-', '-', '-', '-']
+        end
+      end
+
+      ttable = TTY::Table.new header: header, rows: Array.new(rows)
+      renderer = TTY::Table::Renderer::Unicode.new(ttable)
+      renderer.border.style = :cyan
+      renderer.padding = [0, 1, 0, 1]
+      puts renderer.render
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require_relative 'common'
+
+module Central::Cli::Apps
+  class LogsCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Common
+
+    option ['-f', '--file'], 'FILE', 'Specify an alternate Central compose file', attribute_name: :filename, default: 'central.yml'
+    option ['-p', '--project-name'], 'NAME', 'Specify an alternate project name (default: directory name)'
+    option ['-l', '--lines'], 'LINES', 'How many lines to show', default: '100'
+    option '--since', 'SINCE', 'Show logs since given timestamp'
+    option ['-t', '--tail'], :flag, 'Tail (follow) logs', default: false
+    parameter '[SERVICE] ...', 'Show only specified service logs'
+
+    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)
+      if services.size > 0
+        show_logs(services)
+      elsif !service_list.empty?
+        puts "No such service: #{service_list.join(', ')}".colorize(:red)
+      end
+    end
+
+    def show_logs(services)
+      last_id = nil
+      loop do
+        query_params = []
+        query_params << "from=#{last_id}" unless last_id.nil?
+        query_params << "limit=#{lines}"
+        query_params << "since=#{since}" if !since.nil? && last_id.nil?
+        logs = []
+        services.each do |service_name, _opts|
+          service = begin
+                      get_service(token, prefixed_name(service_name))
+                    rescue
+                      false
+                    end
+          result = client(token).get("services/#{service['id']}/container_logs?#{query_params.join('&')}") if service
+          logs += result['logs'] if result && result['logs']
+        end
+        logs.sort! { |x, y| DateTime.parse(x['created_at']) <=> DateTime.parse(y['created_at']) }
+        logs.each do |log|
+          color = color_for_container(log['name'])
+          prefix = "#{log['created_at']} #{log['name']}:".colorize(color)
+          puts "#{prefix} #{log['data']}"
+          last_id = log['id']
+        end
+        break unless tail?
+        sleep(2)
+      end
+    end
+
+    def color_for_container(container_id)
+      color_maps[container_id] = colors.shift unless color_maps[container_id]
+      color_maps[container_id].to_sym
+    end
+
+    def color_maps
+      @color_maps ||= {}
+    end
+
+    def colors
+      if @colors.nil? || @colors.size == 0
+        @colors = [:green, :magenta, :yellow, :cyan, :red,
+                   :light_green, :light_yellow, :ligh_magenta, :light_cyan, :light_red]
+      end
+      @colors
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require_relative 'common'
+
+module Central::Cli::Apps
+  class MonitorCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Common
+
+    option ['-f', '--file'], 'FILE', 'Specify an alternate Central compose file', attribute_name: :filename, default: 'central.yml'
+    option ['-p', '--project-name'], 'NAME', 'Specify an alternate project name (default: directory name)'
+
+    parameter '[SERVICE] ...', 'Services to start'
+
+    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)
+      if services.size > 0
+        show_monitor(services)
+      elsif !service_list.empty?
+        puts "No such service: #{service_list.join(', ')}".colorize(:red)
+      end
+    end
+
+    def show_monitor(services)
+      require_api_url
+      token = require_token
+      loop do
+        nodes = {}
+        services.each do |name, _data|
+          service = prefixed_name(name)
+          result = begin
+                     client(token).get("services/#{current_stack}/#{service}/containers")
+                   rescue
+                     nil
+                   end
+          next unless result
+          services[name]['instances'] = result['containers'].size
+          result['containers'].each do |container|
+            container['service'] = name
+            nodes[container['node']['name']] ||= []
+            nodes[container['node']['name']] << container
+          end
+        end
+        clear_terminal
+        puts 'services:'
+        services.each do |name, data|
+          color = color_for_service(name)
+          puts "  #{"■".colorize(color)} #{name} (#{data['instances']} instances)"
+        end
+        puts 'nodes:'
+        node_names = nodes.keys.sort
+        node_names.each do |name|
+          containers = nodes[name]
+          puts "  #{name} (#{containers.size} instances)"
+          print '  '
+          containers.each do |container|
+            icon = "■"
+            icon = "□" if container['status'] != 'running'
+            color = color_for_service(container['service'])
+            print icon.colorize(color)
+          end
+          puts ''
+        end
+        sleep 1
+      end
+    end
+
+    def color_for_service(service)
+      color_maps[service] = colors.shift unless color_maps[service]
+      color_maps[service].to_sym
+    end
+
+    def color_maps
+      @color_maps ||= {}
+    end
+
+    def colors
+      if @colors.nil? || @colors.size == 0
+        @colors = [:green, :magenta, :yellow, :cyan, :red,
+                   :light_green, :light_yellow, :ligh_magenta, :light_cyan, :light_red]
+      end
+      @colors
+    end
+
+    def clear_terminal
+      print "\e[H\e[2J"
+    end
+  end
+end