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 errorHandling(self):
running = self.isRunning(self.instance.process_name)
if running:
return CommandResultSuccess("process is already running")
valid = self.isValidInstanceForStart()
if not valid:
return valid
def errorHandling(self):
if self.use_systemd:
ret = subprocess.call([
'/bin/systemctl', 'is-active', '--quiet',
self.getSystemdServiceName()
])
if not ret:
return CommandResultSuccess('Running')
else:
running = self.isRunning(self.instance.process_name)
if running:
return CommandResultSuccess('Process is already running')
valid = self.isValidInstanceForStart()
if not valid:
return valid
def reload(self):
self.szig.reload()
if self.szig.reload_result():
result = CommandResultSuccess("Reload successful")
else:
result = CommandResultFailure("Reload failed")
return result
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 get(self):
algorithm = GetProcInfoAlgorithm()
algorithm.setInstance(self.instance)
proc_info = algorithm.run()
if not proc_info:
return proc_info
return CommandResultSuccess("", int(proc_info["rss"])*4)
def services(self):
services = []
service = self.szig.get_child("service")
while service:
services.append(service[len("service."):])
service = self.szig.get_sibling(service)
return CommandResultSuccess("", services)
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):
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 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 test_service_rate_algorithm(self):
algorithm = GetServiceRateAlgorithm()
algorithm.szig = self.szig
rate = {}
for service in self.data["service"].keys():
avg1 = self.data["service"][service]["rate_avg1"]
avg5 = self.data["service"][service]["rate_avg5"]
avg15 = self.data["service"][service]["rate_avg15"]
rate[service] = {"avg1": avg1, "avg5": avg5, "avg15": avg15}
services = CommandResultSuccess("", self.data["service"].keys())
self.assertEquals(algorithm.getServiceRate(services), rate)
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 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 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 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)
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 getDeadlockcheck(self):
return CommandResultSuccess('Deadlockcheck={}'.format(
self.szig.deadlockcheck))
def getloglevel(self):
return CommandResultSuccess(
"verbose_level=%d, logspec='%s'" %
(self.szig.loglevel, self.szig.logspec), self.szig.loglevel)
def modifyloglevel(self, value):
self.szig.loglevel = value
return CommandResultSuccess()
def setDeadlockcheck(self, value):
self.szig.deadlockcheck = value
return CommandResultSuccess("")
def getDeadlockcheck(self):
return CommandResultSuccess("deadlockcheck=%s" %
self.szig.deadlockcheck)
def setLevel(self, value):
self.szig.loglevel = value
return CommandResultSuccess('New verbose_level={}'.format(value))
def getLevel(self):
return CommandResultSuccess(
"verbose_level={}, logspec='{}'".format(self.szig.loglevel,
self.szig.logspec),
self.szig.loglevel)
def errorHandling(self):
running = self.isRunning(self.instance.process_name)
if not running:
# Ignore not running process
return CommandResultSuccess(running.msg)
def execute(self):
try:
self.szig = SZIG(self.instance.process_name)
except IOError as e:
return CommandResultFailure(e.message)
return CommandResultSuccess("", self.get())
def execute(self):
self.parse_algorithm.setInstance(self.instance)
self.errorHandling()
zorp_arguments = self.parse_algorithm.run()
return CommandResultSuccess("", zorp_arguments['threads'])
