bcome 0.7.0 → 1.0.0

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

@@ -0,0 +1,88 @@
+module Bcome::Node::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]
+    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)
+      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}'"
+      end
+    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

@@ -0,0 +1,112 @@
+module Bcome::Node::Inventory
+  class Defined < ::Bcome::Node::Inventory::Base
+    MACHINES_CACHE_PATH = 'machines-cache.yml'.freeze
+
+    def self.to_s
+      'inventory'
+    end
+
+    attr_reader :dynamic_nodes_loaded
+
+    def initialize(*params)
+      @load_machines_from_cache = false
+      @cache_handler = ::Bcome::Node::CacheHandler.new(self)
+      super
+    end
+
+    def enabled_menu_items
+      super + %i[save reload]
+    end
+
+    def menu_items
+      base_items = super.dup
+
+      base_items[:reload] = {
+        description: "Restock this inventory from remote (hit 'save' after to persist)",
+        console_only: true
+      }
+      base_items
+    end
+
+    def reload
+      do_reload
+      puts "\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)
+        end
+      end
+    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 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 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] ? ")
+
+      if @answer && @answer == 'Y'
+        cache_nodes_in_memory
+        data = load_machines_config
+        data[namespace] = views[:static_servers]
+
+        File.open(machines_cache_path, 'w') do |file|
+          file.write data.to_yaml
+        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 cache_nodes_in_memory
+      @cache_handler.do_cache_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_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
+    end
+
+    def fetch_server_list
+      return [] unless network_driver
+      network_driver.fetch_server_list(filters)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Bcome::Node::Inventory
+  class Subselect < ::Bcome::Node::Inventory::Base
+    def initialize(*params)
+      super
+      raise Bcome::Exception::MissingSubselectionKey, @views unless @views[:subselect_from]
+      update_nodes
+    end
+
+    def resources
+      @resources ||= do_set_resources
+    end
+
+    def update_nodes
+      resources.update_nodes(self)
+    end
+
+    def do_set_resources
+      ::Bcome::Node::Resources::SubselectInventory.new(parent_inventory: parent_inventory, filters: filters)
+    end
+
+    def nodes_loaded?
+      true
+    end
+
+    def filters
+      # Flex point for filters, as obviously we need to support more than just ec2 filtering eventually
+      @views[:filters] ? @views[:filters] : {}
+    end
+
+    def self.to_s
+      'sub-inventory'
+    end
+
+    def do_reload
+      parent_inventory.do_reload
+      resources.run_subselect
+      update_nodes
+    end
+
+    private
+
+    def parent_inventory
+      @parent_inventory ||= load_parent_inventory
+    end
+
+    def load_parent_inventory
+      parent_crumb = @views[:subselect_from]
+      parent = ::Bcome::Node::Factory.instance.bucket[parent_crumb]
+      raise Bcome::Exception::CannotFindSubselectionParent, "for key '#{parent_crumb}'" unless parent
+      raise Bcome::Exception::CanOnlySubselectOnInventory, "breadcrumb'#{parent_crumb}' represents a #{parent.class}'" unless parent.inventory?
+      parent
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Bcome::Node::Meta
+  class Base
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    def has_key_and_value?(matchers)
+      matchers[:values] = [matchers[:values]] if matchers[:values] && !matchers[:values].is_a?(Array)
+
+      raise Bcome::Exception::InvalidMatcherQuery unless matchers[:key] && matchers[:values].is_a?(Array)
+      key = matchers[:key].to_sym
+      values = matchers[:values]
+      @data.key?(key) && values.include?(@data[key])
+    end
+
+    def dump
+      @data.each do |k, v|
+        puts "#{k} => #{v.resource_value}"
+      end
+    end
+
+    def all
+      @data
+    end
+
+    def fetch(key)
+      if @data.key?(key)
+        @data[key]
+      else
+        raise Bcome::Exception::CantFindKeyInMetadata, key unless @data.key?(key)
+      end
+    end
+  end
+end

data/lib/objects/node/meta/cloud.rb

@@ -0,0 +1,4 @@
+module Bcome::Node::Meta
+  class Cloud < Bcome::Node::Meta::Base
+  end
+end

data/lib/objects/node/meta/local.rb

