central-cli 0.6.3

data/lib/central/cli/nodes/labels/remove_command.rb

@@ -0,0 +1,23 @@
+module Central::Cli::Nodes::Labels
+  class RemoveCommand < Clamp::Command
+    include Central::Cli::Common
+
+    parameter 'NODE_ID', 'Node id'
+    parameter 'LABEL', 'Label'
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+
+      node = client(token).get("stacks/#{current_stack}/nodes/#{node_id}")
+      unless node['labels'].include?(label)
+        abort("Node #{node['name']} does not have label #{label}")
+      end
+      node['labels'].delete(label)
+      data = {}
+      data[:labels] = node['labels']
+      client.put("nodes/#{node['id']}", data, {}, 'Central-Stack-Token' => node['stack']['token'])
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+
+require 'tty'
+
+module Central::Cli::Nodes
+  class ListCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    option ['--all'], :flag, 'List nodes for all stacks', default: false
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+      rows = []
+
+      if all?
+        stacks = client(token).get('stacks')
+        header = ['Name', 'Public IP', 'Status', 'Labels']
+
+        stacks['stacks'].each do |stack|
+          nodes = client(token).get("stacks/#{stack['name']}/nodes")
+          nodes['nodes'].each do |node|
+            status = if node['connected']
+                       ' ✓ '.colorize(:green)
+                     else
+                       ' ✘ '.colorize(:red)
+                     end
+            rows << [
+              "#{stack['name']}/#{node['name']}",
+              node['public_ip'],
+              status,
+              (node['labels'] || ['-']).join(', ')
+            ]
+          end
+        end
+      else
+        nodes = client(token).get("stacks/#{current_stack}/nodes")
+        header = ['Name', 'Public IP', 'Status', 'Labels']
+        nodes['nodes'].each do |node|
+          status = if node['connected']
+                     ' ✓ '.colorize(:green)
+                   else
+                     ' ✘ '.colorize(:red)
+                   end
+          rows << [
+            node['name'],
+            node['public_ip'],
+            status,
+            (node['labels'] || ['-']).join(', ')
+          ]
+        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
+end

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

@@ -0,0 +1,16 @@
+module Central::Cli::Nodes
+  class RemoveCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NODE_ID', 'Node id'
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+
+      client(token).delete("stacks/#{current_stack}/nodes/#{node_id}")
+    end
+  end
+end

data/lib/central/cli/nodes/remove_label_command.rb

@@ -0,0 +1,23 @@
+module Central::Cli::Nodes
+  class RemoveLabelCommand < Clamp::Command
+    include Central::Cli::Common
+
+    parameter 'NODE_ID', 'Node id'
+    parameter 'LABEL', 'Label'
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+
+      node = client(token).get("stacks/#{current_stack}/nodes/#{node_id}")
+      unless node['labels'].include?(label)
+        abort("Node #{node['name']} does not have label #{label}")
+      end
+      node['labels'].delete(label)
+      data = {}
+      data[:labels] = node['labels']
+      client.put("nodes/#{node['id']}", data, {}, 'Central-Stack-Token' => node['stack']['token'])
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Central::Cli::Nodes
+  class ShowCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+    include Central::Cli::BytesHelper
+
+    parameter 'NODE_ID', 'Node id'
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+
+      node = client(token).get("stacks/#{current_stack}/nodes/#{node_id}")
+      puts "#{node['name']}:"
+      puts "  id: #{node['id']}"
+      puts "  connected: #{node['connected'] ? 'yes' : 'no'}"
+      puts "  last connect: #{node['updated_at']}"
+      puts "  last seen: #{node['last_seen_at']}"
+      puts "  public ip: #{node['public_ip']}"
+      puts "  private ip: #{node['private_ip']}"
+      puts "  overlay network: 10.81.#{node['node_number']}.0/24"
+      puts "  os: #{node['os']}"
+      puts "  driver: #{node['driver']}"
+      puts "  kernel: #{node['kernel_version']}"
+      puts "  cpus: #{node['cpus']}"
+      puts "  memory: #{node['mem_total'] / 1024 / 1024}M"
+      puts '  labels:'
+      node['labels'].each { |l| puts "    - #{l}" } if node['labels']
+      puts '  stats:'
+      puts "    cpus: #{node['cpus']}"
+      loads = node.dig('resource_usage', 'load')
+      if loads
+        puts "    load: #{loads['1m'].round(2)} #{loads['5m'].round(2)} #{loads['15m'].round(2)}"
+      end
+      mem = node.dig('resource_usage', 'memory')
+      if mem
+        mem_used = mem['used'] - (mem['cached'] + mem['buffers'])
+        puts "    memory: #{to_gigabytes(mem_used, 2)} of #{to_gigabytes(mem['total'], 2)} GB"
+      end
+      if node['resource_usage']['filesystem']
+        puts '    filesystem:'
+        node['resource_usage']['filesystem'].each do |filesystem|
+          puts "      - #{filesystem['name']}: #{to_gigabytes(filesystem['used'], 2)} of #{to_gigabytes(filesystem['total'], 2)} GB"
+        end
+      end
+    end
+  end
+end

