bcome 1.3.6 → 1.4.0

data/lib/objects/registry/command/internal.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Bcome::Registry::Command
   class Internal < Base
-    # In which the bcome context is an external (extended framework) call
+    # In which the bcome context is an internal (extended framework) call
 
     def execute(node, arguments)
       merged_arguments = process_arguments(arguments)

data/lib/objects/registry/command/shortcut.rb

@@ -1,24 +1,32 @@
+# frozen_string_literal: true
+
 module Bcome::Registry::Command
   class Shortcut < Base
     # In which the bcome context is a shortcut to a more complex command
 
-    def execute(node, arguments)  ## We'll add in arguments later
-      if run_as_pseudo_tty?
-        node.pseudo_tty command
-      else
-        node.run command
+    def execute(node, _arguments) ## We'll add in arguments later
+      begin
+        if run_as_pseudo_tty?
+          node.pseudo_tty command
+        else
+          puts "\n(#{node.namespace})$".terminal_prompt + ">\s#{command}"
+          ::Bcome::Orchestrator.instance.tail_all_command_output!(node)
+          node.run command
+          ::Bcome::Orchestrator.instance.reset!
+        end
+      rescue Interrupt
+        ::Bcome::Orchestrator.instance.reset!
+        puts "\nExiting gracefully from interrupt\n".warning
       end
-    rescue Interrupt
-      puts "\nExiting gracefully from interrupt\n".warning
+      nil
     end
 
     def command
       @data[:shortcut_command]
     end
- 
+
     def run_as_pseudo_tty?
       @data[:run_as_pseudo_tty]
     end
- 
   end
 end

data/lib/objects/registry/command_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Registry
   class CommandList
     include Singleton

data/lib/objects/registry/loader.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Bcome::Registry
   class Loader
     include ::Singleton
 
-    FILE_PATH = 'bcome/registry.yml'.freeze
+    FILE_PATH = 'bcome/registry.yml'
 
     def data
       @data ||= do_load
@@ -17,19 +19,17 @@ module Bcome::Registry
 
       data.each do |key, commands|
         begin
-          if /^#{key.to_s}$/.match(node.keyed_namespace)
+          if /^#{key}$/.match(node.keyed_namespace)
             commands.each do |c|
-
               unless c[:console_command]
                 error_message = "Registry method is missing key 'console_command'."
                 error_message += "\n\n#{c.inspect}"
-                raise Bcome::Exception::InvalidRegistryDataConfig.new error_message
+                raise Bcome::Exception::InvalidRegistryDataConfig, error_message
               end
 
               # Verify that the proposed user registered method does not conflict with either an existing method name, instance var, or other registry command name for this node
-              if node.is_node_level_method?(c[:console_command]) || command_group.console_method_name_exists?(c[:console_command])
-                raise Bcome::Exception::MethodNameConflictInRegistry, "'#{c[:console_command]}'"
-              end
+              raise Bcome::Exception::MethodNameConflictInRegistry, "'#{c[:console_command]}'" if node.is_node_level_method?(c[:console_command]) || command_group.console_method_name_exists?(c[:console_command])
+
               command_group << ::Bcome::Registry::Command::Base.new_from_raw_command(c) unless restrict_config?(node, c)
               ::Bcome::Registry::CommandList.instance.register(node, c[:console_command].to_sym)
             end
@@ -47,11 +47,10 @@ module Bcome::Registry
 
     def restrict_config?(node, command_config)
       return false unless command_config.key?(:restrict_to_node)
+
       node_klass_mapping = restriction_to_node_klass_mappings[command_config[:restrict_to_node].to_sym]
 
-      unless node_klass_mapping
-        raise Bcome::Exception::InvalidRestrictionKeyInRegistry, "'#{command_config[:restrict_to_node]}' is invalid. Valid keys: #{restriction_to_node_klass_mappings.keys.join(', ')}"
-      end
+      raise Bcome::Exception::InvalidRestrictionKeyInRegistry, "'#{command_config[:restrict_to_node]}' is invalid. Valid keys: #{restriction_to_node_klass_mappings.keys.join(', ')}" unless node_klass_mapping
 
       !node.is_a?(node_klass_mapping)
     end
@@ -66,6 +65,7 @@ module Bcome::Registry
 
     def do_load
       return {} unless File.exist?(FILE_PATH)
+
       begin
         file_data = YAML.load_file(FILE_PATH).deep_symbolize_keys
       rescue Psych::SyntaxError => e

data/lib/objects/ssh/bootstrap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Ssh
   class Bootstrap
     def initialize(config)