@@ -0,0 +1,4 @@
+module Bcome::Node::Meta
+  class Local < Bcome::Node::Meta::Base
+  end
+end

data/lib/objects/node/meta_data_factory.rb

@@ -0,0 +1,23 @@
+module Bcome::Node::LocalMetaDataFactory
+  META_DATA_FILE_PATH_PREFIX = 'bcome/metadata'.freeze
+
+  def metadata
+    @node_metadata ||= do_create_metadata
+  end
+
+  def do_create_metadata
+    ::Bcome::Node::Meta::Local.new(raw_metadata)
+  end
+
+  def meta
+    data_print_from_hash(raw_metadata, 'Metadata')
+  end
+
+  def raw_metadata
+    has_parent? ? parent.raw_metadata.merge(metadata_for_namespace) : metadata_for_namespace
+  end
+
+  def metadata_for_namespace
+    ::Bcome::Node::MetaDataLoader.instance.data_for_namespace(namespace)
+  end
+end

data/lib/objects/node/meta_data_loader.rb

@@ -0,0 +1,32 @@
+module Bcome::Node
+  class MetaDataLoader
+    include ::Singleton
+
+    META_DATA_FILE_PATH_PREFIX = 'bcome/metadata'.freeze
+
+    def initialize
+      @all_metadata_filenames = Dir["#{META_DATA_FILE_PATH_PREFIX}/*"]
+    end
+
+    def data
+      @data ||= do_load
+    end
+
+    def data_for_namespace(namespace)
+      data[namespace.to_sym] ? data[namespace.to_sym] : {}
+    end
+
+    def do_load
+      all_meta_data = {}
+      @all_metadata_filenames.each do |filename|
+        begin
+          filedata = YAML.load_file(filename)
+          all_meta_data.deep_merge!(filedata)
+        rescue Psych::SyntaxError => e
+          raise Bcome::Exception::InvalidMetaDataConfig, "Error: #{e.message}"
+        end
+      end
+      all_meta_data
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Bcome::Node::Resources
+  class Base
+    include Enumerable
+
+    attr_reader :nodes
+
+    def initialize(*_params)
+      @nodes = []
+      @disabled_resources = []
+    end
+
+    def each
+      @nodes.each { |node| yield(node) }
+    end
+
+    def <<(node)
+      existing_node = for_identifier(node.identifier)
+      if existing_node
+        exception_message = "#{node.identifier} is not unique within namespace #{node.parent.namespace}"
+        raise Bcome::Exception::NodeIdentifiersMustBeUnique, exception_message
+      end
+      @nodes << node
+    end
+
+    def clear!
+      @disabled_resources = []
+    end
+    alias enable! clear!
+
+    def do_disable(identifier)
+      if identifier.is_a?(Array)
+        identifier.each { |id| disable(id) }
+      else
+        disable(identifier)
+      end
+      nil
+    end
+
+    def do_enable(identifier)
+      if identifier.is_a?(Array)
+        identifier.each { |id| enable(id) }
+      else
+        enable(identifier)
+      end
+      nil
+    end
+
+    def disable!
+      @disabled_resources = @nodes
+    end
+
+    def disable(identifier)
+      resource = for_identifier(identifier)
+      raise Bcome::Exception::NoNodeNamedByIdentifier, identifier unless resource
+      @disabled_resources << resource unless @disabled_resources.include?(resource)
+    end
+
+    def enable(identifier)
+      resource = for_identifier(identifier)
+      raise Bcome::Exception::NoNodeNamedByIdentifier, identifier unless resource
+      @disabled_resources -= [resource]
+    end
+
+    def clear!
+      @disabled_resources = []
+      nil
+    end
+
+    def active
+      @nodes - @disabled_resources
+    end
+
+    def is_active_resource?(resource)
+      active.include?(resource)
+    end
+
+    def for_identifier(identifier)
+      resource = @nodes.select { |node| node.identifier == identifier }.first
+      resource
+    end
+
+    def empty?
+      @nodes.empty?
+    end
+
+    def has_active_nodes?
+      active.any?
+    end
+
+    def size
+      @nodes.size
+    end
+
+    def first
+      @nodes.first
+    end
+  end
+end