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 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 __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(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