data/lib/central/cli/nodes/ssh_command.rb

@@ -0,0 +1,31 @@
+module Central::Cli::Nodes
+  class SshCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NODE_ID', 'Node id'
+    option ['-i', '--identity-file'], 'IDENTITY_FILE', 'Path to ssh private key'
+    option ['-u', '--user'], 'USER', 'Login as a user', default: 'core'
+    option '--private-ip', :flag, "Connect to node's private IP address"
+    option '--internal-ip', :flag, "Connect to node's internal IP address (requires VPN connection)"
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+
+      node = client(token).get("stacks/#{current_stack}/nodes/#{node_id}")
+      cmd = ['ssh']
+      cmd << "-i #{identity_file}" if identity_file
+      ip = if internal_ip?
+             "10.81.0.#{node['node_number']}"
+           elsif private_ip?
+             node['private_ip']
+           else
+             node['public_ip']
+      end
+      cmd << "#{user}@#{ip}"
+      exec(cmd.join(' '))
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Central::Cli::Nodes
+  class UpdateCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NODE_ID', 'Node id'
+    option ['-l', '--label'], 'LABEL', 'Node label', multivalued: true
+
+    def execute
+      require_api_url
+      require_current_stack
+      token = require_token
+
+      node = client(token).get("stacks/#{current_stack}/nodes/#{node_id}")
+      data = {}
+      data[:labels] = label_list if label_list
+      client.put("nodes/#{node['id']}", data, {}, 'Central-Stack-Token' => node['stack']['token'])
+    end
+  end
+end

data/lib/central/cli/nodes/vagrant/create_command.rb

@@ -0,0 +1,27 @@
+module Central::Cli::Nodes::Vagrant
+  class CreateCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter '[NAME]', 'Node name'
+    option '--memory', 'MEMORY', 'How much memory node has', default: '1024'
+    option '--version', 'VERSION', 'Define installed Central version', default: 'latest'
+
+    def execute
+      require_api_url
+      require_current_stack
+
+      require 'central/machine/vagrant'
+      stack = client(require_token).get("stacks/#{current_stack}")
+      provisioner = Central::Machine::Vagrant::NodeProvisioner.new(client(require_token))
+      provisioner.run!(
+        master_uri: api_url,
+        stack_token: stack['token'],
+        stack: current_stack,
+        name: name,
+        memory: memory,
+        version: version
+      )
+    end
+  end
+end

data/lib/central/cli/nodes/vagrant/restart_command.rb

