class DataHandler:
def __init__(self, config_path='openstack_dashboard/api/telemetry_api/environment.conf'):
self.__config = ConfigParser.ConfigParser()
self.__config.read(config_path)
#self.__ceilometer = CeilometerClient(self.__config)
self.__ceilometer = CeilometerClient()
self.__keystone = KeystoneClient(self.__config)
#self.__nova = NovaClient(self.__config)
self.__nova = NovaClient()
server = self.__config.get('Misc', 'dbserver')
user = self.__config.get('Misc', 'dbuser')
passwd = self.__config.get('Misc', 'dbpass')
database = self.__config.get('Misc', 'hostsdbname')
table = self.__config.get('Misc', 'hostsdbtable')
self.__hosts = ast.literal_eval(self.get_config().get('Openstack', 'Hosts'))
self.__hosts_db = HostDataHandler()
self.__benchmark_db = BenchmarkDataHandler(server, user, passwd)
self.__reduction = Reduction()
def get_config(self):
return self.__config
def projects(self):
return json.dumps(self.__keystone.projects)
def get_critical_hosts(self,instances_critical, information):
critical_hosts = []
for cpn in information:
cpn_name = cpn.keys()[0]
cpn_server_list = cpn[cpn_name]['vms'].keys()
for server in cpn_server_list:
if server in instances_critical:
critical_hosts.append(cpn_name)
return critical_hosts
def suggestion(self, list_not_ignore=[]):
project_list = [ project['name'] for project in json.loads(self.projects())] #returns the list of existing projects
compute_nodes_info_list = self.__nova.vm_info(project_list) #list of jsons - json correspond to a compute node information
instances_id_project = {} #dict instances_id : project_name
for compute_node_aux in compute_nodes_info_list:
try:
compute_name = compute_node_aux.keys()[0] #get the name of compute node to access information
for key in compute_node_aux[compute_name]['Info_project'].keys(): #key represent a project
#id represent de id of any instance present in a given project(key) and in the compute_name
for id in compute_node_aux[compute_name]['Info_project'][key]:
instances_id_project[id] = key
except Exception as excp:
return {"error": excp.message}
#get the list of critical instances (can't migrate them)
critical_instances = self.__nova.critical_instances(project_list)
#list of critical hosts
critical_cpn = self.get_critical_hosts(critical_instances,compute_nodes_info_list)
shutdown = {} #dict compute_node : True/False for shutdown
migrations = {} #dict with all migrations
compute_nodes_copy = compute_nodes_info_list[:] #copy to aux with the algorithm
owner_cpn_instance = {}
#for cp in compute_nodes_info_list:
# owner_cpn = cp.keys()[0]
# vms_cp = cp[owner_cpn]['vms'].keys()
# for v in vms_cp:
# owner_cpn_instance[v] = owner_cpn
#begin of algorithm
#cpn_data - compute node data
try:
for cpn_data in compute_nodes_info_list:
data = cpn_data.copy() #contains all information about a compute node
actual_cpn = cpn_data.keys()[0] #actual compute node (try migration for all instances)
#verify is the compute node has critical instances
if actual_cpn not in critical_cpn:
if( len( data[actual_cpn]['vms'].keys()) > 0 ):
instances_data = data[actual_cpn]['vms'].copy() #copy the list of vms
compute_nodes_copy.remove(cpn_data) #remove all data from compute node in the copy
migration_flag = False #flag to say if the instace can migrate to other compute node
migrations[actual_cpn] = {} #dict with all migrations for compute node
for instance_id in instances_data:
for other_cpn in compute_nodes_copy:
#verification - instance is not critical
if (other_cpn not in critical_cpn and instance_id not in critical_instances):
migration_flag = False
other_cpn_name = other_cpn.keys()[0]
if list_not_ignore == [] or actual_cpn in list_not_ignore:
if(other_cpn[other_cpn_name]['Livre'][0] >= instances_data[instance_id][0] and
other_cpn[other_cpn_name]['Livre'][1] >= instances_data[instance_id][1] and
other_cpn[other_cpn_name]['Livre'][2] >= instances_data[instance_id][2]):
from_cpn = None
migrate_to_cpn = None
if instance_id in owner_cpn_instance:
from_cpn = owner_cpn_instance[instance_id].keys()[0]
migrate_to_cpn = owner_cpn_instance[instance_id][from_cpn]
else:
from_cpn = actual_cpn
migrate_to_cpn = other_cpn_name
if actual_cpn == from_cpn or actual_cpn == migrate_to_cpn:
#update values of free resources
new_values = [other_cpn[other_cpn_name]['Livre'][0] - instances_data[instance_id][0],
other_cpn[other_cpn_name]['Livre'][1] - instances_data[instance_id][1],
other_cpn[other_cpn_name]['Livre'][2] - instances_data[instance_id][2]]
other_cpn[other_cpn_name]['Livre'] = new_values
#sending instance to the other host with all information
instances_other_cpn = other_cpn[other_cpn_name]['vms']
instances_other_cpn[instance_id] = instances_data[instance_id]
other_cpn[other_cpn_name]['vms'] = instances_other_cpn
other_cpn[other_cpn_name]['nomes'][instance_id] = data[actual_cpn]['nomes'][instance_id]
migration_flag = True
migrations[actual_cpn][instance_id] = [ other_cpn_name , cpn_data[actual_cpn]['nomes'].get(instance_id) ,instances_id_project[instance_id]]
#update future owner of instance
owner_cpn_instance[instance_id] = {actual_cpn : other_cpn_name}
else:
continue
else:
break
else:
migration_flag = False
else:
continue
#update owner
if migration_flag == False:
if instance_id in owner_cpn_instance:
if( owner_cpn_instance[instance_id].has_key(actual_cpn) or actual_cpn in owner_cpn_instance[instance_id].values()):
continue
else:
migrations[actual_cpn][instance_id] = None
shutdown[actual_cpn] = False
if not actual_cpn in shutdown:
shutdown[actual_cpn] = True
else:
compute_nodes_copy.remove(cpn_data)
shutdown[actual_cpn] = True
continue
else:
compute_nodes_copy.remove(cpn_data)
shutdown[actual_cpn] = False
except Exception as excp2:
return {"error in algorithm suggestion":excp2.message}
for host_key in migrations.keys():
if None in migrations[host_key].values():
migrations[host_key] = {}
output = {} #json output with all data
output['Hosts'] = shutdown
output['Migracoes'] = migrations
#recomendation = self.remove_duplicated_migrations(output)
return output
#Not using anymore
#def remove_duplicated_migrations(self, output):
# result = output
# for compute_node in result['Migracoes'].keys():
# for server in result['Migracoes'][compute_node].keys():
# if not self.__nova.verify_host_has_server(compute_node,server):
# result['Migracoes'][compute_node].pop(server)
# return result
def cpu_util_from(self, timestamp_begin=None, timestamp_end=None, resource_id=None):
return json.dumps(self.__ceilometer.get_cpu_util(timestamp_begin, timestamp_end, resource_id))
def cpu_util_flavors(self, timestamp_begin=None, timestamp_end=None):
data = self.__ceilometer.get_cpu_util_flavors(timestamp_begin, timestamp_end)
ret = analytics.recommendations.recomenda_flavor(data)
return json.dumps(ret)
def network_incoming_bytes_rate_from(self, timestamp_begin=None, timestamp_end=None, resource_id=None):
return json.dumps(self.__ceilometer.get_network_incoming_bytes_rate(timestamp_begin, timestamp_end, resource_id))
def network_outgoing_bytes_rate_from(self, timestamp_begin=None, timestamp_end=None, resource_id=None):
return json.dumps(self.__ceilometer.get_network_outgoing_bytes_rate(timestamp_begin, timestamp_end, resource_id))
def projects_with_instances_and_cpu_util(self):
projects = self.__keystone.tenants
ret = { 'name' : 'cloud', 'children' : [] }
for p in projects:
proj = { 'name' : p.name, 'children' : [] }
instances = self.__nova.instances(p.name)
for i in instances:
proj['children'].append({ 'resource_id' : i.id, 'instance_name' : i.name })
ret['children'].append(proj)
return ret
def alarms_history(self, timestamp_begin=None, timestamp_end=None):
return self.__ceilometer.get_alarms_history(timestamp_begin, timestamp_end)
def add_alarm(self, name, resource, threshold, operator, period, ev_period, send_mail, email_admin, instance=""):
return self.__ceilometer.set_alarm(name, resource, threshold, operator, period, ev_period, send_mail, email_admin, instance)
def alarm_email(self, data_requested):
alarm_id = ast.literal_eval(data_requested)['alarm_id']
userId = self.__ceilometer.get_alarm_userid(alarm_id)
projectId = self.__ceilometer.get_alarm_projectid(alarm_id)
userEmail = self.__keystone.get_user_email(userId, projectId)
copy_admin = self.__ceilometer.get_alarm_email_status(alarm_id)
adminEmail = self.__keystone.get_user_email(self.__keystone.get_user(projectId,'admin'),projectId)
if 'True' in copy_admin[0] and 'True' in copy_admin[1] :
send_email('*****@*****.**',
[adminEmail],
[],
'Alert Telemetry Cloud',
'Email disparado pelo alarme!!!',
'*****@*****.**',
'4n4lyt1cs')
send_email('*****@*****.**',
[userEmail],
[],
'Alert Telemetry Cloud',
'Email disparado pelo alarme!!!',
'*****@*****.**',
'4n4lyt1cs')
elif 'True' in copy_admin[0] and 'False' in copy_admin[1]:
send_email('*****@*****.**',
[userEmail],
[],
'Alert Telemetry Cloud',
'Email disparado pelo alarme!!!',
'*****@*****.**',
'4n4lyt1cs')
elif 'False' in copy_admin[0] and 'True' in copy_admin[1]:
send_email('*****@*****.**',
[adminEmail],
[],
'Alert Telemetry Cloud',
'Email disparado pelo alarme!!!',
'*****@*****.**',
'4n4lyt1cs')
def alarm_description(self):
return self.__ceilometer.get_alarm_parameters()
def delete_alarm(self, alarm_id):
return json.dumps(self.__ceilometer.delete_alarms(alarm_id))
def hosts_cpu(self, timestamp_begin, timestamp_end):
return self.__hosts_db.get_data_db('Cpu_Util', timestamp_begin, timestamp_end)
def hosts_memory(self, timestamp_begin, timestamp_end):
return self.__hosts_db.get_data_db('Memory', timestamp_begin, timestamp_end)
def hosts_disk(self, timestamp_begin, timestamp_end):
return self.__hosts_db.get_data_db('Disk', timestamp_begin, timestamp_end)
def hosts_network(self, timestamp_begin, timestamp_end):
return self.__hosts_db.get_data_db('Network', timestamp_begin, timestamp_end)
def host_metrics(self, project):
return self.__nova.metrics(project)
def host_aggregates(self, project):
return self.__nova.host_aggregates(project)
def resource_host(self, host):
return self.__nova.resource_host(host)
def hosts_recommendation(self, r_cpu, r_memory , r_disk):
resource = []
ret = {}
r_cpu = json.loads(r_cpu)
r_memory = json.loads(r_memory)
r_disk = json.loads(r_disk)
for host in r_cpu:
host_http = host["host_address"]
if host["data"] is None:
continue
for data in host["data"]:
resource.append(data["data"])
resource = sorted(resource)
if(len(resource)%2 == 0):
index = len(resource)/2
mediana = (resource[index-1] + resource[index+1])/2
else:
mediana = resource[int(math.ceil(len(resource)/2))]
if mediana >= 95:
ret[host_http] ="sobrecarregado"
else:
resource = []
for host_mem in r_memory:
if(host["host_address"] == host_mem["host_address"]):
for data in host_mem["data"]:
for value in json.loads(data["data"]):
resource.append(value["percent"])
resource = sorted(resource)
if(len(resource)%2 == 0):
index = len(resource)/2
mediana = (resource[index-1] + resource[index+1])/2
else:
mediana = resource[int(math.ceil(len(resource)/2))]
if mediana >= 95:
ret[host_http] ="sobrecarregado"
else:
ret[host_http] ="normal"
return json.dumps(ret)
#return json.dumps(cpu)
def instances_from_host(self, host_name):
attr_host = 'OS-EXT-SRV-ATTR:host'
ret = []
projects = self.__keystone.projects
for project in projects:
instances = self.__nova.instances(project['name'])
for instance in instances:
print instance._info
if instance._info[attr_host] == host_name:
ret.append({'instance_name' : instance.name, 'instance_id' : instance.id})
return ret
def migrate_to_host(self, project_name, host_name, instance_id):
#host_vm = self.__nova.vm_hostname(project_name,instance_id)
#attr_host = 'OS-EXT-SRV-ATTR:host'
#if host_vm._info[attr_host] == host_name:
# raise MigrateException(400,"Migracao para o mesmo destino")
#elif host_vm._info[attr_host] == 'truta' and host_name != 'truta':
# raise MigrateException(500,"Migracao de host para compute node")
#else:
try:
retorno = self.__nova.vm_migration(project_name,host_name,instance_id)
except Exception as a:
return {"erro":a.message}
return {"status":"success"}
def get_benchmark_bd(self):
ret = self.__benchmark_db.get_data_db()
return ret
def start_instance_bench(self, project, host):
return self.__nova.start_instance_bench(project, host)
def get_benchmark(self, project, host):
benchmark_ip = self.__nova.get_benchmark_ip(project, host)
data = requests.get('http://'+benchmark_ip+':5151/get_benchmarking')
return data.json()
def get_benchmark_status(self, project, host):
benchmark_ip = self.__nova.get_benchmark_ip(project, host)
print benchmark_ip
data = requests.get('http://'+benchmark_ip+':5151/get_status')
return data.text
def repeat_benchmark(self, project):
benchmark_ip = self.__nova.get_benchmark_ip(project)
data = requests.get('http://'+benchmark_ip+':5151/start_benchmarking')
return data.text
def remove_benchmark_instance(self, host):
id = self.__nova.benchmark_id(host)
if id == None:
return "sem instancia benchmark"
else:
remove = self.__nova.remove_instance(id)
return remove
def hosts_aggregation_cpu(self, timestamp_begin=None, timestamp_end=None):
ret = []
cpu_data = self.hosts_cpu(timestamp_begin, timestamp_end)
aggregates = self.__nova.host_aggregates('admin')
for aggregate in aggregates:
result = []
host_address = aggregate["host_address"]
for host in host_address:
host_name = self.__nova.server_name_by_ip(host)
host_cpu = self.__nova.resource_host(host_name)["cpu"]
for data in cpu_data:
if(data["host_address"]==host):
convert = []
for cpu_percent in data["data"]:
cpu_percent["data"] = (1 - cpu_percent["data"]/100.0)* host_cpu
convert.append(cpu_percent)
if(len(result)==0):
result = convert
else:
if(len(result) > len(convert)):
result = result[0:len(convert)]
for i in range(len(result)):
value = result[i]
value["data"] = value["data"] + (convert[i])["data"]
result[i] = value
break
ret.append({"Aggregate":aggregate["name"], "data":result})
return json.dumps(ret)
def hosts_aggregation_memory(self, timestamp_begin=None, timestamp_end=None):
ret = []
memory_data = self.hosts_memory(timestamp_begin, timestamp_end)
aggregates = self.__nova.host_aggregates('admin')
for aggregate in aggregates:
result = []
host_address = aggregate["host_address"]
aggregate_memory = self.__nova.resource_aggregates(aggregate['name'])['memory_mb']
for host in host_address:
host_name = self.__nova.server_name_by_ip(host)
host_memory = self.__nova.resource_host(host_name)["memory_mb"]
for data in memory_data:
if(data["host_address"]==host):
convert = []
for memory_percent in data["data"]:
memory_percent['data'] = ((json.loads(memory_percent['data'])[0]['percent']/100.0 )*host_memory)/aggregate_memory
convert.append(memory_percent)
if(len(result)==0):
result = convert
else:
if(len(result) > len(convert)):
result = result[0:len(convert)]
for i in range(len(result)):
value = result[i]
value["data"] = (value["data"] + (convert[i])["data"])
result[i] = value
break
ret.append({"Aggregate":aggregate["name"], "data":result})
return json.dumps(ret)
def hosts_aggregation_disk(self, timestamp_begin=None, timestamp_end=None):
ret = []
disk_data = self.hosts_disk(timestamp_begin, timestamp_end)
aggregates = self.__nova.host_aggregates('admin')
for aggregate in aggregates:
result = []
host_address = aggregate["host_address"]
aggregate_disk = self.__nova.resource_aggregates(aggregate['name'])['disk']
for host in host_address:
host_name = self.__nova.server_name_by_ip(host)
host_disk = self.__nova.resource_host(host_name)["disk_gb"]
for data in disk_data:
if(data["host_address"]==host):
convert = []
for disk_percent in data["data"]:
disk_percent['data'] = ((json.loads(disk_percent['data'])[0]['percent']/100)*host_disk)/aggregate_disk
convert.append(disk_percent)
if(len(result)==0):
result = convert
else:
if(len(result) > len(convert)):
result = result[0:len(convert)]
for i in range(len(result)):
value = result[i]
value["data"] = value["data"] + (convert[i])["data"]
result[i] = value
break
ret.append({"Aggregate":aggregate["name"], "data":result})
return json.dumps(ret)
def hosts_aggregation_network(self, timestamp_begin=None, timestamp_end=None):
ret = []
hosts = self.get_compute_nodes_ips()
network_data = self.points_reduction_by_server_network(timestamp_begin, timestamp_end, hosts)
aggregates = self.__nova.host_aggregates('admin')
for aggregate in aggregates:
result_incoming = []
result_outgoing = []
host_address = aggregate["host_address"]
for host in host_address:
for data in network_data:
if(data["host_address"]==host):
convert_incoming = []
for network_incoming_rate in data["incoming_rate"]:
convert_incoming.append(network_incoming_rate)
if(len(result_incoming)==0):
result_incoming = convert_incoming
else:
if(len(result_incoming) > len(convert_incoming)):
result_incoming = result_incoming[0:len(convert_incoming)]
for i in range(len(result_incoming)):
value = result_incoming[i]
value["net_bytes_recv"] = value["net_bytes_recv"] + (convert_incoming[i])["net_bytes_recv"]
result_incoming[i] = value
convert_outgoing = []
for network_outgoing_rate in data["outgoing_rate"]:
convert_outgoing.append(network_outgoing_rate)
if(len(result_outgoing)==0):
result_outgoing = convert_outgoing
else:
if(len(result_outgoing) > len(convert_outgoing)):
result_outgoing = result_outgoing[0:len(convert_outgoing)]
for i in range(len(result_outgoing)):
value = result_outgoing[i]
value["net_bytes_sent"] = value["net_bytes_sent"] + (convert_outgoing[i])["net_bytes_sent"]
result_outgoing[i] = value
break
ret.append({"Aggregate":aggregate["name"], 'incoming_rate': result_incoming, 'outgoing_rate': result_outgoing})
return json.dumps(ret)
def points_reduction_by_server_cpu(self, timestamp_begin, timestamp_end, hosts):
data = []
old_data = self.hosts_cpu(timestamp_begin, timestamp_end)
key = 'data'
if len(old_data)==0 or len(old_data[0][key]) <= 3:
result = old_data
else:
for host in range(len(hosts)):
dict_host = {}
dict_host["host_address"] = hosts[host]
dict_host['data'] = self.__reduction.points_reduction(old_data[host]['data'],key)
data.append(dict_host)
result = data
return result
def points_reduction_by_server_memory(self, timestamp_begin, timestamp_end, hosts):
data = []
old_data = self.hosts_memory(timestamp_begin, timestamp_end)
key = 'data'
if len(old_data)==0 or len(old_data[0][key]) <= 3:
result = old_data
else:
for host in range(len(hosts)):
dict_host = {}
dict_host["host_address"] = hosts[host]
dict_host['data'] = self.__reduction.points_reduction_for_percent(old_data[host]['data'],key)
data.append(dict_host)
result = data
return result
def points_reduction_by_server_disk(self, timestamp_begin, timestamp_end, hosts):
data = []
old_data = self.hosts_disk(timestamp_begin, timestamp_end)
if len(old_data)==0 or len(old_data[0]['data']) <= 3:
result = old_data
else:
for host in range(len(hosts)):
dict_host = {}
dict_host["host_address"] = hosts[host]
dict_host['data'] = self.__reduction.points_reduction_disk(old_data[host]['data'])
data.append(dict_host)
result = data
return result
def points_reduction_by_server_network(self, timestamp_begin, timestamp_end, hosts):
data = []
old_data = self.hosts_network(timestamp_begin, timestamp_end)
for host in old_data:
single_host_data = {'host_address': host['host_address'], 'incoming_rate': [], 'outgoing_rate': []}
if len(host['data']) > 1:
sample = host['data'][0]
for sample_index in range(len(host['data']) - 1):
sample_index += 1
network_data = json.loads(sample['data'])[0]
before_timestamp = datetime.strptime(sample['timestamp'], '%Y-%m-%dT%H:%M:%S')
before_net_bytes_recv = network_data['net_bytes_recv']
before_net_bytes_sent = network_data['net_bytes_sent']
next_sample = host['data'][sample_index]
network_data = json.loads(next_sample['data'])[0]
after_timestamp = datetime.strptime(next_sample['timestamp'], '%Y-%m-%dT%H:%M:%S')
after_net_bytes_recv = network_data['net_bytes_recv']
after_net_bytes_sent = network_data['net_bytes_sent']
timestamp_delta = (after_timestamp - before_timestamp).total_seconds()
net_bytes_recv_delta = after_net_bytes_recv - before_net_bytes_recv
net_bytes_sent_delta = after_net_bytes_sent - before_net_bytes_sent
if (net_bytes_recv_delta < 0) or (net_bytes_sent_delta < 0):
continue
else:
sample = next_sample
net_bytes_recv_delta = net_bytes_recv_delta / timestamp_delta
net_bytes_sent_delta = net_bytes_sent_delta / timestamp_delta
single_host_data['incoming_rate'].append({'timestamp': sample['timestamp'], 'net_bytes_recv': net_bytes_recv_delta})
single_host_data['outgoing_rate'].append({'timestamp': sample['timestamp'], 'net_bytes_sent': net_bytes_sent_delta})
single_host_data['incoming_rate'] = self.__reduction.points_reduction(single_host_data['incoming_rate'], 'net_bytes_recv')
if math.isnan(single_host_data['incoming_rate'][-1]['net_bytes_recv']):
single_host_data['incoming_rate'].pop()
single_host_data['outgoing_rate'] = self.__reduction.points_reduction(single_host_data['outgoing_rate'], 'net_bytes_sent')
if math.isnan(single_host_data['outgoing_rate'][-1]['net_bytes_sent']):
single_host_data['outgoing_rate'].pop()
data.append(single_host_data)
return data
def points_reduction_vm(self, timestamp_begin,timestamp_end,resource_id):
old_data = json.loads(self.cpu_util_from(timestamp_begin,timestamp_end,resource_id))
key2 = "cpu_util_percent"
data = self.__reduction.points_reduction(old_data,key2)
return data
def points_reduction_vm_network_incoming(self, timestamp_begin,timestamp_end,resource_id):
old_data = json.loads(self.network_incoming_bytes_rate_from(timestamp_begin,timestamp_end,resource_id))
key2 = "network_incoming_bytes_rate"
data = self.__reduction.points_reduction(old_data,key2)
return data
def points_reduction_vm_network_outgoing(self, timestamp_begin,timestamp_end,resource_id):
old_data = json.loads(self.network_outgoing_bytes_rate_from(timestamp_begin,timestamp_end,resource_id))
key2 = "network_outgoing_bytes_rate"
data = self.__reduction.points_reduction(old_data,key2)
return data
def vm_info(self):
ret = []
project = []
for project_data in json.loads(self.projects()):
project.append(project_data["name"])
for project_name in project:
informations = self.__nova.vm_info(project)
vms_data = {}
for node in informations:
for node_name in node.keys():
vms_name = (node[node_name])['nomes']
for key in vms_name.keys():
vms_data[key] = vms_name[key]
ret.append({project_name:vms_data})
return ret
def instances_by_project(self):
project = []
for project_data in json.loads(self.projects()):
project.append(project_data["name"])
informations = self.__nova.vm_info(project)
vms_data = {}
for node in informations:
for node_name in node.keys():
project_name = (node[node_name])['Info_project']
vms_name = (node[node_name])['nomes']
for key in project_name.keys():
for instance_id in project_name[key]:
if not (key in vms_data.keys()):
vms_data[key] = {}
vms_data[key][instance_id] = vms_name[instance_id]
else:
vms_data[key][instance_id] = vms_name[instance_id]
return vms_data
def vcpus_for_aggregate(self, project):
return json.dumps(self.__nova.vcpus_for_aggregate(project))
def create_snapshot(self, instance_id):
self.__nova.create_snapshot(instance_id)
def suspend_instance(self, instance_id):
self.__nova.suspend_instance(instance_id)
def get_computenodes_names(self):
return self.__nova.list_compute_nodes()
def get_compute_nodes_ips(self):
ips = []
all_hosts = self.get_hosts('compute_node')
for host in all_hosts:
ips.append(host.get_ip())
return ips
def get_host_availability_metrics(self, timestamp_begin, timestamp_end):
calculator = HostMetricsCalculator()
return calculator.get_host_availability_metrics(timestamp_begin, timestamp_end)
def get_services_status(self, host, timestamp_begin, timestamp_end):
return self.__hosts_db.get_service_status_db(host, timestamp_begin, timestamp_end)
def points_reduction_services_status(self, host, timestamp_begin, timestamp_end):
data = self.get_services_status(host, timestamp_begin, timestamp_end)
output = {}
for key in data.keys():
output[key] = self.__reduction.points_reduction_for_step(data[key], 'status')
return output
def get_host_status(self, host, timestamp_begin, timestamp_end):
return self.__hosts_db.get_host_status_db(host, timestamp_begin, timestamp_end)
def points_reduction_host_status(self, host, timestamp_begin, timestamp_end):
data = self.get_host_status(host, timestamp_begin, timestamp_end)
return {'data': self.__reduction.points_reduction_for_step(data['data'], 'status')}
def get_hosts(self, type=None):
return hosts_from_dict_list(self.__hosts, type)
class DataHandler:
def __init__(self):
self.__ceilometer = CeilometerClient()
self.__keystone = KeystoneClient()
self.__nova = NovaClient()
self.__hosts_db = HostDataHandler()
self.__benchmark_db = BenchmarkDataHandler()
def projects(self):
return json.dumps(self.__keystone.projects)
def sugestion(self):
project_list = [ a['name'] for a in json.loads(self.projects()) ]
host_vm_info = self.__nova.vm_info(project_list)
desligar = {}
migracoes = {}
copia_hosts = host_vm_info[:]
for e in host_vm_info:
dic_aux = e.copy()
chave = e.keys()[0]
if( len( dic_aux[chave]['vms'].keys() ) > 0 ):
vms_aux = dic_aux[chave]['vms'].copy()
copia_hosts.remove(e)
migra = False
migracoes[chave] = {}
for i in vms_aux:
for j in copia_hosts:
migra = False
if( (j[j.keys()[0]]['Livre'][0] >= vms_aux[i][0]) and (j[j.keys()[0]]['Livre'][1] >= vms_aux[i][1]) and (j[j.keys()[0]]['Livre'][2] >= vms_aux[i][2])):
valores = [ j[j.keys()[0]]['Livre'][0] - vms_aux[i][0], j[j.keys()[0]]['Livre'][1] - vms_aux[i][1], j[j.keys()[0]]['Livre'][2] - vms_aux[i][2] ]
j[j.keys()[0]]['Livre'] = valores
migracoes[chave][ e[chave]['nomes'].get(i) ] = j.keys()[0]
migra = True
break
else:
continue
if migra == False:
migracoes[chave][ e[chave]['nomes'].get(i) ] = None
desligar[chave] = False
if not chave in desligar:
desligar[chave] = True
else:
copia_hosts.remove(e)
desligar[chave] = True
continue
saida = {}
saida['Hosts']= desligar
saida['Migracoes'] = migracoes
return json.dumps(saida)
def cpu_util_from(self, timestamp_begin=None, timestamp_end=None, resource_id=None):
return json.dumps(self.__ceilometer.get_cpu_util(timestamp_begin, timestamp_end, resource_id))
def cpu_util_flavors(self, timestamp_begin=None, timestamp_end=None):
data = self.__ceilometer.get_cpu_util_flavors(timestamp_begin, timestamp_end)
ret = analytics.recommendations.recomenda_flavor(data)
return json.dumps(ret)
def projects_with_instances_and_cpu_util(self):
projects = self.__keystone.tenants
ret = { 'name' : 'cloud', 'children' : [] }
for p in projects:
proj = { 'name' : p.name, 'children' : [] }
instances = self.__nova.instances(p.name)
for i in instances:
proj['children'].append({ 'resource_id' : i.id, 'instance_name' : i.name })
ret['children'].append(proj)
return json.dumps(ret)
def alarms_history(self, timestamp_begin=None, timestamp_end=None):
return json.dumps(self.__ceilometer.get_alarms_history(timestamp_begin, timestamp_end))
def add_alarm(self, name, resource, threshold, operator, period, ev_period):
return self.__ceilometer.set_alarm(name, resource, threshold, operator, period, ev_period)
def alarm_email(self, data_requested):
alarm_id = ast.literal_eval(data_requested)['alarm_id']
userId = self.__ceilometer.get_alarm_userid(alarm_id)
projectId = self.__ceilometer.get_alarm_projectid(alarm_id)
userEmail = self.__keystone.get_user_email(userId, projectId)
send_email('*****@*****.**',
[userEmail],
[],
'Alert Telemetry Cloud',
'Email disparado pelo alarme!!!',
'*****@*****.**',
'4n4lyt1cs')
def alarm_description(self):
return json.dumps(self.__ceilometer.get_alarm_parameters())
def delete_alarm(self, alarm_id):
return json.dumps(self.__ceilometer.delete_alarms(alarm_id))
def hosts_cpu(self, timestamp_begin, timestamp_end):
return self.__hosts_db.get_data_db('Cpu_Util', timestamp_begin, timestamp_end)
def hosts_memory(self, timestamp_begin, timestamp_end):
return self.__hosts_db.get_data_db('Memory', timestamp_begin, timestamp_end)
def hosts_disk(self, timestamp_begin, timestamp_end):
return self.__hosts_db.get_data_db('Disk', timestamp_begin, timestamp_end)
def host_metrics(self, project):
return self.__nova.metrics(project)
def hosts_recommendation(self, r_cpu, r_memory , r_disk):
resource = []
ret = {}
r_cpu = json.loads(r_cpu)
r_memory = json.loads(r_memory)
r_disk = json.loads(r_disk)
for host in r_cpu:
host_http = host["host_address"]
if host["data"] is None:
continue
for data in host["data"]:
resource.append(data["data"])
resource = sorted(resource)
if(len(resource)%2 == 0):
index = len(resource)/2
mediana = (resource[index-1] + resource[index+1])/2
else:
mediana = resource[int(math.ceil(len(resource)/2))]
if mediana >= 95:
ret[host_http] ="sobrecarregado"
else:
resource = []
for host_mem in r_memory:
if(host["host_address"] == host_mem["host_address"]):
for data in host_mem["data"]:
for value in json.loads(data["data"]):
resource.append(value["percent"])
resource = sorted(resource)
if(len(resource)%2 == 0):
index = len(resource)/2
mediana = (resource[index-1] + resource[index+1])/2
else:
mediana = resource[int(math.ceil(len(resource)/2))]
if mediana >= 95:
ret[host_http] ="sobrecarregado"
else:
ret[host_http] ="normal"
return json.dumps(ret)
#return json.dumps(cpu)
def instances_from_host(self, host_name):
ret = []
projects = self.__keystone.projects
for project in projects:
instances = self.__nova.instances(project['name'])
for instance in instances:
print instance._info
if instance._info['os-extended-server-attributes:host'] == host_name:
ret.append({'instance_name' : instance.name, 'instance_id' : instance.id})
return ret
def migrate_to_host(self, project_name, host_name, instance_id):
host_vm = self.__nova.vm_hostname(project_name,instance_id)
if host_vm._info['os-extended-server-attributes:host'] == host_name:
raise MigrateException(400,"Migracao para o mesmo destino")
elif host_vm._info['os-extended-server-attributes:host'] == 'truta' and host_name != 'truta':
raise MigrateException(500,"Migracao de host para compute node")
else:
self.__nova.vm_migration(project_name,host_name,instance_id)
return True
def get_benchmark_bd(self):
ret = self.__benchmark_db.get_data_db()
return ret
def start_instance_bench(self, project):
return self.__nova.start_instance_bench(project)
def get_benchmark(self, project):
benchmark_ip = self.__nova.get_benchmark_ip(project)
data = requests.get('http://'+benchmark_ip+':5151/get_benchmarking')
return data.json()
def get_benchmark_status(self, project):
benchmark_ip = self.__nova.get_benchmark_ip(project)
data = requests.get('http://'+benchmark_ip+':5151/get_status')
return data.text
def repeat_benchmark(self, project):
benchmark_ip = self.__nova.get_benchmark_ip(project)
data = requests.get('http://'+benchmark_ip+':5151/start_benchmarking')
return data.text
def remove_benchmark_instance(self):
id = self.__nova.benchmark_id()
if id == None:
return "sem instancia benchmark"
else:
remove = self.__nova.remove_instance(id)
return remove