central-cli 0.6.3

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

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

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

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

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

@@ -0,0 +1,74 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class StatsCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    MEM_MAX_LIMITS = [
+      1.8446744073709552e+19, 9.223372036854772e+18
+    ].freeze
+
+    parameter 'NAME', 'Service name'
+    option ['-t', '--tail'], :flag, 'Tail (follow) stats in real time', default: false
+
+    def execute
+      require_api_url
+      token = require_token
+      if tail?
+        system('clear')
+        render_header
+      end
+      loop do
+        fetch_stats(token, name, tail?)
+        break unless tail?
+        sleep(2)
+      end
+    end
+
+    private
+
+    def fetch_stats(token, service_id, follow)
+      result = client(token).get("services/#{current_stack}/#{service_id}/stats")
+      system('clear') if follow
+      render_header
+      result['stats'].each do |stat|
+        render_stat_row(stat)
+      end
+    end
+
+    def render_header
+      puts '%-30.30s %-15s %-20s %-15s %-15s' % ['CONTAINER', 'CPU %', 'MEM USAGE/LIMIT', 'MEM %', 'NET I/O']
+    end
+
+    def render_stat_row(stat)
+      memory = stat['memory'].nil? ? 'N/A' : filesize_to_human(stat['memory']['usage'])
+      if !stat['memory'].nil? && (stat['memory']['limit'] && !MEM_MAX_LIMITS.include?(stat['memory']['limit']))
+        memory_limit = filesize_to_human(stat['memory']['limit'])
+        memory_pct = "#{(stat['memory']['usage'].to_f / stat['memory']['limit'].to_f * 100).round(2)}%"
+      else
+        memory_limit = 'N/A'
+        memory_pct = 'N/A'
+      end
+
+      cpu = stat['cpu'].nil? ? 'N/A' : stat['cpu']['usage']
+      network_in = stat['network'].nil? ? 'N/A' : filesize_to_human(stat['network']['rx_bytes'])
+      network_out = stat['network'].nil? ? 'N/A' : filesize_to_human(stat['network']['tx_bytes'])
+      puts '%-30.30s %-15s %-20s %-15s %-15s' % [stat['container_id'], "#{cpu}%", "#{memory} / #{memory_limit}", memory_pct.to_s, "#{network_in}/#{network_out}"]
+    end
+
+    ##
+    # @param [Integer] size
+    # @return [String]
+    def filesize_to_human(size)
+      return '0B' if size.to_f == 0.0
+      units = %w(B K M G T)
+      e = (Math.log(size) / Math.log(1000)).floor
+      s = '%.2f' % (size.to_f / 1000**e)
+      s.sub(/\.?0*$/, units[e])
+    rescue FloatDomainError
+      'N/A'
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+require_relative '../stack_options'
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class UnlinkCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+    parameter 'TARGET', 'Link target service name'
+
+    def execute
+      require_api_url
+      token = require_token
+
+      service = client(token).get("services/#{parse_service_id(name)}")
+      links = service['links'].map { |l| { name: l['stack_service_id'].split('/')[1], alias: l['alias'] } }
+      abort("Service is not linked to #{target}") unless links.find { |l| l[:name] == target.to_s }
+      links.delete_if { |l| l[:name] == target.to_s }
+      data = { links: links }
+      update_service(token, name, data)
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require_relative 'services_helper'
+
+module Central::Cli::Services
+  class UpdateCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include ServicesHelper
+
+    parameter 'NAME', 'Service name'
+
+    option '--image', 'IMAGE', 'Docker image to use'
+    option ['-p', '--ports'], 'PORT', "Publish a service's port to the host", multivalued: true
+    option ['-e', '--env'], 'ENV', 'Set environment variables', multivalued: true
+    option ['-l', '--link'], 'LINK', 'Add link to another service in the form of name:alias', multivalued: true
+    option ['-a', '--affinity'], 'AFFINITY', 'Set service affinity', multivalued: true
+    option ['-c', '--cpu-shares'], 'CPU_SHARES', 'CPU shares (relative weight)'
+    option ['-m', '--memory'], 'MEMORY', 'Memory limit (format: <number><optional unit>, where unit = b, k, m or g)'
+    option ['--memory-swap'], 'MEMORY_SWAP', "Total memory usage (memory + swap), set \'-1\' to disable swap (format: <number><optional unit>, where unit = b, k, m or g)"
+    option '--cmd', 'CMD', 'Command to execute'
+    option '--instances', 'INSTANCES', 'How many instances should be deployed'
+    option ['-u', '--user'], 'USER', 'Username who executes first process inside container'
+    option '--privileged', :flag, 'Give extended privileges to this service', default: false
+    option '--cap-add', 'CAP_ADD', 'Add capabitilies', multivalued: true
+    option '--cap-drop', 'CAP_DROP', 'Drop capabitilies', multivalued: true
+    option '--net', 'NET', 'Network mode'
+    option '--log-driver', 'LOG_DRIVER', 'Set logging driver'
+    option '--log-opt', 'LOG_OPT', 'Add logging options', multivalued: true
+    option '--deploy-strategy', 'STRATEGY', 'Deploy strategy to use (ha, daemon, random)'
+    option '--deploy-wait-for-port', 'PORT', 'Wait for port to respond when deploying'
+    option '--deploy-min-health', 'FLOAT', 'The minimum percentage (0.0 - 1.0) of healthy instances that do not sacrifice overall service availability while deploying'
+    option '--deploy-interval', 'TIME', 'Auto-deploy with given interval (format: <number><unit>, where unit = min, h, d)'
+    option '--pid', 'PID', 'Pid namespace to use'
+    option '--secret', 'SECRET', 'Import secret from Vault (format: <secret>:<name>:<type>)', multivalued: true
+
+    def execute
+      require_api_url
+      token = require_token
+
+      data = parse_service_data_from_options
+      update_service(token, name, data)
+    end
+
+    ##
+    # parse given options to hash
+    # @return [Hash]
+    def parse_service_data_from_options
+      data = {}
+      data[:strategy] = deploy_strategy if deploy_strategy
+      data[:ports] = parse_ports(ports_list) unless ports_list.empty?
+      data[:links] = parse_links(link_list) unless link_list.empty?
+      data[:memory] = parse_memory(memory) if memory
+      data[:memory_swap] = parse_memory(memory_swap) if memory_swap
+      data[:cpu_shares] = cpu_shares if cpu_shares
+      data[:affinity] = affinity_list unless affinity_list.empty?
+      data[:env] = env_list unless env_list.empty?
+      data[:secrets] = parse_secrets(secret_list) unless secret_list.empty?
+      data[:container_count] = instances if instances
+      data[:cmd] = cmd.split(' ') if cmd
+      data[:user] = user if user
+      data[:image] = parse_image(image) if image
+      data[:privileged] = privileged?
+      data[:cap_add] = cap_add_list unless cap_add_list.empty?
+      data[:cap_drop] = cap_drop_list unless cap_drop_list.empty?
+      data[:net] = net if net
+      data[:log_driver] = log_driver if log_driver
+      data[:log_opts] = parse_log_opts(log_opt_list)
+      data[:deploy_opts] = {}
+      data[:deploy_opts][:min_health] = deploy_min_health.to_f if deploy_min_health
+      data[:deploy_opts][:wait_for_port] = deploy_wait_for_port.to_i if deploy_wait_for_port
+      if deploy_interval
+        data[:deploy_opts][:interval] = parse_relative_time(deploy_interval)
+      end
+      data.delete(:deploy_opts) if data[:deploy_opts].empty?
+      data[:pid] = pid if pid
+      data
+    end
+  end
+end

