central-cli 0.6.3

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

@@ -0,0 +1,42 @@
+require_relative 'services_helper'
+require 'tty'
+
+module Central::Cli::Services
+  class ListCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    def execute
+      require_api_url
+      token = require_token
+      stacks = client(token).get("stacks/#{current_stack}/services")
+      services = stacks['services'].sort_by { |s| s['updated_at'] }.reverse
+      header = ['Name', 'Instances', 'Stateful', 'State', 'Exposed Ports']
+      rows = []
+
+      services.each do |service|
+        stateful = service['stateful'] ? 'yes' : 'no'
+        running = service['instances']['running']
+        desired = service['container_count']
+        instances = "#{running} / #{desired}"
+        ports = service['ports'].map do|p|
+          "#{p['ip']}:#{p['node_port']}->#{p['container_port']}/#{p['protocol']}"
+        end.join(', ')
+        rows << [
+          service['name'],
+          instances,
+          stateful,
+          (service['state'] ? ' ✓ '.colorize(:green) : ' ✘ '.colorize(:red)),
+          ports
+        ]
+      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/services/logs_command.rb

@@ -0,0 +1,57 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class LogsCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    option ['-t', '--tail'], :flag, 'Tail (follow) logs', default: false
+    option ['-l', '--lines'], 'LINES', 'How many lines to show', default: '100'
+    option '--since', 'SINCE', 'Show logs since given timestamp'
+    option ['-i', '--instance'], 'INSTANCE', 'Show only given instance specific logs'
+
+    def execute
+      require_api_url
+      token = require_token
+      last_id = nil
+      loop do
+        query_params = []
+        query_params << "limit=#{lines}"
+        query_params << "from=#{last_id}" unless last_id.nil?
+        query_params << "since=#{since}" if !since.nil? && last_id.nil?
+        query_params << "container=#{name}-#{instance}" if instance
+
+        result = client(token).get("services/#{current_stack}/#{name}/container_logs?#{query_params.join('&')}")
+        result['logs'].each do |log|
+          color = color_for_container(log['name'])
+          instance_number = log['name'].match(/^.+-(\d+)$/)[1]
+          name = instance_number.nil? ? log['name'] : instance_number
+          prefix = "#{log['created_at']} [#{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, :yellow, :magenta, :cyan, :red,
+                   :light_green, :light_yellow, :ligh_magenta, :light_cyan, :light_red]
+      end
+      @colors
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class MonitorCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    option '--interval', 'SECONDS', 'How often view is refreshed', default: 2
+
+    def execute
+      require_api_url
+      token = require_token
+
+      loop do
+        nodes = {}
+        service = client(token).get("services/#{current_stack}/#{name}")
+        result = client(token).get("services/#{current_stack}/#{name}/containers")
+        result['containers'].each do |container|
+          nodes[container['node']['name']] ||= []
+          nodes[container['node']['name']] << container
+        end
+        clear_terminal
+        puts "service: #{name} (#{result['containers'].size}/#{service['container_count']} instances)"
+        puts "strategy: #{service['strategy']}"
+        puts "status: #{service['state']}"
+        puts "stateful: #{service['stateful'] == true ? 'yes' : 'no'}"
+        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|
+            color = container['status']
+            color = if container['status'] == 'running'
+                      :green
+                    elsif container['status'] == 'killed'
+                      :red
+                    elsif container['status'] == 'stopped'
+                      :gray
+                    else
+                      :yellow
+            end
+            print "■".colorize(color)
+          end
+          puts ''
+        end
+        sleep interval.to_f
+      end
+    end
+
+    def clear_terminal
+      print "\e[H\e[2J"
+    end
+  end
+end

data/lib/central/cli/services/remove_command.rb

@@ -0,0 +1,17 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class RemoveCommand < Clamp::Command
+    include Central::Cli::Common
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+
+    def execute
+      require_api_url
+      token = require_token
+
+      result = client(token).delete("services/#{parse_service_id(name)}")
+    end
+  end
+end

data/lib/central/cli/services/remove_env_command.rb

@@ -0,0 +1,18 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class RemoveEnvCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    parameter 'ENV', 'Environment variable name'
+
+    def execute
+      require_api_url
+      token = require_token
+      client(token).delete("services/#{parse_service_id(name)}/envs/#{env}")
+    end
+  end
+end

data/lib/central/cli/services/remove_secret_command.rb

