bcome 0.7.0 → 1.0.0

data/lib/objects/ssh/bootstrap.rb

@@ -0,0 +1,19 @@
+module Bcome::Ssh
+  class Bootstrap
+    def initialize(config)
+      @config = config
+    end
+
+    def ssh_key_path
+      @config[:ssh_key_path]
+    end
+
+    def user
+      @config[:user]
+    end
+
+    def bastion_host_user
+      @config[:bastion_host_user]
+    end
+  end
+end

data/lib/objects/ssh/command.rb

@@ -0,0 +1,46 @@
+module ::Bcome::Ssh
+  class Command
+    attr_reader :raw, :stdout, :stderr, :exit_code, :node, :bootstrap
+
+    def initialize(params)
+      @raw = params[:raw]
+      @node = params[:node]
+      @exit_code = nil
+      @exit_signal = nil
+      @stdin = ''; @stdout = ''; @stderr = ''
+    end
+
+    def unset_node
+      @node = nil
+    end
+
+    def pretty_result
+      is_success? ? 'success'.success : 'failure'.error
+    end
+
+    attr_writer :bootstrap
+
+    def output
+      command_output = is_success? ? @stdout : "Exit code: #{@exit_code}\n\nSTDERR: #{@stderr}"
+      "\n#{command_output}"
+    end
+
+    def is_success?
+      exit_code.to_i == 0
+    end
+
+    def success_codes
+      ['0']
+    end
+
+    attr_writer :stdout
+
+    attr_writer :stderr
+
+    attr_writer :exit_code
+
+    def exit_signal(data)
+      @exit_signal = data
+    end
+  end
+end

data/lib/objects/ssh/command_exec.rb

@@ -0,0 +1,65 @@
+module ::Bcome::Ssh
+  class CommandExec
+    attr_reader :commands
+
+    def initialize(commands)
+      @commands = commands
+    end
+
+    def output_append(output_string)
+      @output_string = "#{@output_string}#{output_string}"
+    end
+
+    def print_output
+      print "#{@output_string}\n\n"
+    end
+
+    def execute!
+      # TODO: - catch IOError: closed stream here and re-connect gracefully
+      # to reproduce: open connections, and let them timeout then re-enter command (interactive mode)
+
+      @commands.each do |command|
+        node = command.node
+        ssh = node.ssh_driver.ssh_connection
+
+        begin
+          ssh_exec!(ssh, command)
+        rescue IOError # Typically occurs after a timeout if the session has been left idle
+          node.open_ssh_connection
+          ssh_exec!(ssh, command) # retry, once
+        end
+
+        output_append("\n(#{node.namespace})$".terminal_prompt + ">\s#{command.raw} (#{command.pretty_result})\n")
+        output_append(command.output.to_s)
+      end
+      print_output unless ::Bcome::Orchestrator.instance.command_output_silenced?
+    end
+
+    def ssh_exec!(ssh, command) #  NON PTY (i.e no pseudo-terminal)
+      ssh.open_channel do |channel|
+        channel.exec(command.raw) do |_cha, success|
+          unless success
+            abort "FAILED: couldn't execute command (ssh.channel.exec)"
+          end
+
+          channel.on_data do |_ch, data|
+            command.stdout += data
+          end
+
+          channel.on_extended_data do |_ch, _type, data|
+            command.stderr += data
+          end
+
+          channel.on_request('exit-status') do |_ch, data|
+            command.exit_code = data.read_long
+          end
+
+          channel.on_request('exit-signal') do |_ch, data|
+            command.exit_signal = data.read_long
+          end
+        end
+      end
+      ssh.loop
+    end
+  end
+end

data/lib/objects/ssh/connection_handler.rb

