bcome 1.3.4 → 2.0.1

data/lib/objects/node/cache_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Node
   class CacheHandler
     def initialize(inventory_node)
@@ -11,7 +13,7 @@ module Bcome::Node
     end
 
     def write_to_in_memory_cache!(nodes)
-      @inventory_node.views[:load_machines_from_cache] = true
+      # @inventory_node.views[:load_machines_from_cache] = true
       static_server_data = dynamic_nodes_to_cache_hash(nodes)
       @inventory_node.views[:static_servers] = static_server_data
       nil

data/lib/objects/node/collection.rb

@@ -1,9 +1,7 @@
+# frozen_string_literal: true
+
 module Bcome::Node
   class Collection < ::Bcome::Node::Base
-    def self.to_s
-      'collection'
-    end
-
     def inventories
       inv = []
       @resources.active.each do |r|
@@ -28,20 +26,23 @@ module Bcome::Node
       filtered_set
     end
 
-    def machines
+    def machines(skip_for_hidden = true)
       set = []
-      @resources.active.each do |resource|
+
+      resources = skip_for_hidden ? @resources.active.reject(&:hide?) : @resources.active
+
+      resources.each do |resource|
         if resource.inventory?
           resource.load_nodes unless resource.nodes_loaded?
           set << resource.resources.active
         else
-          set << resource.machines
+          set << resource.machines(skip_for_hidden)
         end
       end
 
       set.flatten!
-
-      filter_duplicates(set)
+      filtered_machines = filter_duplicates(set)
+      filtered_machines
     end
 
     def collection?

data/lib/objects/node/factory.rb

@@ -1,30 +1,36 @@
+# frozen_string_literal: true
+
 module Bcome::Node
   class Factory
     include Singleton
 
     attr_reader :estate
 
-    CONFIG_PATH = 'bcome'.freeze
-    DEFAULT_CONFIG_NAME = 'networks.yml'.freeze
-    SERVER_OVERRIDE_CONFIG_NAME = 'machines-data.yml'.freeze
-    LOCAL_OVERRIDE_CONFIG_NAME = 'me.yml'.freeze
+    CONFIG_PATH = 'bcome'
+    DEFAULT_CONFIG_NAME = 'networks.yml'
+    SERVER_OVERRIDE_CONFIG_NAME = 'server-overrides.yml'
+    LOCAL_OVERRIDE_CONFIG_NAME = 'me.yml'
+
+    INVENTORY_KEY = 'inventory'
+    COLLECTION_KEY = 'collection'
+    SUBSELECT_KEY = 'inventory-subselect'
+    MERGE_KEY = 'inventory-merge'
+    KUBE_CLUSTER = 'kube-cluster'
 
-    INVENTORY_KEY = 'inventory'.freeze
-    COLLECTION_KEY = 'collection'.freeze
-    SUBSELECT_KEY = 'inventory-subselect'.freeze
-    BCOME_RC_FILENAME = '.bcomerc'.freeze
+    BCOME_RC_FILENAME = '.bcomerc'
 
     def bucket
       @bucket ||= {}
     end
 
     def init_tree
+      raise ::Bcome::Exception::EmptyNamespaceTree, "no namespaces found in #{config_path}.\n\nPlease refer to the documentation for assistance at https://docs.bcome.com." if estate_config.nil?
       @estate = create_node(estate_config)
       @estate
     end
 
     def config_path
-      "#{CONFIG_PATH}/#{config_file_name}"
+      ENV['CONF'] || "#{CONFIG_PATH}/#{config_file_name}"
     end
 
     def machines_data_path
@@ -32,7 +38,7 @@ module Bcome::Node
     end
 
     def config_file_name
-      @config_file_name ||= ENV['CONF'] ? ENV['CONF'] : DEFAULT_CONFIG_NAME
+      @config_file_name || DEFAULT_CONFIG_NAME
     end
 
     def create_tree(context_node, views)
@@ -50,36 +56,39 @@ module Bcome::Node
     end
 
     def create_node(config, parent = nil)
-      raise Bcome::Exception::InvalidNetworkConfig, 'missing config type' unless config[:type]
+      raise Bcome::Exception::InvalidNetworkConfig, "missing config type for config #{config}" unless config[:type]
 
       klass = klass_for_view_type[config[:type]]
- 
+
       raise Bcome::Exception::InvalidNetworkConfig, "invalid config type #{config[:type]}" unless klass
 
       node = klass.new(views: config, parent: parent)