@@ -0,0 +1,28 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class RemoveSecretCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    parameter 'SECRET', 'Secret to be removed (format: secret:name:type)'
+
+    def execute
+      require_api_url
+      token = require_token
+      result = client(token).get("services/#{parse_service_id(name)}")
+      secrets = result['secrets']
+      remove_secret = parse_secrets([secret])[0]
+      if secrets.delete_if { |s| s['name'] == remove_secret[:name] && s['secret'] == remove_secret[:secret] }
+        data = {
+          secrets: secrets
+        }
+        client(token).put("services/#{parse_service_id(name)}", data)
+      else
+        abort('Secret not found')
+      end
+    end
+  end
+end

data/lib/central/cli/services/restart_command.rb

@@ -0,0 +1,17 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class RestartCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+
+    def execute
+      require_api_url
+      token = require_token
+      restart_service(token, name)
+    end
+  end
+end

data/lib/central/cli/services/scale_command.rb

@@ -0,0 +1,17 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class ScaleCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    parameter 'INSTANCES', 'Scales service to given number of instances'
+
+    def execute
+      token = require_token
+      scale_service(token, name, instances)
+    end
+  end
+end

data/lib/central/cli/services/secret_command.rb

@@ -0,0 +1,9 @@
+module Central::Cli::Services
+  require_relative 'secrets/link_command'
+  require_relative 'secrets/unlink_command'
+
+  class SecretCommand < Clamp::Command
+    subcommand 'link', 'Link secret from Vault', Secrets::LinkCommand
+    subcommand 'unlink', 'Unlink secret from Vault', Secrets::UnlinkCommand
+  end
+end

data/lib/central/cli/services/secrets/link_command.rb

@@ -0,0 +1,24 @@
+require_relative '../services_helper'
+
+module Central::Cli::Services::Secrets
+  class LinkCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Central::Cli::Services::ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    parameter 'SECRET', 'Secret to be added from Vault (format: secret:name:type)'
+
+    def execute
+      require_api_url
+      token = require_token
+      result = client(token).get("services/#{parse_service_id(name)}")
+      secrets = result['secrets']
+      secrets << parse_secrets([secret])[0]
+      data = {
+        secrets: secrets
+      }
+      client(token).put("services/#{parse_service_id(name)}", data)
+    end
+  end
+end

data/lib/central/cli/services/secrets/unlink_command.rb

@@ -0,0 +1,28 @@
+require_relative '../services_helper'
+
+module Central::Cli::Services::Secrets
+  class UnlinkCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Central::Cli::Services::ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    parameter 'SECRET', 'Secret to be removed (format: secret:name:type)'
+
+    def execute
+      require_api_url
+      token = require_token
+      result = client(token).get("services/#{parse_service_id(name)}")
+      secrets = result['secrets']
+      remove_secret = parse_secrets([secret])[0]
+      if secrets.delete_if { |s| s['name'] == remove_secret[:name] && s['secret'] == remove_secret[:secret] }
+        data = {
+          secrets: secrets
+        }
+        client(token).put("services/#{parse_service_id(name)}", data)
+      else
+        abort('Secret not found')
+      end
+    end
+  end
+end

data/lib/central/cli/services/services_helper.rb

