bcome 1.3.4 → 2.0.1

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Node::Resources
   class Base
     include Enumerable
@@ -23,7 +25,7 @@ module Bcome::Node::Resources
     end
 
     def should_rename_initial_duplicate?
-      return false
+      false
     end
 
     def clear!
@@ -56,12 +58,14 @@ module Bcome::Node::Resources
     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
 

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

@@ -1,6 +1,27 @@
+# frozen_string_literal: true
+
 module Bcome::Node::Resources
   class Inventory < Bcome::Node::Resources::Base
+    def initialize(inventory)
+      @inventory = inventory
+      super
+    end
+
+    def set_overrides(inventory, node)
+      override_server_identifier(inventory, node)
+      node.set_network_configuration_overrides
+    end
+
+    def override_server_identifier(inventory, node)
+      if inventory.override_server_identifier?
+        node.identifier =~ /#{inventory.override_identifier}/
+        node.update_identifier(Regexp.last_match(1)) if Regexp.last_match(1)
+      end
+    end
+
     def <<(node)
+      set_overrides(@inventory, node)
+
       if existing_node = for_identifier(node.identifier)
         if existing_node.static_server? && node.dynamic_server?
           # We've got a duplicate, but we'll treat the remote node as authoritative
@@ -16,14 +37,14 @@ module Bcome::Node::Resources
     end
 
     def should_rename_initial_duplicate?
-      return true
-    end    
+      true
+    end
 
     def rename_initial_duplicate
-      duplicate_nodes.each do |node_identifier, count|
+      duplicate_nodes.each do |node_identifier, _count|
         node = for_identifier(node_identifier)
         node.identifier = "#{node.identifier}_1"
-      end 
+      end
     end
 
     def duplicate_nodes
@@ -32,7 +53,7 @@ module Bcome::Node::Resources
 
     def reset_duplicate_nodes!
       @duplicate_nodes = {}
-    end   
+    end
 
     def dynamic_nodes
       active.select(&:dynamic_server?)

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bcome::Node::Resources
+  class Merged < Bcome::Node::Resources::Inventory
+    def initialize(config)
+      super
+      @inventory = config[:inventory]
+      @nodes = []
+      run_select
+    end
+
+    def run_select
+      @inventory.contributing_inventories.each do |inventory|
+        raise ::Bcome::Exception::Generic, "#{inventory.namespace} is not an inventory, and cannot be merged." unless inventory.is_a?(::Bcome::Node::Inventory::Base)
+
+        inventory.load_nodes unless inventory.nodes_loaded?
+      end
+
+      contributing_nodes = @inventory.contributing_inventories.collect { |inv| inv.resources.nodes }.flatten
+      dup_nodes(contributing_nodes)
+
+      @nodes
+    end
+
+    def dup_nodes(contributing_nodes)
+      contributing_nodes.each do |original_node|
+        # Duplicate the node, setting its origin inventory to this one, and
+        # resetting its ssh_driver to the original node's driver.
+        new_node = original_node.dup_with_new_parent(@inventory)
+        set_overrides(@inventory, new_node)
+        new_node.ssh_driver = original_node.ssh_driver
+
+        # Rename the node as contributing inventories may provide duplicate node names
+        rename_node_for_merged_inventory(original_node, new_node)
+
+        # Register the new node with the registry
+        ::Bcome::Registry::Loader.instance.set_command_group_for_node(new_node)
+
+        @nodes << new_node
+      end
+    end
+
+    def rename_node_for_merged_inventory(original_node, new_node)
+      new_node.identifier = original_node.namespace.gsub(':', '_')
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bcome::Node::Resources
   class SubselectInventory < Bcome::Node::Resources::Inventory
     def initialize(config)
@@ -10,8 +12,9 @@ module Bcome::Node::Resources
       parent_inventory.load_nodes unless parent_inventory.nodes_loaded?
       new_set = parent_inventory.resources.nodes
 
