bcome 1.3.4 → 2.0.1

data/lib/objects/ssh/driver.rb

@@ -1,276 +1,62 @@
+# 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 proxy_chain
+      @proxy_chain ||= ::Bcome::Ssh::ProxyChain.new(connection_wrangler)
     end
 
-    def has_bootstrap_settings?
-      !@bootstrap_settings.nil?
+    def set_connection_wrangler
+      @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
+        config[:host_or_ip] = node_host_or_ip
       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
-    end
-
-    def node_level_ssh_key_connection_string
-      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
+    def multi_hop_proxy_config
+      @config[:multi_hop_proxy]
     end
 
-    def get_overriden_local_user
-      ::Bcome::Node::Factory.instance.local_data[:ssh_user]       
+    def has_multi_hop_proxy?
+      !multi_hop_proxy_config.nil?
     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
-    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?
+    def has_proxy?
+      return connection_wrangler.has_hop?
     end
   end
 end

data/lib/objects/ssh/driver_concerns/command_strings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ::Bcome::Ssh
+  module DriverCommandStrings
+    def ssh_command(as_pseudo_tty = false)
+      connection_wrangler.get_ssh_command(as_pseudo_tty: as_pseudo_tty)
+    end
+
+    def rsync_command(local_path, remote_path)
+      connection_wrangler.get_rsync_command(local_path, remote_path)
+    end
+
+    def local_port_forward_command(start_port, end_port)
+      connection_wrangler.get_local_port_forward_command(start_port, end_port)
+    end
+  end
+end

data/lib/objects/ssh/driver_concerns/connection.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ::Bcome::Ssh
+  module DriverConnection
+    DEFAULT_TIMEOUT_IN_SECONDS = 1
+
+    attr_reader :connection
+
+    ## CONNECTION --
+
+    def ssh_connect!
+      @connection = nil
+      begin
+        raise ::Bcome::Exception::InvalidProxyConfig, "missing target ip address for #{@context_node.identifier}. Perhaps you meant to configure a proxy?" unless node_host_or_ip
+        @connection = ::Net::SSH.start(node_host_or_ip, user, net_ssh_params)
+      rescue Net::SSH::AuthenticationFailed, Net::SSH::Proxy::ConnectError, Net::SSH::ConnectionTimeout => e
+        raise Bcome::Exception::CouldNotInitiateSshConnection, @context_node.namespace + "\s-\s#{e.message}"
+      end
+      @connection
+    end
+
+    def close_ssh_connection
+      return unless @connection
+
+      begin
+        @connection.close unless @connection.closed?
+        @connection = nil
+      rescue Net::SCP::Error
+        @connection = nil
+      end
+    end
+
+    def ssh_connection(ping = false)
+      if ping
+        # We do not cache ping results
+        ssh_connect!
+      else
+        has_open_ssh_con? ? @connection : ssh_connect!
+      end
+    end
+
+    def has_open_ssh_con?
+      !@connection.nil? && !@connection.closed?
+    end
+
+    def node_host_or_ip
+      return @context_node.internal_ip_address if @context_node.local_network?
+
+      if has_proxy? || !@context_node.public_ip_address
+        @context_node.internal_ip_address
+      else
+        @context_node.public_ip_address
+      end 
+    end
+
+    def net_ssh_params
+      params = { paranoid: false }
+      params[:proxy] = proxy if has_proxy?
+      params[:timeout] = timeout_in_seconds
+      params[:verbose] = :fatal # All but silent
+
+      params
+    end
+
+    def timeout_in_seconds
+      @config[:timeout_in_seconds] ||= DEFAULT_TIMEOUT_IN_SECONDS
+    end
+
+    ## PROXYING --
+
+    def proxy
+      connection_wrangler.proxy
+    end
+  end
+end

data/lib/objects/ssh/driver_concerns/functions.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ::Bcome::Ssh
+  module DriverFunctions
+    def do_ssh
+      cmd = ssh_command
+      @context_node.execute_local(cmd)
+    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 local_port_forward(start_port, end_port)
+      tunnel_command = local_port_forward_command(start_port, end_port)
+
+      if ::Bcome::Workspace.instance.console_set?
+        puts "\sOpening ssh tunnel:\s".informational + tunnel_command.to_s.terminal_prompt
+        tunnel = ::Bcome::Ssh::Tunnel::LocalPortForward.new(tunnel_command)
+        ::Bcome::Ssh::TunnelKeeper.instance << tunnel
+        tunnel.open!
+        tunnel
+      else
+        puts "\n\nOpening ssh tunnel".informational + "\slocalhost:#{start_port} ~> #{@context_node.namespace}:#{end_port}"
+        puts "\nTo use, navigate to another terminal window or application."
+        puts "\nctrl+c to close."
+        ::Bcome::Command::Local.run(tunnel_command)
+      end
+    end
+
+    def ping
+      ssh_connect!
+      { success: true }
+    rescue Exception => e
+      { success: false, error: e, backtrace: e.backtrace }
+    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, silence_progress = false)
+      raise Bcome::Exception::MissingParamsForScp, "'put' requires a string and a remote_path" if string.nil? || remote_path.to_s.empty?
+
+      puts "\n(#{@context_node.namespace})\s".namespace + "Uploading from string to #{remote_path}\n".informational unless silence_progress
+
+      begin
+        scp.upload!(StringIO.new(string), remote_path) do |_ch, name, sent, total|
+          puts "#{name}: #{sent}/#{total}".progress unless silence_progress
+        end
+      rescue StandardError => e
+        raise ::Bcome::Exception::Generic, e.message
+      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
+        puts e.message.error
+      end
+    end
+  end
+end