-      create_tree(node, config[:views]) if config[:views] && config[:views].any?
+      create_tree(node, config[:views]) if config[:views]&.any?
       parent.resources << node if parent
 
+      # Load inventory resources as early as possible
+      if node.is_a?(Bcome::Node::Inventory::Base)
+        node.load_nodes unless node.nodes_loaded?
+      end
+
       bucket[node.keyed_namespace] = node
 
       node
     end
 
     def validate_view(breadcrumb, data)
-      unless data && data[:type]
-        raise Bcome::Exception::InvalidNetworkConfig, "Missing namespace type for for namespace '#{breadcrumb}'"
-      end
+      raise Bcome::Exception::InvalidNetworkConfig, "Missing namespace type for namespace '#{breadcrumb}'" unless data && data[:type]
 
-      unless is_valid_view_type?(data[:type])
-        raise Bcome::Exception::InvalidNetworkConfig, "Invalid View Type '#{data[:type]}' for namespace '#{breadcrumb}'. Expecting View Type to be one of: #{klass_for_view_type.keys.join(', ')}"
-      end
+      raise Bcome::Exception::InvalidNetworkConfig, "Invalid View Type '#{data[:type]}' for namespace '#{breadcrumb}'. Expecting View Type to be one of: #{klass_for_view_type.keys.join(', ')}" unless is_valid_view_type?(data[:type])
     end
 
     def klass_for_view_type
       {
         COLLECTION_KEY => ::Bcome::Node::Collection,
         INVENTORY_KEY => ::Bcome::Node::Inventory::Defined,
-        SUBSELECT_KEY => ::Bcome::Node::Inventory::Subselect
+        SUBSELECT_KEY => ::Bcome::Node::Inventory::Subselect,
+        MERGE_KEY => ::Bcome::Node::Inventory::Merge,
+        KUBE_CLUSTER => ::Bcome::Node::Kube::Estate
       }
     end
 
@@ -96,53 +105,55 @@ module Bcome::Node
     end
 
     def machines_data_for_namespace(namespace)
-      machines_data[namespace] ? machines_data[namespace] : {}
-    end
-
-    def rewrite_estate_config(data)
-      File.open(config_path, 'w') do |file|
-        file.write data.to_yaml
-      end
+      machines_data[namespace] || {}
     end
 
     def load_estate_config
       config = YAML.load_file(config_path).deep_symbolize_keys
-      return config
+      config.deep_merge(local_data)
     rescue ArgumentError, Psych::SyntaxError => e
       raise Bcome::Exception::InvalidNetworkConfig, 'Invalid yaml in network config' + e.message
     rescue Errno::ENOENT
       raise Bcome::Exception::DeprecationWarning if is_running_deprecated_configs?
+
       raise Bcome::Exception::MissingNetworkConfig, config_path
     end
 
     def load_machines_data
-      return {} unless File.exist?(machines_data_path)    
+      return {} unless File.exist?(machines_data_path)
+
       config = YAML.load_file(machines_data_path).deep_symbolize_keys
-      return config
+      config
     rescue ArgumentError, Psych::SyntaxError => e
       raise Bcome::Exception::InvalidNetworkConfig, 'Invalid yaml in machines data config' + e.message
     end
 
     def local_data
       @local_data ||= load_local_data
-    end  
+    end
 
     def local_data_path
-      "#{CONFIG_PATH}/#{LOCAL_OVERRIDE_CONFIG_NAME}"
+      ENV['ME'] || "#{CONFIG_PATH}/#{LOCAL_OVERRIDE_CONFIG_NAME}"
     end
 
     def load_local_data
       return {} unless File.exist?(local_data_path)
-      config = YAML.load_file(local_data_path) 
+
+      begin
+        config = YAML.load_file(local_data_path).deep_symbolize_keys
+      rescue StandardError => e
+        raise ::Bcome::Exception::Generic, "Error parsing configuration file #{local_data_path}"
+      end
+
       return {} if config.nil?
-      return config
+
+      config
     rescue ArgumentError, Psych::SyntaxError => e
       raise Bcome::Exception::InvalidNetworkConfig, 'Invalid yaml in machines data config' + e.message
     end
 
     def is_running_deprecated_configs?
-      File.exist?("bcome/config/platform.yml")
+      File.exist?('bcome/config/platform.yml')
     end
-
   end
 end

data/lib/objects/node/inventory/base.rb

