bcome 1.3.2 → 1.4.0

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,78 @@
+# 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::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
+      has_proxy? ? @context_node.internal_ip_address : @context_node.public_ip_address
+    end
+
+    def net_ssh_params
+      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] = :fatal # All but silent
+
+      params
+    end
+
+    def timeout_in_seconds
+      @config[:timeout_in_seconds] ||= DEFAULT_TIMEOUT_IN_SECONDS
+    end
+
+    ## SSH KEYS
+
+    def ssh_keys
+      @config[:ssh_keys]
+    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 }
+    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
+        puts e.message.error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ::Bcome::Ssh
+  module DriverUser
+    def user
+      # If we have a user explictly 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 fallback_bastion_host_user
+      user
+    end
+  end
+end

data/lib/objects/ssh/{proxy_data.rb → proxy_hop.rb}

@@ -1,16 +1,55 @@
+# frozen_string_literal: true
+
 module Bcome::Ssh
-  class ProxyData
-    def initialize(config, context_node)
+  class ProxyHop
+    attr_reader :parent
+
+    def initialize(config, context_node, parent)
       @config = config
       @context_node = context_node
+      @parent = parent
+    end
+
+    def proxy_details
+      @config.merge(
+        proxy_host: host,
+        user: user
+      )
     end
 
     def host
       @host ||= get_host
     end
 
-    def bastion_host_user
-      @bastion_host_user ||= get_bastion_host_user
+    def user
+      @user ||= get_user
+    end
+
+    def has_parent?
+      !parent.nil?
+    end
+
+    def get_ssh_string(_is_first_hop = false)
+      con_str = "#{user}@#{host}"
+      con_str
+    end
+
+    def get_rsync_string
+      con_str = ''
+
+      con_str += "#{parent.get_rsync_string}\s" if has_parent?
+
+      con_str += "'ssh -o \"ProxyCommand ssh -A #{user}@#{host} -W %h:%p\"'"
+      con_str
+    end
+
+    def get_local_port_forward_string
+      con_str = ''
+
+      con_str += parent.get_local_port_forward_string.to_s if has_parent?
+
+      con_str += "#{user}@#{host}\s"
+      con_str
     end
 
     private
@@ -23,16 +62,20 @@ module Bcome::Ssh
       }
     end
 
-    def get_bastion_host_user
-      @config[:bastion_host_user]
+    def get_user
+      @config[:bastion_host_user] || @config[:fallback_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)
+
+      h = send(host_lookup_method)
+
+      h
     end
 
     def get_host_or_ip_from_config
@@ -44,12 +87,14 @@ module Bcome::Ssh
       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

data/lib/objects/ssh/script_exec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ::Bcome::Ssh
   class ScriptExec
-    SCRIPTS_PATH = 'bcome/scripts'.freeze
+    SCRIPTS_PATH = 'bcome/scripts'
 
     class << self
       def execute(server, script_name)
@@ -24,6 +26,7 @@ module ::Bcome::Ssh
     def execute_command
       local_path_to_script = "#{SCRIPTS_PATH}/#{@script_name}.sh"
       raise Bcome::Exception::OrchestrationScriptDoesNotExist, local_path_to_script unless File.exist?(local_path_to_script)
+
       execute_script_command = "#{@ssh_driver.ssh_command} \"bash -s\" < #{local_path_to_script}"
       command = ::Bcome::Command::Local.run(execute_script_command)
       command

data/lib/objects/ssh/tunnel/local_port_forward.rb

@@ -1,20 +1,19 @@
+# frozen_string_literal: true
+
 module Bcome::Ssh::Tunnel
   class LocalPortForward
- 
     def initialize(tunnel_command)
       @tunnel_command = tunnel_command
       @process_pid = nil
-    end 
+    end
 
     def open!
-      puts "Opening tunnel: #{@tunnel_command}".informational
       @process_pid = spawn(@tunnel_command)
     end
 
     def close!
-      puts "Closing tunnel with process pid ##{@process_pid}: #{@tunnel_command}".informational
-      ::Process.kill("HUP", @process_pid)
+      puts "Closing tunnel:\s".informational + @tunnel_command.to_s.terminal_prompt
+      ::Process.kill('HUP', @process_pid)
     end
-
   end
 end

data/lib/objects/ssh/tunnel_keeper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Bcome
+  module Ssh
+    class TunnelKeeper
+      include Singleton
+
+      def initialize
+        @tunnels = []
+      end
+
+      def <<(tunnel)
+        @tunnels << tunnel
+      end
+
+      def close_tunnels
+        @tunnels.each(&:close!)
+      end
+    end
+  end
+end

data/lib/objects/ssh/window.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bcome
+  module Ssh
+    class Window
+      attr_reader :lines
+
+      include Singleton
+
+      def initialize(*_params)
+        @lines = []
+      end
+
+      def add(node, log_line)
+        multi_line = log_line =~ /\n/ ? true : false
+
+        @lines << if ::Bcome::Orchestrator.instance.is_multi_node?
+                    "\n#{node.namespace}".terminal_prompt + "\n#{log_line}"
+                  else
+                    log_line
+                  end
+
+        pop
+      end
+
+      def pop
+        print @lines.pop
+      end
+    end
+  end
+end

data/lib/objects/startup.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Bcome
+  class Startup
+    def initialize(breadcrumbs, arguments)
+      @breadcrumbs = breadcrumbs
+      @arguments = arguments
+    end
+
+    def do
+      case @breadcrumbs
+      when '-v', '--version', '--v'
+        puts ::Bcome::Version.display
+      when 'pack_metadata'
+        ::Bcome::Encryptor.instance.pack
+      when 'unpack_metadata'
+        ::Bcome::Encryptor.instance.unpack
+      else
+        bootup
+      end
+    end
+
+    def bootup
+      spawn_into_console = true
+      ::Bcome::Bootup.set_and_do({ breadcrumbs: @breadcrumbs, arguments: @arguments }, spawn_into_console)
+      clean_up
+    rescue ::Bcome::Exception::Base => e
+      clean_up
+      puts e.pretty_display
+    rescue Excon::Error::Socket => e
+      clean_up
+      puts "\nNo network access - please check your connection and try again\n".error
+    rescue Exception => e
+      clean_up
+      raise e
+    end
+
+    def clean_up
+      stop_loading_bars
+      close_connections
+    end
+
+    def close_connections
+      ::Bcome::Bootup.instance.close_ssh_connections
+      ::Bcome::Ssh::TunnelKeeper.instance.close_tunnels
+    end
+
+    def stop_loading_bars
+      ::Bcome::LoadingBar::PidBucket.instance.stop_all
+    end
+  end
+end