bcome 1.3.4 → 2.0.1

data/lib/objects/modules/workspace_menu.rb

@@ -1,140 +1,204 @@
-module Bcome::WorkspaceMenu
-  def menu
-    print "\n\n"
-    puts "#{mode} menu".title + "\sfor #{self.class} #{namespace}".resource_value + "\n\n"
-    enabled_menu_items.each_with_index do |menu_item, _index|
-      item = menu_items[menu_item]
-      next if !::Bcome::System::Local.instance.in_console_session? && item[:console_only]
-      puts tab_spacing + menu_item.to_s.resource_key + item_spacing(menu_item) + (menu_items[menu_item][:description]).to_s.resource_value
-      if item[:usage] || item[:terminal_usage]
-        usage_string = ::Bcome::System::Local.instance.in_console_session? ? item[:usage] : "bcome #{keyed_namespace.empty? ? '' : "#{keyed_namespace}:"}#{item[:terminal_usage]}"
-        puts tab_spacing + ("\s" * menu_item_spacing_length) + 'usage: '.instructional + usage_string
+# frozen_string_literal: true
+
+module Bcome
+  module WorkspaceMenu
+    def menu
+      print "\n\n"
+      puts 'COMMAND MENU'.bc_cyan + "\sfor #{self.class} #{namespace}".resource_value
+
+      grouped_menu_items = menu_items.group_by { |m| m[1][:group] }
+      grouped_menu_items.each do |group_key, items|
+        # If we're not in a console session, we filter out console only methods
+        items = items.reject { |item| item[1][:console_only] } unless ::Bcome::System::Local.instance.in_console_session?
+
+        next if items.empty?
+
+        s_heading = "/ #{menu_group_names[group_key]}"
+        print "\n\n" + tab_spacing + s_heading.upcase.bc_cyan
+        print item_spacing(s_heading) + ("\s" * 110).to_s.bc_cyan.underline
+        print "\n\n"
+        print_menu_items(items)
       end
-      puts "\n"
+
+      nil
     end
 
-    nil
-  end
+    def print_menu_items(items)
+      items.each_with_index do |item, _index|
+        key = item[0]
+        config = item[1]
 
-  def mode
-    ::Bcome::System::Local.instance.in_console_session? ? 'Console' : 'Terminal'
-  end
+        next if !::Bcome::System::Local.instance.in_console_session? && config[:console_only]
 
-  def item_spacing(item)
-    "\s" * (menu_item_spacing_length - item.length)
-  end
+        puts tab_spacing + key.to_s.resource_key + item_spacing(key) + (config[:description]).to_s.resource_value
+        if config[:usage] || config[:terminal_usage]
+          usage_string = if ::Bcome::System::Local.instance.in_console_session?
+                           config[:usage]
+                         else
+                           "bcome #{keyed_namespace.empty? ? '' : "#{keyed_namespace}:"}#{config[:terminal_usage]}"
+                         end
+          puts tab_spacing + ("\s" * menu_item_spacing_length) + 'usage: '.instructional + usage_string
+        end
+        puts "\n"
+      end
+    end
 
-  def menu_item_spacing_length
-    16
-  end
+    def mode
+      ::Bcome::System::Local.instance.in_console_session? ? 'Console' : 'Terminal'
+    end
 
-  def tab_spacing
-    "\s" * 3
-  end
+    def item_spacing(item)
+      "\s" * (menu_item_spacing_length - item.length)
+    end
 
