hybrid_platforms_conductor 32.3.6

data/lib/hybrid_platforms_conductor/plugins.rb

@@ -0,0 +1,101 @@
+require 'hybrid_platforms_conductor/logger_helpers'
+
+module HybridPlatformsConductor
+
+  # Give a simple and harmonized way to access to plugins, whether they are in the common repository or in other gems
+  class Plugins
+
+    include LoggerHelpers
+
+    # Make sure we can iterate over plugins like a standard collection
+    include Enumerable
+
+    # Constructor
+    #
+    # Parameters::
+    # * *plugins_type* (Symbol): Plugins type to look for
+    # * *init_plugin* (Proc or nil): Proc used to initialize the plugin from the plugin class, or nil if no initialization [default: nil]
+    #   * Parameters::
+    #     * *plugin_class* (Class): The plugin class that has been found
+    #   * Result::
+    #     * Object: Corresponding object that will be used as the plugin instance
+    # * *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))
+      init_loggers(logger, logger_stderr)
+      @plugins_type = plugins_type
+      @init_plugin = init_plugin
+      # All the plugins classes we know of this type, per plugin ID
+      # Hash<Symbol, Class>
+      @plugins = {}
+      register_plugins_from_gems if parse_gems
+    end
+
+    # Make an API similar to a Hash, delegated to @plugins
+    extend Forwardable
+    def_delegators :@plugins, *%i[
+      []
+      each
+      empty?
+      key?
+      keys
+      select
+      to_hash
+      values
+    ]
+
+    # Register a new plugin
+    #
+    # Parameters::
+    # * *plugin_id* (Symbol): The plugin ID to register
+    # * *plugin_class* (Class): The corresponding plugin class
+    def []=(plugin_id, plugin_class)
+      if @plugins.key?(plugin_id)
+        log_warn "[ #{@plugins_type} ] - A plugin of type #{@plugins_type} named #{plugin_id} is already registered. Can't overwrite #{@plugins[plugin_id]} with #{plugin_class.name}. Will ignore #{plugin_class.name}."
+      else
+        # Set the logger in the class so that we can use it in class methods
+        plugin_class.logger = @logger
+        plugin_class.logger_stderr = @logger_stderr
+        if plugin_class.valid?
+          log_debug "[ #{@plugins_type} ] - Register #{plugin_id} to #{plugin_class.name}."
+          @plugins[plugin_id] = @init_plugin.nil? ? plugin_class : @init_plugin.call(plugin_class)
+        else
+          log_error "[ #{@plugins_type} ] - The plugin #{plugin_id} (#{plugin_class.name}) is missing some dependencies to be activated. Will ignore it."
+        end
+      end
+    end
+
+    private
+
+    # 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$/
+      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
+        end
+      end
+      # Parse the registered classes to search for our plugins
+      ancestor_class = HybridPlatformsConductor.const_get(@plugins_type.to_s.split('_').collect(&:capitalize).join.to_sym)
+      ObjectSpace.each_object(Class).each do |klass|
+        # Only select classes that:
+        # * 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
+        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
+          self[plugin_id] = klass
+        end
+      end
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/provisioner.rb

