opennebula 6.10.3 → 6.99.85.pre

data/lib/ActionManager.rb

@@ -1,280 +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 'thread'
-
-=begin rdoc
-
-This class provides support to handle actions. Class methods, or actions, can be
-registered in the action manager. The manager will wait for actions to be
-triggered (thread-safe), and will execute them concurrently. The action manager
-can be used to synchronize different objects in different threads
-
-== Example
-
-    class Sample
-        attr_reader :am
-
-        def initialize
-            @am = ActionManager.new(15,true)
-
-            @am.register_action("SLEEP",method("sleep_action"))
-        end
-
-        def sleep_action(secs)
-            sleep(secs)
-        end
-
-        def finalize_action
-            p "Exiting..."
-            @am.stop_listener
-        end
-    end
-
-
-    s = Sample.new
-
-    s.@am.start_listener
-
-#   Objects in other threads can trigger actions like this
-#   s.am.trigger_action("SLEEP",rand(3)+1)
-#   s.am.trigger_action("FINALIZE")
-=end
-
-class ActionManager
-
-    # Creates a new Action Manager
-    #
-    # +concurrency+ is the maximun number of actions that can run at the same
-    # time
-    # +threaded+ if true actions will be executed by default in a different
-    # thread
-    def initialize(concurrency=10, threaded=true)
-        @finalize       = false
-        @actions        = Hash.new
-        @threaded       = threaded
-
-        @concurrency    = concurrency
-        @num_running    = 0
-
-        @action_queue   = Array.new
-        @action_running = Hash.new
-
-        @threads_mutex  = Mutex.new
-        @threads_cond   = ConditionVariable.new
-    end
-
-    # Registers a new action in the manager. An action is defined by:
-    #
-    # +aname+ name of the action, it will identify the action
-    # +method+ it's invoked with call. It should be a Proc or Method object
-    # +threaded+ execute the action in a new thread
-    def register_action(aname, method, threaded=nil)
-        threaded ||= @threaded
-
-        @actions[aname]={
-            :method     => method,
-            :threaded   => threaded
-        }
-    end
-
-    # Triggers the execution of the action.
-    #
-    # +aname+ name of the action
-    # +action_id+ an id to identify the action (to cancel it later)
-    # +aargs+ arguments to call the action
-    def trigger_action(aname, action_id, *aargs)
-
-        @threads_mutex.synchronize {
-            return if @finalize
-
-            if aname == :FINALIZE
-                finalize if respond_to?(:finalize)
-                @finalize = true
-                @threads_cond.signal if @num_running == 0
-                return
-            end
-
-            if !@actions.has_key?(aname)
-                return
-            end
-
-            arity=@actions[aname][:method].arity
-
-            if arity < 0
-                # Last parameter is an array
-                arity = -arity - 1
-                if arity > aargs.length
-                    # Message has not enough parameters
-                    return
-                end
-                # Converts last parameters to an array
-                aargs[arity..-1]=[aargs[arity..-1]]
-            else
-                if arity != aargs.length
-                    return
-                end
-            end
-
-            @action_queue << @actions[aname].merge(:args => aargs,
-                    :id => action_id)
-
-            if @num_running < @concurrency
-                @threads_cond.signal
-            end
-        }
-    end
-
-    def cancel_action(action_id)
-        @threads_mutex.synchronize {
-            action = @action_running[action_id]
-            if action
-                thread = action[:thread]
-            else
-                thread = nil
-            end
-
-            if thread
-                thread.kill
-
-                @num_running -= 1
-                delete_running_action(action_id)
-
-                @threads_cond.signal
-            else
-                i = @action_queue.select{|x| x[:id] == action_id}.first
-                @action_queue.delete(i) if i
-            end
-        }
-    end
-
-    def start_listener
-        while true
-            @threads_mutex.synchronize {
-                while ((@concurrency - @num_running)==0) || empty_queue
-                    @threads_cond.wait(@threads_mutex)
-
-                    return if (@finalize && @num_running == 0)
-                end
-
-                run_action
-            }
-        end
-    end
-
-    protected
-
-    def delete_running_action(action_id)
-        @action_running.delete(action_id)
-    end
-
-    def get_runable_action
-        @action_queue.shift
-    end
-
-    def empty_queue
-        @action_queue.size==0
-    end
-
-    def run_action
-        action = get_runable_action
-
-        if action
-            @num_running += 1
-
-            if action[:threaded]
-                thread = Thread.new {
-                    begin
-                        action[:method].call(*action[:args])
-                    ensure
-                        @threads_mutex.synchronize {
-                            @num_running -= 1
-                            delete_running_action(action[:id])
-
-                            @threads_cond.signal
-                        }
-                    end
-                }
-
-                action[:thread] = thread
-                @action_running[action[:id]] = action
-            else
-                action[:method].call(*action[:args])
-
-                @num_running -= 1
-            end
-        end
-    end
-end
-
-if __FILE__ == $0
-
-    class Sample
-        attr_reader :am
-
-        def initialize
-            @am = ActionManager.new(15,true)
-
-            @am.register_action(:SLEEP,method("sleep_action"))
-#            @am.register_action(:SLEEP,Proc.new{|s,i| p s ; sleep(s)})
-            @am.register_action(:NOP,method("nop_action"))
-
-            def @am.get_runable_action
-                action = super
-                puts "getting: #{action.inspect}"
-                action
-            end
-
-            def @am.delete_running_action(action_id)
-                puts "deleting: #{action_id}"
-                super(action_id)
-            end
-       end
-
-        def sleep_action(secs, id)
-            p "ID: #{id} sleeping #{secs} seconds"
-            sleep(secs)
-            p "ID: #{id} Awaken!"
-        end
-
-        def nop_action
-            p " - Just an action"
-        end
-
-    end
-
-    s = Sample.new
-
-    Thread.new {
-        sleep 1
-
-        100.times {|n|
-           s.am.trigger_action(:SLEEP,n,rand(3)+1,n)
-           s.am.trigger_action(:NOP,100+n)
-        }
-
-        s.am.trigger_action(:SLEEP,301,5,301)
-
-        s.am.cancel_action(301)
-
-        s.am.trigger_action(:FINALIZE,0)
-
-        s.am.trigger_action(:SLEEP,999,rand(3)+1,999)
-        s.am.trigger_action(:SLEEP,333,rand(3)+1,333)
-    }
-
-    s.am.start_listener
-end
-

