bcome 1.3.4 → 2.0.1

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_chain.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Bcome::Ssh
+  class ProxyChain
+    attr_reader :hops
+
+    def initialize(wrangler)
+      @hops = wrangler.hops
+    end
+
+    def eql?(other_chain)
+      hops == other_chain.hops
+    end
+
+    def ==(other_chain)
+      eql?(other_chain)
+    end
+  end
+end

data/lib/objects/ssh/proxy_chain_link.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Bcome::Ssh
+  class ProxyChainLink
+    attr_reader :link
+
+    def initialize(node)
+      @link = {}
+      init(node.machines)
+    end
+
+    protected
+
+    def init(machines)
+      machines.each do |machine|
+        proxy_chain = machine.proxy_chain
+
+        if key = @link.keys.detect { |key| key.eql?(proxy_chain) }
+          @link[key] << machine
+        else
+          @link[proxy_chain] = [machine]
+        end
+      end
+    end
+  end
+end

data/lib/objects/ssh/proxy_hop.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Bcome::Ssh
+  class ProxyHop
+    include Bcome::Draw
+
+    attr_reader :parent, :config, :host, :bcome_proxy_node
+
+    def initialize(config, context_node, parent)
+      @config = config
+      @context_node = context_node
+      @parent = parent
+      set_host
+    end
+
+    def proxy_details
+      @config.merge(
+        proxy_host: host,
+        user: user
+      ).except!(:bastion_host_user, :fallback_bastion_host_user)
+    end
+
+    def pretty_proxy_details(n = 1)
+      lines = ["proxy\s".bc_cyan + "[#{n}]"]
+
+      lines << "bcome node\s".bc_yellow + @bcome_proxy_node.keyed_namespace if @bcome_proxy_node
+
+      lines << "host\s".bc_yellow + host
+      lines << "user\s".bc_yellow + user
+
+      lines
+    end
+
+    def user
+      @user ||= get_user
+    end
+
+    def has_parent?
+      !parent.nil?
+    end
+
+    def ==(other)
+      config == other.config
+    end
+
+    def eql?(other)
+      config == other.config
+    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
+
+    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_user
+      # If an explicit user has been set for this hop, use it.
+      return @config[:bastion_host_user] if @config[:bastion_host_user]
+
+      # Otherwise, if our proxy hop is a defined bcome server, i.e. it exists in the network map, we can infer the user and so we'll use that.
+      return @bcome_proxy_node.ssh_driver.user if @bcome_proxy_node
+
+      # Otherwise, we'll fallback
+      @config[:fallback_bastion_host_user]
+    end
+
+    def set_host
+      raise Bcome::Exception::InvalidProxyConfig, 'Missing host id or namespace' unless @config[:node_identifier] || @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
+
+      @host = send(host_lookup_method)
+    end
+
+    def get_host_or_ip_from_config
+      @config[:host_id]
+    end
+
+    # Older lookup - within same parent-child tree only. Retained for backwards compatibility
+    def get_host_by_inventory_node
+      identifier = @config[:host_id] || @config[:node_identifier]
+      @bcome_proxy_node = @context_node.recurse_resource_for_identifier(identifier)
+      raise Bcome::Exception::CantFindProxyHostByIdentifier, identifier unless @bcome_proxy_node
+      raise Bcome::Exception::ProxyHostNodeDoesNotHavePublicIp, identifier unless @bcome_proxy_node.public_ip_address
+
+      bcome_node_host
+    end
+
+    # Newer lookup - across entire network
+    def get_host_by_namespace
+      @bcome_proxy_node = ::Bcome::Orchestrator.instance.get(@config[:namespace])
+      raise Bcome::Exception::CantFindProxyHostByNamespace, @config[:namespace] unless @bcome_proxy_node
+
+      bcome_node_host
+    end
+
+    def bcome_node_host
+      @bcome_proxy_node.public_ip_address || @bcome_proxy_node.internal_ip_address
+    end
+  end
+end

data/lib/objects/ssh/script_exec.rb

@@ -1,18 +1,19 @@
+# frozen_string_literal: true
+
 module ::Bcome::Ssh
   class ScriptExec
-    SCRIPTS_PATH = 'bcome/scripts'.freeze
-
     class << self
-      def execute(server, script_name)
-        executor = new(server, script_name)
+      def execute(server, path_to_script)
+        executor = new(server, path_to_script)
         executor.execute
       end
     end
 
-    def initialize(server, script_name)
+    def initialize(server, path_to_script)
       @server = server
-      @script_name = script_name
+      @path_to_script = path_to_script
       @ssh_driver = server.ssh_driver
+      @output_string = ''
     end
 
     def execute
@@ -22,22 +23,22 @@ module ::Bcome::Ssh
     end
 
     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}"
+      raise Bcome::Exception::OrchestrationScriptDoesNotExist, @path_to_script unless File.exist?(@path_to_script)
+
+      execute_script_command = "#{@ssh_driver.ssh_command} \"bash -s\" < #{@path_to_script}"
       command = ::Bcome::Command::Local.run(execute_script_command)
       command
     end
 
     def pretty_print(command)
-      output_append("\n(#{@server.namespace})$".terminal_prompt + "> ./#{SCRIPTS_PATH}/#{@script_name}.sh - \s#{command.pretty_result}\n")
+      output_append("\n(#{@server.namespace})$".terminal_prompt + "> ./#{@path_to_script} - \s#{command.pretty_result}\n")
       output_append(command.stdout) # append stderr
       output_append "\nSTDERR: #{command.stderr}" if command.failed?
       puts "\n\n#{@output_string}\n\n"
     end
 
     def output_append(output_string)
-      @output_string = "#{@output_string}#{output_string}"
+      @output_string += "#{@output_string}#{output_string}"
     end
   end
 end

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,58 @@
+# 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
+      when 'diff_metadata'
+        ::Bcome::Encryptor.instance.diff
+      when 'init'
+        ::Bcome::Initialization::Factory.do
+      else
+        bootup
+      end
+    rescue Bcome::Exception::Base => e
+      e.pretty_display
+    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
+      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

data/lib/objects/system/local.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::System
   class Local
     include Singleton
@@ -10,6 +12,7 @@ module Bcome::System
         # we fail fast if we're not in a console session
         raise Bcome::Exception::FailedToRunLocalCommand, "#{raw_command}. Error: " + local_command.stderr
       end
+
       local_command
     end
 

data/lib/objects/terraform/output.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Bcome::Terraform
+  class Output
+    require 'json'
+
+    OUTPUT_COMMAND = 'terraform output -json'
+
+    def initialize(namespace)
+      @namespace = namespace
+    end
+
+    def output
+      @output ||= get_output
+    end
+
+    private
+
+    def terraform_installation_path
+      @terraform_installation_path ||= "terraform/environments/#{@namespace.gsub(':', '_')}"
+    end
+
+    def get_output
+      get_output_result = do_get_output
+
+      # Until this feature is officially featured, failure to get terraform data will fail silently
+      # One thing not decided upon yet is how to indicate that we wish to load terraform data or not.
+      if get_output_result.failed?
+        raise "Received authorisation error retrieving metadata from Terraform outputs for namespace #{@namespace}. Command was '#{get_output_command}'. Are you authorised to access the TFstate?" if get_output_result.stderr =~ /HTTP response code 401/
+
+        return {}
+      end
+
+      JSON.parse(get_output_result.stdout)
+    end
+
+    def get_output_command
+      "cd #{terraform_installation_path} ; #{OUTPUT_COMMAND}"
+    end
+
+    def do_get_output
+      ::Bcome::Command::Local.run(get_output_command)
+    end
+  end
+end