@@ -0,0 +1,26 @@
+module Central::Cli::Nodes::Vagrant
+  class RestartCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NAME', 'Node name'
+
+    def execute
+      require_api_url
+      require_current_stack
+
+      require 'central/machine/vagrant'
+      vagrant_path = "#{Dir.home}/.central/#{current_stack}/#{name}"
+      abort("Cannot find Vagrant node #{name}".colorize(:red)) unless Dir.exist?(vagrant_path)
+      Dir.chdir(vagrant_path) do
+        ShellSpinner "Restarting Vagrant machine #{name.colorize(:cyan)} " do
+          Open3.popen2('vagrant reload') do |_stdin, output, _wait|
+            while o = output.gets
+              print o if ENV['DEBUG']
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/central/cli/nodes/vagrant/ssh_command.rb

@@ -0,0 +1,21 @@
+module Central::Cli::Nodes::Vagrant
+  class SshCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NAME', 'Node name'
+
+    def execute
+      require_api_url
+      require_current_stack
+
+      require 'central/machine/vagrant'
+      vagrant_path = "#{Dir.home}/.central/#{current_stack}/#{name}"
+      abort("Cannot find Vagrant node #{name}".colorize(:red)) unless Dir.exist?(vagrant_path)
+
+      Dir.chdir(vagrant_path) do
+        system('vagrant ssh')
+      end
+    end
+  end
+end

data/lib/central/cli/nodes/vagrant/start_command.rb

@@ -0,0 +1,26 @@
+module Central::Cli::Nodes::Vagrant
+  class StartCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NAME', 'Node name'
+
+    def execute
+      require_api_url
+      require_current_stack
+
+      require 'central/machine/vagrant'
+      vagrant_path = "#{Dir.home}/.central/#{current_stack}/#{name}"
+      abort("Cannot find Vagrant node #{name}".colorize(:red)) unless Dir.exist?(vagrant_path)
+      Dir.chdir(vagrant_path) do
+        ShellSpinner "Starting Vagrant machine #{name.colorize(:cyan)} " do
+          Open3.popen2('vagrant up') do |_stdin, output, _wait|
+            while o = output.gets
+              print o if ENV['DEBUG']
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/central/cli/nodes/vagrant/stop_command.rb

@@ -0,0 +1,26 @@
+module Central::Cli::Nodes::Vagrant
+  class StopCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NAME', 'Node name'
+
+    def execute
+      require_api_url
+      require_current_stack
+
+      require 'central/machine/vagrant'
+      vagrant_path = "#{Dir.home}/.central/#{current_stack}/#{name}"
+      abort("Cannot find Vagrant node #{name}".colorize(:red)) unless Dir.exist?(vagrant_path)
+      Dir.chdir(vagrant_path) do
+        ShellSpinner "Stopping Vagrant machine #{name.colorize(:cyan)} " do
+          Open3.popen2('vagrant halt') do |_stdin, output, _wait|
+            while o = output.gets
+              print o if ENV['DEBUG']
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/central/cli/nodes/vagrant/terminate_command.rb

@@ -0,0 +1,17 @@
+module Central::Cli::Nodes::Vagrant
+  class TerminateCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    parameter 'NAME', 'Node name'
+
+    def execute
+      require_api_url
+      require_current_stack
+
+      require 'central/machine/vagrant'
+      destroyer = Central::Machine::Vagrant::NodeDestroyer.new(client(require_token))
+      destroyer.run!(current_stack, name)
+    end
+  end
+end

data/lib/central/cli/nodes/vagrant_command.rb

@@ -0,0 +1,20 @@
+require_relative 'vagrant/create_command'
+require_relative 'vagrant/start_command'
+require_relative 'vagrant/stop_command'
+require_relative 'vagrant/restart_command'
+require_relative 'vagrant/terminate_command'
+require_relative 'vagrant/ssh_command'
+
+module Central::Cli::Nodes
+  class VagrantCommand < Clamp::Command
+    subcommand 'create', 'Create a new Vagrant node', Vagrant::CreateCommand
+    subcommand 'ssh', 'SSH into Vagrant node', Vagrant::SshCommand
+    subcommand 'start', 'Start Vagrant node', Vagrant::StartCommand
+    subcommand 'stop', 'Stop Vagrant node', Vagrant::StopCommand
+    subcommand 'restart', 'Restart Vagrant node', Vagrant::RestartCommand
+    subcommand 'terminate', 'Terminate Vagrant node', Vagrant::TerminateCommand
+
+    def execute
+    end
+  end
+end