@@ -1,104 +1,110 @@
-module Bcome::Node::Inventory
-  class Base < ::Bcome::Node::Base
-
-    def initialize(*params)
-      super
-      raise Bcome::Exception::InventoriesCannotHaveSubViews, @views if @views[:views] && !@views[:views].empty?
-
-      @bootstrap = false
-    end
-
-    def meta_matches(matchers)
-      data_wrapper = :metadata
-      matches_for(data_wrapper, matchers)
-    end
-
-    def cloud_matches(matchers)
-      data_wrapper = :cloud_tags
-      matches_for(data_wrapper, matchers)
-    end
-
-    def machine_by_identifier(identifier)
-      resources.active.select { |machine| machine.identifier == identifier }.first
-    end
-
-    def matches_for(data_wrapper, matchers)
-      resources.active.select do |machine|
-        machine.send(data_wrapper).has_key_and_value?(matchers)
-      end
-    end
-
-    def toggle_bootstrap(set_to = (@bootstrap ? false : true))
-      resources.active.each do |machine|
-        machine.toggle_bootstrap(set_to)
-      end
-      @bootstrap = (@bootstrap ? false : true)
-      return
-    end
-     
-    def enabled_menu_items
-      super + %i[ssh]
-    end
-
-    def menu_items
-      base_items = super.dup
-      base_items[:ssh] = {
-        description: 'ssh directly into a resource',
-        usage: 'ssh identifier',
-        console_only: true
-      }
-
-      base_items
-    end
-
-    def resources
-      @resources ||= ::Bcome::Node::Resources::Inventory.new
-    end
-
-    def ssh(identifier = nil)
-      direct_invoke_server(:ssh, identifier)
-    end
-
-    def tags(identifier = nil)
-      identifier.nil? ? direct_invoke_all_servers(:tags) : direct_invoke_server(:tags, identifier)
-    end
-
-    def direct_invoke_server(method, identifier)
-      unless identifier
-        puts "\nPlease provide a machine identifier, e.g. #{method} machinename\n".warning unless identifier
-        return
-      end
-
-      if resource = resources.for_identifier(identifier)
-        resource.send(method)
-      else
-        raise Bcome::Exception::InvalidBreadcrumb, "Cannot find a node named '#{identifier}'"
+# frozen_string_literal: true
+
+module Bcome
+  module Node
+    module Inventory
+      class Base < ::Bcome::Node::Base
+        def initialize(*params)
+          super
+          raise Bcome::Exception::InventoriesCannotHaveSubViews, @views if @views[:views] && !@views[:views].empty?
+        end
+
+        def meta_matches(matchers)
+          data_wrapper = :metadata
+          matches_for(data_wrapper, matchers)
+        end
+
+        def cloud_matches(matchers)
+          data_wrapper = :cloud_tags
+          matches_for(data_wrapper, matchers)
+        end
+
+        def machine_by_identifier(identifier)
+          resources.active.select { |machine| machine.identifier == identifier }.first
+        end
+
+        def matches_for(data_wrapper, matchers)
+          resources.active.select do |machine|
+            machine.send(data_wrapper).has_key_and_value?(matchers)
+          end
+        end
+
+        def enabled_menu_items
+          super + %i[ssh tags]
+        end
+
+        def menu_items
+          base_items = super.dup
+          base_items[:ssh] = {
+            description: 'ssh directly into a resource',
+            usage: 'ssh identifier',
+            console_only: true,
+            group: :ssh
+          }
+
+          base_items[:tags] = {
+            description: 'print out server tags/labels',
+            group: :informational
+          }
+
+          base_items
+        end
+
+        def resources
+          @resources ||= ::Bcome::Node::Resources::Inventory.new(self)
+        end
+
+        def ssh(identifier = nil)
+          direct_invoke_server(:ssh, identifier)
+        end
+
+        def tags(identifier = nil)
+          identifier.nil? ? direct_invoke_all_servers(:tags) : direct_invoke_server(:tags, identifier)
+        end
+
+        def direct_invoke_server(method, identifier)
+          # If we only have a single resource in our inventory, then just allow direct invocation
+          if resources.size == 1
+            resource = resources.first
+          else
+            # Otherwise, we expect to find the resource by its identifier
+            unless identifier
+              puts "\nPlease provide a machine identifier, e.g. #{method} machinename\n".warning unless identifier
+              return
+            end
+
+            resource = resources.for_identifier(identifier)
+            raise Bcome::Exception::InvalidBreadcrumb, "Cannot find a node named '#{identifier}'" unless resource
+          end
+
+          resource.send(method)
+        end
+
+        def direct_invoke_all_servers(method)
+          resources.active.each { |m| m.send(method) }
+          nil
+        end
+
+        def cache_nodes_in_memory
+          @cache_handler.do_cache_nodes!
+        end
+
+        def list_key
+          :server
+        end
+
+        def machines(skip_for_hidden = true)
+          skip_for_hidden ? resources.active : resources.active.reject(&:hide?)
+        end
+
+        def inventory?
+          true
+        end
+
+        def override_server_identifier?
+          respond_to?(:override_identifier) && !override_identifier.nil?
+        end
       end
     end
