hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/test_action.rb

@@ -0,0 +1,66 @@
+module HybridPlatformsConductorTest
+
+  # Dummy action plugin that can be used to test interactions between Actions Executor and actions
+  class TestAction < HybridPlatformsConductor::Action
+
+    class << self
+
+      # List of executions info
+      # Array< Hash<Symbol,Object> >
+      # * *node* (String): Node on which the action has been executed
+      # * *message* (String): Message executed
+      attr_accessor :executions
+
+      # Reset variables, so that they don't interfere between tests
+      def reset
+        @executions = []
+      end
+
+    end
+
+    # Setup the action
+    #
+    # Parameters::
+    # * *input* (Hash<Symbol, Object>): The action input, as a set of properties:
+    #   * *message* (String): The message to log in the executions. This is the default property that can be used in place of the Hash. [default = 'Action executed']
+    #   * *run_cmd* (String or nil): A command to run with run_cmd, or nil if none [default = nil]
+    #   * *need_connector* (Boolean): Does this action need a remote connection to the node? [default = false]
+    #   * *code* (Proc or nil): Code to be called during action's execution, or nil if none [default = nil]
+    #     * Parameters::
+    #       * *stdout_io* (IO): stdout IO to be used for stdout logging
+    #       * *stderr_io* (IO): stdout IO to be used for stderr logging
+    #       * *action* (TestAction): The test action
+    def setup(input)
+      # Normalize input
+      input = { message: input } if input.is_a?(String)
+      # Set defaults
+      @input = {
+        message: 'Action executed',
+        need_connector: false
+      }.merge(input)
+    end
+
+    # Do we need a connector to execute this action on a node?
+    #
+    # Result::
+    # * Boolean: Do we need a connector to execute this action on a node?
+    def need_connector?
+      @input[:need_connector]
+    end
+
+    # Execute the action
+    def execute
+      run_cmd(@input[:run_cmd]) if @input.key?(:run_cmd)
+      @input[:code].call(@stdout_io, @stderr_io, self) if @input.key?(:code)
+      TestAction.executions << {
+        node: @node,
+        message: @input[:message]
+      }
+    end
+
+    # Integer: Timeout that the action should respect
+    attr_reader :timeout
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/test_connector.rb

