def MultiCloudIdentityHelper(multicloud_api_prefix, cloud_owner,
cloud_region_id, uri, data={}, header=''):
auth_api_url_format = "/{f_cloudowner}/{f_cloudregionid}/identity{f_uri}"
auth_api_url = auth_api_url_format.format(f_cloudowner=cloud_owner,
f_cloudregionid=cloud_region_id,
f_uri=uri)
extra_headers = header
ret = restcall._call_req(multicloud_api_prefix, "", "", 0, auth_api_url, "POST", extra_headers, json.dumps(data))
if ret[0] == 0 and ret[1]:
content = json.JSONDecoder().decode(ret[1])
ret[1] = content
return ret
def MultiCloudServiceHelper(
cloud_owner, cloud_region_id, v2_token_resp_json, service_type,
uri, data=None, method="GET"):
# get endpoint from token response
token = v2_token_resp_json["access"]["token"]["id"]
catalogs = v2_token_resp_json["access"]["serviceCatalog"]
for catalog in catalogs:
if catalog['type'] == service_type:
# now we have endpoint
endpoint_url = catalog['endpoints'][0]['publicURL']
extra_headers = {'X-Auth-Token': token}
ret = restcall._call_req(endpoint_url, "", "", 0, uri, method, extra_headers, json.dumps(data) if data else "")
if ret[0] == 0 and ret[1]:
content = json.JSONDecoder().decode(ret[1])
ret[1] = content
return ret
return [1, None, status.HTTP_404_NOT_FOUND] # return resource not found in case no type found
def buildBacklog_fault_vm(vimid, backlog_input):
# build backlog with domain:"fault", type:"vm"
logger.info("vimid: %s" % vimid)
logger.debug("with input: %s" % backlog_input)
try:
# must resolve the tenant id and server id while building the backlog
tenant_id = backlog_input.get("tenantid", None)
server_id = backlog_input.get("sourceid", None)
server_name = backlog_input.get("source", None)
# should resolve the name to id later
if tenant_id is None:
tenant_name = backlog_input["tenant"]
# get token
# resolve tenant_name to tenant_id
auth_api_url_format = "/{f_vim_id}/identity/v2.0/tokens"
auth_api_url = auth_api_url_format.format(f_vim_id=vimid)
auth_api_data = {"auth": {"tenantName": tenant_name}}
base_url = settings.MULTICLOUD_PREFIX
extra_headers = ''
ret = restcall._call_req(base_url, "", "", 0, auth_api_url, "POST",
extra_headers, json.dumps(auth_api_data))
if ret[0] > 0 or ret[1] is None:
logger.critical("call url %s failed with status %s" %
(auth_api_url, ret[0]))
return None
token_resp = json.JSONDecoder().decode(ret[1])
token = token_resp["access"]["token"]["id"]
tenant_id = token_resp["access"]["token"]["tenant"]["id"]
if server_id is None and server_name:
# resolve server_name to server_id in case no wildcast in server_name
vserver_api_url_format \
= "/{f_vim_id}/compute/v2.1/{f_tenant_id}/servers?name={f_server_name}"
vserver_api_url = vserver_api_url_format.format(
f_vim_id=vimid,
f_tenant_id=tenant_id,
f_server_name=server_name)
base_url = settings.MULTICLOUD_PREFIX
extra_headers = {'X-Auth-Token': token}
ret = restcall._call_req(base_url, "", "", 0, vserver_api_url,
"GET", extra_headers, "")
if ret[0] > 0 or ret[1] is None:
logger.critical("call url %s failed with status %s" %
(vserver_api_url, ret[0]))
return None
server_resp = json.JSONDecoder().decode(ret[1])
# find out the server wanted
for s in server_resp.get("servers", []):
if s["name"] == server_name:
server_id = s["id"]
break
if server_id is None:
logger.warn(
"source %s cannot be found under tenant id %s " %
(server_name, tenant_id))
return None
# m.c. proxied OpenStack API
if server_id is None and server_name is None:
# monitor all VMs of the specified VIMs since no server_id can be resolved
api_url_fmt = "/{f_vim_id}/compute/v2.1/{f_tenant_id}/servers/detail"
api_url = api_url_fmt.format(f_vim_id=vimid, f_tenant_id=tenant_id)
else:
api_url_fmt = "/{f_vim_id}/compute/v2.1/{f_tenant_id}/servers/{f_server_id}"
api_url = api_url_fmt.format(f_vim_id=vimid,
f_tenant_id=tenant_id,
f_server_id=server_id)
backlog = {
"backlog_uuid":
str(
uuid.uuid3(uuid.NAMESPACE_URL,
str("%s-%s-%s" % (vimid, tenant_id, server_id)))),
"tenant_id":
tenant_id,
"server_id":
server_id,
"api_method":
"GET",
"api_link":
api_url,
}
backlog.update(backlog_input)
except Exception as e:
logger.error("exception:%s" % str(e))
return None
logger.info("return")
logger.debug("with backlog: %s" % backlog)
return backlog
def processBacklog_fault_vm(vesAgentConfig, vesAgentState, oneBacklog):
logger.debug("vesAgentConfig:%s, vesAgentState:%s, oneBacklog: %s" %
(vesAgentConfig, vesAgentState, oneBacklog))
try:
vimid = vesAgentConfig["vimid"]
tenant_name = oneBacklog["tenant"]
# get token
auth_api_url_format = "/{f_vim_id}/identity/v2.0/tokens"
auth_api_url = auth_api_url_format.format(f_vim_id=vimid)
auth_api_data = {"auth": {"tenantName": tenant_name}}
base_url = settings.MULTICLOUD_PREFIX
extra_headers = ''
logger.debug("authenticate with url:%s" % auth_api_url)
ret = restcall._call_req(base_url, "", "", 0, auth_api_url, "POST",
extra_headers, json.dumps(auth_api_data))
if ret[0] > 0 or ret[1] is None:
logger.critical("call url %s failed with status %s" %
(auth_api_url, ret[0]))
token_resp = json.JSONDecoder().decode(ret[1])
logger.debug("authenticate resp: %s" % token_resp)
token = token_resp["access"]["token"]["id"]
# collect data by issue API
api_link = oneBacklog["api_link"]
method = oneBacklog["api_method"]
base_url = settings.MULTICLOUD_PREFIX
data = ''
extra_headers = {'X-Auth-Token': token}
# which one is correct? extra_headers = {'HTTP_X_AUTH_TOKEN': token}
logger.debug("authenticate with url:%s, header:%s" %
(auth_api_url, extra_headers))
ret = restcall._call_req(base_url, "", "", 0, api_link, method,
extra_headers, data)
if ret[0] > 0 or ret[1] is None:
logger.critical("call url %s failed with status %s" %
(api_link, ret[0]))
server_resp = json.JSONDecoder().decode(ret[1])
logger.debug("collected data: %s" % server_resp)
# encode data
backlog_uuid = oneBacklog.get("backlog_uuid", None)
backlogState = vesAgentState.get("%s" % (backlog_uuid), None)
# iterate all VMs
all_events = []
server_1 = server_resp.get("server",
None) # in case querying single server
for s in server_resp.get("servers", [server_1] if server_1 else []):
server_id = s.get("id", None)
server_name = s.get("name", None)
if not server_id:
continue
last_event = backlogState.get("last_event_%s" % (server_id), None)
logger.debug("last event for server name %s: %s" %
(server_name, last_event))
this_event = data2event_fault_vm(vimid, oneBacklog, last_event, s)
if this_event is not None:
logger.debug("this event: %s" % this_event)
all_events.append(this_event.get("event", None))
backlogState["last_event_%s" % (server_id)] = this_event
# report data to VES
if len(all_events) > 0:
ves_subscription = vesAgentConfig.get("subscription", None)
publishAnyEventToVES(ves_subscription, all_events)
# store the latest data into cache, never expire
except Exception as e:
logger.error("exception:%s" % str(e))
return
logger.info("return")
return