Files
one/src/mad/ruby/CommandManager.rb
T
Javi Fontan da63aaadd4 Moved get_error_message from TM to CommandManager
(cherry picked from commit f038c2c36afd3b899da428698e7d5cd29d281747)
2011-04-13 00:15:40 +02:00

239 lines
6.3 KiB
Ruby

# --------------------------------------------------------------------------
# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)
#
# 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 follows.")
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 "Error message not available" 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
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
# 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
if cmd.code == MAGIC_RC
cmd.update_remotes(host, remote_dir, logger)
@command = command
cmd.run
end
while cmd.code != 0 and retries != 0
sleep 1
cmd.run
retries = retries - 1
end
cmd
end
def update_remotes(host, remote_dir, logger=nil)
log("Remote worker node files not found")
log("Updating remotes")
# Use SCP to sync:
sync_cmd = "scp -r #{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