@@ -7,7 +9,7 @@ module Bcome::Ssh
     def ssh_key_path
       key_path = `eval directory=#{@config[:ssh_key_path]}; echo $directory`
       key_path =~ /(.+)\n/
-      $1
+      Regexp.last_match(1)
     end
 
     def user

data/lib/objects/ssh/command.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ::Bcome::Ssh
   class Command
-    attr_reader :raw, :stdout, :stderr, :exit_code, :node, :bootstrap
+    attr_reader :raw, :stdout, :stderr, :exit_code, :node
 
     def initialize(params)
       @raw = params[:raw]
@@ -18,11 +20,14 @@ module ::Bcome::Ssh
       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}"
+      cmd_output = @stdout
+
+      unless is_success?
+        cmd_output += "\nExit code: #{@exit_code}"
+        cmd_output += "\nSTDERR: #{@stderr}" unless @stderr.empty?
+      end
+      "\n#{cmd_output}"
     end
 
     def is_success?

data/lib/objects/ssh/command_exec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ::Bcome::Ssh
   class CommandExec
     attr_reader :commands
@@ -10,14 +12,15 @@ module ::Bcome::Ssh
       @output_string = "#{@output_string}#{output_string}"
     end
 
+    def log_window
+      ::Bcome::Ssh::Window.instance
+    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
@@ -25,24 +28,25 @@ module ::Bcome::Ssh
         begin
           ssh_exec!(ssh, command)
         rescue IOError # Typically occurs after a timeout if the session has been left idle
-          node.open_ssh_connection
+          node.reopen_ssh_connection
+          ssh = node.ssh_driver.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?
+
+      print_output unless ::Bcome::Orchestrator.instance.command_output_silenced? || ::Bcome::Orchestrator.instance.tail_all_command_output?
     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
+          abort "FAILED: couldn't execute command (ssh.channel.exec)" unless success
 
           channel.on_data do |_ch, data|
+            log_window.add(command.node, data) if ::Bcome::Orchestrator.instance.tail_all_command_output?
             command.stdout += data
           end
 
@@ -55,7 +59,7 @@ module ::Bcome::Ssh
           end
 
           channel.on_request('exit-signal') do |_ch, data|
-            command.exit_signal = data.read_long
+            command.exit_code = data.read_long
           end
         end
       end

data/lib/objects/ssh/connection_wrangler.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'net/ssh/proxy/jump'
+
+module Bcome::Ssh
+  class ConnectionWrangler
+    def initialize(ssh_driver)
+      @ssh_driver = ssh_driver
+      @config = ssh_driver.config[:proxy]
+      @context_node = ssh_driver.context_node
+      @user = ssh_driver.user
+    end
+
+    ## Accessors --
+
+    def proxy_details
+      hops.reverse.collect(&:proxy_details)
+    end
+
+    def first_hop
+      hops.reverse.first
+    end
+
+    def has_hop?
+      hops.any?
+    end
+
+    def single_hop?
+      has_hop? && hops.size == 1
+    end
+
+    def proxy
+      @proxy ||= create_proxy
+    end
+
+    def create_proxy
+      proxy = Net::SSH::Proxy::Jump.new(hops.reverse.collect(&:get_ssh_string).join(','))
+      proxy
+    end
+
+    def get_ssh_command(config = {}, _proxy_only = false)
+      cmd = has_hop? ? 'ssh -J' : 'ssh'
+      cmd += "\s" + hops.collect(&:get_ssh_string).join(',') if has_hop?
+      cmd += "\s#{@ssh_driver.node_level_ssh_key_connection_string}\s#{@ssh_driver.user}@#{target_machine_ingress_ip}"
+
+      config[:as_pseudo_tty] ? "#{cmd} -t" : cmd
+    end
+
+    def get_rsync_command(local_path, remote_path)
+      cmd = 'rsync -azv'
+      cmd += "\s-e 'ssh\s-A -J\s" + hops.collect(&:get_ssh_string).join(',') + "'" if has_hop?
+      cmd += "\s#{local_path}\s#{@ssh_driver.user}@#{target_machine_ingress_ip}:#{remote_path}"
+      cmd
+    end
+
+    def get_local_port_forward_command(start_port, end_port)
+      # TODO: - below check is not actaully true... you might still want to proxy over SSH...
+      raise ::Bcome::Exception::InvalidPortForwardRequest, 'Connections to this node are not via a proxy. Rather than port forward, try connecting directly.' unless has_hop?
+
+      cmd = "ssh -N -L #{start_port}:localhost:#{end_port} -J"
+      cmd += "\s" + hops.collect(&:get_ssh_string).join(',') if has_hop?
+      cmd += "\s#{@ssh_driver.node_level_ssh_key_connection_string}\s#{@ssh_driver.user}@#{target_machine_ingress_ip}"
+
+      cmd
+    end
+
+    protected
+
+    def target_machine_ingress_ip
+      unless has_hop?
+        raise ::Bcome::Exception::InvalidProxyConfig, "missing target ip address for #{@context_node.identifier}. Perhaps you meant to configure a proxy?" unless @context_node.public_ip_address
+      end
+
+      has_hop? ? @context_node.internal_ip_address : @context_node.public_ip_address
+    end
+
+    def hops
+      @hops ||= set_hops
+    end
+
+    private
+
+    def set_hops
+      hop_collection = []
+
+      parent = nil
+      iterable_configs.each do |config|
+        hop = set_proxy_hop(config, parent)
+        hop_collection << hop
+        parent = hop
+      end
+
+      hop_collection
+    end
+
+    def set_proxy_hop(config, parent)
+      config[:fallback_bastion_host_user] = @ssh_driver.fallback_bastion_host_user
+      ::Bcome::Ssh::ProxyHop.new(config, @context_node, parent)
+    end
+
+    def iterable_configs
+      @iterable ||= @config ? (@config.is_a?(Hash) ? [@config] : @config) : []
+    end
+  end
+end