data/lib/central/cli/register_command.rb

@@ -0,0 +1,21 @@
+class Central::Cli::RegisterCommand < Clamp::Command
+  include Central::Cli::Common
+
+  option '--auth-provider-url', 'AUTH_PROVIDER_URL', 'Auth provider URL'
+
+  def execute
+    require 'highline/import'
+
+    auth_api_url = auth_provider_url || 'https://auth.bluebeluga.io'
+    if !auth_api_url.start_with?('http://') && !auth_api_url.start_with?('https://')
+      auth_api_url = "https://#{auth_api_url}"
+    end
+    email = ask('Email: ')
+    password = ask('Password: ') { |q| q.echo = '*' }
+    password2 = ask('Password again: ') { |q| q.echo = '*' }
+    abort("Passwords don't match".colorize(:red)) if password != password2
+    params = { email: email, password: password }
+    auth_client = Central::Client.new(auth_api_url)
+    auth_client.post('users', params)
+  end
+end

data/lib/central/cli/registry/create_command.rb

@@ -0,0 +1,144 @@
+require 'shell-spinner'
+
+module Central::Cli::Registry
+  class CreateCommand < Clamp::Command
+    include Central::Cli::Common
+    include Central::Cli::StackOptions
+
+    REGISTRY_VERSION = '2.2.0'.freeze
+
+    option '--node', 'NODE', 'Node name'
+    option '--s3-bucket', 'S3_BUCKET', 'S3 bucket'
+    option '--s3-region', 'S3_REGION', 'S3 region', default: 'us-west-2'
+    option '--s3-encrypt', :flag, 'Encrypt S3 objects', default: false
+    option '--s3-secure', :flag, 'Use secure connection in S3', default: true
+    option '--azure-account-name', 'AZURE_ACCOUNT_NAME', 'Azure account name'
+    option '--azure-container-name', 'AZURE_CONTAINER_NAME', 'Azure container name'
+
+    def execute
+      require_api_url
+      token = require_token
+      preferred_node = node
+      secrets = []
+      affinity = []
+      stateful = true
+      instances = 1
+
+      registry = begin
+                   client(token).get("services/#{current_stack}/registry")
+                 rescue
+                   nil
+                 end
+      abort('Registry already exists') if registry
+
+      nodes = client(token).get("stacks/#{current_stack}/nodes")
+
+      if s3_bucket
+        %w(REGISTRY_STORAGE_S3_ACCESSKEY REGISTRY_STORAGE_S3_SECRETKEY).each do |secret|
+          abort("#{secret} secret is missing from the vault") unless vault_secret_exists?(secret)
+        end
+        env = [
+          'REGISTRY_STORAGE=s3',
+          "REGISTRY_STORAGE_S3_REGION=#{s3_region}",
+          "REGISTRY_STORAGE_S3_BUCKET=#{s3_bucket}",
+          "REGISTRY_STORAGE_S3_ENCRYPT=#{s3_encrypt?}",
+          "REGISTRY_STORAGE_S3_SECURE=#{s3_secure?}"
+        ]
+        secrets = [
+          { secret: 'REGISTRY_STORAGE_S3_ACCESSKEY', name: 'REGISTRY_STORAGE_S3_ACCESSKEY', type: 'env' },
+          { secret: 'REGISTRY_STORAGE_S3_SECRETKEY', name: 'REGISTRY_STORAGE_S3_SECRETKEY', type: 'env' }
+        ]
+        stateful = false
+        instances = 2 if nodes['nodes'].size > 1
+      elsif azure_account_name || azure_container_name
+        abort('--azure-account-name is missing') if azure_account_name.nil?
+        abort('--azure-container-name is missing') if azure_container_name.nil?
+        abort('REGISTRY_STORAGE_AZURE_ACCOUNTKEY is not saved to vault') unless vault_secret_exists?('REGISTRY_STORAGE_AZURE_ACCOUNTKEY')
+        env = [
+          'REGISTRY_STORAGE=azure',
+          "REGISTRY_STORAGE_AZURE_ACCOUNTNAME=#{azure_account_name}",
+          "REGISTRY_STORAGE_AZURE_ACCOUNTKEY=#{azure_account_key}"
+        ]
+        secrets = [
+          { secret: 'REGISTRY_STORAGE_AZURE_ACCOUNTKEY', name: 'REGISTRY_STORAGE_AZURE_ACCOUNTKEY', type: 'env' }
+        ]
+        stateful = false
+        instances = 2 if nodes['nodes'].size > 1
+      else
+        env = [
+          'REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY=/registry'
+        ]
+        if preferred_node
+          node = nodes['nodes'].find { |n| n['connected'] && n['name'] == preferred_node }
+          abort('Node not found') if node.nil?
+          affinity << "node==#{node['name']}"
+        end
+      end
+
+      if vault_secret_exists?('REGISTRY_AUTH_PASSWORD')
+        secrets << { secret: 'REGISTRY_AUTH_PASSWORD', name: 'AUTH_PASSWORD', type: 'env' }
+        configure_registry_auth(vault_secret('REGISTRY_AUTH_PASSWORD'))
+      end
+      if vault_secret_exists?('REGISTRY_HTTP_TLS_CERTIFICATE')
+        secrets << { secret: 'REGISTRY_HTTP_TLS_CERTIFICATE', name: 'REGISTRY_HTTP_TLS_CERTIFICATE', type: 'env' }
+        secrets << { secret: 'REGISTRY_HTTP_TLS_KEY', name: 'REGISTRY_HTTP_TLS_KEY', type: 'env' }
+        env << 'REGISTRY_HTTP_ADDR=0.0.0.0:443'
+      else
+        env << 'REGISTRY_HTTP_ADDR=0.0.0.0:80'
+      end
+      env << "REGISTRY_HTTP_SECRET=#{SecureRandom.hex(24)}"
+
+      data = {
+        name: 'registry',
+        stateful: stateful,
+        container_count: instances,
+        image: "fishyard/registry:#{REGISTRY_VERSION}",
+        volumes: ['/registry'],
+        env: env,
+        secrets: secrets,
+        affinity: affinity
+      }
+      client(token).post("stacks/#{current_stack}/services", data)
+      client(token).post("services/#{current_stack}/registry/deploy", {})
+      ShellSpinner 'Deploying registry service ' do
+        sleep 1 until client(token).get("services/#{current_stack}/registry")['state'] != 'deploying'
+      end
+      puts "\n"
+      puts "Docker Registry #{REGISTRY_VERSION} is now running at registry.#{current_stack}.central.local."
+      puts 'Note: '
+      puts '  - OpenVPN connection is needed to establish connection to this registry. See http://www.central.io/docs/using-central/vpn-access for details'
+      puts "  - you must set '--insecure-registry registry.#{current_stack}.central.local' to your client docker daemon before you are able to push to this registry"
+    end
+
+    # @param [String] name
+    # @return [Boolean]
+    def vault_secret_exists?(name)
+      client(require_token).get("secrets/#{current_stack}/#{name}")
+      true
+    rescue
+      false
+    end
+
+    # @param [String] name
+    # @return [String]
+    def vault_secret(name)
+      secret = client(require_token).get("secrets/#{current_stack}/#{name}")
+      secret['value']
+    end
+
+    # @param [String] password
+    def configure_registry_auth(password)
+      data = {
+        username: 'admin',
+        password: password,
+        email: 'not@val.id',
+        url: "http://registry.#{current_stack}.central.local/"
+      }
+      begin
+        client(require_token).post("stacks/#{current_stack}/external_registries", data)
+      rescue
+        nil
+      end
+    end
+  end
+end