@@ -0,0 +1,101 @@
+module Bcome::Ssh
+  class ConnectionHandler
+    MAX_CONNECTION_ATTEMPTS = 3
+
+    class << self
+      def connect(node, config = {})
+        handler = new(node, config)
+        handler.connect
+      end
+    end
+
+    def initialize(node, config = {})
+      @node = node
+      @config = config
+      @servers_to_connect = machines.dup
+      @connection_exceptions = {}
+      reset_progress if show_progress?
+    end
+
+    def machines
+      @node.server? ? [@node] : @node.machines
+    end
+
+    def show_progress?
+      @config[:show_progress] ? true : false
+    end
+
+    def ping?
+      @config[:is_ping] ? true : false
+    end
+
+    def reset_progress
+      ::Bcome::ProgressBar.instance.reset!
+    end
+
+    def ping
+      connect
+    end
+
+    def connect
+      connection_attempt = 0
+      ::Bcome::ProgressBar.instance.indicate(progress_bar_config, true) if show_progress?
+
+      # So here we have a bit of a hack: If you're connecting to a network via a bastion host, it may not be able to handle over a certain amount of consecutive/parallelized ssh connection attempts
+      # from bcome, so, we'll sweep up failures and re-try to connect up to MAX_CONNECTION_ATTEMPTS.  Once connected, we're generally good - and any subsequent connection failures
+      # within a specific session will be handled ad-hoc and re-connection is automatic.
+      while @servers_to_connect.any? && connection_attempt <= MAX_CONNECTION_ATTEMPTS
+        puts connection_attempt == 0 ? 'Initiating connections'.informational : 'Retrying failed connections'.warning
+        do_connect
+        connection_attempt += 1
+      end
+
+      if show_progress?
+        ::Bcome::ProgressBar.instance.indicate(progress_bar_config, false)
+        reset_progress
+      end
+
+      if ping?
+        # If any machines remain, then we couldn't connect to them
+        @servers_to_connect.each do |server|
+          ping_result = {
+            success: false,
+            error: last_connection_exception_for(server)
+          }
+          puts server.print_ping_result(ping_result)
+        end
+      end
+
+      if @servers_to_connect.any?
+        puts "Failed to connect to #{@servers_to_connect.size} nodes".error
+      else
+        puts 'All nodes reachable'.success
+      end
+    end
+
+    def last_connection_exception_for(server)
+      @connection_exceptions[server]
+    end
+
+    def do_connect
+      @servers_to_connect.pmap do |server|
+        begin
+          server.open_ssh_connection unless server.has_ssh_connection?
+          Bcome::ProgressBar.instance.indicate_and_increment!(progress_bar_config, true) if show_progress?
+          @servers_to_connect -= [server]
+          puts server.print_ping_result if ping?
+        rescue Exception => e
+          @connection_exceptions[server] = e
+        end
+      end
+    end
+
+    def progress_bar_config
+      {
+        prefix: "\sOpening SSH connections\s",
+        indice: '...',
+        indice_descriptor: "of #{machines.size}"
+      }
+    end
+  end
+end

data/lib/objects/ssh/driver.rb

