opennebula 6.10.3 → 6.99.85.pre

data/lib/DriverExecHelper.rb

@@ -1,213 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2024, OpenNebula Project, OpenNebula Systems                #
-#                                                                            #
-# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
-# not use this file except in compliance with the License. You may obtain    #
-# a copy of the License at                                                   #
-#                                                                            #
-# http://www.apache.org/licenses/LICENSE-2.0                                 #
-#                                                                            #
-# Unless required by applicable law or agreed to in writing, software        #
-# distributed under the License is distributed on an "AS IS" BASIS,          #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
-# See the License for the specific language governing permissions and        #
-# limitations under the License.                                             #
-#--------------------------------------------------------------------------- #
-
-# This module provides an abstraction to generate an execution context for
-# OpenNebula Drivers. The module has been designed to be included as part
-# of a driver and not to be used standalone.
-module DriverExecHelper
-
-    # Action result strings for messages
-    RESULT = {
-        :success => 'SUCCESS',
-        :failure => 'FAILURE'
-    }
-
-    def self.failed?(rc_str)
-        rc_str == RESULT[:failure]
-    end
-
-    # Initialize module variables
-    def initialize_helper(directory, options)
-        @config = read_configuration
-        @remote_scripts_base_path = @config['SCRIPTS_REMOTE_DIR']
-
-        @local_actions = options[:local_actions]
-        @per_drvr_local_actions = options[:per_drvr_local_actions] || []
-
-        if ENV['ONE_LOCATION'].nil?
-            @local_scripts_base_path = '/var/lib/one/remotes'
-        else
-            @local_scripts_base_path = "#{ENV['ONE_LOCATION']}/var/remotes"
-        end
-
-        # dummy paths
-        @remote_scripts_path = File.join(@remote_scripts_base_path, directory)
-        @local_scripts_path  = File.join(@local_scripts_base_path, directory)
-
-        # mutex for logging
-        @send_mutex = Mutex.new
-    end
-
-    #
-    #                 METHODS FOR COMMAND LINE & ACTION PATHS
-    #
-    # Given the action name and the parameter returns full path of the script
-    # and appends its parameters. It uses @local_actions hash to know if the
-    # actions is remote or local. If the local actions has defined an special
-    # script name this is used, otherwise the action name in downcase is
-    # used as the script name.
-    # When action is a String starting with '/' it's considered alreay full
-    # path command and no modification is performed apart from adding params.
-    #
-    # @param [String, Symbol] action name of the action
-    # @param [String] parameters arguments for the script
-    # @param [String, nil] default_name alternative name for the script
-    # @param [String, ''] directory to append to the scripts path for actions
-    # @return [String] command line needed to execute the action
-    def action_command_line(action, parameters, default_name = nil, directory = '')
-        if action.is_a?(String) && action[0] == '/'
-            return action + ' ' + parameters if parameters
-
-            return action
-        elsif action_is_local?(action, directory)
-            script_path=File.join(@local_scripts_path, directory)
-        else
-            script_path=File.join(@remote_scripts_path, directory)
-        end
-
-        File.join(script_path, action_script_name(action, default_name))+
-            ' '+parameters
-    end
-
-    # True if the action is meant to be executed locally
-    #
-    # @param [String, Symbol] action name of the action
-    # @param [String, Symbol] driver name
-    def action_is_local?(action, driver = '')
-        @local_actions.include? action.to_s.upcase if driver.empty?
-
-        @local_actions.include? action.to_s.upcase or
-            @per_drvr_local_actions.include? "#{driver}-#{action}"
-    end
-
-    # Name of the script file for the given action
-    #
-    # @param [String, Symbol] action name of the action
-    # @param [String, nil] default_name alternative name for the script
-    def action_script_name(action, default_name = nil)
-        name=@local_actions[action.to_s.upcase]
-
-        name || default_name || action.to_s.downcase
-    end
-
-    #
-    #                METHODS FOR LOGS & COMMAND OUTPUT
-    #
-    # Sends a message to the OpenNebula core through stdout
-    # rubocop:disable Metrics/ParameterLists
-    def send_message(action = '-', result = RESULT[:failure], id = '-', info = '-')
-        @send_mutex.synchronize do
-            STDOUT.puts "#{action} #{result} #{id} #{info}"
-            STDOUT.flush
-        end
-    end
-    # rubocop:enable Metrics/ParameterLists
-
-    # Sends a log message to ONE. The +message+ can be multiline, it will
-    # be automatically splitted by lines.
-    def log(number, message, all = true)
-        msg = message.strip
-
-        msg.each_line do |line|
-            all ? severity='I' : severity=nil
-
-            if line.match(/^(ERROR|DEBUG|INFO):(.*)$/)
-                line=Regexp.last_match(2)
-
-                case Regexp.last_match(1)
-                when 'ERROR'
-                    severity='E'
-                when 'DEBUG'
-                    severity='D'
-                when 'INFO'
-                    severity='I'
-                end
-            end
-
-            send_message('LOG', severity, number, line.strip) if severity
-        end
-    end
-
-    # Generates a proc with that calls log with a hardcoded number. It will
-    # be used to add loging to command actions
-    def log_method(num)
-        lambda {|message, all = true|
-            log(num, message, all)
-        }
-    end
-
-    # This method returns the result in terms
-    def get_info_from_execution(command_exe)
-        if command_exe.code == 0
-            result = RESULT[:success]
-            info   = command_exe.stdout
-        else
-            result = RESULT[:failure]
-            info   = command_exe.get_error_message
-        end
-
-        info = '-' if info.nil? || info.empty?
-
-        [result, info]
-    end
-
-    #
-    #
-    # Simple parser for the config file generated by OpenNebula
-    def read_configuration
-        one_config=nil
-
-        if ENV['ONE_LOCATION']
-            one_config = ENV['ONE_LOCATION']+'/var/config'
-        else
-            one_config = '/var/lib/one/config'
-        end
-
-        config = {}
-        cfg    = ''
-
-        begin
-            File.open(one_config, 'r') do |file|
-                cfg=file.read
-            end
-
-            cfg.split("\n").each do |line|
-                m=line.match(/^([^=]+)=(.*)$/)
-
-                next unless m
-
-                name  = m[1].strip.upcase
-                value = m[2].strip
-
-                if config[name]
-                    if config[name].instance_of? Array
-                        config[name] << value
-                    else
-                        config[name] = [config[name], value]
-                    end
-                else
-                    config[name]=value
-                end
-            end
-        rescue StandardError => e
-            STDERR.puts "Error reading config: #{e.inspect}"
-            STDERR.flush
-        end
-
-        config
-    end
-
-end