-  def menu_items
-    {
-      ls: {
-        description: 'list all available resources',
-        console_only: false
-      },
-      lsa: {
-        description: 'list all active resources',
-        console_only: true
-      },
-      workon: {
-        description: 'work on specific resources only, inactivating all others from this selection',
-        usage: 'workon identifier1, identifier2 ...',
-        console_only: true
-      },
-      disable: {
-        description: 'remove a resource from this selection',
-        usage: 'disable identifier1, identifier2 ...',
-        console_only: true
-      },
-      enable: {
-        description: 're-enable a resource within this selection',
-        usage: 'enable identifier1, identifier2 ...',
-        console_only: true
-      },
-      enable!: {
-        description: 'enable all resources within this selection',
-        console_only: true
-      },
-      disable!: {
-        description: 'disable all resources within this selection',
-        console_only: true
-      },
-      run: {
-        description: 'execute a command to be run over ssh against all active resources',
-        usage: "run 'command1', 'command2', ...",
-        console_only: false,
-        terminal_usage: "run 'command1' 'command2' ..."
-      },
-      interactive: {
-        description: 'enter an interactive command session for all active resources',
-        console_only: false
-      },
-      tree: {
-        description: 'print a tree view for all resources and their sub-resources',
-        console_only: false
-      },
-      ping: {
-        description: 'ping all resources to test connectivity',
-        console_only: false
-      },
-      put: {
-        description: 'upload a file or directory using scp',
-        usage: "put 'local/path','remote/path'",
-        console_only: false,
-        terminal_usage: "put 'local/path' 'remote/path'"
-      },
-      put_str: {
-        description: 'Write a file /to/remote/path from a string',
-        usage: 'put_str',
-        console_only: false,
-        terminal_usage: "put_str '<file contents>', 'remote/path'"
-      },
-      rsync: {
-        description: 'upload a file or directory using rsync (faster)',
-        usage: "rsync 'local/path','remote/path'",
-        console_only: false,
-        terminal_usage: "rsync 'local/path' 'remote/path'"
-      },
-      get: {
-        description: 'download a file',
-        usage: "get 'remote/path', 'local/path'",
-        console_only: false,
-        terminal_usage: "get 'remote/path' 'local/path"
-      },
-      cd: {
-        description: 'enter the namespace for a resource from this selection',
-        usage: 'cd identifier',
-        console_only: true
-      },
-      save: {
-        description: 'Save the current tree state',
-        console_only: true
-      },
-      meta: {
-        description: 'Print out all metadata related to this node'
-      },
-      pack_metadata: {
-        description: 'Encrypt your metadata files',
-      },
-      unpack_metadata: {
-        description: 'Decrypt and expose your encrypted metadata files',
-      },
-      registry: {
-        description: 'List all user defined commands present in your registry, and available to this namespace',
-        console_only: false
-      },
-      execute_script: {
-        description: 'execute a bash script',
-        console_only: false,
-        usage: 'execute_script "script_name"',
-        terminal_usage: 'execute_script script_name'
+    def menu_item_spacing_length
+      16
+    end
+
+    def tab_spacing
+      "\s" * 3
+    end
+
+    def menu_group_names
+      {
+        ssh: 'Ssh',
+        informational: 'Informational',
+        selection: 'Selections',
+        file: 'File & Script',
+        navigation: 'Navigational',
+        miscellany: 'Miscellaneous',
+        command_list: 'Command lists'
       }
-    }
+    end
+
+    def menu_items
+      {
+        routes: {
+          description: 'Print SSH routing tree',
+          console_only: false,
+          group: :informational
+        },
+        ls: {
+          description: 'list all available namespaces',
+          console_only: false,
+          group: :informational
+        },
+        lsa: {
+          description: 'list all active namespaces',
+          console_only: true,
+          group: :informational
+        },
+        workon: {
+          description: 'work on specific namespaces only, inactivating all others from this selection',
+          usage: 'workon identifier1, identifier2 ...',
+          console_only: true,
+          group: :selection
+        },
+        disable: {
+          description: 'remove a namespace from this selection',
+          usage: 'disable identifier1, identifier2 ...',
+          console_only: true,
+          group: :selection
+        },
+        enable: {
+          description: 're-enable a namespace within this selection',
+          usage: 'enable identifier1, identifier2 ...',
+          console_only: true,
+          group: :selection
+        },
+        enable!: {
+          description: 'enable all namespaces within this selection',
+          console_only: true,
+          group: :selection
+        },
+        disable!: {
+          description: 'disable all namespaces within this selection',
+          console_only: true,
+          group: :selection
+        },
+        run: {
+          description: 'execute a command to be run over ssh against all active namespaces',
+          usage: "run 'command1', 'command2', ...",
+          console_only: false,
+          terminal_usage: "run 'command1' 'command2' ...",
+          group: :ssh
+        },
+        interactive: {
+          description: 'enter an interactive command session for all active namespaces',
+          console_only: false,
+          group: :ssh
+        },
+        tree: {
+          description: 'print a tree view for all namespaces and their sub-namespaces',
+          console_only: false,
+          group: :informational
+        },
+        ping: {
+          description: 'ping all namespaces to test connectivity',
+          console_only: false,
+          group: :ssh
+        },
+        put: {
+          description: 'upload a file or directory using scp',
+          usage: "put 'local/path','remote/path'",
+          console_only: false,
+          terminal_usage: "put 'local/path' 'remote/path'",
+          group: :file
+        },
+        put_str: {
+          description: 'Write a file /to/remote/path from a string',
+          usage: 'put_str "string" "remote/path"',
+          console_only: false,
+          terminal_usage: "put_str '<file contents>', 'remote/path'",
+          group: :file
+        },
+        rsync: {
+          description: 'upload a file or directory using rsync (faster)',
+          usage: "rsync 'local/path','remote/path'",
+          console_only: false,
+          terminal_usage: "rsync 'local/path' 'remote/path'",
+          group: :file
+        },
+        cd: {
+          description: 'enter a console session for a child namespace from this selection',
+          usage: 'cd identifier',
+          console_only: true,
+          group: :navigation
+        },
+        quit: {
+          description: 'Quit out of bcome',
+          usage: 'quit',
+          console_only: true,
+          group: :navigation
+        },
+        back: {
+          description: 'Go back up a namespace, or quit',
+          usage: 'back',
+          console_only: true,
+          group: :navigation
+        },
+        meta: {
+          description: 'Print out all metadata related to this node',
+          group: :informational
+        },
+        registry: {
+          description: 'List all user defined commands present in your registry, and available to this namespace',
+          console_only: false,
+          group: :command_list
+        },
+        menu: {
+          description: 'List all available commands',
+          console_only: false,
+          group: :command_list
+        },
+        execute_script: {
+          description: 'execute a bash script',
+          console_only: false,
+          usage: 'execute_script "script_name"',
+          terminal_usage: 'execute_script script_name',
+          group: :ssh
+        }
+      }
+    end
   end
 end

data/lib/objects/node/attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Node::Attributes
   ## -- Attributes --
 
@@ -5,12 +7,8 @@ module Bcome::Node::Attributes
     @identifier
   end
 
-  def description
-    @description
-  end
-
-  def type
-    @type
+  def ssh_driver=(alternative_ssh_driver)
+    @ssh_driver = alternative_ssh_driver
   end
 
   def ssh_driver
@@ -18,28 +16,28 @@ module Bcome::Node::Attributes
   end
 
   def ssh_data
-    instance_var_name = '@ssh_settings'
-    recurse_hash_data_for_instance_var(instance_var_name, :ssh_data)
+    recurse_hash_data_for_instance_key(:ssh_settings, :ssh_data)
   end
 
-  def network_driver
-    return nil if !network_data || (network_data.is_a?(Hash) && network_data.empty?)
-    @network_driver ||= ::Bcome::Driver::Bucket.instance.driver_for_network_data(network_data)
-    @network_driver
+  def network_data
+    recurse_hash_data_for_instance_key(:network, :network_data)
   end
 
+  # From 2.0.0 onwards, filters can be loaded from the network block only. The older key, 'ec2_filters'
+  #  is retained at this level for backwards compatibility.
   def filters
-    instance_var_name = '@ec2_filters'
-    recurse_hash_data_for_instance_var(instance_var_name, :filters)
+    recurse_hash_data_for_instance_key(:ec2_filters, :filters)
   end
 
-  def network_data
-    instance_var_name = '@network'
-    recurse_hash_data_for_instance_var(instance_var_name, :network_data)
+  def network_driver
+    return nil if !network_data || (network_data.is_a?(Hash) && network_data.empty?)
+
+    @network_driver ||= ::Bcome::Driver::Bucket.instance.driver_for_network_data(network_data, self)
+    @network_driver
   end
 
-  def recurse_hash_data_for_instance_var(instance_var_name, parent_key)
-    instance_data = instance_variable_defined?(instance_var_name) ? instance_variable_get(instance_var_name) : {}
+  def recurse_hash_data_for_instance_key(instance_key, parent_key)
+    instance_data = respond_to?(instance_key) ? send(instance_key) : {}
     instance_data ||= {}
     instance_data = parent.send(parent_key).deep_merge(instance_data) if has_parent?
     instance_data

data/lib/objects/node/base.rb

@@ -1,24 +1,32 @@
+# frozen_string_literal: true
+
 module Bcome::Node
   class Base
-
     include Bcome::Context
     include Bcome::WorkspaceCommands
     include Bcome::Node::Attributes
     include Bcome::WorkspaceMenu
     include Bcome::Node::LocalMetaDataFactory
     include Bcome::Node::RegistryManagement
- 
-    DEFAULT_IDENTIFIER = "bcome"
+    include Bcome::Tree
+
+    def inspect
+      "<##{self.class}: #{namespace} @network_driver=#{network_driver}>"
+    end
 
     def self.const_missing(constant)
       ## Hook for direct access to node level resources by constant name where
       ## cd ServerName should yield the same outcome as cd "ServerName"
-      set_context  = ::IRB.CurrentContext.workspace.main
-      return (set_context.resource_for_identifier(constant.to_s)) ? constant.to_s : super
+      set_context = ::IRB.CurrentContext.workspace.main
+      set_context.resource_for_identifier(constant.to_s) ? constant.to_s : super
     end
 
     attr_reader :params
 
+    DEFAULT_IDENTIFIER = 'bcome'
+
+    include Bcome::LoadingBar::Handler
+
     def initialize(params)
       @params = params
       @identifier = nil
@@ -27,14 +35,34 @@ module Bcome::Node
       @parent = params[:parent]
       @type = params[:type]
       @metadata = {}
+      @nodes_loaded = false
 
       set_view_attributes if @views
       validate_attributes
+
+      @original_identifier = @identifier
+
       ::Bcome::Registry::Loader.instance.set_command_group_for_node(self)
     end
 
-    def bootstrap?
-      false
+    attr_reader :parent
+
+    attr_reader :views
+
+    def method_missing(method_sym, *arguments)
+      raise Bcome::Exception::Generic, "undefined method '#{method_sym}' for #{self.class}" unless method_is_available_on_node?(method_sym)
+
+      if resource_identifiers.include?(method_sym.to_s)
+        method_sym.to_s
+      elsif command = user_command_wrapper.command_for_console_command_name(method_sym)
+        command.execute(self, arguments)
+      else
+        raise NameError, "Missing method #{method_sym} for #{self.class}"
+      end
+    end
+
+    def ssh_connect(params = {})
+      ::Bcome::Ssh::Connector.connect(self, params)
     end
 
     def collection?
@@ -50,48 +78,61 @@ module Bcome::Node
     end
 
     def enabled_menu_items
-      [:ls, :lsa, :workon, :enable, :disable, :enable!, :disable!, :run, :tree, :ping, :put, :put_str, :rsync, :cd, :meta, :pack_metadata, :unpack_metadata, :registry, :interactive, :execute_script] 
+      %i[ls lsa workon enable disable enable! disable! run tree ping put put_str rsync cd meta registry interactive execute_script]
     end
 
     def has_proxy?
       ssh_driver.has_proxy?
     end
 
-    def identifier=(new_identifier)
-      @identifier = new_identifier
-    end
+    attr_writer :identifier
 
     def proxy
       ssh_driver.proxy
     end
-   
-    # TODO - why not do these in parallel?
+
+    def proxy_chain
+      ssh_driver.proxy_chain
+    end
+
+    def proxy_chain_link
+      @proxy_chain_link ||= ::Bcome::Ssh::ProxyChainLink.new(self)
+    end
+
+    def scoped_resources
+      # Active & not hidden
+      resources.active.reject(&:hide?)
+    end
+
     def scp(local_path, remote_path)
-      resources.active.each do |resource|
+      scoped_resources.each do |resource|
         resource.put(local_path, remote_path)
       end
-      return
+      nil
     end
 
     def rsync(local_path, remote_path)
-      resources.active.each do |resource|
+      scoped_resources.each do |resource|
         resource.rsync(local_path, remote_path)
-      end   
-      return
+      end
+      nil
     end
 
-    def put(local_path, remote_path)
-      resources.active.each do |resource|
-        resource.put(local_path, remote_path)
+    def put(local_path, remote_path, connect = true)
+      ssh_connect if connect # Initiate connect at highest namespace level
+
+      scoped_resources.each do |resource|
+        resource.put(local_path, remote_path, false)
       end
-      return
+      nil
     end
 
-    def put_str(string, remote_path)
-      resources.active.each do |resource|
-        resource.put_str(string, remote_path)
+    def put_str(string, remote_path, connect = true)
+      ssh_connect if connect # Initiate connect at highest namespace level
+      scoped_resources.pmap do |resource|
+        resource.put_str(string, remote_path, false)
       end
-      return
+      nil
     end
 
     def execute_script(script_name)
@@ -103,30 +144,28 @@ module Bcome::Node
       results
     end
 
-    def pack_metadata
-      ::Bcome::Encryptor.instance.pack
+    def hide?
+      return true if @views.key?(:hidden) && @views[:hidden]
+
+      false
     end
 
-    def unpack_metadata
-      ::Bcome::Encryptor.instance.unpack
-    end 
- 
     def validate_attributes
-      validate_identifier 
-      raise ::Bcome::Exception::MissingDescriptionOnView.new(@views.inspect) if requires_description? && !@description
-      raise ::Bcome::Exception::MissingTypeOnView.new(@views.inspect) if requires_type? && !@type
+      validate_identifier
+      raise ::Bcome::Exception::MissingDescriptionOnView, views.inspect if requires_description? && !defined?(:description)
+      raise ::Bcome::Exception::MissingTypeOnView, views.inspect if requires_type? && !defined?(:type)
     end
 
     def validate_identifier
-      @identifier = DEFAULT_IDENTIFIER if is_top_level_node? && !@identifier && !is_a?(::Bcome::Node::Server::Base)
+      @identifier = DEFAULT_IDENTIFIER.dup if is_top_level_node? && !@identifier && !is_a?(::Bcome::Node::Server::Base)
 
-      @identifier = "NO-ID_#{Time.now.to_i}" unless @identifier
+      @identifier ||= "NO-ID_#{Time.now.to_i}".dup
 
-      #raise ::Bcome::Exception::MissingIdentifierOnView.new(@views.inspect) unless @identifier
-      @identifier.gsub!(/\s/, "_") # Remove whitespace 
-      @identifier.gsub!("-", "_") # change hyphens to undescores, hyphens don't play well in var names in irb
+      # raise ::Bcome::Exception::MissingIdentifierOnView.new(@views.inspect) unless @identifier
+      @identifier.gsub!(/\s/, '_') # Remove whitespace
+      @identifier.gsub!('-', '_') # change hyphens to undescores, hyphens don't play well in var names in irb
 
-      #raise ::Bcome::Exception::InvalidIdentifier.new("'#{@identifier}' contains whitespace") if @identifier =~ /\s/
+      # raise ::Bcome::Exception::InvalidIdentifier.new("'#{@identifier}' contains whitespace") if @identifier =~ /\s/
     end
 
     def requires_description?
@@ -142,9 +181,15 @@ module Bcome::Node
     end
 
     def nodes_loaded?
-      resources.any?
+      # resources.any? # This was buggy:  an inventory may validly contain no resources. This does not mean that we haven't attempted to load them
+      # we no explicitly set a flag for when we've loaded nodes. This will prevents uneccessary lookups over the wire
+      @nodes_loaded
+    end
+
+    def nodes_loaded!
+      @nodes_loaded = true
     end
-   
+
     def resources
       @resources ||= ::Bcome::Node::Resources::Base.new
     end
@@ -155,16 +200,16 @@ module Bcome::Node
 
     def invoke(method_name, arguments = [])
       if method_is_available_on_node?(method_name)
-        if respond_to?(method_name)        
+        if respond_to?(method_name)
           # Invoke a method on node that's defined by the system
           begin
-            if arguments && arguments.any?
+            if arguments&.any?
               send(method_name, *arguments)
             else
               send(method_name)
             end
           rescue ArgumentError => e
-            raise ::Bcome::Exception::ArgumentErrorInvokingMethodFromCommmandLine.new method_name + "error message - #{e.message}"
+            raise ::Bcome::Exception::ArgumentErrorInvokingMethodFromCommmandLine, method_name + " error message - #{e.message}"
           end
         else
           # Invoke a user defined (registry) method
@@ -173,7 +218,7 @@ module Bcome::Node
         end
       else
         # Final crumb is neither a node level context nor an executable method on the penultimate node level context
-        raise ::Bcome::Exception::InvalidBreadcrumb.new("Method '#{method_name}' is not available on bcome node of type #{self.class}, at namespace #{namespace}")
+        raise ::Bcome::Exception::InvalidBreadcrumb, "Method '#{method_name}' is not available on bcome node of type #{self.class}, at namespace #{namespace}"
       end
     end
 
@@ -183,20 +228,24 @@ module Bcome::Node
 
     def recurse_resource_for_identifier(identifier)
       resource = resource_for_identifier(identifier)
-      return resource ? resource : (has_parent? ? parent.recurse_resource_for_identifier(identifier) : nil)
+      resource || (has_parent? ? parent.recurse_resource_for_identifier(identifier) : nil)
     end
 
     def prompt_breadcrumb
-      "#{has_parent? ? "#{parent.prompt_breadcrumb}> " : "" }#{ is_current_context? ? (has_parent? ? identifier.terminal_prompt : identifier) : identifier}" 
+      "#{has_parent? ? "#{parent.prompt_breadcrumb}> " : ''}#{if current_context?
+                                                                has_parent? ? identifier.terminal_prompt : identifier
+                                                              else
+                                                                identifier
+                                                              end}"
     end
 
     def namespace
