hybrid_platforms_conductor 32.3.6

data/lib/hybrid_platforms_conductor/topographer/plugin.rb

@@ -0,0 +1,20 @@
+module HybridPlatformsConductor
+
+  class Topographer
+
+    # Base class of any topographer plugin
+    class Plugin
+
+      # Constructor
+      #
+      # Parameters::
+      # * *topographer* (Topographer): Topographer instance containing the graph to be output
+      def initialize(topographer)
+        @topographer = topographer
+      end
+
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/topographer/plugins/graphviz.rb

@@ -0,0 +1,127 @@
+module HybridPlatformsConductor
+
+  class Topographer
+
+    module Plugins
+
+      # Output in Graphviz format
+      class Graphviz < Topographer::Plugin
+
+        # Output the nodes graph in a file
+        # [API] - This method is mandatory.
+        #
+        # Parameters::
+        # * *file_name* (String): The file name for output
+        def write_graph(file_name)
+          # GraphViz format does not support that nodes belong to more than 1 cluster.
+          @topographer.force_cluster_strict_hierarchy
+          # Write a Graphviz file
+          File.open(file_name, 'w') do |f|
+            f.puts 'digraph unix {
+              size="6,6";
+              node [style=filled];'
+            # First write the definition of all nodes
+            # Find all nodes belonging to no cluster
+            orphan_nodes = @topographer.nodes_graph.keys
+            @topographer.nodes_graph.each do |node_name, node_info|
+              orphan_nodes -= node_info[:includes]
+            end
+            orphan_nodes.sort.each do |node_name|
+              write_node_def_gv(f, node_name)
+            end
+            # Then write all connections
+            @topographer.nodes_graph.sort.each do |node_name, node_info|
+              node_info[:connections].each do |connected_node_name, labels|
+                link_label = labels.sort.join(', ')
+                link_label = "#{link_label[0..@topographer.config[:max_link_label_length] - 1]}..." if link_label.size > @topographer.config[:max_link_label_length]
+                link_options = {
+                  label: link_label
+                }
+                f.puts "  \"#{dot_name_for_link(node_name)}\" -> \"#{dot_name_for_link(connected_node_name)}\" [ #{link_options.map { |opt, val| "#{opt}=\"#{val}\"" }.join(' ') } ];"
+              end
+            end
+            f.puts '}'
+          end
+        end
+
+        private
+
+        # Write a node defintion in a GraphViz file
+        #
+        # Parameters::
+        # * *file* (IO): File to write to
+        # * *node_name* (String): Node to write
+        def write_node_def_gv(file, node_name)
+          description = @topographer.description_for(node_name)
+          dot_name = dot_name_for(node_name)
+          node_options = {
+            label: "#{@topographer.title_for(node_name)}#{description.nil? ? '' : "\\n#{description}"}",
+            color: color_for(node_name)
+          }
+          if @topographer.is_node_cluster?(node_name)
+            # A cluster node
+            file.puts "  subgraph \"#{dot_name}\" {\n#{node_options.map { |opt, val| "    #{opt}=\"#{val}\";\n" }.join}"
+            # Always define an anchor node per cluster, as it will serve for links to and from the cluster itself.
+            anchor_node_options = {
+              label: "#{@topographer.title_for(node_name)}#{description.nil? ? '' : "\\n#{description}"}",
+              color: 'green'
+            }
+            file.puts "    \"#{dot_name_for_link(node_name)}\" [ #{anchor_node_options.map { |opt, val| "#{opt}=\"#{val}\"" }.join(' ') } ];"
+            @topographer.nodes_graph[node_name][:includes].sort.each do |included_node_name|
+              write_node_def_gv(file, included_node_name)
+            end
+            file.puts '  }'
+          else
+            # A normal node
+            file.puts "  \"#{dot_name}\" [ #{node_options.map { |opt, val| "#{opt}=\"#{val}\"" }.join(' ') } ];"
+          end
+        end
+
+        # Get the node color of a given node
+        #
+        # Parameters::
+        # * *node_name* (String): Node name
+        # Result::
+        # * String: Color code
+        def color_for(node_name)
+          case @topographer.nodes_graph[node_name][:type]
+          when :node
+            if @topographer.is_node_physical?(node_name)
+              'lightpink'
+            else
+              'lightblue2'
+            end
+          when :cluster
+            'black'
+          when :unknown
+            'red'
+          end
+        end
+
+        # Get the DOT node name a given node
+        #
+        # Parameters::
+        # * *node_name* (String): Node name
+        # Result::
+        # * String: DOT node name
+        def dot_name_for(node_name)
+          @topographer.is_node_cluster?(node_name) ? "cluster_#{node_name}" : node_name
+        end
+
+        # Get the DOT node name used in a link for a given node
+        #
+        # Parameters::
+        # * *node_name* (String): Node name
+        # Result::
+        # * String: DOT node name used for links
+        def dot_name_for_link(node_name)
+          @topographer.is_node_cluster?(node_name) ? "cluster_#{node_name}_anchor" : node_name
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/topographer/plugins/json.rb

