hybrid_platforms_conductor 32.17.1 → 33.0.3

data/lib/hybrid_platforms_conductor/parallel_threads.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 module HybridPlatformsConductor
 
   # Provide utilities to handle parallel threads
@@ -14,10 +12,10 @@ module HybridPlatformsConductor
     # * *parallel* (Boolean): Iterate in a multithreaded way? [default: false]
     # * *nbr_threads_max* (Integer or nil): Maximum number of threads to be used in case of parallel, or nil for no limit [default: nil]
     # * *progress* (String or nil): Name of a progress bar to follow the progression, or nil for no progress bar [default: 'Progress']
-    # * Proc: The code called for each node being iterated on.
+    # * *block* (Proc): The code called for each node being iterated on.
     #   * Parameters::
     #     * *element* (Object): The object
-    def for_each_element_in(list, parallel: false, nbr_threads_max: nil, progress: 'Process')
+    def for_each_element_in(list, parallel: false, nbr_threads_max: nil, progress: 'Process', &block)
       if parallel
         # Threads to wait for
         threads_to_join = []
@@ -46,6 +44,7 @@ module HybridPlatformsConductor
                   pools[:processing] << element unless element.nil?
                 end
                 break if element.nil?
+
                 begin
                   yield element
                 ensure
@@ -56,7 +55,7 @@ module HybridPlatformsConductor
                 end
               end
             rescue
-              log_error "Unhandled exception occurred in thread #{Thread.current.object_id}: #{$!}\n#{$!.backtrace.join("\n")}"
+              log_error "Unhandled exception occurred in thread #{Thread.current.object_id}: #{$ERROR_INFO}\n#{$ERROR_INFO.backtrace.join("\n")}"
               raise
             end
           end
@@ -76,19 +75,16 @@ module HybridPlatformsConductor
               progress_bar.title = "Queue: #{nbr_to_process} - Processing: #{nbr_processing} - Done: #{nbr_processed} - Total: #{nbr_total}"
               progress_bar.progress = nbr_processed
               break if nbr_processed == nbr_total
+
               sleep 0.5
             end
           end
         end
         # Wait for threads to be joined
-        threads_to_join.each do |thread|
-          thread.join
-        end
+        threads_to_join.each(&:join)
       else
         # Execute synchronously
-        list.each do |element|
-          yield element
-        end
+        list.each(&block)
       end
     end
 

data/lib/hybrid_platforms_conductor/platform_handler.rb

@@ -16,7 +16,7 @@ module HybridPlatformsConductor
     def self.inherited(subclass)
       # Make sure we define automatically a helper for such a platform
       mixin = Module.new
-      platform_type = subclass.name.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+      platform_type = subclass.name.split('::').last.gsub(/([a-z\d])([A-Z\d])/, '\1_\2').downcase.to_sym
       mixin.define_method("#{platform_type}_platform".to_sym) do |path: nil, git: nil, branch: 'master', &platform_config_code|
         repository_path =
           if !path.nil?
@@ -28,7 +28,7 @@ module HybridPlatformsConductor
               branch = "refs/heads/#{branch}" unless branch.include?('/')
               local_ref = "refs/remotes/origin/#{branch.split('/').last}"
               section "Cloning #{git} (#{branch} => #{local_ref}) into #{local_repository_path}" do
-                git_repo = Git.init(local_repository_path, )
+                git_repo = Git.init(local_repository_path)
                 git_repo.add_remote('origin', git).fetch(ref: "#{branch}:#{local_ref}")
                 git_repo.checkout local_ref
               end
@@ -39,7 +39,7 @@ module HybridPlatformsConductor
           end
         @platform_dirs[platform_type] = [] unless @platform_dirs.key?(platform_type)
         @platform_dirs[platform_type] << repository_path
-        platform_config_code.call(repository_path) unless platform_config_code.nil?
+        platform_config_code&.call(repository_path)
       end
       # Register this new mixin in the Config DSL
       extend_config_dsl_with(mixin)
@@ -69,8 +69,8 @@ module HybridPlatformsConductor
     def initialize(
       platform_type,
       repository_path,
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new
     )
