bcome 1.3.3 → 2.0.0

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

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module Bcome::Registry::Command
   class Base
     class << self
       def new_from_raw_command(data)
         raise Bcome::Exception::InvalidContextCommand, "#{data.inspect} is missing key type" unless data[:type]
         raise Bcome::Exception::InvalidContextCommand, "#{data.inspect} has invalid type '#{data[:type]}'" unless is_valid_type?(data[:type])
+
         valid_types[data[:type].to_sym].new(data)
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Registry::Command
   class External < Base
     # In which the bcome context is passed to an external call
@@ -28,15 +30,19 @@ module Bcome::Registry::Command
           error_message_suffix = "- missing '#{substitution}' from command '#{local_command}'"
           raise Bcome::Exception::MissingArgumentForRegistryCommand, error_message_suffix
         end
-  
-        substitute_with = [TrueClass, FalseClass].include?(substitute_with.class) ? (substitute_with ? "true" : "false") : substitute_with
+
+        substitute_with = if [TrueClass, FalseClass].include?(substitute_with.class)
+                            substitute_with ? 'true' : 'false'
+                          else
+                            substitute_with
+                          end
         substituted_command.gsub!("%#{substitution}%", substitute_with)
       end
       substituted_command
     end
 
     def namespace_command(node, command)
-      "#{command} bcome_context=\"#{node.keyed_namespace}\""
+      "bcome_context=\"#{node.keyed_namespace}\" #{command}"
     end
 
     def local_command_substitutions

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Registry::Command
   class Group
     def initialize(node)
@@ -32,7 +34,8 @@ module Bcome::Registry::Command
     end
 
     def item_spacing(item)
-      raise ::Bcome::Exception::InvalidRegistryCommandNameLength.new "command '#{item}' exceeds length limit of #{menu_item_spacing_length}" if item.length > menu_item_spacing_length
+      raise ::Bcome::Exception::InvalidRegistryCommandNameLength, "command '#{item}' exceeds length limit of #{menu_item_spacing_length}" if item.length > menu_item_spacing_length
+
       "\s" * (menu_item_spacing_length - item.length)
     end
 
@@ -48,7 +51,7 @@ module Bcome::Registry::Command
       ::Bcome::System::Local.instance.in_console_session?
     end
 
-    def pretty_print ## TODO - revisit. This is a mess
+    def pretty_print
       puts "\nRegistry commands".title + "\sfor #{@node.class} #{@node.keyed_namespace}".resource_value + "\n\n"
       all_commands.sort.each do |group_name, commands|
         puts tab_spacing + group_name.title + "\n\n"
@@ -59,11 +62,15 @@ module Bcome::Registry::Command
 
           puts tab_spacing + command_key.resource_key + item_spacing(command_key) + description.resource_value
 
-          usage_string = in_console_session? ? command_key.to_s : "bcome #{@node.keyed_namespace.empty? ? '' : "#{@node.keyed_namespace}:"}#{command_key}"
+          usage_string = if in_console_session?
+                           command_key.to_s
+                         else
+                           "bcome #{@node.keyed_namespace.empty? ? '' : "#{@node.keyed_namespace}:"}#{command_key}"
+                         end
           puts tab_spacing + ("\s" * menu_item_spacing_length) + 'usage: '.instructional + usage_string
 
           if defaults.keys.any?
-            defaults_usage = in_console_session? ? "\s\"#{defaults.collect { |key, _value| "#{key}=your-value" }.join(',')}\"" : "\s" + defaults.collect { |key, _value| "#{key}=your-value" }.join("\s")
+            defaults_usage = in_console_session? ? "\s#{defaults.collect { |key, _value| "\"#{key}=your-value\"" }.join(",\s")}" : "\s" + defaults.collect { |key, _value| "#{key}=your-value" }.join("\s")
             puts tab_spacing + ("\s" * menu_item_spacing_length) + "defaults:\s".instructional + defaults.collect { |k, v| "#{k}=#{v}" }.join(', ')
             puts tab_spacing + ("\s" * menu_item_spacing_length) + "override:\s".instructional + usage_string + defaults_usage
           end

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,20 @@ module Bcome::Registry
 
       data.each do |key, commands|
         begin
-          if /^#{key.to_s}$/.match(node.keyed_namespace)
-            commands.each do |c|
+          if /^#{key}$/.match(node.keyed_namespace)
+
+            next if commands.nil?
 
+            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 +50,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 +68,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]
@@ -14,15 +16,14 @@ module ::Bcome::Ssh
       @node = nil
     end
 
-    def pretty_result
-      is_success? ? 'success'.success : 'failure'.error
-    end
+    def output
+      cmd_output = @stdout
 
-    attr_writer :bootstrap
+      cmd_output += "\nExit code:" + "\s#{@exit_code}"
 
-    def output
-      command_output = is_success? ? @stdout : "Exit code: #{@exit_code}\n\nSTDERR: #{@stderr}"
-      "\n#{command_output}"
+      cmd_output += "\nSTDERR: #{@stderr}" if exit_code == 1 && !@stderr.empty?
+
+      "\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,17 @@ 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"
+    rescue StandardError => e
+      puts "Could not print #{@output_string.inspect}"
     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 +30,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("\n(#{node.namespace})$".terminal_prompt + ">\s#{command.raw}\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 +61,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,122 @@
+# frozen_string_literal: true
+
+require 'net/ssh/proxy/jump'
+
+module Bcome::Ssh
+  class ConnectionWrangler
+    attr_accessor :proxy_details
+
+    def initialize(ssh_driver)
+      @ssh_driver = ssh_driver
+      @config = ssh_driver.config[:proxy]
+      @context_node = ssh_driver.context_node
+      @user = ssh_driver.user
+      set_proxy_details
+    end
+
+    ## Accessors --
+    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.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 actually 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.user}@#{target_machine_ingress_ip}"
+
+      cmd
+    end
+
+    def hops
+      @hops ||= set_hops
+    end
+
+    protected
+
+    def set_proxy_details
+      @proxy_details ||= hops.compact.collect(&:proxy_details)
+    end
+
+    def target_machine_ingress_ip
+      return @context_node.internal_ip_address if @context_node.local_network?
+
+      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
+
+    private
+
+    def set_hops
+      hop_collection = []
+
+      parent = nil
+      iterable_configs.each do |config|
+        hop = get_proxy_hop(config, parent)
+  
+        if @context_node.is_same_machine?(hop.bcome_proxy_node)
+          # We don't hop through ourselves.  If we're reached ourselves in the proxy chain,
+          # then we'll break the chain at that point.
+          break
+        end  
+
+        # Set proxy hop
+        hop_collection << hop
+        parent = hop
+      end
+
+      hop_collection.compact
+    end
+
+    def get_proxy_hop(config, parent)
+      config[:fallback_bastion_host_user] = @ssh_driver.fallback_bastion_host_user
+      h = ::Bcome::Ssh::ProxyHop.new(config, @context_node, parent)
+      return h
+    end
+
+    def iterable_configs
+      @iterable ||= if @config
+                      @config.is_a?(Hash) ? [@config] : @config
+                    else
+                      []
+                    end
+    end
+  end
+end

data/lib/objects/ssh/connector.rb

@@ -0,0 +1,108 @@
+# 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?
+          print "\n"
+          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
+
+        # Ensure that all connections are loaded. A machine might need to proxy through another that
+        # has not yet been loaded. Here we ensure that we've traversed the tree for all required nodes.
+        @servers_to_connect.each do |server|
+          server.ssh_driver.set_connection_wrangler
+        end
+      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