@@ -0,0 +1,151 @@
+module HybridPlatformsConductorTest
+
+  # Test connector
+  class TestConnector < HybridPlatformsConductor::Connector
+
+    # Array<Object<: Access calls made to the test connector
+    attr_reader :calls
+
+    # Array<String>: List of nodes accepted by this connector
+    attr_accessor :accept_nodes
+
+    # Array<String> or nil: List of nodes that will be connected, or nil for all
+    attr_accessor :connected_nodes
+
+    # Proc: Code executed when remote_bash is called
+    # Parameters::
+    # * *stdout* (IO): stdout to return
+    # * *stderr* (IO): stderr to return
+    # * *connector* (TestConnector): The current connector
+    attr_accessor :remote_bash_code
+
+    # Proc: Code executed when remote_copy is called
+    # Parameters::
+    # * *stdout* (IO): stdout to return
+    # * *stderr* (IO): stderr to return
+    # * *connector* (TestConnector): The current connector
+    attr_accessor :remote_copy_code
+
+    # Initialize the connector.
+    # This can be used to initialize global variables that are used for this connector
+    # [API] - This method is optional
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    def init
+      @calls = []
+      @accept_nodes = []
+      @connected_nodes = nil
+      @remote_bash_code = nil
+    end
+
+    # Complete an option parser with options meant to control this connector
+    # [API] - This method is optional
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    #
+    # Parameters::
+    # * *options_parser* (OptionParser): The option parser to complete
+    def options_parse(options_parser)
+      @calls << [:options_parse]
+    end
+
+    # Validate that parsed parameters are valid
+    # [API] - This method is optional
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    def validate_params
+      @calls << [:validate_params]
+    end
+
+    # Select nodes where this connector can connect.
+    # [API] - This method is mandatory
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    #
+    # Parameters::
+    # * *nodes* (Array<String>): List of candidate nodes
+    # Result::
+    # * Array<String>: List of nodes we can connect to from the candidates
+    def connectable_nodes_from(nodes)
+      @calls << [:connectable_nodes_from, nodes]
+      nodes & @accept_nodes
+    end
+
+    # Prepare connections to a given set of nodes.
+    # Useful to prefetch metadata or open bulk connections.
+    # [API] - This method is optional
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    #
+    # Parameters::
+    # * *nodes* (Array<String>): Nodes to prepare the connection to
+    # * *no_exception* (Boolean): Should we still continue if some nodes have connection errors? [default: false]
+    # * Proc: Code called with the connections prepared.
+    #   * Parameters::
+    #     * *connected_nodes* (Array<String>): The list of connected nodes (should be equal to nodes unless no_exception == true and some nodes failed to connect)
+    def with_connection_to(nodes, no_exception: false)
+      @calls << [:with_connection_to, nodes, { no_exception: no_exception }]
+      yield @connected_nodes.nil? ? nodes : @connected_nodes
+    end
+
+    # Run bash commands on a given node.
+    # [API] - This method is mandatory
+    # [API] - If defined, then with_connection_to has been called before this method.
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    # [API] - @node can be used to access the node on which we execute the remote bash
+    # [API] - @timeout can be used to know when the action should fail
+    # [API] - @stdout_io can be used to send stdout output
+    # [API] - @stderr_io can be used to send stderr output
+    #
+    # Parameters::
+    # * *bash_cmds* (String): Bash commands to execute
+    def remote_bash(bash_cmds)
+      @calls << [:remote_bash, bash_cmds]
+      @remote_bash_code.call(@stdout_io, @stderr_io, self) unless @remote_bash_code.nil?
+    end
+
+    # Execute an interactive shell on the remote node
+    # [API] - This method is mandatory
+    # [API] - If defined, then with_connection_to has been called before this method.
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    # [API] - @node can be used to access the node on which we execute the remote bash
+    # [API] - @timeout can be used to know when the action should fail
+    # [API] - @stdout_io can be used to send stdout output
+    # [API] - @stderr_io can be used to send stderr output
+    def remote_interactive
+      @calls << [:remote_interactive]
+    end
+
+    # Copy a file to the remote node in a directory
+    # [API] - This method is mandatory
+    # [API] - If defined, then with_connection_to has been called before this method.
+    # [API] - @cmd_runner can be used
+    # [API] - @nodes_handler can be used
+    # [API] - @node can be used to access the node on which we execute the remote bash
+    # [API] - @timeout can be used to know when the action should fail
+    # [API] - @stdout_io can be used to send stdout output
+    # [API] - @stderr_io can be used to send stderr output
+    #
+    # Parameters::
+    # * *from* (String): Local file to copy
+    # * *to* (String): Remote directory to copy to
+    # * *sudo* (Boolean): Do we use sudo to copy? [default: false]
+    # * *owner* (String or nil): Owner to be used when copying the files, or nil for current one [default: nil]
+    # * *group* (String or nil): Group to be used when copying the files, or nil for current one [default: nil]
+    def remote_copy(from, to, sudo: false, owner: nil, group: nil)
+      extra_opts = {}
+      extra_opts[:sudo] = sudo if sudo
+      extra_opts[:owner] = owner if owner
+      extra_opts[:group] = group if group
+      @calls << [:remote_copy, from, to] + (extra_opts.empty? ? [] : [extra_opts])
+      @remote_copy_code.call(@stdout_io, @stderr_io, self) unless @remote_copy_code.nil?
+    end
+
+    # Integer: The current desired timeout
+    attr_reader :timeout
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/test_plugins/global.rb

@@ -0,0 +1,30 @@
+module HybridPlatformsConductorTest
+
+  module TestPlugins
+
+    # Test plugin at global level
+    class Global < HybridPlatformsConductor::Test
+
+      class << self
+
+        # Number of times our test has been run
+        # Integer
+        attr_accessor :nbr_runs
+
+        # Do we fail?
+        # Boolean
+        attr_accessor :fail
+
+      end
+
+      # Check my_test_plugin.rb.sample documentation for signature details.
+      def test
+        raise 'Failing test' if Global.fail
+        Global.nbr_runs += 1
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/test_plugins/node.rb

@@ -0,0 +1,53 @@
+module HybridPlatformsConductorTest
+
+  module TestPlugins
+
+    # Test plugin at node level
+    class Node < HybridPlatformsConductor::Test
+
+      class << self
+
+        # Sequences of nodes on which this test has been run
+        # Array< [ Symbol,    String ] >
+        # Array< [ test_name, node   ] >
+        attr_accessor :runs
+
+        # List of nodes for which we fail, per test name
+        # Hash<Symbol, Array<String> >
+        attr_accessor :fail_for
+
+        # List of platform types that should only be concerned by this test
+        # Array<Symbol>
+        attr_accessor :only_on_platform_types
+
+        # List of nodes that should only be concerned by this test
+        # Array<Symbol>
+        attr_accessor :only_on_nodes
+
+        # Eventual sleep time per node name, per test name
+        # Hash<Symbol, Hash<String, Integer> >
+        attr_accessor :sleeps
+
+      end
+
+      # Check my_test_plugin.rb.sample documentation for signature details.
+      def test_for_node
+        raise "Failing test #{@name} for #{@node}" if Node.fail_for.key?(@name) && Node.fail_for[@name].include?(@node)
+        sleep_time = Node.sleeps.dig(@name, @node)
+        sleep sleep_time unless sleep_time.nil?
+        Node.runs << [@name, @node]
+      end
+
+      # Limit the list of platform types for these tests.
+      #
+      # Result::
+      # * Array<Symbol> or nil: List of platform types allowed for this test, or nil for all
+      def self.only_on_platforms
+        Node.only_on_platform_types
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/test_plugins/node_check.rb