@@ -0,0 +1,72 @@
+require 'json'
+
+module HybridPlatformsConductor
+
+  class Topographer
+
+    module Plugins
+
+      # Output in Graphviz format
+      class Json < Topographer::Plugin
+
+        # Output the nodes graph in a file
+        # [API] - This method is mandatory.
+        #
+        # Parameters::
+        # * *file_name* (String): The file name for output
+        def write_graph(file_name)
+          # Build the JSON
+          json = {
+            nodes: [],
+            links: [],
+          }
+          @topographer.nodes_graph.sort.each do |node_name, node_info|
+            node_json = {
+              id: node_name,
+              description: "#{@topographer.title_for(node_name)} - #{@topographer.description_for(node_name)}",
+              group: group_for(node_name),
+            }
+            node_json[:includes] = node_info[:includes] if @topographer.is_node_cluster?(node_name)
+            json[:nodes] << node_json
+            node_info[:connections].each do |connected_node_name, labels|
+              json[:links] << {
+                source: node_name,
+                target: connected_node_name,
+                value: 1,
+                labels: labels.sort
+              }
+            end
+          end
+          File.write(file_name, JSON.pretty_generate(json))
+        end
+
+        private
+
+        # Get the group of a given node
+        #
+        # Parameters::
+        # * *node_name* (String): Node name
+        # Result::
+        # * String: Group
+        def group_for(node_name)
+          case @topographer.nodes_graph[node_name][:type]
+          when :node
+            if @topographer.is_node_physical?(node_name)
+              1
+            else
+              2
+            end
+          when :cluster
+            3
+          when :unknown
+            4
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/topographer/plugins/my_topographer_output_plugin.rb.sample

@@ -0,0 +1,37 @@
+# This file is an example of a generic Test plugin.
+# The MyTopographerOutputPlugin example contains example of code that could be used to write a plugin for new topographer output formats.
+module HybridPlatformsConductor
+
+  class Topographer
+
+    module Plugins
+
+      # Brief description of the plugin here.
+      # The name should match the file name.
+      # It should always inherit from Topographer::Plugin.
+      # In all instance methods of a test plugin, the following variables are accessible:
+      # * @topographer (Topographer): Topographer used to get info about the graph to render.
+      class MyTopographerOutputPlugin < Topographer::Plugin
+
+        # Output the nodes graph in a file
+        # [API] - This method is mandatory.
+        #
+        # Parameters::
+        # * *file_name* (String): The file name for output
+        def write_graph(file_name)
+          # This method is meant to dump into a file named file_name the graph in the plugin-specific format.
+          File.open(file_name, 'w') do |f|
+            f.puts 'Graph dump'
+            @topographer.nodes_graph.each do |node_name, node_info|
+              f.puts "#{node_name} is linked to #{node_info[:connections].map { |connected_node_name, _labels| connected_node_name }.join(', ')}"
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/topographer/plugins/svg.rb

@@ -0,0 +1,30 @@
+require "#{File.dirname(__FILE__)}/graphviz"
+
+module HybridPlatformsConductor
+
+  class Topographer
+
+    module Plugins
+
+      # Output in Graphviz format
+      class Svg < Topographer::Plugins::Graphviz
+
+        # Output the nodes graph in a file
+        # [API] - This method is mandatory.
+        #
+        # Parameters::
+        # * *file_name* (String): The file name for output
+        def write_graph(file_name)
+          gv_file_name = "#{file_name}.gv"
+          super(gv_file_name)
+          system "dot -Tsvg #{gv_file_name} -o #{file_name}"
+          File.unlink gv_file_name
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/version.rb

@@ -0,0 +1,5 @@
+module HybridPlatformsConductor
+
+  VERSION = '32.3.6'
+
+end

data/spec/hybrid_platforms_conductor_test.rb