data/lib/objects/ssh/connector.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Bcome
+  module Ssh
+    class Connector
+      include ::Bcome::LoadingBar::Handler
+
+      class << self
+        def connect(node, config = {})
+          handler = new(node, config)
+          handler.connect
+        end
+      end
+
+      def initialize(node, config)
+        @node = node
+        @config = config
+        set_servers
+        @connected_machines = []
+        @connection_exceptions = {}
+      end
+
+      def show_progress?
+        @config[:show_progress] ? true : false
+      end
+
+      def ping?
+        @config[:is_ping] ? true : false
+      end
+
+      def connect
+        return if number_unconnected_machines == 0 && !ping?
+
+        if show_progress?
+          wrap_indicator type: :progress, size: @servers_to_connect.size, title: 'Opening connections' do
+            open_connections
+          end
+        else
+          open_connections
+        end
+
+        report_connection_outcome
+      end
+
+      def report_connection_outcome
+        print "\n"
+
+        if ping?
+          @connected_machines.pmap do |machine|
+            puts machine.print_ping_result
+          end
+
+          # If any machines remain, then we couldn't connect to them
+          @servers_to_connect.each do |machine|
+            ping_result = {
+              success: false,
+              error: @connection_exceptions[machine]
+            }
+            puts machine.print_ping_result(ping_result)
+          end
+        end
+
+        puts "Failed to connect to #{@servers_to_connect.size} node#{@servers_to_connect.size > 1 ? 's' : ''}".error if @servers_to_connect.any?
+      end
+
+      def open_connections
+        @servers_to_connect.pmap do |machine|
+          begin
+           machine.open_ssh_connection(ping?)
+           if machine.has_ssh_connection?
+             @servers_to_connect -= [machine]
+             @connected_machines << machine
+             signal_success if show_progress?
+           else
+             signal_failure if show_progress?
+           end
+          rescue Errno::EPIPE, Bcome::Exception::CouldNotInitiateSshConnection, ::Bcome::Exception::InvalidProxyConfig => e
+            signal_failure if show_progress?
+            @connection_exceptions[machine] = e
+         end
+        end
+      end
+
+      private
+
+      def set_servers
+        @servers_to_connect = machines.dup
+      end
+
+      def number_unconnected_machines
+        @servers_to_connect.reject(&:has_ssh_connection?).size
+      end
+
+      def machines
+        skip_for_hidden = true # Skip servers with hidden namespaces
+        @node.server? ? [@node] : @node.machines(skip_for_hidden)
+      end
+    end
+  end
+end

data/lib/objects/ssh/driver.rb

@@ -1,276 +1,73 @@
+# frozen_string_literal: true
+
+require 'net/scp'
+
 module Bcome::Ssh
   class Driver
-    attr_reader :config, :bootstrap_settings
+    attr_reader :config, :context_node
 
-    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
+    include Bcome::Ssh::DriverConnection
+    include Bcome::Ssh::DriverFunctions
+    include Bcome::Ssh::DriverUser
+    include Bcome::Ssh::DriverCommandStrings
 
     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?
+    def connection_wrangler
+      @connection_wrangler ||= set_connection_wrangler
     end
 