data/lib/CommandManager.rb

@@ -1,328 +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 'pp'
-require 'open3'
-require 'timeout'
-require 'base64'
-
-# Generic command executor that holds the code shared by all the command
-# executors.
-#
-# Properties:
-#
-# * +code+: integer holding the exit code. Read-only
-# * +stdout+: string of the standard output. Read-only
-# * +stderr+: string of the standard error. Read-only
-# * +command+: command to execute. Read-only
-#
-# The protocol for scripts to log is as follows:
-#
-# * Log messages will be sent to STDOUT
-# * The script will return 0 if it succeded or any other value
-#   if there was a failure
-# * In case of failure the cause of the error will be written to STDERR.
-
-class GenericCommand
-
-    attr_reader :code, :stdout, :stderr, :command
-
-    # Creates a command and runs it
-    def self.run(command, logger=nil, stdin=nil, timeout=nil)
-        cmd = self.new(command, logger, stdin, timeout)
-        cmd.run
-        cmd
-    end
-
-    # Creates the new command:
-    # +command+: string with the command to be executed
-    # +logger+: proc that takes a message parameter and logs it
-    def initialize(command, logger=nil, stdin=nil, timeout=nil)
-        @command = command
-        @logger  = logger
-        @stdin   = stdin
-        @timeout = timeout
-    end
-
-    # Sends a log message to the logger proc
-    def log(message, all=true)
-        @logger.call(message, all) if @logger
-    end
-
-    # Runs the command
-    def run
-        begin
-            @stdout, @stderr, status = execute
-
-            if status && status.exited?
-                @code = status.exitstatus
-            else
-                @code = 255
-            end
-
-            if @code != 0
-                log("Command execution failed (exit code: #{@code}): #{command}")
-                log(@stderr)
-            end
-        rescue Exception => e
-            if e.is_a?(Timeout::Error)
-                error_message = "Timeout executing #{command}"
-            else
-                error_message = "Internal error #{e}"
-            end
-
-            log(error_message)
-
-            @stderr = error_message
-            @code   = 255
-        end
-
-        return @code
-    end
-
-    # Parses error message from +stderr+ output
-    def get_error_message
-        return '-' if @stderr.empty?
-
-        @stderr.tr("\n",' ').strip
-    end
-
-    def to_xml
-        stdout = @stdout.nil? ? '' : @stdout
-        stderr = @stderr.nil? ? '' : @stderr
-
-        '<EXECUTION_RESULT>' \
-            "<COMMAND>#{@command}</COMMAND>" \
-            "<STDOUT>#{Base64.encode64(stdout)}</STDOUT>" \
-            "<STDERR>#{Base64.encode64(stderr)}</STDERR>" \
-            "<CODE>#{@code}</CODE>" \
-        '</EXECUTION_RESULT>'
-    end
-
-private
-
-    # Low level command execution. This method has to be redefined
-    # for each kind of command execution. Returns an array with
-    # +stdout+, +stderr+ and +status+ of the command execution.
-    def execute
-        puts "About to execute \"#{@command}\""
-        ['', '', nil]
-    end
-
-    # modified Open3.capture with terminator thread
-    # to deal with timeouts
-    def capture3_timeout(*cmd)
-        if Hash === cmd.last
-            opts = cmd.pop.dup
-        else
-            opts = {}
-        end
-
-        stdin_data = opts.delete(:stdin_data) || ''
-        binmode = opts.delete(:binmode)
-
-        Open3.popen3(*cmd, opts) {|i, o, e, t|
-            if binmode
-                i.binmode
-                o.binmode
-                e.binmode
-            end
-
-            terminator_e = nil
-            mutex = Mutex.new
-
-            out_reader = Thread.new { o.read }
-            err_reader = Thread.new { e.read }
-            terminator = Thread.new {
-                if @timeout and @timeout>0
-                    begin
-                        pid = Process.getpgid(t.pid) * -1
-                    rescue
-                        pid = t.pid
-                    end
-
-                    if pid
-                        begin
-                            sleep @timeout
-
-                            mutex.synchronize do
-                                terminator_e = Timeout::Error
-                            end
-                        ensure
-                        end
-
-                        Process.kill('TERM', pid)
-                    end
-                end
-            }
-
-            begin
-                i.write stdin_data
-                i.close
-            rescue Errno::EPIPE
-                # the cmd doesn't read the input, ignore error
-            end
-
-            # blocking wait for process termination
-            t.value
-
-            # if reader threads are not dead yet, kill them
-            [out_reader, err_reader].each do |reader|
-                next unless reader.status
-
-                reader.join(0.1)
-                reader.kill
-            end
-
-            mutex.lock
-            terminator.kill
-            raise terminator_e if terminator_e
-
-            # return values
-            [out_reader.value, err_reader.value, t.value]
-        }
-    end
-
-end
-
-# Executes commands in the machine where it is called. See documentation
-# for GenericCommand
-class LocalCommand < GenericCommand
-private
-
-    def execute
-        capture3_timeout("#{command}",
-                        :pgroup => true, :stdin_data => @stdin)
-    end
-end
-
-# Executes commands in a remote machine ussing ssh. See documentation
-# for GenericCommand
-class SSHCommand < GenericCommand
-
-    attr_accessor :host, :ssh_opts
-
-    # Creates a command and runs it
-    def self.run(command, host, logger=nil, stdin=nil, timeout=nil, ssh_opts='')
-        cmd=self.new(command, host, logger, stdin, timeout, ssh_opts)
-        cmd.run
-        cmd
-    end
-
-    # This one takes another parameter. +host+ is the machine
-    # where the command is going to be executed
-    def initialize(command, host, logger=nil, stdin=nil, timeout=nil, ssh_opts='')
-        @host=host
-        @ssh_opts = ssh_opts
-
-        super(command, logger, stdin, timeout)
-    end
-
-private
-
-    def execute
-        if @stdin
-            capture3_timeout("ssh #{@ssh_opts} #{@host} #{@command}",
-                            :pgroup => true, :stdin_data => @stdin)
-        else
-            capture3_timeout("ssh -n #{@ssh_opts} #{@host} #{@command}",
-                            :pgroup => true)
-        end
-    end
-end
-
-class RemotesCommand < SSHCommand
-
-    # Creates a command and runs it
-    def self.run(command, host, remote_dir, logger=nil, stdin=nil, retries=0, timeout=nil)
-        cmd_file = command.split(' ')[0]
-
-        cmd_string = "'if [ -x \"#{cmd_file}\" ]; then #{command}; else\
-                              exit #{MAGIC_RC}; fi'"
-
-        cmd = self.new(cmd_string, host, logger, stdin, timeout)
-        cmd.run
-
-        while cmd.code != 0 and retries != 0
-            if cmd.code == MAGIC_RC
-                update_remotes(host, remote_dir, logger)
-            end
-
-            sleep 1
-            cmd.run
-            retries = retries - 1
-        end
-
-        cmd
-    end
-
-private
-
-    ONE_LOCATION=ENV["ONE_LOCATION"]
-
-    if !ONE_LOCATION
-        REMOTES_LOCATION="/var/lib/one/remotes"
-    else
-        REMOTES_LOCATION=ONE_LOCATION+"/var/remotes/"
-    end
-
-    MAGIC_RC = 42
-
-    def self.update_remotes(host, remote_dir, logger=nil)
-        if logger != nil
-            logger.call("Remote worker node files not found")
-            logger.call("Updating remotes")
-        end
-
-        #recreate remote dir structure
-        SSHCommand.run("mkdir -p #{remote_dir}",host,logger)
-
-        # Use SCP to sync:
-        sync_cmd = "scp -rp #{REMOTES_LOCATION}/* #{host}:#{remote_dir}"
-
-        # Use rsync to sync:
-        # sync_cmd = "rsync -Laz #{REMOTES_LOCATION} #{host}:#{@remote_dir}"
-        LocalCommand.run(sync_cmd, logger)
-    end
-end
-
-
-if $0 == __FILE__
-
-    command=GenericCommand.run("uname -a")
-    puts command.stderr
-
-    local_command=LocalCommand.run("uname -a")
-    puts "STDOUT:"
-    puts local_command.stdout
-    puts
-    puts "STDERR:"
-    puts local_command.stderr
-
-    ssh_command=SSHCommand.run("uname -a", "localhost")
-    puts "STDOUT:"
-    puts ssh_command.stdout
-    puts
-    puts "STDERR:"
-    puts ssh_command.stderr
-
-    fd  = File.new("/etc/passwd")
-    str = String.new
-    fd.each {|line| str << line}
-    fd.close
-
-    ssh_in = SSHCommand.run("cat > /tmp/test","localhost",nil,str)
-end