opennebula 4.90.10.rc1 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c03ee98531e1a62d3b49aaf94ba9095902f47705
-  data.tar.gz: 1e78cdfffd8f093032950c10187c08d9001d5974
+  metadata.gz: 16cda589536bb5239ef70cb6898e8b00e3ebd9c9
+  data.tar.gz: 4e71745bc284fb49c762321fc7523064c3f11716
 SHA512:
-  metadata.gz: a5cdec6a7a768b3c5b909d79cc6a945b8d84e1826940a4faa55a3d1ef7d107e1ec4a5760e9186aa6d824341cca7aef8c3bff7e71c23dcb99dd8d0cf5c240a941
-  data.tar.gz: 21ae1b74c18aec9e508c4e0a570d3159fa6e7b606bf03800643b447a5eea1dc3cb19418ce535fc4e2944fb70d735f88986348dd854e9a775ae57b61d408c29b9
+  metadata.gz: cd3b03e5187e2efe9d6cee742e58e917b6fec606388282657c9a4a0b276facc22e859084b9e26d9447e2b664997727653ff33e6792d0744b80a7e7c16436da87
+  data.tar.gz: 3dec23410ed0b0b8f53f9bdec6bea441b70d1df9f8cdb3f1a270a8cbba313750565e16a0f2c78985c9f00184120c03252b53fc7e63ca1a111a4350116c70e239

data/lib/ActionManager.rb

@@ -0,0 +1,278 @@
+# -------------------------------------------------------------------------- */
+# Copyright 2002-2016, 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 {
+                    action[:method].call(*action[:args])
+
+                    @threads_mutex.synchronize {
+                        @num_running -= 1
+                        delete_running_action(action[:id])
+
+                        @threads_cond.signal
+                    }
+                }
+
+                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

@@ -0,0 +1,242 @@
+# --------------------------------------------------------------------------
+# Copyright 2002-2016, 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 'stringio'
+
+# 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
+#   wrapped by start and end marks as follows:
+#
+#     ERROR MESSAGE --8<------
+#     error message for the failure
+#     ERROR MESSAGE ------>8--
+
+
+class GenericCommand
+    attr_reader :code, :stdout, :stderr, :command
+
+    # Creates a command and runs it
+    def self.run(command, logger=nil, stdin=nil)
+        cmd = self.new(command, logger, stdin)
+        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)
+        @command = command
+        @logger  = logger
+        @stdin   = stdin
+    end
+
+    # Sends a log message to the logger proc
+    def log(message)
+        @logger.call(message) if @logger
+    end
+
+    # Runs the command
+    def run
+        std = execute
+
+        # Close standard IO descriptors
+        if @stdin
+            std[0] << @stdin
+            std[0].flush
+        end
+        std[0].close if !std[0].closed?
+
+        @stdout=std[1].read
+        std[1].close if !std[1].closed?
+
+        @stderr=std[2].read
+        std[2].close if !std[2].closed?
+
+        @code=get_exit_code(@stderr)
+
+        if @code!=0
+            log("Command execution fail: #{command}")
+            log(@stderr)
+        end
+
+        return @code
+    end
+
+    # Parses error message from +stderr+ output
+    def get_error_message
+        tmp=@stderr.scan(/^ERROR MESSAGE --8<------\n(.*?)ERROR MESSAGE ------>8--$/m)
+        return "-" if !tmp[0]
+        tmp[0].join(' ').strip
+    end
+
+private
+
+    # Gets exit code from STDERR
+    def get_exit_code(str)
+        tmp=str.scan(/^ExitCode: (\d*)$/)
+        return nil if !tmp[0]
+        tmp[0][0].to_i
+    end
+
+    # Low level command execution. This method has to be redefined
+    # for each kind of command execution. Returns an array with
+    # +stdin+, +stdout+ and +stderr+ handlers of the command execution.
+    def execute
+        puts "About to execute \"#{@command}\""
+        [StringIO.new, StringIO.new, StringIO.new]
+    end
+
+end
+
+# Executes commands in the machine where it is called. See documentation
+# for GenericCommand
+class LocalCommand < GenericCommand
+private
+
+    def execute
+        Open3.popen3("#{command} ; echo ExitCode: $? 1>&2")
+    end
+end
+
+# Executes commands in a remote machine ussing ssh. See documentation
+# for GenericCommand
+class SSHCommand < GenericCommand
+    attr_accessor :host
+
+    # Creates a command and runs it
+    def self.run(command, host, logger=nil, stdin=nil)
+        cmd=self.new(command, host, logger, stdin)
+        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)
+        @host=host
+        super(command, logger, stdin)
+    end
+
+private
+
+    def execute
+        if @stdin
+            Open3.popen3("ssh #{@host} #{@command} ; echo ExitCode: $? 1>&2")
+        else
+            Open3.popen3("ssh -n #{@host} #{@command} ; echo ExitCode: $? 1>&2")
+        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)
+        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)
+        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