def searchInstance(instance_name):
try:
for instance in InstancesConf():
if instance.name == instance_name:
return instance
return CommandResultFailure("instance %s not found!" % instance_name)
except IOError as e:
return CommandResultFailure(e.message)
def isValidInstanceForStart(self):
if not 0 <= self.instance.process_num < self.instance.number_of_processes:
return CommandResultFailure("number %d must be between [0..%d)"
% (self.instance.process_num, self.instance.number_of_processes))
if not self.instance.auto_start and not self.force:
return CommandResultFailure("not started, because no-auto-start is set")
return CommandResultSuccess()
def execute(self):
try:
self.szig = SZIG(self.instance.process_name)
except IOError as e:
return CommandResultFailure(e.message)
try:
return self.services()
except SZIGError as e:
return CommandResultFailure("error while communicating through szig: %s" % e.msg)
def execute(self):
error = self.errorHandling()
if error != None:
error.value = self.instance.process_name
return error
try:
reloaded = self.reload()
except SZIGError as e:
reloaded = CommandResultFailure("error while communicating through szig: %s" % e.msg)
if not reloaded:
reloaded.value = self.instance.process_name
return reloaded
def execute(self):
error = self.errorHandling()
if error != None:
error.value = self.instance.process_name
return error
try:
reloaded = self.reload()
except SZIGError as e:
reloaded = CommandResultFailure("error while communicating through szig: %s" % e.msg)
if not reloaded:
reloaded.value = self.instance.process_name
return reloaded
def errorHandling(self):
running = self.isRunning(self.instance.process_name)
if not running:
return running
try:
self.stat_file = open(self.proc_stat_filename, 'r')
except IOError:
return CommandResultFailure("Can not open %s" % self.proc_stat_filename)
try:
uptime_file = open(self.uptime_filename, 'r')
uptime_file.close()
except IOError:
return CommandResultFailure("Can not open %s" % self.uptime_filename)
def reject(self):
try:
result = self.szig.authorize_reject(self.session_id,
self.description)
return CommandResultSuccess(result)
except SZIGError as e:
return CommandResultFailure(e.msg)
def reload(self):
self.szig.reload()
if self.szig.reload_result():
result = CommandResultSuccess("Reload successful")
else:
result = CommandResultFailure("Reload failed")
return result
def start_with_systemd(self):
try:
subprocess.check_call(
['/bin/systemctl', 'start',
self.getSystemdServiceName()])
except:
return CommandResultFailure(
"Error invoking 'systemctl start zorp{}@{}.service'".format(
Zorp.Config.config.options.package_suffix,
self.instance.name))
running = self.isRunning(self.instance.process_name)
if running:
return CommandResultSuccess(running)
else:
return CommandResultFailure('Failed to start')
def killProcess(self, sig):
self.pid = self.getProcessPid(self.instance.process_name)
try:
os.kill(self.pid, sig)
return CommandResultSuccess()
except OSError as e:
return CommandResultFailure(e.message)
def removeProcessPid(self, process):
try:
file_path = self._getProcessPidPath(process)
if os.path.exists(file_path):
os.remove(file_path)
except IOError as e:
return CommandResultFailure(
"Could not remove pid file '{}'".format(file_path), e.message)
def errorHandling(self):
running = self.isRunning(self.instance.process_name)
if not running:
return running
try:
self.szig = SZIG(self.instance.process_name)
except IOError as e:
return CommandResultFailure(e.message)
def callAlgorithmToAllInstances(algorithm):
result = []
try:
for instance in InstancesConf():
result += InstanceHandler.executeAlgorithmOnInstanceProcesses(instance, algorithm)
return result
except BaseException as e:
return CommandResultFailure(e.message)
def execute(self):
error = self.errorHandling()
if error != None:
return error
try:
return self.status()
except SZIGError as e:
return CommandResultFailure("error while communicating through szig: %s" % e.msg)
def errorHandling(self):
running = self.isRunning(self.instance.process_name)
if not running:
return running
pid = self.getProcessPid(self.instance.process_name)
try:
self.procinfo_file = open("/proc/%s/stat" % pid, 'r')
except IOError:
return CommandResultFailure("Can not open /proc/%s/stat" % pid)
def getProcessPid(self, process):
try:
file_name = self.pidfiledir + '/zorp-' + process + '.pid'
pid_file = open(file_name)
pid = int(pid_file.read())
pid_file.close()
except IOError as e:
return CommandResultFailure("Can not open %s" % file_name, e.message)
return pid
def execute(self):
self.status = GUIStatus(self.instance.process_name)
error = self.errorHandling()
if error != None:
return error
try:
return self.gui_status()
except SZIGError as e:
return CommandResultFailure("error while communicating through szig: %s" % e.msg)
def execute(self):
error = self.errorHandling()
if error != None:
return error
try:
result = self.szig.stop_session(self.session_id)
return CommandResultSuccess(result)
except SZIGError as e:
return CommandResultFailure(
'Error while communicating through szig: ' + e.msg)
def errorHandling(self):
running = self.isRunning(self.instance.process_name)
if not running:
# Ignore not running process
return CommandResultSuccess(running.msg)
try:
self.szig = SZIG(self.instance.process_name)
except IOError as e:
return CommandResultFailure(e.message)
return None
def getProcessPid(self, process):
try:
file_path = self._getProcessPidPath(process)
pid_file = open(file_path)
pid = int(pid_file.read())
pid_file.close()
except IOError as e:
return CommandResultFailure(
"'Can not open pid file '{}'".format(file_path), e.message)
return pid
def execute(self):
error = self.errorHandling()
if error != None:
return error
try:
actual_value = self.getLevel().value
if self.mode == self.GET:
return self.getLevel()
elif self.mode == self.SET and self.value >= 0 and self.value <= 10:
return self.setLevel(self.value)
elif self.mode == self.INCREMENT and actual_value < 10:
return self.setLevel(actual_value + 1)
elif self.mode == self.DECREMENT and actual_value > 0:
return self.setLevel(actual_value - 1)
else:
return CommandResultFailure('Log level is out of range')
except SZIGError as e:
return CommandResultFailure(
'Error while communicating through szig: ' + e.msg)
def execute(self):
error = self.errorHandling()
if error != None:
return error
try:
if self.value != None:
return self.setDeadlockcheck(self.value)
else:
return self.getDeadlockcheck()
except SZIGError as e:
return CommandResultFailure("error while communicating through szig: %s" % e.msg)
def start(self):
args = self.assembleStartCommand()
try:
subprocess.Popen(args, stderr=open("/dev/null", 'w'))
except OSError:
pass
self.waitTilTimoutToStart()
running = self.isRunning(self.instance.process_name)
if running:
return CommandResultSuccess(running)
else:
return CommandResultFailure("did not start in time")
def execute(self):
error = self.errorHandling()
if error != None:
return error
try:
if self.behaviour:
return self.accept()
else:
return self.reject()
except SZIGError as e:
return CommandResultFailure("error while communicating through szig: %s" % e.msg)
def searchInstance(instance_name):
instances = []
try:
manually_started_instances = ZorpHandler.findManullyStartedInstances(
)
for manually_started_instance in manually_started_instances:
if manually_started_instance.name == instance_name:
instances.append(manually_started_instance)
for instance in InstancesConf():
if instance.name == instance_name:
instances.append(instance)
if instances:
return instances
else:
return [
CommandResultFailure(
"Instance {0} not found!".format(instance_name),
instance_name)
]
except IOError as e:
return [CommandResultFailure(e.message)]
def isRunning(self, process):
"""
Opening the right pidfile in the pidfile dir,
checking if there is a running process with that pid,
returning True if there is.
FIXME: Delete pid file if there is no runnig processes with that pid
"""
pid = self.getProcessPid(process)
if not pid:
if pid.value == "Permission denied":
return CommandResultFailure(pid.value)
else:
return CommandResultFailure("Process not running")
try:
open('/proc/' + str(pid) + '/status')
except IOError:
return CommandResultFailure("Invalid pid file no running process with pid %d!" % pid)
return CommandResultSuccess("running")
def stop(self):
sig = signal.SIGKILL if self.force else signal.SIGTERM
isKilled = self.killProcess(sig)
if not isKilled:
return isKilled
self.waitTilTimeoutToStop()
if self.isRunning(self.instance.process_name):
return CommandResultFailure(
"did not exit in time (pid='%d', signo='%d', timeout='%d')" %
(self.pid, sig, self.stop_timout))
else:
return CommandResultSuccess("stopped")
def errorHandling(self):
running = self.isRunning(self.instance.process_name)
if not running:
self.status.pid = "missing"
self.status.running = "missing"
self.status.threads_running = "missing"
self.status.thread_number = "missing"
self.status.thread_rate_avg1 = "missing"
self.status.thread_rate_avg5 = "missing"
self.status.thread_rate_avg15 = "missing"
return self.status
try:
self.szig = SZIG(self.instance.process_name)
except IOError as e:
return CommandResultFailure(e.message)
def start(self):
args = self.assembleStartCommand()
environment = None
try:
start_process = subprocess.Popen(args, env=environment)
except OSError:
pass
self.waitTilTimoutToStart(start_process)
running = self.isRunning(self.instance.process_name)
if running:
return CommandResultSuccess(running)
else:
return CommandResultFailure('Did not start in time')
def callAlgorithmToAllInstances(algorithm):
result = []
try:
manually_started_instances = ZorpHandler.findManullyStartedInstances(
)
for manually_started_instance in manually_started_instances:
result.extend(
InstanceHandler.executeAlgorithmOnInstanceProcesses(
manually_started_instance, algorithm))
for instance in InstancesConf():
result.extend(
InstanceHandler.executeAlgorithmOnInstanceProcesses(
instance, algorithm))
return result
except Exception as e:
return [CommandResultFailure(e.message)]
def execute(self):
def _prepend_instance_name(tree):
return {self.instance.process_name : tree}
error = self.errorHandling()
if error != None:
return error
try:
if self.root:
szig_dict = _prepend_instance_name({self.root : self.walk(self.root)})
else:
szig_dict = _prepend_instance_name(self.walk(self.root))
return CommandResultSuccess("", szig_dict)
except SZIGError as e:
return CommandResultFailure("error while communicating through szig: %s" % e.msg)