data/lib/central/cli/stack_command.rb

@@ -0,0 +1,32 @@
+require_relative 'stacks/list_command'
+require_relative 'stacks/create_command'
+require_relative 'stacks/update_command'
+require_relative 'stacks/use_command'
+require_relative 'stacks/show_command'
+require_relative 'stacks/logs_command'
+require_relative 'stacks/remove_command'
+require_relative 'stacks/current_command'
+require_relative 'stacks/env_command'
+require_relative 'stacks/audit_log_command'
+require_relative 'stacks/user_command'
+require_relative 'stacks/cloud_config_command'
+require_relative 'stacks/trusted_subnet_command'
+
+class Central::Cli::StackCommand < Clamp::Command
+  subcommand %w(list ls), 'List all stacks', Central::Cli::Stacks::ListCommand
+  subcommand 'create', 'Create a new stack', Central::Cli::Stacks::CreateCommand
+  subcommand 'update', 'Update stack', Central::Cli::Stacks::UpdateCommand
+  subcommand 'use', 'Switch to use specific stack', Central::Cli::Stacks::UseCommand
+  subcommand 'show', 'Show stack details', Central::Cli::Stacks::ShowCommand
+  subcommand 'logs', 'Show logs from stack containers', Central::Cli::Stacks::LogsCommand
+  subcommand %w(remove rm), 'Remove a stack', Central::Cli::Stacks::RemoveCommand
+  subcommand 'current', 'Show current stack details', Central::Cli::Stacks::CurrentCommand
+  subcommand 'env', 'Show the current stack environment details', Central::Cli::Stacks::EnvCommand
+  subcommand 'audit-log', 'Show audit log of the current stack', Central::Cli::Stacks::AuditLogCommand
+  subcommand 'user', 'User specific commands', Central::Cli::Stacks::UserCommand
+  subcommand 'cloud-config', 'Generate cloud-config', Central::Cli::Stacks::CloudConfigCommand
+  subcommand 'trusted-subnet', 'Trusted subnet related commands', Central::Cli::Stacks::TrustedSubnetCommand
+
+  def execute
+  end
+end