data/lib/HostSyncManager.rb

@@ -1,111 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2024, OpenNebula Project, OpenNebula Systems                #
-#                                                                            #
-# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
-# not use this file except in compliance with the License. You may obtain    #
-# a copy of the License at                                                   #
-#                                                                            #
-# http://www.apache.org/licenses/LICENSE-2.0                                 #
-#                                                                            #
-# Unless required by applicable law or agreed to in writing, software        #
-# distributed under the License is distributed on an "AS IS" BASIS,          #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
-# See the License for the specific language governing permissions and        #
-# limitations under the License.                                             #
-# -------------------------------------------------------------------------- #
-
-# rubocop:disable Lint/MissingCopEnableDirective
-# rubocop:disable Layout/FirstArgumentIndentation
-# rubocop:disable Layout/FirstHashElementIndentation
-# rubocop:disable Layout/HashAlignment
-# rubocop:disable Layout/HeredocIndentation
-# rubocop:disable Layout/IndentationWidth
-# rubocop:disable Style/HashSyntax
-# rubocop:disable Style/ParallelAssignment
-
-require 'CommandManager'
-
-# This helper module introduces a common routine that synchronizes
-# the "remotes".
-class HostSyncManager
-
-    def initialize(one_config = nil)
-        one_location = ENV['ONE_LOCATION']&.delete("'")
-        if one_location.nil?
-            @one_config_path         = '/var/lib/one/config'
-            @local_scripts_base_path = '/var/lib/one/remotes'
-        else
-            @one_config_path         = one_location + '/var/config'
-            @local_scripts_base_path = one_location + '/var/remotes'
-        end
-
-        # Do a simple parsing of the config file unless the values
-        # are already provided. NOTE: We don't care about "arrays" here..
-        one_config ||= File.read(@one_config_path).lines.each_with_object({}) \
-        do |line, object|
-            key, value = line.split('=').map(&:strip)
-            object[key.upcase] = value
-        end
-
-        @remote_scripts_base_path = one_config['SCRIPTS_REMOTE_DIR']
-        @remote_scripts_base_path&.delete!("'")
-    end
-
-    def update_remotes(hostname, logger = nil, copy_method = :rsync, subset = nil)
-        sources = '.'
-
-        if subset && copy_method == :rsync
-            # Make sure all files in the subset exist (and are relative).
-            subset.each do |path|
-                File.realpath path, @local_scripts_base_path
-            end
-
-            sources = subset.join(' ')
-        end
-
-        assemble_cmd = lambda do |steps|
-            "exec 2>/dev/null; #{steps.join(' && ')}"
-        end
-
-        case copy_method
-        when :ssh
-            mkdir_cmd = assemble_cmd.call [
-                "rm -rf '#{@remote_scripts_base_path}'/",
-                "mkdir -p '#{@remote_scripts_base_path}'/"
-            ]
-
-            sync_cmd = assemble_cmd.call [
-                "cd '#{@local_scripts_base_path}'/",
-                "scp -rp #{sources} " \
-                    "'#{hostname}':'#{@remote_scripts_base_path}'/"
-            ]
-        when :rsync
-            mkdir_cmd = assemble_cmd.call [
-                "mkdir -p '#{@remote_scripts_base_path}'/"
-            ]
-
-            sync_cmd = assemble_cmd.call [
-                "cd '#{@local_scripts_base_path}'/",
-                "rsync -LRaz --delete #{sources} " \
-                    "'#{hostname}':'#{@remote_scripts_base_path}'/"
-            ]
-        end
-
-        cmd = SSHCommand.run(mkdir_cmd, hostname, logger)
-        return cmd.code if error?(cmd)
-
-        cmd = LocalCommand.run(sync_cmd, logger)
-        return cmd.code if error?(cmd)
-
-        0
-    end
-
-    def error?(cmd)
-        return false if cmd.code == 0
-
-        STDERR.puts cmd.stderr
-        STDOUT.puts cmd.stdout
-        true
-    end
-
-end