@@ -0,0 +1,159 @@
+require 'fileutils'
+require 'tmpdir'
+require 'hybrid_platforms_conductor/config'
+require 'hybrid_platforms_conductor/platforms_handler'
+require 'hybrid_platforms_conductor/actions_executor'
+require 'hybrid_platforms_conductor/cmd_runner'
+require 'hybrid_platforms_conductor/deployer'
+require 'hybrid_platforms_conductor/nodes_handler'
+require 'hybrid_platforms_conductor/platform_handler'
+require 'hybrid_platforms_conductor/provisioner'
+require 'hybrid_platforms_conductor/report'
+require 'hybrid_platforms_conductor/reports_handler'
+require 'hybrid_platforms_conductor/test'
+require 'hybrid_platforms_conductor/test_report'
+require 'hybrid_platforms_conductor/tests_runner'
+require 'hybrid_platforms_conductor/hpc_plugins/cmdb/config'
+require 'hybrid_platforms_conductor/hpc_plugins/cmdb/host_ip'
+require 'hybrid_platforms_conductor/hpc_plugins/cmdb/host_keys'
+require 'hybrid_platforms_conductor/hpc_plugins/cmdb/platform_handlers'
+require 'hybrid_platforms_conductor_test/cmdb_plugins/test_cmdb'
+require 'hybrid_platforms_conductor_test/cmdb_plugins/test_cmdb2'
+require 'hybrid_platforms_conductor_test/cmdb_plugins/test_cmdb_others'
+require 'hybrid_platforms_conductor_test/cmdb_plugins/test_cmdb_others2'
+require 'hybrid_platforms_conductor_test/helpers/actions_executor_helpers'
+require 'hybrid_platforms_conductor_test/helpers/cmd_runner_helpers'
+require 'hybrid_platforms_conductor_test/helpers/cmdb_helpers'
+require 'hybrid_platforms_conductor_test/helpers/config_helpers'
+require 'hybrid_platforms_conductor_test/helpers/connector_ssh_helpers'
+require 'hybrid_platforms_conductor_test/helpers/deployer_helpers'
+require 'hybrid_platforms_conductor_test/helpers/deployer_test_helpers'
+require 'hybrid_platforms_conductor_test/helpers/executables_helpers'
+require 'hybrid_platforms_conductor_test/helpers/nodes_handler_helpers'
+require 'hybrid_platforms_conductor_test/helpers/platform_handler_helpers'
+require 'hybrid_platforms_conductor_test/helpers/platforms_handler_helpers'
+require 'hybrid_platforms_conductor_test/helpers/plugins_helpers'
+require 'hybrid_platforms_conductor_test/helpers/provisioner_proxmox_helpers'
+require 'hybrid_platforms_conductor_test/helpers/reports_handler_helpers'
+require 'hybrid_platforms_conductor_test/helpers/services_handler_helpers'
+require 'hybrid_platforms_conductor_test/helpers/tests_runner_helpers'
+require 'hybrid_platforms_conductor_test/platform_handler_plugins/test'
+require 'hybrid_platforms_conductor_test/platform_handler_plugins/test2'
+require 'hybrid_platforms_conductor_test/report_plugin'
+require 'hybrid_platforms_conductor_test/test_action'
+require 'hybrid_platforms_conductor_test/test_connector'
+require 'hybrid_platforms_conductor_test/test_plugins/global'
+require 'hybrid_platforms_conductor_test/test_plugins/node'
+require 'hybrid_platforms_conductor_test/test_plugins/node_check'
+require 'hybrid_platforms_conductor_test/test_plugins/node_ssh'
+require 'hybrid_platforms_conductor_test/test_plugins/platform'
+require 'hybrid_platforms_conductor_test/test_plugins/several_checks'
+require 'hybrid_platforms_conductor_test/test_provisioner'
+require 'hybrid_platforms_conductor_test/tests_report_plugin'
+
+module HybridPlatformsConductorTest
+
+  # Helpers for the tests
+  module Helpers
+
+    include ActionsExecutorHelpers
+    include CmdbHelpers
+    include CmdRunnerHelpers
+    include ConfigHelpers
+    include ConnectorSshHelpers
+    include DeployerHelpers
+    include ExecutablesHelpers
+    include NodesHandlerHelpers
+    include PlatformHandlerHelpers
+    include PlatformsHandlerHelpers
+    include PluginsHelpers
+    include ProvisionerProxmoxHelpers
+    include ReportsHandlerHelpers
+    include ServicesHandlerHelpers
+    include TestsRunnerHelpers
+
+    # Make sure the tested components are being reset before each test case
+    RSpec.configure do |config|
+      config.before(:each) do
+        @actions_executor = nil
+        @cmd_runner = nil
+        @config = nil
+        @deployer = nil
+        @nodes_handler = nil
+        @platforms_handler = nil
+        @reports_handler = nil
+        @services_handler = nil
+        @tests_runner = nil
+        ENV.delete 'hpc_platforms'
+        ENV.delete 'hpc_ssh_gateways_conf'
+        ENV.delete 'hpc_ssh_gateway_user'
+        ENV.delete 'hpc_user_for_proxmox'
+        ENV.delete 'hpc_password_for_proxmox'
+        ENV.delete 'hpc_realm_for_proxmox'
+        ENV.delete 'hpc_user_for_thycotic'
+        ENV.delete 'hpc_password_for_thycotic'
+        ENV.delete 'hpc_domain_for_thycotic'
+        ENV.delete 'hpc_certificates'
+        # Set the necessary Hybrid Platforms Conductor environment variables
+        ENV['hpc_ssh_user'] = 'test_user'
+        HybridPlatformsConductor::ServicesHandler.packaged_deployments.clear
+        HybridPlatformsConductorTest::TestAction.reset
+        HybridPlatformsConductorTest::PlatformHandlerPlugins::Test.reset
+        HybridPlatformsConductorTest::PlatformHandlerPlugins::Test2.reset
+        HybridPlatformsConductorTest::TestsReportPlugin.reports = []
+        HybridPlatformsConductorTest::ReportPlugin.generated_reports = []
+        HybridPlatformsConductorTest::TestProvisioner.mocked_states = []
+        HybridPlatformsConductorTest::TestProvisioner.mocked_ip = nil
+        HybridPlatformsConductorTest::TestProvisioner.mocked_default_timeout = 1
+        HybridPlatformsConductorTest::TestPlugins::Global.nbr_runs = 0
+        HybridPlatformsConductorTest::TestPlugins::Global.fail = false
+        HybridPlatformsConductorTest::TestPlugins::Platform.runs = []
+        HybridPlatformsConductorTest::TestPlugins::Platform.fail_for = []
+        HybridPlatformsConductorTest::TestPlugins::Platform.only_on_platform_types = nil
+        HybridPlatformsConductorTest::TestPlugins::Platform.sleeps = {}
+        HybridPlatformsConductorTest::TestPlugins::Node.runs = []
+        HybridPlatformsConductorTest::TestPlugins::Node.fail_for = {}
+        HybridPlatformsConductorTest::TestPlugins::Node.only_on_platform_types = nil
+        HybridPlatformsConductorTest::TestPlugins::Node.only_on_nodes = nil
+        HybridPlatformsConductorTest::TestPlugins::Node.sleeps = {}
+        HybridPlatformsConductorTest::TestPlugins::NodeSsh.node_tests = {}
+        HybridPlatformsConductorTest::TestPlugins::NodeSsh.only_on_platform_types = nil
+        HybridPlatformsConductorTest::TestPlugins::NodeSsh.only_on_nodes = nil
+        HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs = []
+        HybridPlatformsConductorTest::TestPlugins::NodeCheck.fail_for = []
+        HybridPlatformsConductorTest::TestPlugins::NodeCheck.only_on_platform_types = nil
+        HybridPlatformsConductorTest::TestPlugins::NodeCheck.only_on_nodes = nil
+        HybridPlatformsConductorTest::TestPlugins::SeveralChecks.runs = []
+        FileUtils.rm_rf './run_logs'
+        FileUtils.rm_rf './testadmin.key.pub'
+        FileUtils.rm_rf '/tmp/hpc_ssh'
+        # Make sure CMDB plugin classes loaded by test framework are not added automatically
+        register_plugins(:cmdb, {
+          config: HybridPlatformsConductor::HpcPlugins::Cmdb::Config,
+          host_ip: HybridPlatformsConductor::HpcPlugins::Cmdb::HostIp,
+          host_keys: HybridPlatformsConductor::HpcPlugins::Cmdb::HostKeys,
+          platform_handlers: HybridPlatformsConductor::HpcPlugins::Cmdb::PlatformHandlers
+        })
+      end
+    end
+
+    private
+
+    # Get the logger for tests
+    #
+    # Result::
+    # * Logger: The logger to be used
+    def logger
+      if ENV['TEST_DEBUG'] == '1'
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::DEBUG
+        logger
+      else
+        # Still put the level, as when testing executables we switch the device from /dev/null to a file
+        Logger.new('/dev/null', level: :info)
+      end
+    end
+
+  end
+
+end