def __init__(self):
# implement the singleton class
self.__monitor_dao = HANAMonitorDAO(Mc.get_hana_server(),
Mc.get_hana_port(),
Mc.get_hana_user(),
Mc.get_hana_password())
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_OPERATOR_ALARM)
def __init__(self):
if HANAServerOSOperatorService.__instance is not None:
raise MonitorOSOpError(
"This class is a singleton, use HANAServerOSOperatorService.instance() instead"
)
else:
HANAServerOSOperatorService.__instance = self
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_SERVER_OS_OPERATOR)
def __init__(self):
super().__init__()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_ANALYZER)
self.__producer = Ku.get_producer()
self.__topic = Mc.TOPIC_FILTERED_INFO
self.__mem_info_analyzer = DataAnalyzer.__MemoryInfoAnalyzer()
self.__cpu_info_analyzer = DataAnalyzer.__CPUInfoAnalyzer()
self.__disk_info_analyzer = DataAnalyzer.__DiskInfoAnalyzer()
self.__instance_info_analyzer = DataAnalyzer.__InstanceInfoAnalyzer()
def __init__(self):
super().__init__()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_OPERATOR_APP)
# currently, only support shutdown and log backup clean
self.switcher = {
ActionType.SHUTDOWN.value:
AppOperator.__HANACloser(self.__logger),
ActionType.CLEAN_LOG_BACKUP.value:
AppOperator.__HANALogCleaner(self.__logger)
}
self.__app_operation_interval = Mc.get_app_operation_check_interval()
def __init__(self):
super().__init__()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_COORDINATOR)
self.__configs = {}
self.__os_operator = LinuxOperator()
self.__heartbeat_flag = False
self.__heartbeat_interval = Mc.get_heartbeat_check_interval()
self.__heartbeat_timeout = Mc.get_heartbeat_timeout()
self.__heartbeat_restart_agent_interval = Mc.get_heartbeat_operation_interval(
)
self.__heartbeat_agent_restart_info = {}
def __init__(self):
# implement the singleton class
if MsgProducerService.__instance is not None:
raise MonitorDBOpError(
"This class is a singleton, use HANAServerDBOperatorService.instance() instead"
)
else:
MsgProducerService.__instance = self
self.__producer = Ku.get_producer()
self.__logger = Mu.get_logger(Mc.LOGGER_AGENT_MSG_PRODUCER)
self.__topic = Mc.TOPIC_MONITORING_INFO
self.__topic_heartbeat = Mc.TOPIC_AGENT_HEARTBEAT
def __init__(self):
# implement the singleton class
if HANAOperatorService.__instance is not None:
raise MonitorDBOpError(
"This class is a singleton, use HANAServerDBOperatorService.instance() instead"
)
else:
HANAOperatorService.__instance = self
self.__monitor_dao = HANAMonitorDAO(Mc.get_hana_server(),
Mc.get_hana_port(),
Mc.get_hana_user(),
Mc.get_hana_password())
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_OPERATOR_DB)
def __init__(self, server_name, port, user, password):
# get logging
self.__logger = Mu.get_logger(Mc.LOGGER_HANA_DB)
# get database connection
try:
Mu.log_info(self.__logger, "Connecting {0}:{1} with {2}".format(server_name, port, user))
self.connection = dbapi.connect(server_name, port, user, password)
if self.connection is None:
Mu.log_error(self.__logger, "Connect to HANA error!")
else:
Mu.log_info(self.__logger, "Connected {0}:{1} with {2}".format(server_name, port, user))
except Exception as ex:
error_message = "Connect to HANA error:{0}".format(ex)
Mu.log_error(self.__logger, error_message)
Mu.log_exception(self.__logger, traceback.format_exc())
raise MonitorDBError(error_message)
def __init__(self):
super().__init__()
self.__db_operator = AlarmOperator.__HANAOperatorService()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_OPERATOR_ALARM)
self.__heartbeat_interval = Mc.get_heartbeat_check_interval()
self.__heartbeat_timeout = Mc.get_heartbeat_timeout()
self.__heartbeat_email_interval = Mc.get_heartbeat_email_interval()
self.cpu_threshold = 0
self.mem_threshold = 0
self.disk_threshold = 0
self.email_sender = ""
self.operation_time = ""
self.max_failure_times = 3
self.mem_emergency_threshold = 0
self.check_interval = 0 # the interval for sending email / performing emergency shutdown
self.servers = []
self.__producer = Ku.get_producer()
self.__topic = Mc.TOPIC_APP_OPERATION
self.__heartbeat_email_info = {}
def __init__(self):
self.PID_FILE = "/tmp/monitor_agent.pid"
self.LOCKER_FILE = "/tmp/agent_file.locker"
self.server_id = 0
self.mount_point = '/usr/sap'
self.m_frequency = 15
self.d_frequency = 3600
self.c_frequency = 1800
self.i_frequency = 600
self.__logger = Mu.get_logger(Mc.LOGGER_AGENT)
# register the signals to be caught
signal.signal(signal.SIGINT, self.terminate_process) # kill -2
signal.signal(signal.SIGQUIT, self.terminate_process) # kill -3
signal.signal(signal.SIGABRT, self.terminate_process) # kill -6
signal.signal(signal.SIGBUS, self.terminate_process) # kill -7
signal.signal(signal.SIGFPE, self.terminate_process) # kill -8
signal.signal(signal.SIGUSR1, self.terminate_process) # kill -11
signal.signal(signal.SIGTERM, self.terminate_process) # kill -15
atexit.register(Agent.exit_clean_up,
logger=self.__logger,
file=self.PID_FILE)
def __init__(self):
super().__init__()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_OPERATOR_DB)
self._db_operator = HANAOperatorService.instance()
def __init__(self):
# get logging
self.__logger = Mu.get_logger(Mc.LOGGER_OS_LINUX)
def __init__(self):
super().__init__()
self.__producer = Ku.get_producer()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_CONFIG_MGR)
self.__topic = Mc.TOPIC_CONFIGURATION
self.__configs = {}
def __init__(self, server_id, interval):
super().__init__()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_MEM)
self.__server_id = server_id
self.__interval = interval
def __init__(self, server_id, mount_point, interval):
super().__init__()
self.__logger = Mu.get_logger(Mc.LOGGER_MONITOR_DISK)
self.__server_id = server_id
self.__mount_point = mount_point
self.__interval = interval
def __init__(self):
self.__logger = MonitorUtility.get_logger(
Mc.LOGGER_MONITOR_INIT_SERVER)
super().__init__()