@@ -0,0 +1,181 @@
+require 'hybrid_platforms_conductor/logger_helpers'
+require 'hybrid_platforms_conductor/plugin'
+
+module HybridPlatformsConductor
+
+  # Base class for any provisioner
+  class Provisioner < Plugin
+
+    include LoggerHelpers
+
+    # Constructor
+    #
+    # Parameters::
+    # * *node* (String): Node for which we provision a running instance
+    # * *environment* (String): Environment for which this running instance is provisioned [default: 'production']
+    # * *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): Command executor to be used. [default: CmdRunner.new]
+    # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default: NodesHandler.new]
+    # * *actions_executor* (ActionsExecutor): Actions Executor to be used. [default: ActionsExecutor.new]
+    def initialize(
+      node,
+      environment: 'production',
+      logger: Logger.new(STDOUT),
+      logger_stderr: Logger.new(STDERR),
+      config: Config.new,
+      cmd_runner: CmdRunner.new,
+      nodes_handler: NodesHandler.new,
+      actions_executor: ActionsExecutor.new
+    )
+      super(logger: logger, logger_stderr: logger_stderr, config: config)
+      @node = node
+      @environment = environment
+      @cmd_runner = cmd_runner
+      @nodes_handler = nodes_handler
+      @actions_executor = actions_executor
+    end
+
+    # Return the default timeout to apply when waiting for an instance to be started/stopped...
+    #
+    # Result::
+    # * Integer: The timeout in seconds
+    def default_timeout
+      60
+    end
+
+    # Provision a running instance for the needed node and environment.
+    # If the instance is already created, re-uses it.
+    # If the instance is already running, re-uses it.
+    # Enriches the nodes handler information with the instance metadata as well.
+    # Calls client code only when the instance is up and running, and fail otherwise.
+    #
+    # Parameters::
+    # * *stop_on_exit* (Boolean): Do we stop the instance when exiting? [default: false]
+    # * *destroy_on_exit* (Boolean): Do we destroy the instance when exiting? Ignored if stop_on_exit is false [default: false]
+    # * *port* (Integer or nil): Port to wait to be opened, or nil if none [default: nil]
+    # * Proc: Client code called with the instance up and running
+    def with_running_instance(stop_on_exit: false, destroy_on_exit: false, port: nil)
+      log_debug "[ #{@node}/#{@environment} ] - Create instance..."
+      create
+      begin
+        wait_for_state!(%i[running created exited])
+        if %i[created exited].include?(state)
+          log_debug "[ #{@node}/#{@environment} ] - Start instance..."
+          start
+        end
+        begin
+          wait_for_state!(:running)
+          instance_ip = ip
+          if instance_ip.nil?
+            log_debug "[ #{@node}/#{@environment} ] - No host_ip linked to the instance."
+          elsif instance_ip != @nodes_handler.get_host_ip_of(@node)
+            log_debug "[ #{@node}/#{@environment} ] - Set host_ip to #{instance_ip}."
+            # The instance is running on an IP that is not the one registered by default in the metadata.
+            # Make sure we update it.
+            @nodes_handler.override_metadata_of @node, :host_ip, instance_ip
+            @nodes_handler.invalidate_metadata_of @node, :host_keys
+          end
+          wait_for_port!(port) if port
+          yield
+        ensure
+          if stop_on_exit
+            log_debug "[ #{@node}/#{@environment} ] - Stop instance..."
+            stop
+            wait_for_state!(:exited)
+          end
+        end
+      ensure
+        if stop_on_exit && destroy_on_exit
+          log_debug "[ #{@node}/#{@environment} ] - Destroy instance..."
+          destroy
+        end
+      end
+    end
+
+    # Wait for an instance to be in a given state.
+    #
+    # Parameters::
+    # * *states* (Symbol or Array<Symbol>): States (or single state) the instance should be in
+    # * *timeout* (Integer): Timeout before failing, in seconds [default = default_timeout]
+    # Result::
+    # * Boolean: Is the instance in one of the expected states?
+    def wait_for_state(states, timeout = default_timeout)
+      states = [states] unless states.is_a?(Array)
+      log_debug "[ #{@node}/#{@environment} ] - Wait for instance to be in state #{states.join(', ')} (timeout #{timeout})..."
+      current_state = nil
+      remaining_timeout = timeout
+      until states.include?(current_state)
+        start_time = Time.now
+        current_state = state
+        sleep 1 unless states.include?(current_state)
+        remaining_timeout -= Time.now - start_time
+        break if remaining_timeout <= 0
+      end
+      log_debug "[ #{@node}/#{@environment} ] - Instance is in state #{current_state}"
+      states.include?(current_state)
+    end
+
+    # Wait for an instance to be in a given state, and fail if it can't.
+    #
+    # Parameters::
+    # * *states* (Symbol or Array<Symbol>): States (or single state) the instance should be in
+    # * *timeout* (Integer): Timeout before failing, in seconds [default = default_timeout]
+    def wait_for_state!(states, timeout = default_timeout)
+      states = [states] unless states.is_a?(Array)
+      raise "[ #{@node}/#{@environment} ] - Instance fails to be in a state among (#{states.join(', ')}) with timeout #{timeout}. Currently in state #{state}" unless wait_for_state(states, timeout)
+    end
+
+    # Wait for a given ip/port to be listening before continuing.
+    #
+    # Parameters::
+    # * *port* (Integer): Port to wait for
+    # * *timeout* (Integer): Timeout before failing, in seconds [default = default_timeout]
+    # Result::
+    # * Boolean: Is port listening?
+    def wait_for_port(port, timeout = default_timeout)
+      instance_ip = ip
+      log_debug "[ #{@node}/#{@environment} ] - Wait for #{instance_ip}:#{port} to be opened (timeout #{timeout})..."
+      port_listening = false
+      remaining_timeout = timeout
+      until port_listening
+        start_time = Time.now
+        port_listening =
+          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}: #{$!}"
+            false
+          end
+        sleep 1 unless port_listening
+        remaining_timeout -= Time.now - start_time
+        break if remaining_timeout <= 0
+      end
+      log_debug "[ #{@node}/#{@environment} ] - #{instance_ip}:#{port} is#{port_listening ? '' : ' not'} opened."
+      port_listening
+    end
+
+    # Wait for a given ip/port to be listening before continuing.
+    # Fail if it does not listen.
+    #
+    # Parameters::
+    # * *port* (Integer): Port to wait for
+    # * *timeout* (Integer): Timeout before failing, in seconds [default = default_timeout]
+    def wait_for_port!(port, timeout = default_timeout)
+      raise "[ #{@node}/#{@environment} ] - Instance fails to have port #{port} opened with timeout #{timeout}." unless wait_for_port(port, timeout)
+    end
+
+    # Return the IP address of an instance.
+    # Prerequisite: create has been called before.
+    # [API] - This method is optional
+    #
+    # Result::
+    # * String or nil: The instance IP address, or nil if this information is not relevant
+    def ip
+      nil
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/report.rb