data/lib/central/cli/stack_options.rb

@@ -0,0 +1,11 @@
+module Central
+  module Cli
+    module StackOptions
+      def self.included(base)
+        if base.respond_to?(:option)
+          base.option '--stack', 'STACK', 'Specify stack to use'
+        end
+      end
+    end
+  end
+end

data/lib/central/cli/stacks/add_user_command.rb

@@ -0,0 +1,18 @@
+require_relative 'common'
+
+module Central::Cli::Stacks
+  class AddUserCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Common
+
+    parameter 'EMAIL', 'Email address'
+
+    def execute
+      require_api_url
+      token = require_token
+      data = { email: email }
+      client(token).post("stacks/#{current_stack}/users", data)
+    end
+  end
+end

data/lib/central/cli/stacks/audit_log_command.rb

@@ -0,0 +1,21 @@
+require_relative 'common'
+
+module Central::Cli::Stacks
+  class AuditLogCommand < Clamp::Command
+    include Central::Cli::Common
+    include Common
+
+    option ['-l', '--lines'], 'LINES', 'Number of lines'
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+      audit_logs = client(token).get("stacks/#{current_stack}/audit_log", limit: lines)
+      puts '%-30.30s %-10s %-15s %-25s %-15s %-25s %-15s %-15s' % ['Time', 'Stack', 'Resource Type', 'Resource Name', 'Event Name', 'User', 'Source IP', 'User-Agent']
+      audit_logs['logs'].each do |log|
+        puts '%-30.30s %-10s %-15s %-25s %-15s %-25s %-15s %-15s' % [log['time'], log['stack'], log['resource_type'], log['resource_name'], log['event_name'], log['user_identity']['email'], log['source_ip'], log['user_agent']]
+      end
+    end
+  end
+end

data/lib/central/cli/stacks/cloud_config_command.rb

