bcome 0.7.0 → 1.0.0

data/lib/objects/progress_bar.rb

@@ -0,0 +1,30 @@
+module Bcome
+  class ProgressBar
+    include Singleton
+
+    attr_reader :count
+
+    def initialize
+      @count = 0
+    end
+
+    def increment!
+      @count += 1
+    end
+
+    def reset!
+      @count = 0
+    end
+
+    def indicate(config, in_progress)
+      prefix = in_progress ? config[:prefix].progress : config[:prefix].progress
+      bar = prefix + "#{config[:indice] * @count}>" + " (#{@count} #{config[:indice_descriptor]})".progress + "\r"
+      print bar
+    end
+
+    def indicate_and_increment!(config, in_progress)
+      increment!
+      indicate(config, in_progress)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Bcome::Registry::Arguments
+  class Base
+    attr_reader :arguments, :defaults, :processed_arguments, :merged_arguments
+
+    class << self
+      def process(arguments, defaults)
+        processor = new(arguments, defaults)
+        processor.do_process
+      end
+    end
+
+    def initialize(_arguments, defaults)
+      @defaults = defaults ? defaults : {}
+      validate
+    end
+
+    def do_process
+      merge_arguments_with_defaults
+      @merged_arguments
+    end
+
+    private
+
+    def merge_arguments_with_defaults
+      @merged_arguments = @defaults.symbolize_keys.merge(arguments_to_merge.symbolize_keys)
+    end
+
+    def arguments_to_merge
+      @arguments
+    end
+
+    def validate
+      raise Bcome::Exception::InvalidRegistryArgumentType, 'invalid default registry argument format' unless @defaults.is_a?(Hash)
+    end
+  end
+end

data/lib/objects/registry/arguments/command_line.rb

@@ -0,0 +1,35 @@
+module Bcome::Registry::Arguments
+  class CommandLine < Base
+    def initialize(arguments, defaults)
+      @arguments = arguments ? arguments : []
+      @processed_arguments = {}
+      super
+    end
+
+    def do_process
+      parse_arguments
+      super
+    end
+
+    def arguments_to_merge
+      @processed_arguments
+    end
+
+    private
+
+    def parse_arguments
+      @arguments.each do |argument|
+        argument =~ /^(.+)=(.+)$/
+        raise Bcome::Exception::MalformedCommandLineArguments, argument unless Regexp.last_match(1) || Regexp.last_match(2)
+        key = Regexp.last_match(1).to_sym; value = Regexp.last_match(2)
+        raise Bcome::Exception::DuplicateCommandLineArgumentKey, "'#{key}'" if @processed_arguments.key?(key)
+        @processed_arguments[key] = value
+      end
+    end
+
+    def validate
+      raise Bcome::Exception::InvalidRegistryArgumentType, 'invalid argument format' unless @arguments.is_a?(Array)
+      super
+    end
+  end
+end

data/lib/objects/registry/arguments/console.rb

