224 lines
No EOL
7.2 KiB
Python
224 lines
No EOL
7.2 KiB
Python
"""
|
|
This is what job_function needs as parameter for each job to successfully
|
|
execute.
|
|
|
|
Copyright (c) 2011-2013 by Johannes Findeisen and Rafael Timmerberg
|
|
|
|
This file is part of Linspector (http://linspector.org).
|
|
|
|
Linspector is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as
|
|
published by the Free Software Foundation, either version 3 of the
|
|
License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
from datetime import datetime
|
|
from binascii import crc32
|
|
from logging import getLogger
|
|
from linspector.tasks.task import TaskExecutor
|
|
|
|
logger = getLogger(__name__)
|
|
|
|
|
|
class Job:
|
|
def __init__(self, service, host, members, core, hostgroup):
|
|
self.service = service
|
|
self.host = host
|
|
self.members = members
|
|
self.core = core
|
|
self.hostgroup = hostgroup
|
|
self.job_threshold = 0
|
|
self.enabled = True
|
|
self.scheduler_job = None
|
|
self.job_id = self.hex_string()
|
|
"""
|
|
NONE job was not executed
|
|
OK when everything is fine
|
|
WARNING when a job has errors but not the threshold overridden
|
|
RECOVER when a job recovers e.g. the threshold decrements (not implemented)
|
|
ERROR when a jobs threshold is overridden
|
|
UNKNOWN when a job throws an exception which is not handled by the job itself (not implemented)
|
|
"""
|
|
self.status = "NONE"
|
|
self.last_execution = None
|
|
self.job_information = JobInformation(self.job_id, hostgroup, host, service, members)
|
|
|
|
def __str__(self):
|
|
return str(self.__dict__)
|
|
|
|
def __hex__(self):
|
|
return hex(crc32(str(self.hostgroup) + str(self.host) + str(self.service)))
|
|
|
|
def hex_string(self):
|
|
ret = self.__hex__()
|
|
if ret[0] == "-":
|
|
ret = ret[3:]
|
|
else:
|
|
ret = ret[2:]
|
|
while len(ret) < 8:
|
|
ret = "0" + ret
|
|
return ret
|
|
|
|
def get_job_id(self):
|
|
return self.job_id
|
|
|
|
def set_job(self, scheduler_job):
|
|
self.scheduler_job = scheduler_job
|
|
|
|
def set_enabled(self, enabled=True):
|
|
self.enabled = enabled
|
|
|
|
def handle_threshold(self, service_threshold, execution_successful):
|
|
if execution_successful:
|
|
if self.job_threshold > 0:
|
|
if "threshold_reset" in self.core and self.core["threshold_reset"]:
|
|
logger.info("Job " + self.get_job_id() + ", Threshold Reset")
|
|
self.job_threshold = 0
|
|
else:
|
|
logger.info("Job " + self.get_job_id() + ", Threshold Decrement")
|
|
self.job_threshold -= 1
|
|
|
|
self.status = "OK"
|
|
self.job_information.inc_job_overall_wins()
|
|
else:
|
|
self.status = "WARNING"
|
|
self.job_information.inc_job_overall_fails()
|
|
self.job_threshold += 1
|
|
|
|
if self.job_threshold >= service_threshold:
|
|
logger.info("Job " + self.get_job_id() + ", Threshold reached!")
|
|
self.status = "ERROR"
|
|
|
|
def handle_tasks(self, msg):
|
|
for member in self.members:
|
|
for task in member.get_tasks():
|
|
if self.status.lower() == task.get_task_type().lower():
|
|
logger.debug("Executing Task of type: " + self.status)
|
|
TaskExecutor.Instance().schedule_task(msg, task)
|
|
|
|
def handle_call(self):
|
|
logger.debug("handle call")
|
|
logger.debug(self.service)
|
|
if self.enabled:
|
|
self.job_information.set_execution_start()
|
|
|
|
self.last_execution = None
|
|
try:
|
|
self.last_execution = JobExecution(self.get_host(), self.job_information)
|
|
self.service.execute(self.last_execution)
|
|
except Exception, e:
|
|
logger.debug(e)
|
|
|
|
self.job_information.set_execution_end()
|
|
|
|
self.handle_threshold(self.service.get_threshold(), self.last_execution.was_successful())
|
|
logger.info("Job " + self.get_job_id() +
|
|
", Code: " + str(self.last_execution.get_error_code()) +
|
|
", Message: " + str(self.last_execution.get_message()))
|
|
self.handle_tasks(self.last_execution.get_response_message(self))
|
|
else:
|
|
logger.info("Job " + self.get_job_id() + " disabled")
|
|
|
|
def get_host(self):
|
|
return self.host
|
|
|
|
def get_hostgroup(self):
|
|
return self.hostgroup
|
|
|
|
|
|
class JobExecution(object):
|
|
def __init__(self, host, job_information):
|
|
self.execution_start = datetime.now()
|
|
self.execution_end = -1
|
|
self.host = host
|
|
self.error_code = -1
|
|
self.message = None
|
|
self.kwargs = None
|
|
|
|
def get_host_name(self):
|
|
return self.host
|
|
|
|
def get_message(self):
|
|
return self.message
|
|
|
|
def get_kwargs(self):
|
|
return self.kwargs
|
|
|
|
def set_execution_end(self):
|
|
self.execution_end = datetime.now()
|
|
|
|
def get_error_code(self):
|
|
return self.error_code
|
|
|
|
def was_successful(self):
|
|
return self.get_error_code() == 0
|
|
|
|
def set_result(self, error_code=0, message="", kwargs=None):
|
|
self.error_code = error_code
|
|
self.message = message
|
|
self.kwargs = kwargs
|
|
|
|
def get_response_message(self, job):
|
|
msg = str(job.status) + " [" + job.service.get_config_name() + ": " + str(job.get_job_id()) + "] " + \
|
|
str(job.get_hostgroup()) + " " + str(job.get_host())
|
|
if self.get_message() is not None:
|
|
msg += " " + str(self.get_message())
|
|
if self.get_kwargs() is not None:
|
|
msg += " " + str(self.get_kwargs())
|
|
return msg
|
|
|
|
|
|
class JobInformation(object):
|
|
def __init__(self, job_id, hostgroup, host, service, members):
|
|
self.job_id = job_id
|
|
self.hostgroup = hostgroup
|
|
self.host = host
|
|
self.service = service
|
|
self.members = members
|
|
|
|
self.execution_start = -1
|
|
self.execution_end = -1
|
|
|
|
self.period = None
|
|
self.next_run = None
|
|
self.runs = 0
|
|
self.enabled = None
|
|
self.threshold = 0
|
|
self.fails = 0
|
|
self.job_overall_fails = 0
|
|
self.job_overall_wins = 0
|
|
self.last_execution = None
|
|
self.last_run = None
|
|
self.last_fail = None
|
|
self.last_success = None
|
|
self.last_disabled = None
|
|
self.last_enabled = None
|
|
self.last_threshold_override = None
|
|
self.last_escalation = None
|
|
self.status = "NONE"
|
|
|
|
def set_execution_end(self):
|
|
self.execution_end = datetime.now()
|
|
|
|
def set_execution_start(self):
|
|
self.execution_start = datetime.now()
|
|
|
|
def get_job_overall_fails(self):
|
|
return self.job_overall_fails
|
|
|
|
def inc_job_overall_fails(self):
|
|
self.job_overall_fails += 1
|
|
|
|
def get_job_overall_wins(self):
|
|
return self.job_overall_wins
|
|
|
|
def inc_job_overall_wins(self):
|
|
self.job_overall_wins += 1 |