-      # Filter by ec2_filters
-      new_set = filter_by_tags(new_set)
+      # ...by_tags: ec2
+      # ...by_label: gcp
+      new_set = filter_by_tags_or_label(new_set)
 
       @nodes = new_set
     end
@@ -21,10 +24,7 @@ module Bcome::Node::Resources
 
       @nodes.collect do |node|
         new_node = node.dup_with_new_parent(inventory)
-        if inventory.override_server_identifier?
-          new_node.identifier =~ /#{inventory.override_identifier}/
-          new_node.update_identifier(Regexp.last_match(1)) if Regexp.last_match(1)
-        end
+        set_overrides(inventory, new_node)
 
         # Register the new node with the registry
         ::Bcome::Registry::Loader.instance.set_command_group_for_node(new_node)
@@ -34,7 +34,7 @@ module Bcome::Node::Resources
       @nodes = new_set
     end
 
-    def filter_by_tags(nodes)
+    def filter_by_tags_or_label(nodes)
       tag_filters.each do |key, values|
         nodes = nodes.select { |node| node.has_tagged_value?(key, values) }
       end
@@ -50,11 +50,15 @@ module Bcome::Node::Resources
     end
 
     def tag_filters
-      filters[:by_tag] ? filters[:by_tag] : {}
+      filters[:by_tag] || filters[:by_label] || filters
     end
 
     def parent_inventory
       @config[:parent_inventory]
     end
+
+    def origin_inventory
+      @config[:origin_inventory]
+    end
   end
 end

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

@@ -1,55 +1,67 @@
+# frozen_string_literal: true
 module Bcome::Node::Server
   class Base < Bcome::Node::Base
-    
     attr_reader :origin_object_id
 
     def initialize(*params)
       super
       # Set the object_id - sub inventories dup servers into new collections. This allows us to spot duplicates when interacting with collections
       @origin_object_id = object_id
-      @bootstrap = false
     end
 
-    # override a server namespace's parameters. This enables features such as specific SSH parameters for a specific server, e.g. my use case was a 
-    # single debian box within an ubuntu network, where I needed to access the machine bootstrapping mode with the 'admin' rather 'ubuntu' username.
+    def is_same_machine?(other)
+      origin_object_id == other.origin_object_id
+    end
+
+    def host
+      raise 'Should be overidden'
+    end
+
     def set_view_attributes
       super
+    end
+
+    # Override a server's namespace parameters. Enabled features such as specific SSH config for a particular server, i.e. overidding that of it's parent
+    #  inventory namespace.
+    def set_network_configuration_overrides
       overridden_attributes = ::Bcome::Node::Factory.instance.machines_data_for_namespace(namespace.to_sym)
       overridden_attributes.each do |override_key, override_value|
-        instance_variable_name = "@#{override_key}"
-        instance_variable_set(instance_variable_name, override_value)   
+        singleton_class.class_eval do
+          define_method(override_key) do
+            override_value
+          end
+        end
       end
     end
 
-    def bootstrap?
-      @bootstrap ? true : false
-    end  
-
-    def toggle_bootstrap(set_to = (@bootstrap ? false : true))
-      @bootstrap = set_to
-      puts "Bootstrap #{bootstrap? ? "on" : "off" } for #{namespace}".informational
+    def local_network?
+      defined?(local_network) && local_network
     end
 
     def dup_with_new_parent(new_parent)
-      new_node = self.clone
+      new_node = clone
       new_node.update_parent(new_parent)
       new_node
-    end  
+    end
 
     def update_parent(new_parent)
       @parent = new_parent
     end
 
     def tags
-      data_print_from_hash(cloud_tags.data, "Tags")
+      data_print_from_hash(cloud_tags.data, 'Tags')
     end
-  
+
+    def tags_h
+      cloud_tags.data
+    end
+
     def cloud_tags
       @generated_tags ||= do_generate_cloud_tags
     end
 
     def has_tagged_value?(key, values)