@@ -0,0 +1,15 @@
+module Bcome::Registry::Arguments
+  class Console < Base
+    def initialize(arguments, defaults)
+      @arguments = arguments ? arguments : {}
+      super
+    end
+
+    private
+
+    def validate
+      raise Bcome::Exception::InvalidRegistryArgumentType, 'invalid argument format' unless @arguments.is_a?(Hash)
+      super
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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
+
+      def is_valid_type?(type)
+        valid_types.keys.include?(type.to_sym)
+      end
+
+      def valid_types
+        {
+          external: ::Bcome::Registry::Command::External,
+          internal: ::Bcome::Registry::Command::Internal
+        }
+      end
+    end
+
+    def initialize(data)
+      @data = data
+      @data[:defaults] = {} unless @data[:defaults]
+      validate
+    end
+
+    def defaults
+      @data[:defaults]
+    end
+
+    def process_arguments(arguments)
+      merged_arguments = {}
+
+      if [Array, Hash].include?(arguments.class)
+        processor_klass = arguments.is_a?(Array) ? ::Bcome::Registry::Arguments::CommandLine : ::Bcome::Registry::Arguments::Console
+        merged_arguments = processor_klass.process(arguments, defaults)
+      elsif defaults
+        merged_arguments = defaults
+      end
+      merged_arguments
+    end
+
+    def execute(*_params)
+      raise 'Should be overriden'
+    end
+
+    def expected_keys
+      %i[console_command group description]
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      @data.key?(method_sym) ? @data[method_sym] : super
+    end
+
+    def validate
+      expected_keys.each do |key|
+        validation_error "#{@data.inspect} is missing key #{key}" unless @data.key?(key)
+      end
+    end
+
+    def validation_error(message)
+      raise Bcome::Exception::InvalidContextCommand, message
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Bcome::Registry::Command
+  class External < Base
+    # In which the bcome context is passed to an external call
+
+    def execute(node, arguments)
+      full_command = construct_full_command(node, arguments)
+      begin
+        puts "\n(external) > #{full_command}".bc_blue + "\n\n"
+        system(full_command)
+      rescue Interrupt
+        puts "\nExiting gracefully from interrupt\n".warning
+      end
+    end
+
+    def construct_full_command(node, arguments)
+      substituted_command = construct_substituted_command(arguments)
+      namespaced_command = namespace_command(node, substituted_command)
+      namespaced_command
+    end
+
+    def construct_substituted_command(arguments)
+      substituted_command = local_command.dup
+      merged_arguments = process_arguments(arguments)
+
+      local_command_substitutions.each do |substitution|
+        substitute_with = merged_arguments[substitution.to_sym]
+        unless substitute_with
+          error_message_suffix = "- missing '#{substitution}' from command '#{local_command}'"
+          raise Bcome::Exception::MissingArgumentForRegistryCommand, error_message_suffix
+        end
+
+        substituted_command.gsub!("%#{substitution}%", substitute_with)
+      end
+      substituted_command
+    end
+
+    def namespace_command(node, command)
+      "#{command} bcome_context=\"#{node.keyed_namespace}\""
+    end
+
+    def local_command_substitutions
+      local_command.scan(/%([^%]*)%/).flatten.uniq
+    end
+
+    def expected_keys
+      super + [:local_command]
+    end
+
+    def do_pretty_print
+      menu_str = super + "\n\s\s\s\slocal command:\s".resource_key + local_command.resource_value
+      menu_str += "\n\s\s\s\sdefaults:\s".resource_key + defaults.inspect.resource_value
+      menu_str + "\n\n"
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Bcome::Registry::Command
+  class Group
+    def initialize(node)
+      @all_commands = {}
+      @node = node
+    end
+
+    attr_reader :all_commands
+
+    def <<(command)
+      all_commands[command.group] ? (all_commands[command.group] << command) : (all_commands[command.group] = [command])
+    end
+
+    def has_commands?
+      all_commands.keys.any?
+    end
+
+    def console_method_name_exists?(proposed_name)
+      user_registered_console_command_names.include?(proposed_name)
+    end
+
+    def user_registered_console_command_names
+      user_registered_console_commands.collect(&:console_command)
+    end
+
+    def user_registered_console_commands
+      all_commands.collect { |_group, commands| commands }.flatten
+    end
+
+    def command_for_console_command_name(command_name)
+      user_registered_console_commands.select { |command| command.console_command.to_sym == command_name }.first
+    end
+
+    def item_spacing(item)
+      "\s" * (menu_item_spacing_length - item.length)
+    end
+
+    def menu_item_spacing_length
+      16
+    end
+
+    def tab_spacing
+      "\s" * 3
+    end
+
+    def in_console_session?
+      ::Bcome::System::Local.instance.in_console_session?
+    end
+
+    def pretty_print ## TODO - revisit. This is a mess
+      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"
+        commands.each do |command|
+          command_key = command.console_command
+          description = command.description
+          defaults = command.defaults
+
+          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}"
+          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")
+            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
+          puts "\n"
+        end
+        puts "\n"
+      end
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Bcome::Registry::Command
+  class Internal < Base
+    # In which the bcome context is an external (extended framework) call
+
+    def execute(node, arguments)
+      merged_arguments = process_arguments(arguments)
+      orchestrator = orch_klass.new(node, merged_arguments)
+      orchestrator.do_execute
+    rescue Interrupt
+      puts "\nExiting gracefully from interrupt\n".warning
+    end
+
+    def validate(*params)
+      super
+    end
+
+    def orch_klass
+      @orch_klass ||= do_constantize_orch_klass
+    end
+
+    def do_constantize_orch_klass
+      klass_name = "Bcome::Orchestration::#{@data[:orch_klass]}"
+      begin
+        klass_name.constantize
+      rescue NameError
+        raise Bcome::Exception::CannotFindInternalRegistryKlass, "'#{@data[:console_command]}'. #{klass_name} does not exist. Make sure you've created this class inside your orchestration folder in bcome/orchestration"
+      end
+    end
+
+    def expected_keys
+      super + [:orch_klass]
+    end
+  end
+end