@@ -78,7 +78,7 @@ module HybridPlatformsConductor
       @platform_type = platform_type
       @repository_path = repository_path
       @cmd_runner = cmd_runner
-      self.init if self.respond_to?(:init)
+      init if respond_to?(:init)
     end
 
     # Return the name of the platform
@@ -100,7 +100,7 @@ module HybridPlatformsConductor
     # * Array<String>: The list of nodes impacted by this diff
     # * Array<String>: The list of services impacted by this diff
     # * Boolean: Are there some files that have a global impact (meaning all nodes are potentially impacted by this diff)?
-    def impacts_from(files_diffs)
+    def impacts_from(_files_diffs)
       # By default, consider all nodes of the platform are impacted by whatever diff.
       [
         [],

data/lib/hybrid_platforms_conductor/platforms_handler.rb

@@ -6,6 +6,7 @@ module HybridPlatformsConductor
   # Provide an API to access information given by Platform Handlers
   class PlatformsHandler
 
+    # Add some config DSL
     module ConfigDSLExtension
 
       # List of platforms repository directories, per platform type
@@ -32,8 +33,8 @@ module HybridPlatformsConductor
     # * *config* (Config): Config to be used. [default: Config.new]
     # * *cmd_runner* (CmdRunner): Command executor to be used. [default: CmdRunner.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new
     )
@@ -57,6 +58,7 @@ module HybridPlatformsConductor
           )
           # Check that this platform has unique name
           raise "Platform name #{platform_handler.name} is declared several times." if @platform_handlers.values.flatten.any? { |known_platform| known_platform.name == platform_handler.name }
+
           @platform_handlers[platform_type] = [] unless @platform_handlers.key?(platform_type)
           @platform_handlers[platform_type] << platform_handler
         end
@@ -78,7 +80,7 @@ module HybridPlatformsConductor
     # Result::
     # * Array<PlatformHandler>: List of platform handlers
     def known_platforms(platform_type: nil)
-      (platform_type.nil? ? @platform_handlers.keys : [platform_type]).map { |platform_type| (@platform_handlers[platform_type] || []) }.flatten
+      (platform_type.nil? ? @platform_handlers.keys : [platform_type]).map { |search_platform_type| (@platform_handlers[search_platform_type] || []) }.flatten
     end
 
     # Return the platform handler for a given platform name

data/lib/hybrid_platforms_conductor/plugin.rb

@@ -40,8 +40,8 @@ module HybridPlatformsConductor
     # * *logger_stderr* (Logger): Logger to be used for stderr [default: Logger.new(STDERR)]
     # * *config* (Config): Config to be used. [default: Config.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new
     )
       init_loggers(logger, logger_stderr)

data/lib/hybrid_platforms_conductor/plugins.rb

@@ -22,7 +22,7 @@ module HybridPlatformsConductor
     # * *parse_gems* (Boolean): Do we parse plugins from gems? [default: true]
     # * *logger* (Logger): Logger to be used [default = Logger.new(STDOUT)]
     # * *logger_stderr* (Logger): Logger to be used for stderr [default = Logger.new(STDERR)]
-    def initialize(plugins_type, init_plugin: nil, parse_gems: true, logger: Logger.new(STDOUT), logger_stderr: Logger.new(STDERR))
+    def initialize(plugins_type, init_plugin: nil, parse_gems: true, logger: Logger.new($stdout), logger_stderr: Logger.new($stderr))
       init_loggers(logger, logger_stderr)
       @plugins_type = plugins_type
       @init_plugin = init_plugin
