def calculate_capacity(self):
try:
in_data = json_request()
resource = in_data["Resource"]
if not isinstance(resource, dict):
raise Exception("Resource field is not an object!")
if "Allocation" in in_data:
allocation = in_data["Allocation"]
if not isinstance(allocation, list):
raise Exception("Allocation field is not an array!")
else:
allocation = {}
if "Release" in in_data:
release = in_data["Release"]
if not isinstance(release, list):
raise Exception("Release field is not an array!")
else:
release = {}
return json_reply(
self._calculate_capacity(resource, allocation, release))
except Exception as e:
return json_error(e)
def calculate_capacity(self):
try:
in_data = json_request()
resource = in_data["Resource"]
if not isinstance(resource, dict):
raise Exception("Resource field is not an object!")
if "Allocation" in in_data:
allocation = in_data["Allocation"]
if not isinstance(allocation,list):
raise Exception("Allocation field is not an array!")
else:
allocation = {}
if "Release" in in_data:
release = in_data["Release"]
if not isinstance(release, list):
raise Exception("Release field is not an array!")
else:
release = {}
return json_reply(self._calculate_capacity(resource, allocation, release))
except Exception as e:
return json_error(e)
def create_reservation(self):
try:
in_data = json_request()
alloc_req = in_data["Allocation"]
if not isinstance(alloc_req, list):
raise Exception("Allocation field is not an array!")
if "Constraints" in in_data:
constraints = in_data["Constraints"]
if not isinstance(constraints, list):
raise Exception("Constraints field is not an array!")
else:
constraints = []
if "Monitor" in in_data:
monitor = in_data["Monitor"]
if not isinstance(monitor, dict):
raise Exception("Monitor field is not an object!")
else:
monitor = {}
if "Scheduler" in in_data:
scheduler = in_data["Scheduler"]
else:
scheduler = ""
ResourcesView().request_resources()
return json_reply(
self._create_reservation(scheduler, alloc_req, constraints,
monitor))
except Exception as e:
return json_error(e)
def get_colore_regione(query):
data = json_request("https://covid19.zappi.me/coloreRegioni.php")
for color in data:
for regione in data[color]:
print(regione)
if regione.lower() == query.lower():
return f"Zona {color}"
return "Zona sconosciuta"
def get_categories():
url = "https://opentdb.com/api_category.php"
data = json_request(url)
if not data:
return None
response = ""
for category in data["trivia_categories"]:
response += "{}: {}; ".format(category["id"], category["name"])
return response
def get_user_access(self,uri="/v2.0/tokens"):
url = self.endpoint_url+uri
req_body = {"auth": {"tenantName": self.project_name, "passwordCredentials": {"username": self.username, "password": self.password}}}
req_headers = {'Content-Type': 'application/json','User-Agent': 'python-%s'%(self.user_agent,)}
result = json_request(url,'POST',req_body , req_headers)
if not result.has_key("access"):
raise Exception("get token error")
return result["access"]
def elaborate_query(self, query):
q = {'key': CLEVERBOT_KEY, 'input': query}
if self.cleverbot_state:
q['cs'] = self.cleverbot_state
url = 'https://www.cleverbot.com/getreply?' + urlencode(q)
data = json_request(url)
if data:
self.cleverbot_state = data["cs"]
return data["output"]
def get_italy_province(query):
data = json_request('https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-json/dpc-covid19-ita-province-latest.json')
if not data:
return None
for provincia in data:
if provincia["denominazione_provincia"].lower() == query:
totale_casi = format(provincia["totale_casi"])
info = 'Totale Casi: {}'.format(totale_casi)
return info
def get_global_status():
data = json_request('https://api.covid19api.com/summary')
if not data:
return None
confirmed = format(data["Global"]["TotalConfirmed"])
deaths = format(data["Global"]["TotalDeaths"])
new_cases = format(data["Global"]["NewConfirmed"], sign=True)
new_deaths = format(data["Global"]["NewDeaths"], sign=True)
info = 'Total Cases: {} ({}) - Total Deaths: {} ({})'.format(confirmed, new_cases, deaths, new_deaths)
return info
def request_questions(num_questions, difficulty=None, category=None):
q = {'amount': num_questions}
if category:
q['category'] = category
if difficulty:
q['difficulty'] = difficulty
url = "https://opentdb.com/api.php?" + urlencode(q)
data = json_request(url)
if not data:
return None
if data["response_code"] == 0:
return data["results"]
def _conn_keystone(ip,username="******",password = "******",port = "5000"):
'''
curl -i 'http://192.168.0.2:5000/v2.0/tokens' -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "User-Agent: python-novaclient" -d '{"auth": {"tenantName": "admin", "passwordCredentials": {"username": "******", "password": "******"}}}'
return token id
'''
url = "http://"+ip+":"+port+"/v2.0/tokens"
data = {"auth": {"tenantName": "admin", "passwordCredentials": {"username": username, "password": password}}}
headers = {'Content-Type': 'application/json','User-Agent': 'python-novaclient', 'Accept':"application/json"}
result = json_request(url,'POST',data , headers)
if not result.has_key("access"):
raise Exception("get token error")
return result["access"]
def search_image(query):
q = {'num': 1, 'searchType':'image', 'q': query, 'key': YOUTUBE_KEY, 'cx': SEARCH_ENGINE}
url = "https://www.googleapis.com/customsearch/v1?"+urlencode(q)
data = json_request(url)
if not data:
return None
items = data["items"]
if len(items) > 0:
item = items[0]
url = item['link']
title = item['title']
return f'\x0303[image]\x03 {title} → {url}'
return "I haven't found anything"
def get_country_status(query):
data = json_request('https://api.covid19api.com/summary')
if not data:
return None
for country in data["Countries"]:
if country["Country"].lower() == query or country["Slug"] == query or country["CountryCode"].lower() == query:
confirmed = format(country["TotalConfirmed"])
new_cases = format(country["NewConfirmed"], sign=True)
deaths = format(country["TotalDeaths"])
new_deaths = format(country["NewDeaths"], sign=True)
info = 'Total Cases: {} ({}) - Total Deaths: {} ({})'.format(confirmed, new_cases, deaths, new_deaths)
return info
def get_youtube_description(query):
parsed_url = urlparse(query)
url_queries = parse_qs(parsed_url.query)
if "v" in url_queries:
video_id = url_queries["v"][0]
url = 'https://www.googleapis.com/youtube/v3/videos?part=id%2C+snippet&id={}&key={}'.format(video_id, YOUTUBE_KEY)
data = json_request(url)
if not data:
return None
items = data["items"]
if len(items) > 0:
info = get_youtube_videoinfo(items[0])
return "\x0303[youtube]\x03 {}".format(info)
def release_reservation(self):
try:
in_data = json_request()
reservations = in_data["ReservationID"]
if not isinstance(reservations, list):
raise Exception("ReservationID field is not an array!")
if len(reservations) == 0:
raise Exception("ReservationID field cannot be empty!")
return json_reply(self._release_reservation(reservations))
except Exception as e:
return json_error(e)
def get_latest_news(query = None):
if query:
url = 'http://newsapi.org/v2/everything?q={}&sortBy=relevancy&apiKey={}'.format(query, NEWSAPI_KEY)
else:
url = 'http://newsapi.org/v2/top-headlines?country=it&sortBy=publishedAt&apiKey={}'.format(NEWSAPI_KEY)
data = json_request(url)
if not data:
return None
if data["status"] == "ok" and data["totalResults"] > 0:
article = data["articles"][0]
description = article["description"].replace('\n', ' ')
info = '{} - {}'.format(article["url"], description)
return info
else:
return "I haven't found anything"
def get_all_projects(self,uri="/tenants",token=None):
user_access_str = self.get_user_access()
keystone_endpoint_public_url = self.get_service_accss_url_by_name(user_access_str,"keystone")
url = keystone_endpoint_public_url + uri
req_body = {}
req_headers = {'User-Agent': 'python-%s'%(self.user_agent,)}
if None == token:
req_token = user_access_str["token"]["id"]
else:
req_token = token
req_headers["X-Auth-Token"] = req_token
result = json_request(url,'GET',req_body , req_headers)
if type(result) == type(True):
if result == False:
raise Exception("response error .")
if not result.has_key("tenants"):
raise Exception("get project error")
return result["tenants"]
def search_youtube_video(query, music=False):
q = {'part':'snippet', 'maxResults': 1, 'type':'video', 'q': query, 'key': YOUTUBE_KEY}
if music:
q['videoCategoryId'] = 10
url = "https://www.googleapis.com/youtube/v3/search?"+urlencode(q)
data = json_request(url)
if not data:
return None
items = data["items"]
if len(items) > 0:
item = items[0]
video_id = item["id"]["videoId"]
url = "https://www.youtube.com/watch?v={}".format(video_id)
info = get_youtube_videoinfo(item)
return "\x0303[youtube]\x03 {} {}".format(url, info)
return "I haven't found anything"
def register_manager(self):
try:
in_data = json_request()
if 'Address' in in_data:
addr = in_data['Address']
else:
addr = request.remote_addr
# when testing (no requests), addr is None. We assume localhost
if addr is None:
addr = "127.0.0.1"
port = in_data['Port']
name = in_data['Name']
if not self._acceptManager(addr, port, name):
raise Exception("Manager %s rejected!" % name)
key = ManagersTreeView.gen_key(name, addr, port)
################### check the database ####
conn = sqlite3.connect('manager.db')
c = conn.cursor()
c.execute("SELECT * from managers where key = '%s'" % key)
r = c.fetchone()
if r == None:
idx = str(uuid.uuid1())
c.execute("INSERT INTO managers VALUES ('%s', '%s')" % (key, idx))
conn.commit()
else:
idx = r[1]
conn.close()
data = { 'Address': addr, 'Port': port, 'Name': name, 'ManagerID': idx }
ManagersTreeView.managers[idx] = data
print "Adding manager: %s" % data['Name']
self._registerManager(data)
return json_reply(ManagersTreeView.managers[idx])
except Exception as e:
return json_error(e)
def get_all_vms(self,uri="/servers",is_all_tenants=False):
user_access_str = self.get_user_access()
project_name = user_access_str["token"]["tenant"]["name"]
nova_endpoint_public_url = self.get_service_accss_url_by_name(user_access_str,"nova")
url = nova_endpoint_public_url + uri
self.set_service_clint_agent("novaclient")
if is_all_tenants == True:
url = url + "?" + "all_tenants=True"
req_body = {}
req_headers = {'Accept': 'application/json','User-Agent': 'python-%s'%(self.user_agent,)}
req_headers["X-Auth-Project-Id"] = project_name
req_headers["X-Auth-Token"] = user_access_str["token"]["id"]
result = json_request(url,"GET",req_body,req_headers)
if type(result) == type(True):
if result == False:
raise Exception("response error .")
if not result.has_key("servers"):
raise Exception("get project error")
return result["servers"]
def _query_tenant_quoto(result,tenant_id):
'''
curl -i 'http://10.120.16.100:8774/v2/42b779463dd4444eb5e575ea90e8a6b9/os-quota-sets/e6b0e512f4454f0d92ba81d04f09622c' -X GET -H "Accept: application/json" -H "User-Agent: python-novaclient" -H "X-Auth-Project-Id: admin" -H "X-Auth-Token: {SHA1}1f0cb32237c10a3ec36157036308a13777c33692"
'''
data = {}
url = ""
token_id = result["token"]["id"]
services = result["serviceCatalog"]
for one in services:
if one["name"] == "nova":
endpoints_list = one["endpoints"]
for endpoint in endpoints_list:
if endpoint.has_key("publicURL"):
url = endpoint["publicURL"]+"/os-quota-sets/"+str(tenant_id)
headers = {'X-Auth-Token': token_id,'User-Agent': 'python-novaclient','Accept': 'application/json'}
result = json_request(url,'GET',data , headers)
'''
result :
{"quota_set":
{
"injected_file_content_bytes": 10240,
"metadata_items": 1024,
"ram": 71200,
"floating_ips": 100,
"key_pairs": 10,
"id": "e6b0e512f4454f0d92ba81d04f09622c",
"instances": 100,
"security_group_rules": 20,
"injected_files": 5,
"cores": 300,
"fixed_ips": -1,
"injected_file_path_bytes": 255,
"security_groups": 10}}
'''
quota = {}
try:
quota = result["quota_set"]
except:
pass
return quota
def get_metrics_post(self):
try:
in_data = json_request()
reservID = in_data['ReservationID']
if "Address" not in in_data:
addr = ""
else:
addr = in_data['Address']
if 'Entry' not in in_data:
entry = 1
else:
entry = in_data['Entry']
ret = self._get_metrics(reservID, addr, entry)
return json_reply(ret)
except Exception as e:
return json_error(e)
def get_italy_regione(query):
data = json_request('https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-json/dpc-covid19-ita-regioni-latest.json')
if not data:
return None
for regione in data:
if regione["denominazione_regione"].lower() == query:
totale_positivi = format(regione["totale_positivi"])
variazione_totale_positivi = format(regione["variazione_totale_positivi"], sign = True)
nuovi_positivi = format(regione["nuovi_positivi"], sign = True)
dimessi_guariti = format(regione["dimessi_guariti"])
deceduti = format(regione["deceduti"])
totale_casi = format(regione["totale_casi"])
tamponi = format(regione["tamponi"])
colore = get_colore_regione(query)
info = 'Attualmente positivi: {} ({}) - Dimessi guariti: {} - Deceduti: {} - Totale casi: {} ({}) - Tamponi: {} - {}' \
.format(totale_positivi, variazione_totale_positivi, dimessi_guariti, deceduti, totale_casi, nuovi_positivi, tamponi, colore)
return info
def get_italy_status():
data = json_request('https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-json/dpc-covid19-ita-andamento-nazionale.json')
if not data:
return None
latest = data[-1]
yesterday = data[-2]
totale_positivi = format(latest["totale_positivi"])
variazione_totale_positivi = format(latest["variazione_totale_positivi"], sign = True)
nuovi_positivi = format(latest["nuovi_positivi"], sign = True)
deceduti = format(latest["deceduti"])
nuovi_deceduti = format(latest["deceduti"] - yesterday["deceduti"], sign = True)
dimessi = format(latest["dimessi_guariti"])
nuovi_dimessi = format(latest["dimessi_guariti"] - yesterday["dimessi_guariti"], sign = True)
totale_casi = format(latest["totale_casi"])
info = 'Totale attualmente positivi: {} ({}) - Deceduti: {} ({}) - Dimessi guariti: {} ({}) - Totale casi: {} ({})' \
.format(totale_positivi, variazione_totale_positivi, deceduti, nuovi_deceduti, dimessi, nuovi_dimessi, totale_casi, nuovi_positivi)
return info
def get_weather(location):
url = 'http://api.openweathermap.org/data/2.5/forecast?q={}&units=metric&appid={}'.format(location, OPENWEATHER_KEY)
data = json_request(url)
if not data:
return None
if data["cod"] == '200':
name = data["city"]["name"]
today = data["list"][0]
response = "Weather for {} is {}, the temperature is around {}°C. " \
.format(name, today["weather"][0]["description"], today["main"]["temp"])
for day in data["list"]:
date = datetime.date.today() + datetime.timedelta(days=1)
if day["dt_txt"] == date.strftime("%Y-%m-%d 12:00:00"):
response = response + "Tomorrow at 12:00 will be {}, the temperature will be around {}°C." \
.format(day["weather"][0]["description"], day["main"]["temp"])
else:
response = data["message"]
return response
def _query_flavor(result):
'''
curl -i 'http://10.120.16.100:8774/v2/42b779463dd4444eb5e575ea90e8a6b9/flavors/detail' -X GET -H "Accept: application/json" -H "User-Agent: python-novaclient" -H "X-Auth-Project-Id: admin" -H "X-Auth-Token: {SHA1}b625f16ede3e81b6bd3492b6e9d64648e241232a"
'''
data = {}
url = ""
token_id = result["token"]["id"]
services = result["serviceCatalog"]
for one in services:
if one["name"] == "nova":
endpoints_list = one["endpoints"]
for endpoint in endpoints_list:
if endpoint.has_key("publicURL"):
url = endpoint["publicURL"]+"/flavors/detail"
headers = {'X-Auth-Token': token_id, 'User-Agent': 'python-novaclient' , 'Accept':'application/json','X-Auth-Project-Id':'admin'}
result = json_request(url,'GET',data , headers)
if result.has_key("flavors"):
return result["flavors"]
else:
raise Exception("find flavor error")
def _query_vm(result):
'''
curl -i 'http://10.120.16.100:8774/v2/42b779463dd4444eb5e575ea90e8a6b9/servers/detail?all_tenants=1' -X GET -H "Accept: application/json" -H "User-Agent: python-novaclient" -H "X-Auth-Project-Id: admin" -H "X-Auth-Token: dcf17d8942084972b13ec4504c95496a"
'''
data = {}
url = ""
token_id = result["token"]["id"]
services = result["serviceCatalog"]
for one in services:
if one["name"] == "nova":
endpoints_list = one["endpoints"]
for endpoint in endpoints_list:
if endpoint.has_key("publicURL"):
url = endpoint["publicURL"]+"/servers/detail?all_tenants=1"
headers = {'X-Auth-Token': token_id, 'User-Agent': 'python-novaclient' , 'Accept':'application/json','X-Auth-Project-Id':'admin'}
result = json_request(url,'GET',data , headers)
if result.has_key("servers"):
return result["servers"]
else:
raise Exception("query vm error")
def _query_routers(result):
'''
curl -i http://10.120.16.100:9696/v2.0/routers.json -X GET -H "X-Auth-Token: c03da5a8386746879e238224831d9c4d" -H "Content-Type: application/json" -H "Accept: application/json" -H "User-Agent: python-neutronclient"
'''
data = {}
url = ""
token_id = result["token"]["id"]
services = result["serviceCatalog"]
for one in services:
if one["name"] == "neutron":
endpoints_list = one["endpoints"]
for endpoint in endpoints_list:
if endpoint.has_key("publicURL"):
url = endpoint["publicURL"]+"/v2.0/routers.json"
headers = {'X-Auth-Token': token_id, 'User-Agent': 'python-neutronclient' , 'Accept':'application/json','Content-Type': 'application/json'}
result = json_request(url,'GET',data , headers)
if result.has_key("routers"):
return result["routers"]
else:
raise Exception("find router error")
def _query_tenant(result):
'''
curl -i -X GET http://192.168.0.2:35357/v2.0/tenants -H "User-Agent: python-keystoneclient" -H "X-Auth-Token: 5077f9e5326a457ba5c7c3fa9873c066"
'''
data = {}
url = ""
token_id = result["token"]["id"]
services = result["serviceCatalog"]
for one in services:
if one["name"] == "keystone":
endpoints_list = one["endpoints"]
for endpoint in endpoints_list:
if endpoint.has_key("adminURL"):
url = endpoint["adminURL"]+"/tenants"
headers = {'X-Auth-Token': token_id,'User-Agent': 'python-keystoneclient'}
result = json_request(url,'GET',data , headers)
tenants = []
try:
tenants = result["tenants"]
except:
pass
return tenants