@@ -0,0 +1,47 @@
+module HybridPlatformsConductorTest
+
+  module TestPlugins
+
+    # Test plugin at node level using check-node results
+    class NodeCheck < HybridPlatformsConductor::Test
+
+      class << self
+
+        # Sequences of nodes on which this test has been run
+        # Array< [ Symbol,    String, String, String, Integer     ] >
+        # Array< [ test_name, node,   stdout, stderr, exit_status ] >
+        attr_accessor :runs
+
+        # List of nodes for which we fail
+        # Array<String>
+        attr_accessor :fail_for
+
+        # List of platform types that should only be concerned by this test
+        # Array<Symbol>
+        attr_accessor :only_on_platform_types
+
+        # List of nodes that should only be concerned by this test
+        # Array<Symbol>
+        attr_accessor :only_on_nodes
+
+      end
+
+      # Check my_test_plugin.rb.sample documentation for signature details.
+      def test_on_check_node(stdout, stderr, exit_status)
+        raise 'Failing test' if NodeCheck.fail_for.include? @node
+        NodeCheck.runs << [@name, @node, stdout, stderr, exit_status]
+      end
+
+      # Limit the list of platform types for these tests.
+      #
+      # Result::
+      # * Array<Symbol> or nil: List of platform types allowed for this test, or nil for all
+      def self.only_on_platforms
+        NodeCheck.only_on_platform_types
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/test_plugins/node_ssh.rb

@@ -0,0 +1,42 @@
+module HybridPlatformsConductorTest
+
+  module TestPlugins
+
+    # Test plugin at node level using SSH
+    class NodeSsh < HybridPlatformsConductor::Test
+
+      class << self
+
+        # List of Bash commands and their corresponding testing code, per node name, per test name
+        # Hash< Symbol,    Hash< String, Hash< String,   Proc      > > >
+        # Hash< test_name, Hash< node,   Hash< bash_cmd, test_code > > >
+        attr_accessor :node_tests
+
+        # List of platform types that should only be concerned by this test
+        # Array<Symbol>
+        attr_accessor :only_on_platform_types
+
+        # List of nodes that should only be concerned by this test
+        # Array<Symbol>
+        attr_accessor :only_on_nodes
+
+      end
+
+      # Check my_test_plugin.rb.sample documentation for signature details.
+      def test_on_node
+        NodeSsh.node_tests[@name][@node]
+      end
+
+      # Limit the list of platform types for these tests.
+      #
+      # Result::
+      # * Array<Symbol> or nil: List of platform types allowed for this test, or nil for all
+      def self.only_on_platforms
+        NodeSsh.only_on_platform_types
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/test_plugins/platform.rb

@@ -0,0 +1,50 @@
+module HybridPlatformsConductorTest
+
+  module TestPlugins
+
+    # Test plugin at platform level
+    class Platform < HybridPlatformsConductor::Test
+
+      class << self
+
+        # Sequences of platforms on which this test has been run
+        # Array< [ Symbol,    String   ] >
+        # Array< [ test_name, platform ] >
+        attr_accessor :runs
+
+        # List of platforms for which we fail
+        # Array<String>
+        attr_accessor :fail_for
+
+        # List of platform types that should only be concerned by this test
+        # Array<Symbol>
+        attr_accessor :only_on_platform_types
+
+        # Eventual sleep time per platform name, per test name
+        # Hash<Symbol, Hash<String, Integer> >
+        attr_accessor :sleeps
+
+      end
+
+      # Check my_test_plugin.rb.sample documentation for signature details.
+      def test_on_platform
+        platform_name = @platform.name
+        raise 'Failing test' if Platform.fail_for.include? platform_name
+        sleep_time = Platform.sleeps.dig(@name, platform_name)
+        sleep sleep_time unless sleep_time.nil?
+        Platform.runs << [@name, platform_name]
+      end
+
+      # Limit the list of platform types for these tests.
+      #
+      # Result::
+      # * Array<Symbol> or nil: List of platform types allowed for this test, or nil for all
+      def self.only_on_platforms
+        Platform.only_on_platform_types
+      end
+
+    end
+
+  end
+
+end