def __send_request(self, method, url, headers=None, payload=None, verify=None, query=None):
"""
Send a request to a specific url in a specifig type of http request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
if self.check_json:
parameters.update({'data': json.dumps(payload, ensure_ascii=False).encode('utf-8')})
else:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url, headers=headers, params=query, data=payload, comp='CB',
method=method)
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
def sendRegister(self, apikey, device, asset, model, phenomena):
url = self.getUrl('RegLight', apikey, device)
print 'url: ' + url
uom_id = 1
result = "<rs>"
result += "<id href=\"1:1\">" + device + "</id>"
result += "<id href=\"1:8\">" + asset + "</id>"
result += "<param name=\"ModelName\">"
result += "<text>" + model + "</text>"
result += "</param>"
print phenomena
for phenom in phenomena:
result += "<what href=\"" + str(phenom.get("href", "")) + "\" id=\"" + str(phenom.get("alias", "")) + "\"/>"
for phenom in phenomena:
result += "<data name=\"" + str(phenom.get("phenom", "")) + "\" id=\"" + str(
phenom.get("alias", "")) + "\">"
if phenom.get("uom"):
result += "<quan uom=\"" + str(phenom.get("uom", "")) + "\">" + str(uom_id) + "</quan>"
else:
result += "<text>" + str(uom_id) + "</text>"
uom_id += 1
result += "</data>"
result += "</rs>"
print result
res = requests.post(url, data=result)
#log request
PqaTools.log_requestAndResponse(url=url, headers={}, data=result, comp='IOTA', response=res, method='post')
return res
def send(self, method, url, headers=None, payload=None, query=None):
"""
Funtion to send requests printing data to send by log
:param method: get, post, delete, patch, update...
:param url:
:param headers:
:param payload:
:param query:
:return: response object
"""
self.log.debug('Request: -->')
self.log.debug('Method: %s' % method)
self.log.debug('Url: %s' % url)
self.log.debug('headers: %s' % headers)
self.log.debug('query: %s' % query)
self.log.debug('payload: %s' % payload)
self.log.debug('--------------')
request_parms = {}
if headers is not None:
request_parms.update({'headers': headers})
if payload is not None:
request_parms.update({'data': payload})
if query is not None:
request_parms.update({'params': query})
response = requests.request(method, url, **request_parms)
PqaTools.log_fullRequest(comp='ORC', response=response, params=request_parms)
return response
def __send_request(self, method, url, headers=None, payload=None, verify=None, query=None):
"""
Send a request to a specific url in a specifig type of http request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
if self.check_json:
parameters.update({'data': json.dumps(payload)})
else:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url, headers=headers, data=payload, comp='STH', method=method)
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
def __send_request(self, method, url, headers=None, payload=None, verify=None, query=None):
"""
Send a request to a specific url in a specifig type of http request
"""
parameters = {"method": method, "url": url}
if headers is not None:
parameters.update({"headers": headers})
if payload is not None:
if self.check_json:
parameters.update({"data": json.dumps(payload)})
else:
parameters.update({"data": payload})
if query is not None:
parameters.update({"params": query})
if verify is not None:
parameters.update({"verify": verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url, headers=headers, data=payload, comp="STH", method=method)
assert False, "ERROR: [NETWORK ERROR] {}".format(e)
def send(self, method, url, headers=None, payload=None, query=None):
"""
Funtion to send requests printing data to send by log
:param method: get, post, delete, patch, update...
:param url:
:param headers:
:param payload:
:param query:
:return: response object
"""
self.log.debug('Request: -->')
self.log.debug('Method: %s' % method)
self.log.debug('Url: %s' % url)
self.log.debug('headers: %s' % headers)
self.log.debug('query: %s' % query)
self.log.debug('payload: %s' % payload)
self.log.debug('--------------')
request_parms = {}
if headers is not None:
request_parms.update({'headers': headers})
if payload is not None:
request_parms.update({'data': payload})
if query is not None:
request_parms.update({'params': query})
response = requests.request(method, url, **request_parms)
PqaTools.log_fullRequest(comp='ORC',
response=response,
params=request_parms)
return response
def SendCmdResponse(self, measure_type, apikey, idDevice, command, response):
url = self.getUrl(measure_type, apikey, idDevice, command)
print 'url: ' + url
data = str(command) + "|" + str(response)
res = requests.post(url, data=data)
#log request
PqaTools.log_requestAndResponse(url=url, headers={}, data=data, comp='IOTA', response=res, method='post')
return res
def getCommand(self, measure_type, apikey, idDevice, ip={}):
url = self.getUrl(measure_type, apikey, idDevice)
if ip:
url += "&ip=" + ip
print 'url: ' + url
res = requests.get(url)
#log request
PqaTools.log_requestAndResponse(url=url, headers={}, data='', comp='IOTA', response=res, method='get')
return res
def sendMeasure(self, measure_type, apikey, idDevice, measures, field={}):
url = self.getUrl(measure_type, apikey, idDevice)
if field == 'getCmd':
url += '&getCmd=1'
if "ip" in field:
url += '&ip='
url += field["ip"]
print 'url: ' + url
data = self.getMeasure(measure_type, measures, field)
res = requests.post(url,headers = {'content-type': 'text/plain'},data=data)
#log request
PqaTools.log_requestAndResponse(url=url, headers={}, data=data, comp='IOTA', response=res, method='post')
return res
def SendCmdResponse(self, measure_type, apikey, idDevice, command,
response):
url = self.getUrl(measure_type, apikey, idDevice, command)
print 'url: ' + url
data = str(command) + "|" + str(response)
res = requests.post(url, data=data)
#log request
PqaTools.log_requestAndResponse(url=url,
headers={},
data=data,
comp='IOTA',
response=res,
method='post')
return res
def getCommand(self, measure_type, apikey, idDevice, ip={}):
url = self.getUrl(measure_type, apikey, idDevice)
if ip:
url += "&ip=" + ip
print 'url: ' + url
res = requests.get(url)
#log request
PqaTools.log_requestAndResponse(url=url,
headers={},
data='',
comp='IOTA',
response=res,
method='get')
return res
def __send_request(self,
method,
url,
headers=None,
payload=None,
verify=None,
query=None):
"""
Send a request to a specific url in a specifying type of http request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
if self.check_json:
parameters.update({
'data':
json.dumps(payload, ensure_ascii=False).encode('utf-8')
})
else:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
else:
# If the method does not include the verify parameter, it takes the value from object
parameters.update({'verify': self.verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url,
headers=headers,
params=query,
data=payload,
comp='CB',
method=method)
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
def send(self,
method,
url,
headers=None,
payload=None,
query=None,
verify=None):
"""
Funtion to send requests printing data to send by log
:param method: get, post, delete, patch, update...
:param url:
:param headers:
:param payload:
:param query:
:param verify:
:return: response object
"""
request_parms = {}
if headers is not None:
request_parms.update({'headers': headers})
if payload is not None:
request_parms.update({'data': payload})
if query is not None:
request_parms.update({'params': query})
if verify is not None:
request_parms.update({'verify': verify})
else:
# If the method does not include the verify parameter, it takes the value from object
request_parms.update({'verify': self.verify})
request_parms.update({'timeout': self.timeout})
# Send the requests
response = requests.request(method, url, **request_parms)
# Log data
PqaTools.log_fullRequest(comp='ORC',
response=response,
params=request_parms)
return response
def api_put(self, path, headers={}, params={}, data={}):
res = None
try:
res = requests.put(url=path,
data=data,
headers=headers,
params=params)
except requests.exceptions.Timeout:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data=data,
comp='IOTA',
response="TIMEOUT",
method='put')
except requests.exceptions.RequestException as e:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data=data,
comp='IOTA',
response=e, method='put')
return "ERROR"
# log request
PqaTools.log_requestAndResponse(url=path,
headers=headers,
params=params, data=data,
comp='IOTA',
response=res,
method='put')
return res
def api_put(self, path, headers={}, params={}, data={}, verify=False):
res = None
try:
res = requests.put(url=path,
data=data,
headers=headers,
params=params,
verify=verify)
except requests.exceptions.Timeout:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data=data,
comp='IOTA',
response="TIMEOUT",
method='put')
except requests.exceptions.RequestException as e:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data=data,
comp='IOTA',
response=e, method='put')
return "ERROR"
# log request
PqaTools.log_requestAndResponse(url=path,
headers=headers,
params=params, data=data,
comp='IOTA',
response=res,
method='put')
return res
def sendRegister(self, apikey, device, asset, model, phenomena):
url = self.getUrl('RegLight', apikey, device)
print 'url: ' + url
uom_id = 1
result = "<rs>"
result += "<id href=\"1:1\">" + device + "</id>"
result += "<id href=\"1:8\">" + asset + "</id>"
result += "<param name=\"ModelName\">"
result += "<text>" + model + "</text>"
result += "</param>"
print phenomena
for phenom in phenomena:
result += "<what href=\"" + str(
phenom.get("href", "")) + "\" id=\"" + str(
phenom.get("alias", "")) + "\"/>"
for phenom in phenomena:
result += "<data name=\"" + str(
phenom.get("phenom", "")) + "\" id=\"" + str(
phenom.get("alias", "")) + "\">"
if phenom.get("uom"):
result += "<quan uom=\"" + str(phenom.get(
"uom", "")) + "\">" + str(uom_id) + "</quan>"
else:
result += "<text>" + str(uom_id) + "</text>"
uom_id += 1
result += "</data>"
result += "</rs>"
print result
res = requests.post(url, data=result)
#log request
PqaTools.log_requestAndResponse(url=url,
headers={},
data=result,
comp='IOTA',
response=res,
method='post')
return res
def sendMeasure(self, measure_type, apikey, idDevice, measures, field={}):
url = self.getUrl(measure_type, apikey, idDevice)
if field == 'getCmd':
url += '&getCmd=1'
if "ip" in field:
url += '&ip='
url += field["ip"]
print 'url: ' + url
data = self.getMeasure(measure_type, measures, field)
res = requests.post(url,
headers={'content-type': 'text/plain'},
data=data)
#log request
PqaTools.log_requestAndResponse(url=url,
headers={},
data=data,
comp='IOTA',
response=res,
method='post')
return res
def __send_request(self, method, url, headers=None, payload=None, verify=None, query=None):
"""
Send a request to a specific url in a specific type of http request
:param method: http method (get | post | put | delete)
:param url: url of the requests
:param headers: headers of the request
:param payload: payload of the request
:param verify: if the requests has SSL verification on client (True | False)
:param query: params of the request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
try:
parameters.update({'data': json.dumps(payload)})
except ValueError:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url, headers=headers, data=payload, comp='CKAN')
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
def __send_request(self, method, url, headers=None, payload=None, verify=None, query=None):
"""
Send a request to a specific url in a specific type of http request
:param method: http method (get | post | put | delete)
:param url: url of the requests
:param headers: headers of the request
:param payload: payload of the request
:param verify: if the requests has SSL verification on client (True | False)
:param query: params of the request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
try:
parameters.update({'data': json.dumps(payload)})
except ValueError:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url, headers=headers, data=payload, comp='CKAN')
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
def send(endpoint, method, headers={}, payload={}, url_parameters_list=[], query={}, verify=False):
"""
Send a request to a specific endpoint in a specifig type of http request
"""
if url_parameters_list != []:
log.debug('Setting the parameters "%s" in the url "%s' % (url_parameters_list, endpoint))
for parameter in url_parameters_list:
endpoint = re.sub(r'\${.*?}', parameter, endpoint, 1)
log.debug('**************************************************************************************\nSending:')
parameters = {
'method': method,
'url': endpoint,
}
log.debug('\t*Method:\n %s' % method)
log.debug('\t*Url:\n %s' % endpoint)
if headers != {}:
parameters.update({'headers': headers})
log.debug('\t*Headers:\n %s' % headers)
if payload != {}:
try:
parameters.update({'data': json.dumps(payload)})
log.debug('\t*Payload:\n %s' % json.dumps(payload, sort_keys=True, indent=4, separators=(',', ': ')))
except ValueError:
parameters.update({'data': payload})
log.debug('\t*Payload:\n %s' % payload)
if query != {}:
parameters.update({'params': query})
log.debug('\tQuery:\n %s' % query)
if headers != {}:
parameters.update({'verify': verify})
log.debug('\t*Verify:\n %s' % verify)
log.debug('End Sending\n**************************************************************************************')
response = requests.request(**parameters)
PqaTools.log_fullRequest(comp='ORC', response=response, params=parameters)
return response
def api_get(self, path, headers={}, params={}, verify=False):
res = None
try:
# clean content_type in not allowed requests
if "content-type" in headers:
headers.pop("content-type", None)
elif "Content-Type" in headers: # used in Requests library version 2.11.1 or higher
headers.pop("Content-Type", None)
res = requests.get(url=path,
headers=headers,
params=params,
verify=verify)
except requests.exceptions.Timeout:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data='',
comp='IOTA',
response="TIMEOUT",
method='get')
except requests.exceptions.RequestException as e:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data='',
comp='IOTA',
response=e, method='get')
return "ERROR"
# log request
PqaTools.log_requestAndResponse(url=path,
headers=headers,
params=params,
data='',
comp='IOTA',
response=res,
method='get')
return res
def api_get(self, path, headers={}, params={}):
res = None
try:
# clean content_type in not allowed requests
if "content-type" in headers:
headers.pop("content-type", None)
elif "Content-Type" in headers: # used in Requests library version 2.11.1 or higher
headers.pop("Content-Type", None)
res = requests.get(url=path,
headers=headers,
params=params)
except requests.exceptions.Timeout:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data='',
comp='IOTA',
response="TIMEOUT",
method='get')
except requests.exceptions.RequestException as e:
PqaTools.log_requestAndResponse(url=path,
params=params,
headers=headers,
data='',
comp='IOTA',
response=e, method='get')
return "ERROR"
# log request
PqaTools.log_requestAndResponse(url=path,
headers=headers,
params=params,
data='',
comp='IOTA',
response=res,
method='get')
return res
class SthUtils(object):
"""
Basic functionality for STH
"""
def __init__(self, instance, service=None, subservice=None,
protocol="http",
port="8666",
path_raw_data="/STH/v1/contextEntities",
path_version="/version",
log_instance=None,
log_verbosity='DEBUG',
default_headers={"Accept": "application/json", 'content-type': 'application/json'},
check_json=True,
path_notify="/notify"):
"""
STH Utils constructor
:param instance:
:param service:
:param subservice:
:param protocol:
:param port:
:param path_raw_data:
:param path_version:
:param log_instance:
:param log_verbosity:
:param default_headers:
:param check_json:
:param path_notify:
"""
# initialize logger
if log_instance is not None:
self.log = log_instance
else:
self.log = get_logger('SthUtils', log_verbosity)
# Assign the values
self.default_endpoint = protocol + '://' + instance + ':' + port
self.headers = self.__set_headers(default_headers, service, subservice)
self.path_raw_data = self.default_endpoint + path_raw_data
self.path_version = path_version
self.check_json = check_json
self.path_notify = path_notify
def __send_request(self, method, url, headers=None, payload=None, verify=None, query=None):
"""
Send a request to a specific url in a specifig type of http request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
if self.check_json:
parameters.update({'data': json.dumps(payload)})
else:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url, headers=headers, data=payload, comp='STH', method=method)
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
# Log data
PqaTools.log_fullRequest(comp='STH', response=response, params=parameters)
return response
class CKANUtils:
def __init__(self, instance=DEFAULT_ENDPOINT,
apikey=DEFAULT_APIKEY,
path=DEFAULT_PATH,
port=DEFAULT_PORT,
url=DEFAULT_URL,
protocol=DEFAULT_PROTOCOL,
verbosity='DEBUG',
default_headers={"Accept": "application/json", 'content-type': 'application/json'}):
"""
Method for initialization of CKAN. Basically you can set the endpoint and the apikey of the user you are going
to use by initializing the class (e.g. ckan = CkanUtils(instance='http://81.45.57.227:8443',
apikey='7b321ca7-2193-4adf-8039-d550428620fe')
:param instance: endpoint of the ckan instance (e.g. 192.168.21.194)
:param apikey: unique identifier of the ckan user
:param path: ckan path
:param port: ckan listen port
:param url: url to include in the resources creation
:param protocol: ckan protocol (e.g. http, https)
:param verbosity: verbosity level ('CRITICAL','ERROR', 'WARNING', 'INFO', 'DEBUG')
:param default_headers: default headers for every requests to be sent to ckan
"""
# initialize logger
self.log = get_logger('ckan_utils', verbosity)
self.instance = instance
self.apikey = apikey
self.path = path
self.protocol = protocol
self.port = port
self.url = url
self.verbosity = verbosity
self.default_headers = default_headers
def compose_url(self, protocol, endpoint, port, path, action):
"""
Function to compose the url of the different actions
:param protocol: the protocol set by the instance of the class (e.g. https)
:param port: ckan listen port
:param endpoint: endpoint of the instance of CKAN. e.g. 'http://81.45.57.227:8443'
:param path: by default '/api/3/action'
:param action: the action to be executed
:return: the url (string) e.g. 'http://81.45.57.227:8443//api/3/action/organization_create'
"""
url = protocol + '://' + endpoint + ':' + port + path + action
return url
def __send_request(self, method, url, headers=None, payload=None, verify=None, query=None):
"""
Send a request to a specific url in a specific type of http request
:param method: http method (get | post | put | delete)
:param url: url of the requests
:param headers: headers of the request
:param payload: payload of the request
:param verify: if the requests has SSL verification on client (True | False)
:param query: params of the request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
try:
parameters.update({'data': json.dumps(payload)})
except ValueError:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url, headers=headers, data=payload, comp='CKAN')
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
# Log data
PqaTools.log_fullRequest(comp='CKAN', response=response, params=parameters)
return response
class CbNgsi10v2Utils(object):
"""
Basic functionality for ContextBroker v2 API
"""
def __init__(
self,
instance,
protocol="http",
port="1026",
path_list_entities="/v2/entities",
path_create_entity="/v2/entities",
path_retrieve_entity_by_id="/v2/entities/entityId",
path_retrieve_entity_attributes="/v2/entities/entityId/attrs",
path_update_or_append_entity_attributes="/v2/entities/entityId/attrs",
path_update_existing_entity_attributes="/v2/entities/entityId/attrs",
path_replace_all_entity_attributes="/v2/entities/entityId/attrs",
path_remove_entity="/v2/entities",
path_get_attribute_data="/v2/entities/entityId/attrs/attrName",
path_update_attribute_data="/v2/entities/entityId/attrs/attrName",
path_remove_a_single_attribute="/v2/entities/entityId/attrs/attrName",
path_get_attribute_value="/v2/entities/entityId/attrs/attrName/value",
path_attribute_value_update="/v2/entities/entityId/attrs/attrName/value",
path_retrieve_entity_types="/v2/types",
path_retrieve_emtity_type="/v2/types/entityType",
path_retrieve_subscriptions="/v2/subscriptions",
path_retrieve_subscription_by_id="/v2/subscriptions/subscriptionId",
path_update_subscription="/v2/subscriptions/subscriptionId",
path_delete_subscription="/v2/subscriptions/subscriptionId",
path_statistics="/statistics",
path_version="/version",
log_instance=None,
log_verbosity='DEBUG',
default_headers={'Accept': 'application/json'},
verify=False,
check_json=True):
"""
CB Utils constructor
:param instance:
:param protocol:
:param port:
:param path_list_entities:
:param path_create_entity:
:param path_retrieve_entity_by_id:
:param path_retrieve_entity_attributes:
:param path_update_or_append_entity_attributes:
:param path_update_existing_entity_attributes:
:param path_replace_all_entity_attributes:
:param path_remove_entity:
:param path_get_attribute_data:
:param path_update_attribute_data:
:param path_remove_a_single_attribute:
:param path_get_attribute_value:
:param path_attribute_value_update:
:param path_retrieve_entity_types:
:param path_retrieve_emtity_type:
:param path_retrieve_subscriptions:
:param path_retrieve_subscription_by_id:
:param path_update_subscription:
:param path_delete_subscription:
:param path_statistics:
:param path_version:
:param log_instance:
:param log_verbosity:
:param default_headers:
:param verify: ssl check
:param check_json:
"""
# initialize logger
if log_instance is not None:
self.log = log_instance
else:
self.log = get_logger('CbNgsi10Utilsv2', log_verbosity)
# Assign the values
self.default_endpoint = "{}://{}:{}".format(protocol, instance, port)
self.headers = default_headers
self.path_list_entities = "{}{}".format(self.default_endpoint,
path_list_entities)
self.path_get_attribute_data = "{}{}".format(
self.default_endpoint, path_update_attribute_data)
self.path_statistics = path_statistics
self.path_create_entity = "{}{}".format(self.default_endpoint,
path_create_entity)
self.path_context_subscriptions = "{}{}".format(
self.default_endpoint, path_retrieve_subscriptions)
self.path_context_subscriptions_by_id = "{}{}".format(
self.default_endpoint, path_retrieve_subscription_by_id)
self.path_version = path_version
self.verify = verify
self.check_json = check_json
def __send_request(self,
method,
url,
headers=None,
payload=None,
verify=None,
query=None):
"""
Send a request to a specific url in a specifying type of http request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
if self.check_json:
parameters.update({
'data':
json.dumps(payload, ensure_ascii=False).encode('utf-8')
})
else:
parameters.update({'data': payload})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
else:
# If the method does not include the verify parameter, it takes the value from object
parameters.update({'verify': self.verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url,
headers=headers,
params=query,
data=payload,
comp='CB',
method=method)
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
# Log data
PqaTools.log_fullRequest(comp='CB',
response=response,
params=parameters)
return response
class CEP:
"""
Manage Perseo requests / responses.
"""
def __init__(self,
instance,
protocol="http",
port="9090",
path='/m2m/vrules',
cep_version='',
verbosity='DEBUG',
default_headers={'Accept': 'application/json'},
verify=False,
check_json=True):
"""
constructor with values by default
:param protocol: protocol to be used (e.g. http:// or https://)
:param port: port
:param path: path
:param verbosity: level for debugging purposes
:param default_headers: default headers for CEP requests
:param instance: cep endpoint
:param cep_version: cep version
"""
# initialize logger
self.log = get_logger('cep_utils', verbosity)
# Assign the values
self.default_endpoint = protocol + '://' + instance + ':' + port
self.default_headers = default_headers
self.instance = instance
self.protocol = protocol
self.port = port
self.path = path
self.version = cep_version
self.headers = default_headers
self.verify = verify
self.check_json = check_json
def __create_headers(self, service, subservice='', token=''):
"""
create the header for different requests
:param service: name of the service
:param subservice: name of the subservice
:return: headers dictionary
"""
headers = dict(self.default_headers)
headers.update({"Fiware-Service": service})
headers.update({"Fiware-ServicePath": subservice})
headers.update({"x-auth-token": token})
return headers
def __send_request(self,
method,
url,
headers=None,
payload=None,
verify=None,
query=None):
"""
Send a request to a specific url in a specifying type of http request
"""
parameters = {
'method': method,
'url': url,
}
if headers is not None:
parameters.update({'headers': headers})
if payload is not None:
parameters.update({'data': payload.encode('utf-8')})
if query is not None:
parameters.update({'params': query})
if verify is not None:
parameters.update({'verify': verify})
else:
# If the method does not include the verify parameter, it takes the value from object
parameters.update({'verify': self.verify})
# Send the requests
try:
response = requests.request(**parameters)
except RequestException, e:
PqaTools.log_requestAndResponse(url=url,
headers=headers,
params=query,
data=payload,
comp='CEP',
method=method)
assert False, 'ERROR: [NETWORK ERROR] {}'.format(e)
# Log data
PqaTools.log_fullRequest(comp='CEP',
response=response,
params=parameters)
return response