-    def has_bootstrap_settings?
-      !@bootstrap_settings.nil?
+    def set_connection_wrangler
+      @set_connection_wrangler ||= ::Bcome::Ssh::ConnectionWrangler.new(self)
     end
 
-    def pretty_config_details
+    def pretty_ssh_config
       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
-        }
+        config[:proxy] = connection_wrangler.proxy_details
       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?
-      return false if proxy_config_value && proxy_config_value == -1
-      !@config[:proxy].nil?
+      config
     end
 
     def proxy_config_value
       @config[:proxy]
     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(as_pseudo_tty = false)
-      return bootstrap_ssh_command if bootstrap? && @bootstrap_settings.ssh_key_path
-
-      if has_proxy?
-        "#{as_pseudo_tty ? "ssh -t" : "ssh"} #{PROXY_SSH_PREFIX} #{bastion_host_user}@#{@proxy_data.host}\" #{node_level_ssh_key_connection_string}#{user}@#{@context_node.internal_ip_address}"
-      else
-        "#{as_pseudo_tty ? "ssh -t" : "ssh"} #{node_level_ssh_key_connection_string}#{user}@#{@context_node.public_ip_address}"
-      end
+    def multi_hop_proxy_config
+      @config[:multi_hop_proxy]
     end
 
     def node_level_ssh_key_connection_string
-      key_specified_at_node_level? ? "-i #{node_level_ssh_key}\s" : ""
+      key_specified_at_node_level? ? "-i #{node_level_ssh_key}\s" : ''
     end
 
     def key_specified_at_node_level?
       !node_level_ssh_key.nil?
-    end  
-
-    def node_level_ssh_key
-      return (@config[:ssh_keys]) ? @config[:ssh_keys].first : nil
-    end
-
-    def local_port_forward(start_port, end_port)
-      if has_proxy?
-        
-        if bootstrap?
-          tunnel_command = "ssh -N -L #{start_port}:#{@context_node.internal_ip_address}:#{end_port} -i #{@bootstrap_settings.ssh_key_path} #{bastion_host_user}@#{@proxy_data.host}"
-        else
-          tunnel_command = "ssh -N -L #{start_port}:#{@context_node.internal_ip_address}:#{end_port} #{bastion_host_user}@#{@proxy_data.host}"
-        end
-      else
-        if bootstrap?
-          tunnel_command = "ssh -i #{@bootstrap_settings.ssh_key_path} -N -L #{start_port}:#{@context_node.public_ip_address}:#{end_port}"
-        else
-          tunnel_command = "ssh -N -L #{start_port}:#{@context_node.public_ip_address}:#{end_port}"
-        end
-      end
-
-      tunnel = ::Bcome::Ssh::Tunnel::LocalPortForward.new(tunnel_command)
-      tunnel.open!
-      return tunnel
-    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
-      # If we're in bootstrapping mode and have a bootstrap user set, return it
-      return @bootstrap_settings.user if (bootstrap? && @bootstrap_settings.user)
-
-      # If we have a user explcitly set in the config, then return it
-      return @config[:user] if @config[:user]
-
-      # If the local user has explicitly overriden their user, return that
-      return overriden_local_user if overriden_local_user
-
-      # Else fall back to whichever local user is using bcome
-      fallback_local_user
-    end
-
-    def overriden_local_user
-      @overriden_local_user ||= get_overriden_local_user
-    end
-
-    def get_overriden_local_user
-      ::Bcome::Node::Factory.instance.local_data[:ssh_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 put_str(string, remote_path)
-      raise Bcome::Exception::MissingParamsForScp, "'put' requires a string and a remote_path" if string.to_s.empty? || remote_path.to_s.empty?
-      puts "\n(#{@context_node.namespace})\s".namespace + "Uploading from string to #{remote_path}\n".informational
-
-      begin
-        scp.upload!(StringIO.new(string), remote_path) 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
+    def node_level_ssh_key
+      @config[:ssh_keys] ? @config[:ssh_keys].first : nil
     end
 
-    def close_ssh_connection
-      return unless @connection
-      @connection.close unless @connection.closed?
-      @connection = nil
+    def has_multi_hop_proxy?
+      !multi_hop_proxy_config.nil?
     end
 
-    def ssh_connection(_bootstrap = false)
-      has_open_ssh_con? ? @connection : ssh_connect!
-    end
+    def has_proxy?
+      return false if proxy_config_value && proxy_config_value == -1
 
-    def has_open_ssh_con?
-      !@connection.nil? && !@connection.closed?
+      !@config[:proxy].nil?
     end
   end
 end