-      matchers = { :key => key, :values => values }
+      matchers = { key: key, values: values }
       cloud_tags.has_key_and_value?(matchers)
     end
 
@@ -58,11 +70,11 @@ module Bcome::Node::Server
     end
 
     def do_generate_cloud_tags
-      raise "Should be overidden"
+      raise 'Should be overidden'
     end
 
     def type
-      "server"
+      'server'
     end
 
     def machines
@@ -82,28 +94,39 @@ module Bcome::Node::Server
     end
 
     def enabled_menu_items
-      (super + [:get, :ssh, :tags, :pseudo_tty]) - [:enable, :disable, :enable!, :disable!]
+      (super + %i[get ssh tags pseudo_tty tunnel]) - %i[workon enable disable enable! disable!]
     end
 
     def menu_items
       base_items = super.dup
       base_items[:tags] = {
-        description: "print out remote EC2 tags"
+        description: 'print out server tags/labels',
+        group: :informational
       }
       base_items[:ssh] = {
-        description: "initiate an ssh connection to this server",
+        description: 'initiate an ssh connection to this server',
+        group: :ssh
       }
       base_items[:get] = {
-        description: "Download a file or directory",
+        description: 'Download a file or directory',
         console_only: false,
-        usage: "get \"/remote/path\", \"/local/path\"",
-        terminal_usage: "get \"/remote/path\" \"/local/path\""
+        usage: 'get "/remote/path", "/local/path"',
+        terminal_usage: 'get "/remote/path" "/local/path"',
+        group: :file
       }
       base_items[:pseudo_tty] = {
-        description: "Invoke a pseudo-tty session",
+        description: 'Invoke a pseudo-tty session',
         console_only: false,
-        usage: "pseudo_tty \"your command\"",
-        terminal_usage: "pseudo_tty \"your command\""
+        usage: 'pseudo_tty "your command"',
+        terminal_usage: 'pseudo_tty "your command"',
+        group: :ssh
+      }
+      base_items[:tunnel] = {
+        description: 'Create a Tunnel over SSH',
+        console_only: false,
+        usage: 'tunnel(local_port, destination_port)',
+        terminal_usage: 'tunnel local_port destination_port',
+        group: :ssh
       }
 
       base_items
@@ -112,9 +135,16 @@ module Bcome::Node::Server
     def local_port_forward(start_port, end_port)
       ssh_driver.local_port_forward(start_port, end_port)
     end
+    alias tunnel local_port_forward
+
+    def reopen_ssh_connection
+      puts "Connecting\s".informational + identifier
+      close_ssh_connection
+      open_ssh_connection
+    end
 
-    def open_ssh_connection
-      ssh_driver.ssh_connection  
+    def open_ssh_connection(ping = false)
+      ssh_driver.ssh_connection(ping)
     end
 
     def close_ssh_connection
@@ -128,7 +158,7 @@ module Bcome::Node::Server
     def has_no_ssh_connection?
       !has_ssh_connection?
     end
- 
+
     def ssh
       ssh_driver.do_ssh
     end
@@ -142,18 +172,18 @@ module Bcome::Node::Server
 
     def execute_script(script_name)
       command_result = ::Bcome::Ssh::ScriptExec.execute(self, script_name)
-      return command_result
+      command_result
     end
 
     def rsync(local_path, remote_path)
       ssh_driver.rsync(local_path, remote_path)
     end
-  
-    def put(local_path, remote_path)
+
+    def put(local_path, remote_path, *_params)
       ssh_driver.put(local_path, remote_path)
     end
 
-    def put_str(string, remote_path)
+    def put_str(string, remote_path, *_params)
       ssh_driver.put_str(string, remote_path)
     end
 
@@ -165,7 +195,7 @@ module Bcome::Node::Server
       puts "\n" + visual_hierarchy.hierarchy + "\n"
       puts pretty_description
     end