-
-    def direct_invoke_all_servers(method)
-      resources.active.each {|m| m.send(method) }
-      return
-    end
-
-    def cache_nodes_in_memory
-      @cache_handler.do_cache_nodes!
-    end
-
-    def list_key
-      :server
-    end
-
-    def machines
-      @resources.active
-    end
-
-    def inventory?
-      true
-    end
-
-    def override_server_identifier?
-      !@override_identifier.nil?
-    end
   end
 end

data/lib/objects/node/inventory/defined.rb

@@ -1,117 +1,141 @@
-module Bcome::Node::Inventory
-  class Defined < ::Bcome::Node::Inventory::Base
-    MACHINES_CACHE_PATH = 'machines-cache.yml'.freeze
+# frozen_string_literal: true
 
-    def self.to_s
-      'inventory'
-    end
+module Bcome
+  module Node
+    module Inventory
+      class Defined < ::Bcome::Node::Inventory::Base
+        include ::Bcome::LoadingBar::Handler
 
-    attr_reader :dynamic_nodes_loaded
+        MACHINES_CACHE_PATH = 'static-cache.yml'
 
-    def initialize(*params)
-      @load_machines_from_cache = false
-      @cache_handler = ::Bcome::Node::CacheHandler.new(self)
-      super
-    end
+        attr_reader :dynamic_nodes_loaded
 
-    def enabled_menu_items
-      super + %i[save reload]
-    end
+        def initialize(*params)
+          @load_machines_from_cache = false
+          @cache_handler = ::Bcome::Node::CacheHandler.new(self)
+          super
+        end
 
-    def menu_items
-      base_items = super.dup
+        def enabled_menu_items
+          super + %i[cache reload]
+        end
 
-      base_items[:reload] = {
-        description: "Restock this inventory from remote (hit 'save' after to persist)",
-        console_only: true
-      }
-      base_items
-    end
+        def menu_items
+          base_items = super.dup
+
+          base_items[:cache] = {
+            description: 'Cache the current tree state',
+            console_only: false,
+            group: :miscellany
+          }
+
+          base_items[:reload] = {
+            description: "Restock this inventory from remote (hit 'cache' after to persist)",
+            console_only: true,
+            group: :miscellany
+          }
+          base_items
+        end
 
-    def reload
-      resources.reset_duplicate_nodes!
-      do_reload
-      puts "\nDone. Hit 'ls' to see the refreshed inventory.\n".informational
-    end
+        def reload
+          resources.reset_duplicate_nodes!
+          do_reload
+          puts "\n\nDone. Hit 'ls' to see the refreshed inventory.\n".informational
+        end
 
-    def set_static_servers
-      if raw_static_machines_from_cache
-        raw_static_machines_from_cache.each do |server_config|
-          resources << ::Bcome::Node::Server::Static.new(views: server_config, parent: self)
+        def set_static_servers
+          cached_machines = raw_static_machines_from_cache
+
+          if cached_machines&.any?
+            print "\n"
+            title = 'Loading' + "\sCACHE".bc_orange.bold + "\s" + namespace.to_s.underline
+            wrap_indicator type: :basic, title: title, completed_title: '' do
+              cached_machines.each do |server_config|
+                resources << ::Bcome::Node::Server::Static.new(views: server_config, parent: self)
+              end
+              signal_success
+            end
+          end
         end
-      end
-    end
 
-    def raw_static_machines_from_cache
-      load_machines_config[namespace.to_sym]
-    end
+        def raw_static_machines_from_cache
+          load_machines_config[namespace.to_sym]
+        end
 
-    def machines_cache_path
-      "#{::Bcome::Node::Factory::CONFIG_PATH}/#{MACHINES_CACHE_PATH}"
-    end
+        def machines_cache_path
+          "#{::Bcome::Node::Factory::CONFIG_PATH}/#{MACHINES_CACHE_PATH}"
+        end
 