@@ -0,0 +1,204 @@
+module Bcome::Ssh
+  class Driver
+    attr_reader :config, :bootstrap_settings
+
+    DEFAULT_TIMEOUT_IN_SECONDS = 5
+    PROXY_CONNECT_PREFIX = '-o StrictHostKeyChecking=no -W %h:%p'.freeze
+    PROXY_SSH_PREFIX = '-o UserKnownHostsFile=/dev/null -o "ProxyCommand ssh -W %h:%p'.freeze
+
+    def initialize(config, context_node)
+      @config = config
+      @context_node = context_node
+      @proxy_data = @config[:proxy] ? ::Bcome::Ssh::ProxyData.new(@config[:proxy], @context_node) : nil
+      @bootstrap_settings = @config[:bootstrap_settings] ? ::Bcome::Ssh::Bootstrap.new(@config[:bootstrap_settings]) : nil
+    end
+
+    def bootstrap?
+      @context_node.bootstrap? && has_bootstrap_settings?
+    end
+
+    def has_bootstrap_settings?
+      !@bootstrap_settings.nil?
+    end
+
+    def pretty_config_details
+      config = {
+        user: user,
+        ssh_keys: ssh_keys,
+        timeout: timeout_in_seconds
+      }
+      if has_proxy?
+        config[:host_or_ip] = @context_node.internal_ip_address
+        config[:proxy] = {
+          bastion_host:  @proxy_data.host,
+          bastion_host_user: bastion_host_user
+        }
+      else
+        config[:host_or_ip] = @context_node.public_ip_address
+      end
+      config
+    end
+
+    def timeout_in_seconds
+      @config[:timeout_in_seconds] ||= Bcome::Ssh::Driver::DEFAULT_TIMEOUT_IN_SECONDS
+    end
+
+    def proxy
+      return nil unless has_proxy?
+      connection_string = bootstrap? ? bootstrap_proxy_connection_string : proxy_connection_string
+      ::Net::SSH::Proxy::Command.new(connection_string)
+    end
+
+    def has_proxy?
+      !@config[:proxy].nil?
+    end
+
+    def proxy_connection_string
+      "ssh #{PROXY_CONNECT_PREFIX} #{bastion_host_user}@#{@proxy_data.host}"
+    end
+
+    def bootstrap_proxy_connection_string
+      "ssh -i #{@bootstrap_settings.ssh_key_path} -o StrictHostKeyChecking=no -W %h:%p #{@bootstrap_settings.bastion_host_user}@#{@proxy_data.host}"
+    end
+
+    def do_ssh
+      cmd = ssh_command
+      @context_node.execute_local(cmd)
+    end
+
+    def bastion_host_user
+      bootstrap? && @bootstrap_settings.bastion_host_user ? @bootstrap_settings.bastion_host_user : @proxy_data.bastion_host_user ? @proxy_data.bastion_host_user : user
+    end
+
+    def ssh_command
+      return bootstrap_ssh_command if bootstrap? && @bootstrap_settings.ssh_key_path
+      if has_proxy?
+        "ssh #{PROXY_SSH_PREFIX} #{bastion_host_user}@#{@proxy_data.host}\" #{user}@#{@context_node.internal_ip_address}"
+      else
+        "ssh #{user}@#{@context_node.public_ip_address}"
+      end
+    end
+
+    def bootstrap_ssh_command
+      if has_proxy?
+        "ssh -i #{@bootstrap_settings.ssh_key_path} -t #{bastion_host_user}@#{@proxy_data.host} ssh -t #{user}@#{@context_node.internal_ip_address}"
+      else
+        "ssh -i #{@bootstrap_settings.ssh_key_path} #{user}@#{@context_node.public_ip_address}"
+      end
+    end
+
+    def user
+      bootstrap? && @bootstrap_settings.user ? @bootstrap_settings.user : @config[:user] ? @config[:user] : fallback_local_user
+    end
+
+    def fallback_local_user
+      @fallback_local_user ||= ::Bcome::System::Local.instance.local_user
+    end
+
+    def node_host_or_ip
+      has_proxy? ? @context_node.internal_ip_address : @context_node.public_ip_address
+    end
+
+    def net_ssh_params(verbose = false)
+      raise Bcome::Exception::InvalidSshConfig, "Missing ssh keys for #{@context_node.namespace}" unless ssh_keys
+      params = { keys: ssh_keys, paranoid: false }
+      params[:proxy] = proxy if has_proxy?
+      params[:timeout] = timeout_in_seconds
+      params[:verbose] = :debug if verbose
+      params
+    end
+
+    def ssh_keys
+      if bootstrap?
+        [@bootstrap_settings.ssh_key_path]
+      else
+        @config[:ssh_keys]
+      end
+    end
+
+    def rsync(local_path, remote_path)
+      raise Bcome::Exception::MissingParamsForRsync, "'rsync' requires a local_path and a remote_path" if local_path.to_s.empty? || remote_path.to_s.empty?
+      command = rsync_command(local_path, remote_path)
+      @context_node.execute_local(command)
+    end
+
+    def rsync_command(local_path, remote_path)
+      return bootstrap_rsync_command(local_path, remote_path) if bootstrap? && @bootstrap_settings.ssh_key_path
+      if has_proxy?
+        "rsync -av -e \"ssh -A #{bastion_host_user}@#{@proxy_data.host} ssh -o StrictHostKeyChecking=no\" #{local_path} #{user}@#{@context_node.internal_ip_address}:#{remote_path}"
+      else
+        "rsync -av #{local_path} #{user}@#{@context_node.public_ip_address}:#{remote_path}"
+      end
+    end
+
+    def bootstrap_rsync_command(local_path, remote_path)
+      if has_proxy?
+        "rsync -av -e \"ssh -i #{@bootstrap_settings.ssh_key_path} -A #{bastion_host_user}@#{@proxy_data.host} ssh -o StrictHostKeyChecking=no\" #{local_path} #{user}@#{@context_node.internal_ip_address}:#{remote_path}"
+      else
+        "rsync -i #{@bootstrap_settings.ssh_key_path} -av #{local_path} #{user}@#{@context_node.public_ip_address}:#{remote_path}"
+      end
+    end
+
+    def ssh_connect!(_verbose = false)
+      @connection = nil
+      begin
+        @connection = ::Net::SSH.start(node_host_or_ip, user, net_ssh_params)
+      rescue Net::SSH::Proxy::ConnectError, Net::SSH::ConnectionTimeout, Errno::EPIPE => e
+        raise Bcome::Exception::CouldNotInitiateSshConnection, @context_node.namespace + "\s-\s#{e.message}"
+      end
+      @connection
+    end
+
+    def ping
+      ssh_connect!
+      return { success: true }
+    rescue Exception => e
+      return { success: false, error: e }
+    end
+
+    def scp
+      ssh_connection.scp
+    end
+
+    def put(local_path, remote_path)
+      raise Bcome::Exception::MissingParamsForScp, "'put' requires a local_path and a remote_path" if local_path.to_s.empty? || remote_path.to_s.empty?
+      puts "\n(#{@context_node.namespace})\s".namespace + "Uploading #{local_path} to #{remote_path}\n".informational
+
+      begin
+        scp.upload!(local_path, remote_path, recursive: true) do |_ch, name, sent, total|
+          puts "#{name}: #{sent}/#{total}".progress
+        end
+      rescue Exception => e # scp just throws generic exceptions :-/
+        puts e.message.error
+      end
+      nil
+    end
+
+    def get(remote_path, local_path)
+      raise Bcome::Exception::MissingParamsForScp, "'get' requires a local_path and a remote_path" if local_path.to_s.empty? || remote_path.to_s.empty?
+      puts "\n(#{@context_node.namespace})\s".namespace + "Downloading #{remote_path} to #{local_path}\n".informational
+
+      begin
+        scp.download!(remote_path, local_path, recursive: true) do |_ch, name, sent, total|
+          puts "#{name}: #{sent}/#{total}".progress
+        end
+      rescue Exception => e # scp just throws generic exceptions :-/
+        puts e.message.error
+      end
+    end
+
+    def close_ssh_connection
+      return unless @connection
+      @connection.close unless @connection.closed?
+      @connection = nil
+    end
+
+    def ssh_connection(_bootstrap = false)
+      has_open_ssh_con? ? @connection : ssh_connect!
+    end
+
+    def has_open_ssh_con?
+      !@connection.nil? && !@connection.closed?
+    end
+  end
+end