-    alias :lsa :ls
+    alias lsa ls
 
     def ping
       ping_result = ssh_driver.ping
@@ -173,68 +203,74 @@ module Bcome::Node::Server
     end
 
     def print_ping_result(ping_result = { success: true })
-      result = {
-        namespace => {
-          "connection" => ping_result[:success] ? "success" : "failed",
-          "ssh_config" => ssh_driver.pretty_config_details
-        }
-      }
+      result_string = ping_result[:success] ? 'success'.success : 'failed'.error
 
-      unless ping_result[:success]
-        result[namespace]["error"] = ping_result[:error].message
-      end
+      pretty_ping_result = "\n#{namespace.bc_cyan}:\s#{result_string.bold}\n"
+      pretty_ping_result += "Error:\s".bc_cyan + "#{ping_result[:error].message.bc_red}\n" if !ping_result[:success] && ping_result[:error]
+      # pretty_ping_result += ping_result[:backtrace] if ping_result[:backtrace]
+      pretty_ping_result += "config:\s".bc_cyan + JSON.pretty_generate(ssh_driver.pretty_ssh_config)
+      puts pretty_ping_result
+    end
 
-      colour = ping_result[:success] ? :green : :red
-
-      ap result, {
-        :color => {
-           hash:  colour,
-           symbol: colour,
-           string: colour,
-           keyword: colour,
-           variable: colour,
-           array: colour
-        }
-      }
+    def add_list_attributes(attrs)
+      @attribs = list_attributes.merge(attrs)
+    end
+
+    def origin_namespace
+      parent.namespace
     end
 
     def list_attributes
+      @attribs ||= set_list_attributes
+    end
+
+    def set_list_attributes
       attribs = {
         "identifier": :identifier,
         "internal ip": :internal_ip_address,
         "public ip": :public_ip_address,
+        "host": :host
       }
 
-      attribs.merge!("description": :description ) if has_description?
       attribs
     end
 
     def cache_data
-      d = { identifier: identifier }
+      d = { identifier: @original_identifier }
       d[:internal_ip_address] = internal_ip_address if internal_ip_address
       d[:public_ip_address] = public_ip_address if public_ip_address
       d[:description] = description if description
-      d[:cloud_tags] = cloud_tags 
+      d[:cloud_tags] = cloud_tags
       d
     end
 
     def do_run(raw_commands)
       raw_commands = raw_commands.is_a?(String) ? [raw_commands] : raw_commands
-      commands = raw_commands.collect{|raw_command| ::Bcome::Ssh::Command.new({ :node => self, :raw => raw_command }) }
+      commands = raw_commands.collect { |raw_command| ::Bcome::Ssh::Command.new(node: self, raw: raw_command) }
       command_exec = ::Bcome::Ssh::CommandExec.new(commands)
       command_exec.execute!
-      commands.each {|c| c.unset_node }
-      return commands
+      commands.each(&:unset_node)
+      commands
     end
 
     def run(*raw_commands)
-      raise ::Bcome::Exception::MethodInvocationRequiresParameter.new "Please specify commands when invoking 'run'" if raw_commands.empty?
-      commands = do_run(raw_commands)
-      commands
+      raise ::Bcome::Exception::MethodInvocationRequiresParameter, "Please specify commands when invoking 'run'" if raw_commands.empty?
+
+      do_run(raw_commands)
+    rescue IOError, Errno::EBADF
+      reopen_ssh_connection
+      do_run(raw_commands)
+    rescue Exception => e
+      if e.message == 'Unexpected spurious read wakeup'
+        reopen_ssh_connection
+        do_run(raw_commands)
+      else
+        raise e
+      end
     end
 
     def has_description?
-      !@description.nil?
+      !description.nil?
     end
 
     def static_server?
@@ -244,6 +280,5 @@ module Bcome::Node::Server
     def dynamic_server?
       !static_server?
     end
-
-  end  
+  end
 end