@@ -0,0 +1,360 @@
+require 'central/client'
+require_relative '../common'
+require 'shell-spinner'
+
+module Central
+  module Cli
+    module Services
+      module ServicesHelper
+        include Central::Cli::Common
+
+        # @param [String] token
+        # @param [String] stack_id
+        # @param [Hash] data
+        def create_service(token, stack_id, data)
+          client(token).post("stacks/#{stack_id}/services", data)
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        # @param [Hash] data
+        def update_service(token, service_id, data)
+          param = parse_service_id(service_id)
+          client(token).put("services/#{param}", data)
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        # @param [Integer] instances
+        def scale_service(token, service_id, instances)
+          param = parse_service_id(service_id)
+          client(token).post("services/#{param}/scale", instances: instances)
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        def get_service(token, service_id)
+          param = parse_service_id(service_id)
+          client(token).get("services/#{param}")
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        def show_service(token, service_id)
+          service = get_service(token, service_id)
+          stack = service['id'].split('/')[0]
+          puts "#{service['id']}:"
+          puts "  status: #{service['state']}"
+          puts "  image: #{service['image']}"
+          puts "  stateful: #{service['stateful'] == true ? 'yes' : 'no'}"
+          puts "  scaling: #{service['container_count']}"
+          puts "  strategy: #{service['strategy']}"
+          puts '  deploy_opts:'
+          puts "    min_health: #{service['deploy_opts']['min_health']}"
+          if service['deploy_opts']['wait_for_port']
+            puts "    wait_for_port: #{service['deploy_opts']['wait_for_port']}"
+          end
+          if service['deploy_opts']['interval']
+            puts "    interval: #{service['deploy_opts']['interval']}"
+          end
+          puts "  dns: #{service['name']}.#{stack}.central.local"
+
+          if service['affinity'].to_a.size > 0
+            puts '  affinity: '
+            service['affinity'].to_a.each do |a|
+              puts "    - #{a}"
+            end
+          end
+
+          unless service['cmd'].to_s.empty?
+            if service['cmd']
+              puts "  cmd: #{service['cmd'].join(' ')}"
+            else
+              puts '  cmd: '
+            end
+          end
+
+          if service['hooks'].to_a.size > 0
+            puts '  hooks: '
+            service['hooks'].to_a.each do |hook|
+              puts "    - name: #{hook['name']}"
+              puts "      type: #{hook['type']}"
+              puts "      cmd: #{hook['cmd']}"
+              puts "      oneshot: #{hook['oneshot']}"
+            end
+          end
+
+          if service['secrets'].to_a.size > 0
+            puts '  secrets: '
+            service['secrets'].to_a.each do |s|
+              puts "    - secret: #{s['secret']}"
+              puts "      name: #{s['name']}"
+              puts "      type: #{s['type']}"
+            end
+          end
+
+          if service['env'].to_a.size > 0
+            puts '  env: '
+            service['env'].to_a.each do |e|
+              if e.length > 50
+                puts "    - #{e[0..50]}..."
+              else
+                puts "    - #{e}"
+              end
+            end
+          end
+
+          puts "  net: #{service['net']}" unless service['net'].to_s.empty?
+
+          if service['ports'].to_a.size > 0
+            puts '  ports:'
+            service['ports'].to_a.each do |p|
+              puts "    - #{p['node_port']}:#{p['container_port']}/#{p['protocol']}"
+            end
+          end
+
+          if service['volumes'].to_a.size > 0
+            puts '  volumes:'
+            service['volumes'].to_a.each do |v|
+              puts "    - #{v}"
+            end
+          end
+
+          if service['volumes_from'].to_a.size > 0
+            puts '  volumes_from:'
+            service['volumes_from'].to_a.each do |v|
+              puts "    - #{v}"
+            end
+          end
+
+          if service['links'].to_a.size > 0
+            puts '  links: '
+            service['links'].to_a.each do |l|
+              puts "    - #{l['alias']}"
+            end
+          end
+
+          if service['cap_add'].to_a.size > 0
+            puts '  cap_add:'
+            service['cap_add'].to_a.each do |c|
+              puts "    - #{c}"
+            end
+          end
+
+          if service['cap_drop'].to_a.size > 0
+            puts '  cap_drop:'
+            service['cap_drop'].to_a.each do |c|
+              puts "    - #{c}"
+            end
+          end
+
+          unless service['log_driver'].to_s.empty?
+            puts "  log_driver: #{service['log_driver']}"
+            puts '  log_opts:'
+            service['log_opts'].each do |opt, value|
+              puts "    #{opt}: #{value}"
+            end
+          end
+
+          unless service['memory'].to_s.empty?
+            puts "  memory: #{int_to_filesize(service['memory'])}"
+          end
+
+          unless service['memory_swap'].to_s.empty?
+            puts "  memory_swap: #{int_to_filesize(service['memory_swap'])}"
+          end
+
+          puts "  pid: #{service['pid']}" unless service['pid'].to_s.empty?
+
+          puts '  instances:'
+          result = client(token).get("services/#{parse_service_id(service_id)}/containers")
+          result['containers'].each do |container|
+            puts "    #{container['name']}:"
+            puts "      rev: #{container['deploy_rev']}"
+            puts "      node: #{begin
+                                  container['node']['name']
+                                rescue
+                                  'unknown'
+                                end}"
+            puts "      dns: #{container['name']}.#{stack}.central.local"
+            puts "      ip: #{container['overlay_cidr'].to_s.split('/')[0]}"
+            puts "      public ip: #{begin
+                                       container['node']['public_ip']
+                                     rescue
+                                       'unknown'
+                                     end}"
+            if container['status'] == 'unknown'
+              puts "      status: #{container['status'].colorize(:yellow)}"
+            else
+              puts "      status: #{container['status']}"
+            end
+            if container['state']['error'] && container['state']['error'] != ''
+              puts "      reason: #{container['state']['error']}"
+            end
+          end
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        # @param [Hash] data
+        def deploy_service(token, service_id, data)
+          param = parse_service_id(service_id)
+          client(token).post("services/#{param}/deploy", data)
+        end
+
+        # @param [String] token
+        # @param [String] name
+        def wait_for_deploy_to_finish(token, name)
+          ShellSpinner ' ' do
+            until client(token).get("services/#{name}")['state'] != 'deploying'
+              sleep 1
+            end
+          end
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        def start_service(token, service_id)
+          param = parse_service_id(service_id)
+          client(token).post("services/#{param}/start", {})
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        def stop_service(token, service_id)
+          param = parse_service_id(service_id)
+          client(token).post("services/#{param}/stop", {})
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        def restart_service(token, service_id)
+          param = parse_service_id(service_id)
+          client(token).post("services/#{param}/restart", {})
+        end
+
+        # @param [String] token
+        # @param [String] service_id
+        def delete_service(token, service_id)
+          param = parse_service_id(service_id)
+          client(token).delete("services/#{param}")
+        end
+
+        # @param [String] service_id
+        # @return [String]
+        def parse_service_id(service_id)
+          param = if service_id.to_s.include?('/')
+                    service_id
+                  else
+                    "#{current_stack}/#{service_id}"
+          end
+        end
+
+        # @param [Array<String>] port_options
+        # @return [Array<Hash>]
+        def parse_ports(port_options)
+          port_options.map do|p|
+            node_port, container_port, protocol = p.split(':')
+            if node_port.nil? || container_port.nil?
+              fail ArgumentError.new("Invalid port value #{p}")
+            end
+            {
+              container_port: container_port,
+              node_port: node_port,
+              protocol: protocol || 'tcp'
+            }
+          end
+        end
+
+        # @param [Array<String>] link_options
+        # @return [Array<Hash>]
+        def parse_links(link_options)
+          link_options.map do|l|
+            service_name, alias_name = l.split(':')
+            if service_name.nil?
+              fail ArgumentError.new("Invalid link value #{l}")
+            end
+            alias_name = service_name if alias_name.nil?
+            {
+              name: service_name,
+              alias: alias_name
+            }
+          end
+        end
+
+        # @param [String] memory
+        # @return [Integer]
+        def parse_memory(memory)
+          if memory.end_with?('k')
+            memory.to_i * 1024
+          elsif memory.end_with?('m')
+            memory.to_i * 1024 * 1024
+          elsif memory.end_with?('g')
+            memory.to_i * 1024 * 1024 * 1024
+          else
+            memory.to_i
+          end
+        end
+
+        # @param [String] image
+        # @return [String]
+        def parse_image(image)
+          image = "#{image}:latest" unless image.include?(':')
+          image
+        end
+
+        ##
+        # @param [Array] log_opts
+        # @return [Hash]
+        def parse_log_opts(log_opts)
+          opts = {}
+          log_opts.each do |opt|
+            key, value = opt.split('=')
+            opts[key] = value
+          end
+          opts
+        end
+
+        # @param [Array<String>] secret_opts
+        # @return [Array<Hash>]
+        def parse_secrets(secret_opts)
+          secrets = []
+          secret_opts.each do |s|
+            secret, name, type = s.split(':')
+            secrets << { secret: secret, name: name, type: type }
+          end
+          secrets
+        end
+
+        # @param [String] time
+        # @return [Integer, NilClass]
+        def parse_relative_time(time)
+          if time.end_with?('min')
+            time.to_i * 60
+          elsif time.end_with?('h')
+            time.to_i * 60 * 60
+          elsif time.end_with?('d')
+            time.to_i * 60 * 60 * 24
+          else
+            time = time.to_i
+            if time == 0
+              nil
+            else
+              time
+            end
+          end
+        end
+
+        def int_to_filesize(int)
+          {
+            'B'  => 1000,
+            'KB' => 1000 * 1000,
+            'MB' => 1000 * 1000 * 1000,
+            'GB' => 1000 * 1000 * 1000 * 1000,
+            'TB' => 1000 * 1000 * 1000 * 1000 * 1000
+          }.each_pair { |e, s| return "#{(int.to_i / (s / 1000))}#{e}" if int < s }
+        end
+      end
+    end
+  end
+end