@@ -0,0 +1,41 @@
+require_relative 'common'
+
+module Central::Cli::Stacks
+  class CloudConfigCommand < Clamp::Command
+    include Central::Cli::Common
+    include Common
+
+    parameter 'NAME', 'Stack name'
+    option '--dns', 'DNS',  'DNS server', multivalued: true
+    option '--peer-interface', 'IFACE', 'Peer (private) network interface', default: 'eth1'
+    option '--docker-bip', 'BIP', 'Docker bridge ip', default: '172.17.43.1/16'
+    option '--version', 'VERSION', 'Agent version', default: 'latest'
+
+    def execute
+      require_api_url
+      token = require_token
+
+      stack = find_stack_by_name(name)
+      abort('Stack not found'.colorize(:red)) unless stack
+
+      default_dns = docker_bip.split('/')[0]
+      dns_servers = if dns_list.size > 0
+                      [default_dns] + dns_list
+                    else
+                      [default_dns, '8.8.8.8', '8.8.4.4']
+      end
+
+      require 'central/machine/cloud_config/node_generator'
+      generator = Central::Machine::CloudConfig::NodeGenerator.new
+      config = generator.generate(
+        master_uri: api_url,
+        stack_token: stack['token'],
+        peer_interface: peer_interface,
+        dns_servers: dns_servers,
+        docker_bip: docker_bip,
+        version: version
+      )
+      puts config
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Central::Cli::Stacks
+  module Common
+    ##
+    # @param [Hash] stack
+    def print_stack(stack)
+      puts "#{stack['name']}:"
+      puts "  uri: #{current_master['url'].sub('http', 'ws')}"
+      puts "  token: #{stack['token']}"
+      root_dir = stack['engine_root_dir']
+      nodes = client(require_token).get("stacks/#{stack['name']}/nodes")
+      nodes = nodes['nodes'].select { |n| n['connected'] == true }
+      node_count = nodes.size
+      puts '  stats:'
+      puts "    nodes: #{nodes.size} of #{stack['node_count']}"
+
+      cpu_total = nodes.map { |n| n['cpus'].to_i }.inject(:+)
+      puts "    cpus: #{cpu_total || 0}"
+
+      loads = calculate_loads(nodes, node_count)
+      puts "    load: #{(loads[:'1m'] || 0.0).round(2)} #{(loads[:'5m'] || 0.0).round(2)} #{(loads[:'15m'] || 0.0).round(2)}"
+
+      mem_total = nodes.map { |n| n['mem_total'].to_i }.inject(:+)
+      mem_used = calculate_mem_used(nodes)
+      puts "    memory: #{to_gigabytes(mem_used)} of #{to_gigabytes(mem_total)} GB"
+
+      total_fs = calculate_filesystem_stats(nodes)
+      puts "    filesystem: #{to_gigabytes(total_fs['used'])} of #{to_gigabytes(total_fs['total'])} GB"
+
+      puts "    users: #{stack['user_count']}"
+      puts "    services: #{stack['service_count']}"
+      puts "    containers: #{stack['container_count']}"
+      if statsd = stack.dig('stats', 'statsd')
+        puts '  exports:'
+        puts "    statsd: #{statsd['server']}:#{statsd['port']}"
+      end
+    end
+
+    def stacks
+      @stacks ||= client(require_token).get('stacks')
+    end
+
+    # @param [Array<Hash>] nodes
+    # @param [Fixnum] node_count
+    # @return [Hash]
+    def calculate_loads(nodes, node_count)
+      loads = { :'1m' => 0.0, :'5m' => 0.0, :'15m' => 0.0 }
+      return loads if node_count == 0
+
+      loads[:'1m'] = nodes.map { |n| n.dig('resource_usage', 'load', '1m').to_f }.inject(:+) / node_count
+      loads[:'5m'] = nodes.map { |n| n.dig('resource_usage', 'load', '5m').to_f }.inject(:+) / node_count
+      loads[:'15m'] = nodes.map { |n| n.dig('resource_usage', 'load', '15m').to_f }.inject(:+) / node_count
+      loads
+    end
+
+    # @param [Array<Hash>] nodes
+    # @return [Float]
+    def calculate_mem_used(nodes)
+      nodes.map do|n|
+        mem = n.dig('resource_usage', 'memory')
+        if mem
+          mem['used'] - (mem['cached'] + mem['buffers'])
+        else
+          0.0
+        end
+      end.inject(:+)
+    end
+
+    # @param [Array<Hash>] nodes
+    # @return [Hash]
+    def calculate_filesystem_stats(nodes)
+      total_fs = {
+        'used' => 0.0,
+        'total' => 0.0
+      }
+      nodes.each do |node|
+        root_dir = node['engine_root_dir']
+        filesystems = node.dig('resource_usage', 'filesystem') || []
+        root_fs = filesystems.find { |fs| fs['name'] == root_dir }
+        total_fs['used'] += root_fs['used']
+        total_fs['total'] += root_fs['total']
+      end
+
+      total_fs
+    end
+
+    def find_stack_by_name(name)
+      stacks['stacks'].find { |stack| stack['name'] == name }
+    end
+
+    def to_gigabytes(amount)
+      return 0.0 if amount.nil?
+      (amount.to_f / 1024 / 1024 / 1024).to_f.round(2)
+    end
+  end
+end