data/lib/objects/registry/command_list.rb

@@ -0,0 +1,33 @@
+module Bcome::Registry
+  class CommandList
+    include Singleton
+
+    attr_reader :list
+
+    def initialize
+      @list = {}
+      @groups_for_nodes = {}
+    end
+
+    def add_group_for_node(node, group)
+      @groups_for_nodes[node.keyed_namespace] = group
+    end
+
+    def group_for_node(node)
+      @groups_for_nodes[node.keyed_namespace]
+    end
+
+    def register(node, command_name)
+      @list[node.keyed_namespace] ? (@list[node.keyed_namespace] << command_name) : (@list[node.keyed_namespace] = [command_name])
+    end
+
+    def command_in_list?(node, command_name)
+      @list.key?(node.keyed_namespace) && @list[node.keyed_namespace].include?(command_name.to_sym)
+    end
+
+    def teardown!
+      @groups_for_nodes = {}
+      @list = {}
+    end
+  end
+end

data/lib/objects/registry/loader.rb

@@ -0,0 +1,70 @@
+module Bcome::Registry
+  class Loader
+    include ::Singleton
+
+    FILE_PATH = 'bcome/registry.yml'.freeze
+
+    def data
+      @data ||= do_load
+    end
+
+    def set_command_group_for_node(node)
+      if group_for_node = ::Bcome::Registry::CommandList.instance.group_for_node(node)
+        return group_for_node
+      end
+
+      command_group = init_new_command_group(node)
+
+      data.each do |key, commands|
+        begin
+          if /^#{key.to_s}$/.match(node.keyed_namespace)
+            commands.each do |c|
+              # 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
+              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
+          end
+        rescue RegexpError => e
+          raise Bcome::Exception::InvalidRegexpMatcherInRegistry, e.message
+        end
+      end
+      ::Bcome::Registry::CommandList.instance.add_group_for_node(node, command_group)
+    end
+
+    def init_new_command_group(node)
+      ::Bcome::Registry::Command::Group.new(node)
+    end
+
+    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
+
+      !node.is_a?(node_klass_mapping)
+    end
+
+    def restriction_to_node_klass_mappings
+      {
+        server: ::Bcome::Node::Server::Base,
+        inventory: ::Bcome::Node::Inventory,
+        collection: ::Bcome::Node::Collection
+      }
+    end
+
+    def do_load
+      return {} unless File.exist?(FILE_PATH)
+      begin
+        file_data = YAML.load_file(FILE_PATH).deep_symbolize_keys
+      rescue Psych::SyntaxError => e
+        raise Bcome::Exception::InvalidRegistryDataConfig, "Error: #{e.message}"
+      end
+      file_data
+    end
+  end
+end