@@ -0,0 +1,31 @@
+require 'hybrid_platforms_conductor/logger_helpers'
+require 'hybrid_platforms_conductor/plugin'
+
+module HybridPlatformsConductor
+
+  # Ancestor of all report plugins
+  class Report < 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]
+    # * *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),
+      config: Config.new,
+      platforms_handler: PlatformsHandler.new,
+      nodes_handler: NodesHandler.new
+    )
+      super(logger: logger, logger_stderr: logger_stderr, config: config)
+      @platforms_handler = platforms_handler
+      @nodes_handler = nodes_handler
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/reports_handler.rb

@@ -0,0 +1,84 @@
+require 'logger'
+require 'hybrid_platforms_conductor/logger_helpers'
+require 'hybrid_platforms_conductor/plugins'
+
+module HybridPlatformsConductor
+
+  # Gives ways to produce reports
+  class ReportsHandler
+
+    include LoggerHelpers
+
+    # Format in which the reports handler will provide reports
+    # Symbol
+    attr_accessor :format
+
+    # Locale in which the reports handler will provide reports
+    # Symbol
+    attr_accessor :locale
+
+    # 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]
+    # * *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),
+      config: Config.new,
+      platforms_handler: PlatformsHandler.new,
+      nodes_handler: NodesHandler.new
+    )
+      init_loggers(logger, logger_stderr)
+      @config = config
+      @platforms_handler = platforms_handler
+      @nodes_handler = nodes_handler
+      @platforms_handler.inject_dependencies(nodes_handler: @nodes_handler, actions_executor: nil)
+      # The list of reports plugins, with their associated class
+      # Hash< Symbol, Class >
+      @reports_plugins = Plugins.new(:report, logger: @logger, logger_stderr: @logger_stderr)
+      @format = :stdout
+      @locale = @reports_plugins[@format].supported_locales.first
+    end
+
+    # Complete an option parser with options meant to control this Reports handler
+    #
+    # Parameters::
+    # * *options_parser* (OptionParser): The option parser to complete
+    def options_parse(options_parser)
+      options_parser.separator ''
+      options_parser.separator 'Reports handler options:'
+      options_parser.on('-c', '--locale LOCALE_CODE', "Generate the report in the given format. Possible codes are formats specific. #{@reports_plugins.map { |format, klass| "[#{format}: #{klass.supported_locales.join(', ')}]" }.join(', ')}") do |str_locale|
+        @locale = str_locale.to_sym
+      end
+      options_parser.on('-f', '--format FORMAT', "Generate the report in the given format. Possible formats are #{@reports_plugins.keys.sort.join(', ')}. Default: #{@format}.") do |str_format|
+        @format = str_format.to_sym
+      end
+    end
+
+    # Validate that parsed parameters are valid
+    def validate_params
+      raise "Unknown format: #{@format}" unless @reports_plugins.keys.include? @format
+    end
+
+    # Produce a report for a given list of nodes selectors
+    #
+    # Parameters::
+    # * *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,
+        config: @config,
+        platforms_handler: @platforms_handler,
+        nodes_handler: @nodes_handler
+      ).report_for(@nodes_handler.select_nodes(nodes_selectors), @locale)
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/services_handler.rb

@@ -0,0 +1,274 @@
+require 'git'
+require 'hybrid_platforms_conductor/cmd_runner'
+require 'hybrid_platforms_conductor/cmdb'
+require 'hybrid_platforms_conductor/logger_helpers'
+require 'hybrid_platforms_conductor/parallel_threads'
+require 'hybrid_platforms_conductor/platform_handler'
+
+module HybridPlatformsConductor
+
+  # API around the services that can be deployed
+  class ServicesHandler
+
+    class << self
+
+      # List of deployments that have been packaged.
+      # Each deployment has the following info:
+      # * *platform_name* (String): The platform name
+      # * *services* (Hash< String, Array<String> >): Services to be deployed, per node
+      # * *secrets* (Hash): Secrets for which this has been packaged
+      # * *local_environment* (Boolean): Has it been packaged for local environment?
+      # Make this at class level as several Deployer instances can be used in a multi-thread environmnent.
+      #   Array< Hash<Symbol, Object> >
+      attr_reader :packaged_deployments
+
+    end
+
+    @packaged_deployments = []
+
+    include LoggerHelpers, ParallelThreads
+
+    # 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): Command executor to be used. [default: CmdRunner.new]
+    # * *platforms_handler* (PlatformsHandler): Platforms Handler to be used. [default: PlatformsHandler.new]
+    # * *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),
+      config: Config.new,
+      cmd_runner: CmdRunner.new,
+      platforms_handler: PlatformsHandler.new,
+      nodes_handler: NodesHandler.new,
+      actions_executor: ActionsExecutor.new
+    )
+      init_loggers(logger, logger_stderr)
+      @config = config
+      @cmd_runner = cmd_runner
+      @platforms_handler = platforms_handler
+      @nodes_handler = nodes_handler
+      @actions_executor = actions_executor
+      @platforms_handler.inject_dependencies(nodes_handler: @nodes_handler, actions_executor: @actions_executor)
+    end
+
+    # Are we allowed to deploy?
+    # This checks eventual restrictions on deployments, considering environments, options, secrets...
+    #
+    # 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
+        nil
+      else
+        # Check that master is checked out correctly before deploying.
+        # Check it on every platform having at least 1 node to be deployed.
+        wrong_platforms = platforms_for(services).keys.select do |platform|
+          git = nil
+          begin
+            git = Git.open(platform.repository_path)
+          rescue
+            log_debug "Platform #{platform.repository_path} is not a git repository"
+          end
+          if git.nil?
+            false
+          else
+            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
+              )
+            end
+          end
+        end
+        if wrong_platforms.empty?
+          nil
+        else
+          "The following platforms have not checked out master: #{wrong_platforms.map(&:repository_path).join(', ')}. Only master should be deployed in production."
+        end
+      end
+    end
+
+    # Package a configuration for a given deployment
+    #
+    # 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?
+    def package(
+      services:,
+      secrets:,
+      local_environment:
+    )
+      platforms_for(services).each do |platform, platform_services|
+        platform_name = platform.name
+        deployment_info = {
+          platform_name: platform_name,
+          services: platform_services,
+          secrets: secrets,
+          local_environment: local_environment
+        }
+        if ServicesHandler.packaged_deployments.include?(deployment_info)
+          log_debug "Platform #{platform_name} has already been packaged for this deployment. Won't package it another time."
+        else
+          platform.package(
+            services: platform_services,
+            secrets: secrets,
+            local_environment: local_environment
+          )
+          ServicesHandler.packaged_deployments << deployment_info
+        end
+      end
+    end
+
+    # Prepare the deployment to be performed
+    #
+    # 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?
+    # * *why_run* (Boolean): Are we deploying in why-run mode?
+    def prepare_for_deploy(
+      services:,
+      secrets:,
+      local_environment:,
+      why_run:
+    )
+      platforms_for(services).each do |platform, platform_services|
+        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
+
+    # Get actions to be executed to deploy services to a node
+    #
+    # Parameters::
+    # * *node* (String): The node to be deployed
+    # * *services* (Array<String>): List of services to deploy on this node
+    # * *why_run* (Boolean): Are we in why-run mode?
+    # Result::
+    # * 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) }
+        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' } ====="
+        [{
+          ruby: proc do |stdout, stderr|
+            stdout << "#{deploy_marker} Begin\n"
+            stderr << "#{deploy_marker} Begin\n"
+          end
+        }] +
+          platform.actions_to_deploy_on(node, service, use_why_run: why_run) +
+          [{
+            ruby: proc do |stdout, stderr|
+              stdout << "#{deploy_marker} End\n"
+              stderr << "#{deploy_marker} End\n"
+            end
+          }]
+      end.flatten
+    end
+
+    # Get some information to be logged regarding a deployment of services on a node
+    #
+    # Parameters::
+    # * *node* (String): The node for which we get the info
+    # * *services* (Array<String>): Services that have been deployed on this node
+    # Result::
+    # * Hash<Symbol,Object>: Information to be added to the deployment logs
+    def log_info_for(node, services)
+      log_info = {}
+      # Get all platforms involved in the deployment of those services on this node
+      platforms_for(node => services).keys.each.with_index do |platform, platform_idx|
+        log_info.merge!(
+          "repo_name_#{platform_idx}".to_sym => platform.name
+        )
+        if platform.info.key?(:commit)
+          log_info.merge!(
+            "commit_id_#{platform_idx}".to_sym => platform.info[:commit][:id],
+            "commit_message_#{platform_idx}".to_sym => platform.info[:commit][:message].split("\n").first,
+            "diff_files_#{platform_idx}".to_sym => (platform.info[:status][:changed_files] + platform.info[:status][:added_files] + platform.info[:status][:deleted_files] + platform.info[:status][:untracked_files]).join(', ')
+          )
+        end
+      end
+      log_info
+    end
+
+    # Regexp: The marker regexp used to separate services deployment
+    MARKER_REGEXP = /^===== \[ (.+?) \/ (.+?) \] - 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.
+    #
+    # Parameters::
+    # * *stdout* (String): stdout to be parsed.
+    # * *stderr* (String): stderr to be parsed.
+    # Result::
+    # * Array< Hash<Symbol,Object> >: List of deployed services (in the order of the logs). Here are the returned properties:
+    #   * *node* (String): Node that has been deployed
+    #   * *service* (String): Service that has been deployed
+    #   * *check* (Boolean): Has the service been deployed in check-mode?
+    #   * *tasks* (Array< Hash<Symbol,Object> >): List of task properties. The following properties should be returned, among free ones:
+    #     * *name* (String): Task name
+    #     * *status* (Symbol): Task status. Should be on of:
+    #       * *:changed*: The task has been changed
+    #       * *:identical*: The task has not been changed
+    #     * *diffs* (String): Differences, if any
+    def parse_deploy_output(stdout, stderr)
+      stdout.scan(MARKER_REGEXP).zip(stderr.scan(MARKER_REGEXP)).map do |((stdout_node, stdout_service, stdout_mode, stdout_logs), (stderr_node, stderr_service, stderr_mode, stderr_logs))|
+        # Some consistency checking
+        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) }
+        raise "No platform is able to deploy the service #{stdout_service}" if platform.nil?
+        {
+          node: stdout_node,
+          service: stdout_service,
+          check: stdout_mode == 'Check',
+          tasks: platform.parse_deploy_output(stdout_logs, stderr_logs || '')
+        }
+      end
+    end
+
+    private
+
+    # Get platforms concerned by a list of services to be deployed per node
+    #
+    # Parameters::
+    # * *services* (Hash< String, Array<String> >): Services to be deployed, per node
+    # Result::
+    # * Hash< PlatformHandler, Hash< String, Array<String> > >: List of services to be deployed, per node, per PlatformHandler handling those services
+    def platforms_for(services)
+      concerned_platforms = {}
+      @platforms_handler.known_platforms.each do |platform|
+        deployable_nodes = {}
+        platform_services = platform.deployable_services
+        services.each do |node, node_services|
+          node_deployable_services = platform_services & node_services
+          deployable_nodes[node] = node_deployable_services unless node_deployable_services.empty?
+        end
+        concerned_platforms[platform] = deployable_nodes unless deployable_nodes.empty?
+      end
+      concerned_platforms
+    end
+
+  end
+
+end