-      "#{ parent ? "#{parent.namespace}:" : "" }#{identifier}"
+      "#{parent ? "#{parent.namespace}:" : ''}#{identifier}"
     end
 
     def keyed_namespace
-      splits = namespace.split(":") ; 
-      splits[1..splits.size].join(":")
+      splits = namespace.split(':')
+      splits[1..splits.size].join(':')
     end
 
     def has_parent?
@@ -205,10 +254,10 @@ module Bcome::Node
 
     def is_top_level_node?
       !has_parent?
-    end 
+    end
 
     def list_attributes
-      { 
+      {
         "Identifier": :identifier,
         "Description": :description,
         "Type": :type
@@ -216,58 +265,71 @@ module Bcome::Node
     end
 
     def close_ssh_connections
-      machines.pmap do |machine|
-        machine.close_ssh_connection
-      end
-      return
-    end
-
-    def open_ssh_connections
-      machines.pmap do |machine|
-        machine.open_ssh_connection unless machine.has_ssh_connection?
+      # For every loaded server, we'll close any lingering ssh connection
+      if @resources&.any?
+        resources.pmap do |resource|
+          if resource.is_a?(::Bcome::Node::Server::Base)
+            resource.close_ssh_connection
+          else
+            resource.close_ssh_connections
+          end
+        end
       end
-      return
+      nil
     end
 
     def execute_local(command)
-      puts "(local) > #{command}"
+      puts "(local) > #{command}" unless ::Bcome::Orchestrator.instance.command_output_silenced?
       system(command)
+      puts ''
     end
 
     def data_print_from_hash(data, heading)
       puts "\n#{heading.title}"
-      puts ""
+      puts ''
 
       if data.keys.any?
         data.each do |key, value|
           puts "#{key.to_s.resource_key}: #{value.to_s.informational}"
         end
       else
-        puts "No values found".warning
+        puts 'No values found'.warning
       end
-      puts ""
+      puts ''
     end
 
     private
 
+    def singleton_class
+      class << self
+        self
+      end
+    end
+
     def set_view_attributes
-      @views.keys.each do |view_attribute_key|
+      @identifier = @views[:identifier]
+
+      @views.keys.sort.each do |view_attribute_key|
         next if view_attributes_to_skip_on_setup.include?(view_attribute_key)
-        instance_variable_set("@#{view_attribute_key}", @views[view_attribute_key])
+
+        next if view_attribute_key == :identifier
+
+        singleton_class.class_eval do
+          define_method(view_attribute_key) do
+            @views[view_attribute_key]
+          end
+        end
       end
     end
 
     def view_attributes_to_skip_on_setup
-      [:views] 
+      [:views]
     end
 
-    private
-
     def to_ary
       # due to my method_missing implementation, the following is required.
       # with thanks to https://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary.html & http://yehudakatz.com/2010/01/02/the-craziest-fing-bug-ive-ever-seen/
       nil
     end
-
   end
 end