data/lib/objects/ssh/proxy_data.rb

@@ -0,0 +1,56 @@
+module Bcome::Ssh
+  class ProxyData
+    def initialize(config, context_node)
+      @config = config
+      @context_node = context_node
+    end
+
+    def host
+      @host ||= get_host
+    end
+
+    def bastion_host_user
+      @bastion_host_user ||= get_bastion_host_user
+    end
+
+    private
+
+    def valid_host_lookups
+      {
+        by_inventory_node: :get_host_by_inventory_node,
+        by_host_or_ip: :get_host_or_ip_from_config,
+        by_bcome_namespace: :get_host_by_namespace
+      }
+    end
+
+    def get_bastion_host_user
+      @config[:bastion_host_user]
+    end
+
+    def get_host
+      raise Bcome::Exception::InvalidProxyConfig, 'Missing host id or namespace' unless @config[:host_id] || @config[:namespace]
+      raise Bcome::Exception::InvalidProxyConfig, 'Missing host lookup method' unless @config[:host_lookup]
+      host_lookup_method = valid_host_lookups[@config[:host_lookup].to_sym]
+      raise Bcome::Exception::InvalidProxyConfig, "#{@config[:host_lookup]} is not a valid host lookup method" unless host_lookup_method
+      send(host_lookup_method)
+    end
+
+    def get_host_or_ip_from_config
+      @config[:host_id]
+    end
+
+    def get_host_by_inventory_node
+      identifier = @config[:host_id]
+      resource = @context_node.recurse_resource_for_identifier(identifier)
+      raise Bcome::Exception::CantFindProxyHostByIdentifier, identifier unless resource
+      raise Bcome::Exception::ProxyHostNodeDoesNotHavePublicIp, identifier unless resource.public_ip_address
+      resource.public_ip_address
+    end
+
+    def get_host_by_namespace
+      node = ::Bcome::Orchestrator.instance.get(@config[:namespace])
+      raise Bcome::Exception::CantFindProxyHostByNamespace, @config[:namespace] unless node
+      node.public_ip_address
+    end
+  end
+end