data/lib/OpenNebulaDriver.rb

@@ -1,223 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2024, OpenNebula Project, OpenNebula Systems                #
-#                                                                            #
-# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
-# not use this file except in compliance with the License. You may obtain    #
-# a copy of the License at                                                   #
-#                                                                            #
-# http://www.apache.org/licenses/LICENSE-2.0                                 #
-#                                                                            #
-# Unless required by applicable law or agreed to in writing, software        #
-# distributed under the License is distributed on an "AS IS" BASIS,          #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
-# See the License for the specific language governing permissions and        #
-# limitations under the License.                                             #
-#--------------------------------------------------------------------------- #
-
-require 'ActionManager'
-require 'CommandManager'
-
-require 'DriverExecHelper'
-require 'base64'
-
-# This class provides basic messaging and logging functionality
-# to implement OpenNebula Drivers. A driver is a program that
-# specialize the OpenNebula behavior by interfacing with specific
-# infrastructure functionalities.
-#
-# A Driver inherits this class and only has to provide methods
-# for each action it wants to receive. The method must be associated
-# with the action name through the register_action function
-class OpenNebulaDriver < ActionManager
-
-    include DriverExecHelper
-
-    # @return [String] Base path for scripts
-    attr_reader :local_scripts_base_path, :remote_scripts_base_path
-    # @return [String] Path for scripts
-    attr_reader :local_scripts_path, :remote_scripts_path
-
-    # Initialize OpenNebulaDriver object
-    #
-    # @param [String] directory path inside the remotes directory where the
-    #   scripts are located
-    # @param [Hash] options named options to change the object's behaviour
-    # @option options [Number] :concurrency (10) max number of threads
-    # @option options [Boolean] :threaded (true) enables or disables threads
-    # @option options [Number] :retries (0) number of retries to copy scripts
-    #   to the remote host
-    # @option options [Hash] :local_actions ({}) hash with the actions
-    #   executed locally and the name of the script if it differs from the
-    #   default one. This hash can be constructed using {parse_actions_list}
-    def initialize(directory, options = {})
-        @options={
-            :concurrency => 10,
-            :threaded => true,
-            :retries => 0,
-            :local_actions => {},
-            :timeout => nil
-        }.merge!(options)
-
-        super(@options[:concurrency], @options[:threaded])
-
-        @retries = @options[:retries]
-        @timeout = @options[:timeout]
-
-        # Set default values
-        initialize_helper(directory, @options)
-
-        register_action(:INIT, method('init'))
-    end
-
-    # Calls remotes or local action checking the action name and
-    # @local_actions. Optional arguments can be specified as a hash
-    #
-    # @param [String] parameters arguments passed to the script
-    # @param [Number, String] id action identifier
-    # @param [String] host hostname where the action is going to be executed
-    # @param [String, Symbol] aname name of the action
-    # @param [Hash] ops extra options for the command
-    # @option ops [String] :stdin text to be writen to stdin
-    # @option ops [String] :script_name default script name for the action,
-    #   action name is used by defaults
-    # @option ops [Bool] :respond if defined will send result to ONE core
-    # @option ops [Bool] :base64 encode the information sent to ONE core
-    # @option ops [Bool] :zip compress the information sent to ONE core
-    def do_action(parameters, id, host, aname, ops = {})
-        options = {
-            :stdin => nil,
-            :script_name => nil,
-            :respond => true,
-            :ssh_stream => nil,
-            :base64 => false,
-            :zip => false,
-            :no_extra_params => false
-        }.merge(ops)
-
-        params = parameters
-        params = "#{params} #{id} #{host}" unless options[:no_extra_params]
-        command = action_command_line(aname, params, options[:script_name])
-
-        # if options[:is_local] is not specified (nil)
-        # we rely uniquely in actions_is_local?
-        if action_is_local?(aname) or options[:is_local]
-            stdin = Base64.strict_encode64(options[:stdin].to_s)
-            execution = LocalCommand.run(command,
-                                         log_method(id),
-                                         stdin,
-                                         @timeout)
-        elsif options[:ssh_stream]
-            if options[:stdin]
-                cmdin = "cat << 'EOT' | #{command}"
-                stdin = "#{options[:stdin]}\nEOT\n"
-            else
-                cmdin = command
-                stdin = nil
-            end
-
-            execution = options[:ssh_stream].run(cmdin,
-                                                 stdin,
-                                                 command,
-                                                 @timeout)
-        else
-            execution = RemotesCommand.run(command,
-                                           host,
-                                           @remote_scripts_base_path,
-                                           log_method(id),
-                                           options[:stdin],
-                                           @retries,
-                                           @timeout)
-        end
-
-        result, info = get_info_from_execution(execution)
-
-        if options[:respond]
-            info = Zlib::Deflate.deflate(info, Zlib::BEST_COMPRESSION) if options[:zip]
-            info = Base64.strict_encode64(info) if options[:base64]
-
-            send_message(aname, result, id, info)
-        end
-
-        [result, info]
-    end
-
-    # Start the driver. Reads from STDIN and executes methods associated with
-    # the messages
-    def start_driver
-        Thread.new { loop }
-        start_listener
-    end
-
-    # This function parses a string with this form:
-    #
-    #   'deploy,shutdown,poll=poll_ganglia, cancel '
-    #
-    # and returns a hash:
-    #
-    #   {"POLL"=>"poll_ganglia", "DEPLOY"=>nil, "SHUTDOWN"=>nil,
-    #     "CANCEL"=>nil}
-    #
-    # @param [String] str imput string to parse
-    # @return [Hash] parsed actions
-    def self.parse_actions_list(str)
-        actions = {}
-        str_splitted = str.split(/\s*,\s*/).map {|s| s.strip }
-
-        str_splitted.each do |a|
-            m=a.match(/([^=]+)(=(.*))?/)
-            next unless m
-
-            action=m[1].upcase
-
-            if m[2]
-                script=m[3]
-                script.strip! if script
-            else
-                script=nil
-            end
-
-            actions[action]=script
-        end
-
-        actions
-    end
-
-    private
-
-    def init
-        send_message('INIT', RESULT[:success])
-    end
-
-    def loop
-        Kernel.loop do
-            exit!(-1) if STDIN.eof?
-
-            str = STDIN.gets
-            next unless str
-
-            args = str.split(/\s+/)
-            next if args.empty?
-
-            if args.first.empty?
-                STDERR.puts "Malformed message: #{str.inspect}"
-                next
-            end
-
-            action = args.shift.upcase.to_sym
-
-            if args.empty? || !args[0]
-                action_id = 0
-            else
-                action_id = args[0].to_i
-            end
-
-            if action == :DRIVER_CANCEL
-                cancel_action(action_id)
-                log(action_id, "Driver command for #{action_id} cancelled")
-            else
-                trigger_action(action, action_id, *args)
-            end
-        end
-    end
-
-end