def request_monitor(self):
self.logger.info('-------------'
' Starting RequestMonitor '
'-------------')
timeout = self.request_timeout
interval = self.request_monitor_check_interval
lifetime = self.request_data_lifetime * 60.0 * 60.0
try:
while True:
time.sleep(interval)
now = datetime.now()
self.logger.debug('RequestMonitor: stored requests: %s',
len(self.requests))
for request_id, d in self.requests.items():
elapsed_time = self.elapsed_time(d['created'])
if d['status'] in CompletedStatus:
if elapsed_time > lifetime:
self.logger.debug('removing expired request'
' data: %s [%s]',
request_id,
time_str(elapsed_time))
with self.requests_lock:
if self.requests.get(request_id):
del self.requests[request_id]
else:
if elapsed_time > timeout:
self.timeout_error(request_id,
d['host'], d['port'])
except Exception as e:
unexpected_error(self.logger, 'RequestMonitor', e)
raise
def status(request_id):
webui.logger.debug('status check: %s', request_id)
try:
data = webui.rest_client.status(current_user.username,
current_user.api_password, request_id)
except HayabusaError as e:
data = {'error': str(e)}
except Exception as e:
unexpected_error(webui.logger, 'status', e)
data = {'error': 'Internal Server Error'}
return jsonify(data)
def main_loop(self, index):
self.name = 'Process-%s' % index
self.info('Starting Process: %s', self.name)
message = {}
try:
self.connect_ports()
while True:
# Wait for next command from Request Broker
message = self.receiver.recv_json()
self.main(message)
except Exception as e:
unexpected_error(self.logger, 'Worker-%s' % self.name, e, message)
raise
def main(self):
try:
self.logger.info('-------------'
' Starting SearchQueryPoller '
'-------------')
while True:
now = datetime.now()
th = threading.Thread(target=self.poll, args=(now, ))
th.setDaemon(True)
th.start()
time.sleep(60.0)
except Exception as e:
unexpected_error(self.logger, 'SearchQueryPoller', e)
raise
def main(self):
try:
self.logger.info('-------------'
' Starting TempFileRemover '
'-------------')
while True:
self.logger.debug('finding temp files')
files = glob.glob(self.glob_path)
for file in files:
if not os.path.isfile(file):
continue
ctime = os.path.getctime(file)
delta = time.time() - ctime
self.logger.debug('file: [%s] %s', time_str(delta), file)
if delta > self.max_time:
self.logger.debug('removing %s', file)
os.remove(file)
time.sleep(self.interval)
except Exception as e:
unexpected_error(self.logger, 'TempFileRemover', e)
raise
def search():
try:
time_period = request.form['time_period']
match = request.form['match']
if request.form.get('count'):
count = True
else:
count = False
if request.form.get('sum'):
sum = True
else:
sum = False
if request.form.get('exact'):
exact = True
else:
exact = False
session['log-search-match'] = match
session['log-search-count'] = count
session['log-search-sum'] = sum
session['log-search-exact'] = exact
try:
start_time, end_time = time_period.split(' - ')
except ValueError:
raise HayabusaError('Invalid Time Period: %s' % time_period)
request_id = post_request(current_user, match, start_time, end_time,
count, sum, exact)
except HayabusaError as e:
webui.logger.error('error: %s', e)
return jsonify({'error': str(e)})
except Exception as e:
unexpected_error(webui.logger, 'search', e)
return jsonify({'error': 'Internal Server Error'})
return jsonify({'id': request_id})
def poll(self, now):
try:
now_minute = datetime(now.year, now.month, now.day, now.hour,
now.minute)
target_time = now_minute - timedelta(minutes=1)
executor = ThreadPoolExecutor(max_workers=10)
futures = []
for user_name, v in self.query_data.items():
user = self.user_find(user_name)
for params in v:
query_id = params['query_id']
self.logger.debug('%s: %s', user_name, params)
futures.append(
executor.submit(self.search_receive_data, query_id,
user.username, user.api_password,
params['match'], target_time,
params['exact']))
wait = 60.0
time.sleep(wait)
for i, future in enumerate(futures):
self.logger.debug('future[%s] done?: %s', i, future.done())
executor.shutdown()
except Exception as e:
unexpected_error(self.logger, 'SearchQueryPoller', e)
def unexpected_error(self, e):
unexpected_error(self.logger, self.program_name, e)
def internal_server_error(self, resp, e, log_message):
unexpected_error(self.logger, 'RESTServer', e, log_message)
resp.media = {'error': 'Internal Server Error'}
resp.status = falcon.HTTP_500
def result_collector(self):
self.logger.info('-------------'
' Starting ResultCollector '
'-------------')
message = {}
results = {}
progress = {}
while True:
try:
message = self.receiver.recv_json()
request_id = message['id']
self.logger.debug('ResultCollector')
self.check_request_id(request_id)
if message['type'] == 'timeout_error':
self.update_status(request_id, Status.RC_TimeoutError,
message)
if results.get(request_id):
del results[request_id]
if progress.get(request_id):
del progress[request_id]
self.send_result(request_id, message, update_status=False)
continue
num_commands = message['commands']
if not results.get(request_id):
results[request_id] = []
progress[request_id] = []
for _ in range(num_commands):
results[request_id].append(None)
progress[request_id].append(None)
index = message['index']
if message['type'] == 'notice':
self.notify_status(request_id, Status.RW_ReceivedCommand,
message)
progress[request_id][index] = message['worker']
self.update_status(request_id, Status.WR_CollectingResults,
message, data=progress[request_id])
self.log_progress(progress)
continue
results[request_id][index] = message
progress[request_id][index] = 'completed-' + message['worker']
log_message = self.log_filter(message)
self.notify_status(request_id, Status.WR_ReceivedResult,
log_message)
num_results = len([r for r in results[request_id] if r])
label = '[%d/%d] #%d' % (num_results, num_commands, index)
self.update_status(request_id, Status.WR_CollectingResults,
label, data=progress[request_id])
if num_results == num_commands:
self.update_status(request_id,
Status.WR_ReceivedAllResults,
log_message)
sum = message['sum']
result = self.consolidate_result(request_id, sum,
results[request_id])
del results[request_id]
del progress[request_id]
self.send_result(request_id, result, update_status=True)
self.log_progress(progress)
except HayabusaError as e:
self.logger.error(str(e))
self.ignore_result(message)
except Exception as e:
unexpected_error(self.logger, 'ResultCollector', e)