def _timeout_loop(self):
while True:
gevent.sleep(1)
if not self.__timeout_queue.is_empty():
now = int(time.time())
conn = None
while not self.__timeout_queue.is_empty():
deadline, host_id = self.__timeout_queue.get_top()
if now < deadline:
break
elif conn is None:
conn = db.DBConnection()
print host_id, ' has been timeout.'
self.__timeout_queue.pop()
# set the host to not connected state
report_interval, last_update_time = self.__host_time_info[host_id]
self.__host_time_info[host_id] = (report_interval, None)
connection_info = {'connected': False, 'datetime': last_update_time}
req = monsit_pb2.ReportRequest()
req.host_id = host_id
basic_info = req.basic_infos.add()
basic_info.id = 1
basic_info.info = json.dumps(connection_info, separators=(',', ':'))
conn.update_info(req)
_, info_alarms = conn.get_alarm_settings(host_id)
check_info_alarms(req, info_alarms)
if conn is not None:
conn.commit()
conn.close()
def ajax_hoststat():
stat_ids = request.args.getlist('stat_ids[]', type=int)
host_id = request.args.get('host_id', 0, type=int)
with db.DBConnection() as cnx:
host_stats = cnx.get_host_stats(host_id, stat_ids)
return jsonify(return_code=0, stats=host_stats)
def add_alarm():
with db.DBConnection() as cnx:
host_infos = []
for host in cnx.get_all_hosts():
host_id = host[0]
host_name = host[1]
host_infos.append(HostInfo(host_id, host_name, True, None))
return render_template('add_alarm.html', hosts=host_infos)
def add_stat():
with db.DBConnection() as cnx:
host_infos = []
for host in cnx.get_all_hosts():
host_id = host[0]
host_name = host[1]
host_infos.append(HostInfo(host_id, host_name, True, None))
return render_template('add_stat.html', hosts=host_infos,
value_types=db.ValueType.value_type_str)
def do_set_display():
host_id = int(request.form['host_id'])
display_setting = request.form['display_setting']
with db.DBConnection() as cnx:
cnx.update_display_setting(host_id, display_setting)
cnx.commit()
return render_template(
'admin_msg.html',
msg=('Display for host %d is set successfully' % host_id))
def do_add_info():
host_id = int(request.form['host_id'])
info_name = request.form['info_name']
chart_name = request.form['chart_name']
with db.DBConnection() as cnx:
info_id = cnx.insert_new_info(host_id, info_name, chart_name)
cnx.commit()
return render_template('admin_msg.html',
msg=('New info id is %d' % info_id))
def hostinfo():
try:
host_id = int(request.args['id'])
host_name = request.args['name']
except (KeyError, ValueError):
abort(404)
with db.DBConnection() as cnx:
display_setting = cnx.get_display_setting(host_id)
return render_template('hostinfo.html', host_id=host_id, host_name=host_name,
display_setting=Markup(display_setting))
def index():
with db.DBConnection() as cnx:
host_infos = []
for host in cnx.get_all_hosts():
host_id = host[0]
host_name = host[1]
infos = cnx.get_host_infos(host_id, [1])
info_json = json.loads(infos[1])
host_infos.append(
HostInfo(host_id, host_name, info_json['connected'],
datetime.datetime.fromtimestamp(info_json['datetime'])))
return render_template('index.html', hosts=host_infos)
def __init__(self):
with db.DBConnection() as cnx:
registered_hosts = {}
registered_host_ids = {}
for host_id, host_name in cnx.get_all_hosts():
registered_hosts[host_name] = host_id
registered_host_ids[host_id] = [host_name, False]
self.__registered_host_names = registered_hosts
self.__registered_host_ids = registered_host_ids
self.__host_time_info = {}
self.__timeout_queue = PriorityQueue()
spawn(self._timeout_loop)
def do_add_stat():
host_id = int(request.form['host_id'])
stat_name = request.form['stat_name']
chart_name = request.form['chart_name']
y_value_type = int(request.form['value_type'])
y_unit = request.form['unit']
with db.DBConnection() as cnx:
stat_id = cnx.insert_new_stat(host_id, stat_name, chart_name,
y_value_type, y_unit)
cnx.commit()
return render_template('admin_msg.html',
msg=('New stat id is %d' % stat_id))
def ajax_host_info():
info_ids = request.args.getlist('info_ids[]', type=int)
host_id = request.args.get('id', 0, type=int)
print 'host_id', host_id
with db.DBConnection() as cnx:
try:
host_infos = cnx.get_host_infos(host_id, info_ids)
print host_infos
return jsonify(return_code=0, infos=host_infos)
except:
print 'db error'
import traceback
traceback.print_exc()
return jsonify(return_code=1)
def set_display():
with db.DBConnection() as cnx:
host_infos = []
first_host_id = False
for host in cnx.get_all_hosts():
host_id = host[0]
host_name = host[1]
host_infos.append(HostInfo(host_id, host_name, True, None))
if not first_host_id:
first_host_id = host_id
display_setting = cnx.get_display_setting(first_host_id)
return render_template('set_display.html', hosts=host_infos,
display_setting=Markup(display_setting))
def Report(self, rpc_controller, request, done):
if request.host_id not in self.__registered_host_ids:
print 'Host not registered:', request.host_id
rsp = monsit_pb2.ReportResponse(return_code=1, msg='Host not registered')
return rsp
elif not self.__registered_host_ids[request.host_id][1]:
host_name = self.__registered_host_ids[request.host_id][0]
print 'Host not registered:', host_name
rsp = monsit_pb2.ReportResponse(return_code=1, msg='Host not registered')
return rsp
# print request
# insert the connection time to the info
connection_info = {'connected': True, 'datetime': request.datetime}
basic_info = request.basic_infos.add()
basic_info.id = 1
basic_info.info = json.dumps(connection_info, separators=(',', ':'))
# record the report time, and put it to the timeout queue
report_interval, last_update_time = self.__host_time_info.get(request.host_id)
timeout_period = (report_interval * 3 + 1) / 2
new_deadline = request.datetime + timeout_period
if last_update_time is None:
self.__timeout_queue.push((new_deadline, request.host_id))
else:
last_deadline = last_update_time + timeout_period
time_index = self.__timeout_queue.find((last_deadline, request.host_id))
if time_index >= 0:
self.__timeout_queue.increase_key(time_index, (new_deadline, request.host_id))
else:
self.__timeout_queue.push((new_deadline, request.host_id))
self.__host_time_info[request.host_id] = (report_interval, request.datetime)
with db.DBConnection() as cnx:
report_time = datetime.datetime.fromtimestamp(request.datetime)
report_time = report_time.strftime("%Y-%m-%d %H:%M:%S")
cnx.insert_stat(request, report_time)
cnx.update_info(request)
cnx.commit()
# check the whether the alarm is fired
stat_alarms, info_alarms = cnx.get_alarm_settings(request.host_id)
check_stat_alarms(request, stat_alarms)
check_info_alarms(request, info_alarms)
rsp = monsit_pb2.ReportResponse(return_code=0, msg='SUCCESS')
return rsp
def ajax_latest_stat():
stat_ids = request.args.getlist('stat_ids[]', type=int)
host_id = request.args.get('id', 0, type=int)
last_times = request.args.getlist('latest_time[]')
#print 'stat_id', stat_id, 'host_id', host_id, 'last_time', last_time
with db.DBConnection() as cnx:
try:
latest_stats = cnx.get_updated_stats(host_id, stat_ids, last_times)
except:
print 'db error'
return jsonify(return_code=1)
if latest_stats is None:
return jsonify(return_code=1)
return jsonify(return_code=0, stats=latest_stats)
def Register(self, rpc_controller, request, done):
try:
host_id = self.__registered_host_names[request.host_name]
self.__registered_host_ids[host_id][1] = True
except KeyError:
with db.DBConnection() as cnx:
host_id, host_name = cnx.insert_new_host(request.host_name)
self.__registered_host_names[request.host_name] = host_id
self.__registered_host_ids[host_id] = [request.host_name, True]
print request
self.__host_time_info[host_id] = (30, None) # TODO: change this
rsp = monsit_pb2.RegisterResponse(return_code=0, msg='SUCCESS',
host_id=host_id)
return rsp
def do_add_alarm():
host_id = int(request.form['host_id'])
alarm_name = request.form['alarm_name']
alarm_type = request.form['alarm_type']
stat_or_info_id = int(request.form['stat_info_id'])
threshold_type = request.form['threshold_type']
threshold = request.form['threshold']
if threshold_type == 'int':
threshold = int(threshold)
elif threshold_type == 'double':
threshold = float(threshold)
message = request.form['message']
emails = request.form['emails']
with db.DBConnection() as cnx:
cnx.insert_alarm_setting(host_id, alarm_name, alarm_type,
stat_or_info_id, threshold_type,
threshold, message, emails)
cnx.commit()
return render_template('admin_msg.html',
msg='Alarm has been added successfully')