@@ -37,7 +37,10 @@ module HybridPlatformsConductor
     def_delegators :@plugins, *%i[
       []
       each
+      each_key
+      each_value
       empty?
+      find
       key?
       keys
       select
@@ -71,15 +74,15 @@ module HybridPlatformsConductor
     # Register plugins by parsing gems
     def register_plugins_from_gems
       # Require all possible files that could define such a plugin, from all gems
-      files_regexp = /lib\/(.*hpc_plugins\/#{Regexp.escape(@plugins_type.to_s)}\/[^\/]+)\.rb$/
+      files_regexp = %r{lib/(.*hpc_plugins/#{Regexp.escape(@plugins_type.to_s)}/[^/]+)\.rb$}
       Gem.loaded_specs.each do |gem_name, gem_specs|
         # Careful to not use gem_specs.files here as if your gem name contains "-" or other weird characters, files won't appear in the gemspec list.
         Dir.glob("#{gem_specs.full_gem_path}/lib/**/*.rb").each do |file|
-          if file =~ files_regexp
-            require_name = $1
-            log_debug "[ #{@plugins_type} ] - Require from #{gem_name} file #{require_name}"
-            require require_name
-          end
+          next unless file =~ files_regexp
+
+          require_name = Regexp.last_match(1)
+          log_debug "[ #{@plugins_type} ] - Require from #{gem_name} file #{require_name}"
+          require require_name
         end
       end
       # Parse the registered classes to search for our plugins
@@ -89,10 +92,13 @@ module HybridPlatformsConductor
         # * have been defined by the requires (no unnamed class, as those can be created by clones when using concurrency),
         # * inherit from the base plugin class,
         # * have no descendants
+        # Careful: !(class_1 < class_2) != (class_1 >= class_2), so disable the cop here for inversions.
+        # rubocop:disable Style/InverseMethods
         if !klass.name.nil? && klass < ancestor_class && ObjectSpace.each_object(Class).all? { |other_klass| other_klass.name.nil? || !(other_klass < klass) }
-          plugin_id = klass.name.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+          plugin_id = klass.name.split('::').last.gsub(/([a-z\d])([A-Z\d])/, '\1_\2').downcase.to_sym
           self[plugin_id] = klass
         end
+        # rubocop:enable Style/InverseMethods
       end
     end
 

data/lib/hybrid_platforms_conductor/provisioner.rb

@@ -22,8 +22,8 @@ module HybridPlatformsConductor
     def initialize(
       node,
       environment: 'production',
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new,
       nodes_handler: NodesHandler.new,
@@ -80,7 +80,7 @@ module HybridPlatformsConductor
             @config.ssh_connection_transforms.replace(@config.ssh_connection_transforms.map do |ssh_transform_info|
               {
                 nodes_selectors_stack: ssh_transform_info[:nodes_selectors_stack].map do |nodes_selector|
-                  @nodes_handler.select_nodes(nodes_selector).select { |selected_node| selected_node != @node }
+                  @nodes_handler.select_nodes(nodes_selector).reject { |selected_node| selected_node == @node }
                 end,
                 transform: ssh_transform_info[:transform]
               }
@@ -154,7 +154,7 @@ module HybridPlatformsConductor
           begin
             Socket.tcp(instance_ip, port, connect_timeout: remaining_timeout) { true }
           rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::EADDRNOTAVAIL, Errno::ETIMEDOUT
-            log_warn "[ #{@node}/#{@environment} ] - Can't connect to #{instance_ip}:#{port}: #{$!}"
+            log_warn "[ #{@node}/#{@environment} ] - Can't connect to #{instance_ip}:#{port}: #{$ERROR_INFO}"
             false
           end
         sleep 1 unless port_listening

data/lib/hybrid_platforms_conductor/report.rb

@@ -15,8 +15,8 @@ module HybridPlatformsConductor
     # * *platforms_handler* (PlatformsHandler): Platforms handler to be used. [default: PlatformsHandler.new]
     # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default: NodesHandler.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       platforms_handler: PlatformsHandler.new,
       nodes_handler: NodesHandler.new

data/lib/hybrid_platforms_conductor/reports_handler.rb

@@ -26,8 +26,8 @@ module HybridPlatformsConductor
     # * *platforms_handler* (PlatformsHandler): Platforms handler to be used. [default = PlatformsHandler.new]
     # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default = NodesHandler.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       platforms_handler: PlatformsHandler.new,
       nodes_handler: NodesHandler.new
@@ -70,6 +70,7 @@ module HybridPlatformsConductor
     # * *nodes_selectors* (Array<Object>): List of nodes selectors to produce report for
     def produce_report_for(nodes_selectors)
       raise "Unknown locale for format #{@format}: #{@locale}" unless @reports_plugins[@format].supported_locales.include? @locale
+
       @reports_plugins[@format].new(
         logger: @logger,
         logger_stderr: @logger_stderr,

data/lib/hybrid_platforms_conductor/secrets_reader.rb

@@ -0,0 +1,31 @@
+require 'hybrid_platforms_conductor/logger_helpers'
+require 'hybrid_platforms_conductor/plugin'
+
+module HybridPlatformsConductor
+
+  # Ancestor of all secrets reader plugins
+  class SecretsReader < Plugin
+
+    # Constructor
+    #
+    # Parameters::
+    # * *logger* (Logger): Logger to be used [default: Logger.new(STDOUT)]
+    # * *logger_stderr* (Logger): Logger to be used for stderr [default: Logger.new(STDERR)]
+    # * *config* (Config): Config to be used. [default: Config.new]
+    # * *cmd_runner* (CmdRunner): CmdRunner to be used. [default: CmdRunner.new]
+    # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default: NodesHandler.new]
+    def initialize(
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
+      config: Config.new,
+      cmd_runner: CmdRunner.new,
+      nodes_handler: NodesHandler.new
+    )
+      super(logger: logger, logger_stderr: logger_stderr, config: config)
+      @cmd_runner = cmd_runner
+      @nodes_handler = nodes_handler
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/services_handler.rb

@@ -21,7 +21,8 @@ module HybridPlatformsConductor
 
     @packaged_deployments = []
 
-    include LoggerHelpers, ParallelThreads
+    include ParallelThreads
+    include LoggerHelpers
 
     # Constructor
     #
@@ -34,8 +35,8 @@ module HybridPlatformsConductor
     # * *nodes_handler* (NodesHandler): Nodes Handler to be used. [default: NodesHandler.new]
     # * *actions_executor* (ActionsExecutor): Actions Executor to be used. [default: ActionsExecutor.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new,
       platforms_handler: PlatformsHandler.new,
@@ -56,13 +57,11 @@ module HybridPlatformsConductor
     #
     # Parameters::
     # * *services* (Hash< String, Array<String> >): Services to be deployed, per node
-    # * *secrets* (Hash): Secrets to be used for deployment
     # * *local_environment* (Boolean): Are we deploying to a local environment?
     # Result::
     # * String or nil: Reason for which we are not allowed to deploy, or nil if deployment is authorized
     def deploy_allowed?(
       services:,
-      secrets:,
       local_environment:
     )
       if local_environment
@@ -83,7 +82,7 @@ module HybridPlatformsConductor
             head_commit_id = git.log.first.sha
             git.branches.all? do |branch|
               branch.gcommit.objectish.include?(' -> ') || (
-                !(branch.full == 'master' || branch.full =~ /^remotes\/.+\/master$/) || branch.gcommit.sha != head_commit_id
+                !(branch.full == 'master' || branch.full =~ %r{^remotes/.+/master$}) || branch.gcommit.sha != head_commit_id
               )
             end
           end
@@ -108,25 +107,25 @@ module HybridPlatformsConductor
       local_environment:
     )
       platforms_for(services).each do |platform, platform_services|
-        if platform.respond_to?(:package)
-          platform_name = platform.name
-          # Compute the package ID that is unique to this packaging, so that we don't mix it with others if needed.
-          package_id = {
-            platform_name: platform_name,
-            services: Hash[platform_services.map { |node, node_services| [node, node_services.sort] }].sort,
-            secrets: secrets.sort,
+        next unless platform.respond_to?(:package)
+
+        platform_name = platform.name
+        # Compute the package ID that is unique to this packaging, so that we don't mix it with others if needed.
+        package_id = {
+          platform_name: platform_name,
+          services: platform_services.transform_values(&:sort).sort,
+          secrets: secrets.sort,
+          local_environment: local_environment
+        }
+        if ServicesHandler.packaged_deployments.include?(package_id)
+          log_debug "Platform #{platform_name} has already been packaged for this deployment (package ID #{package_id}). Won't package it another time."
+        else
+          platform.package(
+            services: platform_services,
+            secrets: secrets,
             local_environment: local_environment
-          }
-          if ServicesHandler.packaged_deployments.include?(package_id)
-            log_debug "Platform #{platform_name} has already been packaged for this deployment (package ID #{package_id}). Won't package it another time."
-          else
-            platform.package(
-              services: platform_services,
-              secrets: secrets,
-              local_environment: local_environment
-            )
-            ServicesHandler.packaged_deployments << package_id
-          end
+          )
+          ServicesHandler.packaged_deployments << package_id
         end
       end
     end
@@ -145,12 +144,14 @@ module HybridPlatformsConductor
       why_run:
     )
       platforms_for(services).each do |platform, platform_services|
+        next unless platform.respond_to?(:prepare_for_deploy)
+
         platform.prepare_for_deploy(
           services: platform_services,
           secrets: secrets,
           local_environment: local_environment,
           why_run: why_run
-        ) if platform.respond_to?(:prepare_for_deploy)
+        )
       end
     end
 
@@ -164,10 +165,11 @@ module HybridPlatformsConductor
     # * Array< Hash<Symbol,Object> >: List of actions to be done
     def actions_to_deploy_on(node, services, why_run)
       services.map do |service|
-        platform = @platforms_handler.known_platforms.find { |platform| platform.deployable_services.include?(service) }
+        platform = @platforms_handler.known_platforms.find { |search_platform| search_platform.deployable_services.include?(service) }
         raise "No platform is able to deploy the service #{service}" if platform.nil?
+
         # Add some markers in stdout and stderr so that parsing services-oriented deployment output is easier
-        deploy_marker = "===== [ #{node} / #{service} ] - HPC Service #{why_run ? 'Check' : 'Deploy' } ====="
+        deploy_marker = "===== [ #{node} / #{service} ] - HPC Service #{why_run ? 'Check' : 'Deploy'} ====="
         [{
           ruby: proc do |stdout, stderr|
             stdout << "#{deploy_marker} Begin\n"
@@ -210,7 +212,7 @@ module HybridPlatformsConductor
     end
 
     # Regexp: The marker regexp used to separate services deployment
-    MARKER_REGEXP = /^===== \[ (.+?) \/ (.+?) \] - HPC Service (\w+) ===== Begin$(.+?)^===== \[ \1 \/ \2 \] - HPC Service \3 ===== End$/m
+    MARKER_REGEXP = %r{^===== \[ (.+?) / (.+?) \] - HPC Service (\w+) ===== Begin$(.+?)^===== \[ \1 / \2 \] - HPC Service \3 ===== End$}m
 
     # Parse stdout and stderr of a given deploy run and get the list of tasks with their status, organized per service and node deployed.
     #
@@ -234,8 +236,9 @@ module HybridPlatformsConductor
         log_warn "Mismatch in deployment logs between stdout and stderr: stdout deployed node #{stdout_node}, stderr deployed node #{stderr_node}" unless stdout_node == stderr_node
         log_warn "Mismatch in deployment logs between stdout and stderr: stdout deployed service #{stdout_service}, stderr deployed service #{stderr_service}" unless stdout_service == stderr_service
         log_warn "Mismatch in deployment logs between stdout and stderr: stdout deployed mode is #{stdout_mode}, stderr deployed mode is #{stderr_mode}" unless stdout_mode == stderr_mode
-        platform = @platforms_handler.known_platforms.find { |platform| platform.deployable_services.include?(stdout_service) }
+        platform = @platforms_handler.known_platforms.find { |search_platform| search_platform.deployable_services.include?(stdout_service) }
         raise "No platform is able to deploy the service #{stdout_service}" if platform.nil?
+
         {
           node: stdout_node,
           service: stdout_service,

data/lib/hybrid_platforms_conductor/test_only_remote_node.rb

@@ -10,7 +10,7 @@ module HybridPlatformsConductor
     def self.only_on_nodes
       # Just 1 node per service and platform
       Test.nodes_handler.prefetch_metadata_of Test.nodes_handler.known_nodes, :local_node
-      Test.nodes_handler.known_nodes.select { |node| !Test.nodes_handler.get_local_node_of(node) }
+      Test.nodes_handler.known_nodes.reject { |node| Test.nodes_handler.get_local_node_of(node) }
     end
 
   end