class HsMonitor(object):
"""The HiSPARC Monitor
This process spawns several threads to perform tasks.
- BufferListener: read messages from the MySQL database.
- CheckScheduler: report status to Nagios.
- Uploader: upload message to a datastore server.
"""
def __init__(self):
self.config = EConfigParser()
self.config.read([CONFIG_INI, PERSISTENT_INI, PASSWORD_INI])
# Setup the log mode
log_dirname = '../../persistent/logs/hsmonitor/'
# Making sure the directory exists
if not os.access(log_dirname, os.F_OK):
os.makedirs(log_dirname)
log_filename = os.path.join(log_dirname, 'hsmonitor')
# Remove any existing handlers
logger.handlers = []
# Add file handler
handler = TimedConcurrentRotatingFileHandler(
log_filename, when='midnight', backupCount=14, utc=True)
handler.setFormatter(formatter_file)
logger.addHandler(handler)
# Add handler which prints to the screen
handler = logging.StreamHandler()
handler.setFormatter(formatter_screen)
logger.addHandler(handler)
# Default logging level
logger.setLevel(level=logging.DEBUG)
# Logging level for the handlers
for i, target in enumerate(['File', 'Screen']):
log_level = self.config.ifgetstr('Logging', '%sLevel' % target,
'debug')
if log_level in LEVELS:
logger.handlers[i].setLevel(level=LEVELS[log_level])
logger.info('%s logging level set to %s' % (target, log_level))
else:
logger.warning("Illegal %s logging level '%s' in config, "
"using debug" % (target, log_level))
# List of all the threads
self.hsThreads = []
# Assume one server (datastore)
# if the local is also specified it will be added
self.numServers = 1
def startAll(self):
"""Setup and start all threads."""
try:
# Create StorageManager and Interpreter for BufferListener
storMan = StorageManager()
interpr = Interpreter(storMan)
# Create BufferListener
buffLis = self.createBufferListener(interpr)
if buffLis.conn:
self.hsThreads.append(buffLis)
# Check scheduler
# Get the nagios configuration section from config file
nagiosConf = self.config.itemsdict('NagiosPush')
machine = re.search('([a-z0-9]+).zip',
self.config.get('Station', 'Certificate'))
nagiosConf['machine_name'] = machine.group(1)
checkSched = self.createCheckScheduler(interpr, nagiosConf)
eventRate = checkSched.getEventRate()
storMan.addObserver(eventRate)
self.hsThreads.append(checkSched)
# Uploader central
up = self.createUploader(0, "Upload-datastore", nagiosConf)
self.hsThreads.append(up)
storMan.addObserver(up)
up.setNumServer(self.numServers)
# Try local server
#try:
# up2 = self.createUploader(1, "Upload-local", nagiosConf)
# self.hsThreads.append(up2)
# storMan.addObserver(up2)
# self.numServers += 1
# up.setNumServer(self.numServers)
# up2.setNumServer(self.numServers)
#except Exception, msg:
# logger.debug("Error while parsing local server: %s." % msg)
# logger.debug("Will not upload to a local server.")#
# Set number of servers for our own StorageManager
storMan.setNumServer(self.numServers)
storMan.clearOldUploadedEvents()
# Start all threads, running their run() function.
for thread in self.hsThreads:
thread.start()
except Exception, msg:
logger.critical("Error HsMonitor: %s" % msg)
sys.exit(1)
class Updater(object):
def __init__(self):
self.scheduler = sched.scheduler(time.time, time.sleep)
self.checker = Checker()
self.config = EConfigParser()
self.config.read([CONFIG_INI, PERSISTENT_INI])
# Time between checks in seconds
self.timeBetweenChecks = self.config.ifgetint(
'Update', 'IntervalBetweenChecks', 1800)
# Start and stop time of the interval in which checks may be
# performed on a day (in seconds since midnight) e.g. 7200 is 2am
self.timeStartCheckInterval = self.config.ifgetint(
'Update', 'CheckerIntervalStartTime', 0)
self.timeStopCheckInterval = self.config.ifgetint(
'Update', 'CheckerIntervalStopTime', 24 * 60 * 60)
# Bool determine if there will be an initial delay
self.checkerInitialDelay = self.config.get(
'Update', 'CheckerInitialDelay', 0)
# Setup the log mode
log_dirname = '../../persistent/logs/updater/'
# Making sure the directory exists
if not os.access(log_dirname, os.F_OK):
os.makedirs(log_dirname)
log_filename = os.path.join(log_dirname, 'updater')
# Remove any existing handlers
logger.handlers = []
# Add file handler
handler = TimedRotatingFileHandler(log_filename, when='midnight',
backupCount=14, utc=True)
handler.setFormatter(formatter_file)
logger.addHandler(handler)
# Add handler which prints to the screen
handler = logging.StreamHandler()
handler.setFormatter(formatter_screen)
logger.addHandler(handler)
# Default logging level
logger.setLevel(level=logging.DEBUG)
# Logging level for the handlers
for i, target in enumerate(['File', 'Screen']):
log_level = self.config.ifgetstr('Logging', '%sLevel' % target,
'debug')
if log_level in LEVELS:
logger.handlers[i].setLevel(level=LEVELS[log_level])
logger.info('%s logging level set to %s' % (target, log_level))
else:
logger.warning("Illegal %s logging level '%s' in config, "
"using debug" % (target, log_level))
def checkIfUpdateToInstall(self):
"""Check if there is already an admin update to install
Also check if you are currently in user or admin mode
"""
is_admin = checkFiles.checkIfAdmin()
currentAdmin = self.config.ifgetint("Version", "CurrentAdmin", 0)
currentUser = self.config.ifgetint("Version", "CurrentUser", 0)
logger.info("You are Administrator: %s" % is_admin)
logger.info("Current Admin Version: %s" % currentAdmin)
logger.info("Current User Version: %s" % currentUser)
if is_admin:
location = "../../persistent/downloads"
found, file_found = checkFiles.checkIfNewerFileExists(
location, ADMINUPDATE_NAME, int(currentAdmin))
if found:
logger.info("Found: %s" % file_found)
os.system(".\\runAdminUpdate.bat "
"../../persistent/downloads/%s" % file_found)
def calculateInitialDelay(self):
if self.checkerInitialDelay == 1:
# Calculate the time now
# ..and the time it is be today at four and at noon
now = int(time.time())
last_midnight = now - (now % 86400)
today_at_starttime = last_midnight + self.timeStartCheckInterval
today_at_stoptime = last_midnight + self.timeStopCheckInterval
# Check if you are allowed to update already
# (in the interval between starttime and stoptime)
if today_at_starttime < now < today_at_stoptime:
today_random_moment = random.randint(now, today_at_stoptime)
return today_random_moment - now
else:
tomorrow_at_four = today_at_starttime + 86400
tomorrow_at_noon = today_at_stoptime + 86400
tomorrow_random_moment = random.randint(tomorrow_at_four,
tomorrow_at_noon)
return tomorrow_random_moment - now
else:
return 0
def performOneUpdateCheck(self):
"""First check for and update to install
The first check may be delayed to ensure it occurs during a
certain period of the day.
"""
delay = self.calculateInitialDelay()
self.scheduler.enter(delay, 1, self.checker.checkForUpdates, [])
self.scheduler.run()
def performContinuousCheck(self):
"""Continuously check if there for new updates from the server
Checks are performed on an interval determined by 'timeBetweenChecks'.
"""
while True:
self.scheduler.enter(self.timeBetweenChecks, 1,
self.checker.checkForUpdates, [])
self.scheduler.run()
