def generate_by_group_result_no_fee(cls,
item_search_result,
asg_name=None):
result = {}
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(BY_GROUP_RESULT)
assert row_content_generator != None, 'Row type do not exists'
table_head = row_content_generator.get_head()
metric_count = 0
metric_result = []
for s in item_search_result:
if s.itemtype.aws != None or s.itemtype.itemunit == None:
continue
if s.itemtype.zabbixvaluetype is not None and int(
s.itemtype.zabbixvaluetype) not in [0, 3, 15]:
continue
if asg_name != None and s.host.service.servicename != asg_name:
continue
if s.host.service is None:
continue
try:
tmp_row = row_content_generator.id_2_content(s)
except Exception, e:
continue
if tmp_row not in metric_result:
metric_result.append(tmp_row)
metric_count += 1
def generate_fee_data(cls, item_search_result, awsname):
result = {}
# table_head = AWS_FEE_TABEL_HEAD
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(awsname)
assert row_content_generator != None, 'Row type do not exists'
table_head = row_content_generator.get_head()
metric_count = 0
metric_result = []
for s in item_search_result:
if s.itemtype.aws != None and s.itemtype.aws.awsname == awsname:
try:
row = row_content_generator.id_2_content(s)
except Exception, e:
continue
metric_result.append(row)
metric_count += 1
def generate_per_instance_result_no_fee(cls,
item_search_result,
asg_name=None):
result = {}
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(PER_INSTANCE_RESULT)
assert row_content_generator != None, 'Row type do not exists'
metric_count = 0
metric_result = []
table_head = row_content_generator.get_head()
for s in item_search_result:
if s.itemtype.aws != None or s.itemtype.itemunit == None:
continue
if s.itemtype.zabbixvaluetype is not None and int(
s.itemtype.zabbixvaluetype) not in [0, 3, 15]:
continue
if asg_name != None and s.host.service.servicename != asg_name:
continue
try:
row = row_content_generator.id_2_content(s)
except Exception, e:
continue
metric_result.append(row)
metric_count += 1
def find_hostid_for_table_row_instance(cls, row):
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(PER_INSTANCE_RESULT)
assert row_content_generator != None, 'Row type do not exists'
hostids = row_content_generator.get_hostids(row)
return hostids[0] if len(hostids) > 0 else None
def find_item_list_for_table_row_instance(cls, row):
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(PER_INSTANCE_RESULT)
assert row_content_generator != None, 'Row type do not exists'
result = row_content_generator.content_2_id(row)
return result
def find_item_list_for_table_row_group(cls, row):
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(BY_GROUP_RESULT)
assert row_content_generator != None, 'Row type do not exists'
result = row_content_generator.content_2_id(row)
return result
def row_type_2_name(cls, row_type, row):
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(row_type)
assert row_content_generator != None, 'Row type do not exists'
result = row_content_generator.get_series_name(row)
return result
def row_2_item_list(cls, row_type, row):
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(row_type)
assert row_content_generator != None, 'Row type do not exists'
result = row_content_generator.content_2_id(row)
return result
def server_2_server_data(self, input_dict):
time_from = input_dict['time_from']
time_to = input_dict['time_to']
data = input_dict['data']
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(BY_GROUP_RESULT)
assert row_content_generator != None, 'undefined row generator'
session = loadSession()
result = {}
result['data'] = []
for d in data:
from_tag = d['FROM']
to_tag = d['TO']
servicename = d['servicename']
metricname = d['metricname']
ground = 60
sm = servicename
itemids = row_content_generator.content_2_id(\
row_content_generator.get_fake_row(sm, metricname))
if len(itemids) > 0:
history_data = Chart.item_list_2_history_data(itemids,\
ground, time_from,time_to)
series_data = Chart.\
item_history_data_2_chart_update_series_data(history_data,\
time_from, 1)
last_sum = series_data[1]
tmp = {
'FROM' : from_tag,
'TO' : to_tag,
'servicename': servicename,
'metricname': metricname,
'value': last_sum,
'alias':d['alias']
}
result['data'].append(tmp)
result['time_from'] = input_dict['time_from']
result['time_to'] = input_dict['time_to']
session.close()
return result
def business_health(self,input_dict):
services_metrics = input_dict['service_metrics']
time_from = input_dict['time_from']
time_to = input_dict['time_to']
session = loadSession()
result = {}
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(BY_GROUP_RESULT)
assert row_content_generator != None, 'undefined row generator'
for sm in services_metrics:
group = Service.query.filter_by(servicename=sm).first()
if group != None:
result[sm] = []
for metric_condition in services_metrics[sm]:
metricname = metric_condition['metricname']
condition = metric_condition['condition']
itemids = row_content_generator.content_2_id(\
row_content_generator.get_fake_row(sm, metricname))
if len(itemids) > 0:
recordsuint = Zabbixhistoryuint.\
get_interval_condition_record(itemids,\
time_from, time_to,condition)
records = Zabbixhistory.\
get_interval_condition_record(itemids,\
time_from, time_to, condition)
if records is None and recordsuint is None:
continue
tmp_records = recordsuint if recordsuint is not None \
else records
for r in tmp_records:
itemid = r[0]
clock = r[1]
value = r[2]
item = Item.query.get(itemid)
if item != None:
host = item.host
zinterface = session.query(Zabbixinterface).\
filter_by(hostid=host.hostid).first()
if zinterface != None:
result[sm].append([host.hostname, \
zinterface.ip, item.itemname, clock, value])
session.close()
return result
def save_chart(cls,selected_metrics,chart_config,windowname,user,index,window_type,page):
if window_type == WINDOW_CHART:
tmp_window = user.windows.filter_by(windowname=windowname).filter_by(type=window_type).first()
if tmp_window != None:
raise Exception('same name for saving is already exists')
window = Window(windowname,window_type,index,user,page)
db.session.add(window)
sm = Selectedmetrics(window)
db.session.add(sm)
for option_iter in selected_metrics:
option = Option(option_iter,sm)
db.session.add(option)
for table_title_iter in selected_metrics[option_iter]:
dt = Displaytable(table_title_iter,option)
db.session.add(dt)
row_content_generator = RowContentGeneratorFactory().\
produce_generator(table_title_iter)
assert row_content_generator != None, 'undefined' + \
' row_content_generator'
table_head = row_content_generator.get_head()
for td_content in selected_metrics[option_iter][table_title_iter]['metric_result']:
dtr = Displaytablerow(dt)
db.session.add(dtr)
assert len(table_head) == len(td_content)
for i in range(len(td_content)):
attr = Attr(table_head[i],td_content[i],dtr,None)
db.session.add(attr)
cc = Chartconfig(window)
db.session.add(cc)
for key in chart_config:
tmp_attr = Attr(key,chart_config[key],None,cc)
db.session.add(tmp_attr)
return window
def core_data(self,input_dict):
services_metrics = input_dict
session = loadSession()
result = {}
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(BY_GROUP_RESULT)
assert row_content_generator != None, 'undefined row generator'
for sm in services_metrics:
group = Service.query.filter_by(servicename=sm).first()
if group != None:
result[sm] = {}
for metric in services_metrics[sm]:
time_from = services_metrics[sm][metric]['time_from']
time_to = services_metrics[sm][metric]['time_to']
ground = int(services_metrics[sm][metric]['frequency'])
result[sm][metric] = {}
itemids = row_content_generator.content_2_id(\
row_content_generator.get_fake_row(sm, metric))
# itemids = ItemSearch.find_item_list_for_table_row_group([sm,metric])
if len(itemids) > 0 :
v = Zabbixhistory.get_interval_history_no_ground(\
itemids, time_from, time_to)
vuint = Zabbixhistoryuint.\
get_interval_history_no_ground(itemids, \
time_from, time_to)
if vuint is None and v is None:
continue
result[sm][metric]['statics'] = v if v is not None \
else vuint
time_from = time_to - ground
time_from = (time_from//ground) * ground
history_data = Chart.item_list_2_history_data(itemids, \
ground, time_from, time_to)
series_data = Chart.\
item_history_data_2_chart_update_series_data(\
history_data, time_from, 1)
last_sum = series_data[1]
result[sm][metric]['last'] = last_sum
session.close()
return result
def find_item_list_for_table_row_aws_fee(cls, row):
tmp_aws = Aws.query.first()
assert tmp_aws != None, 'no aws in database currently'
assert tmp_aws.awsname != None, 'fee name can not be empty'
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(tmp_aws.awsname)
assert row_content_generator != None, 'Row type do not exists'
result = row_content_generator.content_2_id(row)
return result
def mechine_health(self,input_dict):
services = input_dict['services']
time_from = input_dict['time_from']
time_to = input_dict['time_to']
metrics = input_dict['metrics']
session = loadSession()
result = {}
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(PER_INSTANCE_RESULT)
assert row_content_generator != None, 'undefined row generator'
for s in services:
group = Service.query.filter_by(servicename=s).first()
if group != None:
result[s] = {}
for h in group.hosts.all():
zinterface = session.query(Zabbixinterface).\
filter_by(hostid=h.hostid).first()
zh = session.query(Zabbixhosts).get(h.hostid)
if zinterface is None or zh is None:
continue
result[s][zinterface.ip] = {}
result[s][zinterface.ip]['available'] = zh.available
for m in metrics:
itemids = row_content_generator.content_2_id(\
row_content_generator.get_fake_row(zinterface.ip, \
m['metricname']))
# itemids = ItemSearch.find_item_list_for_table_row_instance([None,None,zinterface.ip,m['metricname'],None, None, None])
if len(itemids) > 0:
v = Zabbixhistory.get_interval_history_no_ground(\
itemids,time_from,time_to)
vuint = Zabbixhistoryuint.\
get_interval_history_no_ground(\
itemids,time_from,time_to)
if vuint is None and v is None:
continue
result[s][zinterface.ip][m['metricname']] = \
v if v is not None else vuint
session.close()
return result
def load_window_chart(cls,windowid):
result = {}
window = Window.query.get(windowid)
if window == None:
raise Exception('window do not exist')
selected_metrics = {}
selectedmetrics = window.selectedmetrics.first()
chartconfig = window.chartconfig.first()
chart_config = {}
if selectedmetrics != None:
for option in selectedmetrics.options.all():
selected_metrics[option.optionname] = {}
for dt in option.displaytables.all():
selected_metrics[option.optionname][dt.displaytablename] = {}
row_content_generator = RowContentGeneratorFactory()\
.produce_generator(dt.displaytablename)
assert row_content_generator != None, 'not defined ' + \
'row_content_generator'
table_head = row_content_generator.get_head()
if table_head == None:
raise Exception('unknown table head')
selected_metrics[option.optionname][dt.displaytablename]['metric_count'] = 0
selected_metrics[option.optionname][dt.displaytablename]['metric_result'] = []
selected_metrics[option.optionname][dt.displaytablename]['table_head'] = table_head
for dtr in dt.rows.all():
selected_metrics[option.optionname][dt.displaytablename]['metric_count'] += 1
tmp_arr = list(table_head)
for attr in dtr.attrs.all():
tmp_arr[table_head.index(attr.attrname)] = attr.attrvalue
item_list = row_content_generator.content_2_id(tmp_arr)
if len(item_list) > 0:
item = Item.query.get(item_list[0])
tmp_arr = row_content_generator.id_2_content(item)
selected_metrics[option.optionname][dt.displaytablename]['metric_result'].append(tmp_arr)
if chartconfig != None:
for attr in chartconfig.attrs.all():
chart_config[attr.attrname] = attr.attrvalue
if chart_config['use_utc'] == '0':
chart_config['use_utc'] = False
elif chart_config['use_utc'] == '1':
chart_config['use_utc'] = True
result['selected_metrics'] = selected_metrics
result['chart_config'] = chart_config
result['chart_name'] = window.windowname
return result