-    def mark_as_cached!
-      data = ::Bcome::Node::Factory.instance.load_estate_config
-      data[namespace.to_sym][:load_machines_from_cache] = true
-      ::Bcome::Node::Factory.instance.rewrite_estate_config(data)
-    end
+        def cache
+          @answer = ::Bcome::Interactive::Session.run(self,
+                                                      :capture_input, terminal_prompt: 'Are you sure you want to cache these machines (saving will overwrite any previous selections) [Y|N] ? ')
+
+          if @answer && @answer == 'Y'
+            cache_nodes_in_memory
+            data = load_machines_config
 
-    def save
-      @answer = ::Bcome::Interactive::Session.run(self,
-                                                  :capture_input, terminal_prompt: "\nAre you sure you want to cache these machines (saving will overwrite any previous selections) [Y|N] ? ")
+            data.delete(namespace)
+            data.delete(namespace.to_sym)
 
-      if @answer && @answer == 'Y'
-        cache_nodes_in_memory
-        data = load_machines_config
-        data[namespace] = views[:static_servers]
+            data[namespace] = views[:static_servers]
 
-        File.open(machines_cache_path, 'w') do |file|
-          file.write data.to_yaml
+            File.open(machines_cache_path, 'w') do |file|
+              file.write data.to_yaml
+            end
+            puts "\nMachines have been cached to #{machines_cache_path} for node #{namespace}".informational
+          else
+            puts 'Nothing saved'.warning
+          end
         end
-        mark_as_cached!
-        puts "Machines have been cached for node #{namespace}".informational
-      else
-        puts 'Nothing saved'.warning
-      end
-    end
 
-    def load_machines_config
-      config = YAML.load_file(machines_cache_path).deep_symbolize_keys
-      return config
-    rescue ArgumentError, Psych::SyntaxError
-      raise Bcome::Exception::InvalidMachinesCacheConfig, 'Invalid yaml in config'
-    rescue Errno::ENOENT
-      return {}
-    end
+        def load_machines_config
+          config = YAML.load_file(machines_cache_path).deep_symbolize_keys
+          config
+        rescue ArgumentError, Psych::SyntaxError
+          raise Bcome::Exception::InvalidMachinesCacheConfig, 'Invalid yaml in config'
+        rescue Errno::ENOENT
+          {}
+        end
 
-    def cache_nodes_in_memory
-      @cache_handler.do_cache_nodes!
-    end
+        def cache_nodes_in_memory
+          @cache_handler.do_cache_nodes!
+        end
 
-    def do_reload
-      resources.unset!
-      load_dynamic_nodes
-    end
+        def do_reload
+          resources.unset!
+          load_dynamic_nodes
+        end
 
-    def load_nodes
-      set_static_servers
-      load_dynamic_nodes unless @load_machines_from_cache
-    end
+        def load_nodes
+          set_static_servers
+          load_dynamic_nodes unless resources.any?
+          nodes_loaded!
+        end
 
-    def load_dynamic_nodes
-      raw_servers = fetch_server_list
+        def load_dynamic_nodes
+          raw_servers = fetch_server_list
 
-      raw_servers.each do |raw_server|
-        resources << ::Bcome::Node::Server::Dynamic.new_from_fog_instance(raw_server, self)
-      end
+          raw_servers ||= []
 
-      resources.rename_initial_duplicate if resources.should_rename_initial_duplicate?
+          raw_servers.each do |raw_server|
+            if raw_server.is_a?(Google::Apis::ComputeBeta::Instance)
+              resources << ::Bcome::Node::Server::Dynamic::Gcp.new_from_gcp_instance(raw_server, self)
+            elsif raw_server.is_a?(Fog::Compute::AWS::Server)
+              resources << ::Bcome::Node::Server::Dynamic::Ec2.new_from_fog_instance(raw_server, self)
+            else
+              raise Bcome::Exception::UnknownDynamicServerType, "Unknown dynamic server type #{raw_server.class}"
+            end
+          end
 
-    end
+          resources.rename_initial_duplicate if resources.should_rename_initial_duplicate?
+        end
+
+        def fetch_server_list
+          return [] unless network_driver
 
-    def fetch_server_list
-      return [] unless network_driver
-      network_driver.fetch_server_list(filters)
+          network_driver.fetch_server_list(filters)
+        end
+      end
     end
   end
 end