def putPreSubscription(self,JSONdata):
'''
Set pre-subscription rules for all endpoints / resources on the domain.
This can be useful for all current and future endpoints/resources.
:param json JSONdata: data to use as pre-subscription data. Wildcards are permitted
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
if isinstance(JSONdata,str) and self._isJSON(JSONdata):
self.log.warn("pre-subscription data was a string, converting to a list : %s",JSONdata)
JSONdata = json.loads(JSONdata) # convert json string to list
if not (isinstance(JSONdata,list) and self._isJSON(JSONdata)):
self.log.error("pre-subscription data is not valid. Please make sure it is a valid JSON list")
result = asyncResult()
data = self._putURL("/subscriptions",JSONdata, versioned=False)
if data.status_code == 204: # immediate success with no response
result.error = False
result.is_done = True
result.result = []
else:
result.error = response_codes("presubscription",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def getResources(self,ep,noResp=False,cacheOnly=False):
"""
Get list of resources on an endpoint.
:param str ep: Endpoint to get the resources of
:param bool noResp: Optional - specify no response necessary from endpoint
:param bool cacheOnly: Optional - get results from cache on connector, do not wake up endpoint
:return: list of resources
:rtype: asyncResult
"""
# load query params if set to other than defaults
q = {}
result = asyncResult()
result.endpoint = ep
if noResp or cacheOnly:
q['noResp'] = 'true' if noResp == True else 'false'
q['cacheOnly'] = 'true' if cacheOnly == True else 'false'
# make query
self.log.debug("ep = %s, query=%s",ep,q)
data = self._getURL("/endpoints/"+ep, query=q)
result.fill(data)
# check sucess of call
if data.status_code == 200: # sucess
result.error = False
self.log.debug("getResources sucess, status_code = `%s`, content = `%s`", str(data.status_code),data.content)
else: # fail
result.error = response_codes("get_resources",data.status_code)
self.log.debug("getResources failed with error code `%s`" %str(data.status_code))
result.is_done = True
return result
def putResourceSubscription(self,ep,res,cbfn=""):
'''
Subscribe to changes in a specific resource ``res`` on an endpoint ``ep``
:param str ep: name of endpoint
:param str res: name of resource
:param fnptr cbfn: Optional - callback funtion to call when operation is completed
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult(callback=cbfn)
result.endpoint = ep
result.resource = res
data = self._putURL("/subscriptions/"+ep+res)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
elif data.status_code == 202:
self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
else:
result.error = response_codes("subscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def postResource(self,ep,res,data="",cbfn=""):
'''
POST data to a resource on an endpoint.
:param str ep: name of endpoint
:param str res: name of resource
:param str data: Optional - data to send via POST
:param fnptr cbfn: Optional - callback funtion to call when operation is completed
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult(callback=cbfn)
result.endpoint = ep
result.resource = res
data = self._postURL("/endpoints/"+ep+res,data)
if data.status_code == 201: #immediate success
result.error = False
result.is_done = True
elif data.status_code == 202:
self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
else:
result.error = response_codes("resource",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def putPreSubscription(self,JSONdata):
'''
Set pre-subscription rules for all endpoints / resources on the domain.
This can be useful for all current and future endpoints/resources.
:param json JSONdata: data to use as pre-subscription data. Wildcards are permitted
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
if isinstance(JSONdata,str) and self._isJSON(JSONdata):
self.log.warn("pre-subscription data was a string, converting to a list : %s",JSONdata)
JSONdata = json.loads(JSONdata) # convert json string to list
if not (isinstance(JSONdata,list) and self._isJSON(JSONdata)):
self.log.error("pre-subscription data is not valid. Please make sure it is a valid JSON list")
result = asyncResult()
data = self._putURL("/subscriptions",JSONdata, versioned=False)
if data.status_code == 204: # immediate success with no response
result.error = False
result.is_done = True
result.result = []
else:
result.error = response_codes("presubscription",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def putResourceSubscription(self,ep,res,cbfn=""):
'''
Subscribe to changes in a specific resource ``res`` on an endpoint ``ep``
:param str ep: name of endpoint
:param str res: name of resource
:param fnptr cbfn: Optional - callback funtion to call when operation is completed
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult(callback=cbfn)
result.endpoint = ep
result.resource = res
data = self._putURL("/subscriptions/"+ep+res)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
elif data.status_code == 202:
self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
else:
result.error = response_codes("subscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def postResource(self,ep,res,data="",cbfn=""):
'''
POST data to a resource on an endpoint.
:param str ep: name of endpoint
:param str res: name of resource
:param str data: Optional - data to send via POST
:param fnptr cbfn: Optional - callback funtion to call when operation is completed
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult(callback=cbfn)
result.endpoint = ep
result.resource = res
data = self._postURL("/endpoints/"+ep+res,data)
if data.status_code == 201: #immediate success
result.error = False
result.is_done = True
elif data.status_code == 202:
self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
else:
result.error = response_codes("resource",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def putCallback(self,url,headers=""):
'''
Set the callback URL. To be used in place of LongPolling when deploying a webapp.
**note**: make sure you set up a callback URL in your web app
:param str url: complete url, including port, where the callback url is located
:param str headers: Optional - Headers to have Connector send back with all calls
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
payloadToSend = {"url":url}
if headers:
payload['headers':headers]
data = self._putURL(url="/notification/callback",payload=payloadToSend, versioned=False)
if data.status_code == 204: #immediate success
result.error = False
result.result = data.content
else:
result.error = response_codes("put_callback_url",data.status_code)
result.raw_data = data.content
result.status_code = data.status_code
result.is_done = True
return result
def getResources(self,ep,noResp=False,cacheOnly=False):
"""
Get list of resources on an endpoint.
:param str ep: Endpoint to get the resources of
:param bool noResp: Optional - specify no response necessary from endpoint
:param bool cacheOnly: Optional - get results from cache on connector, do not wake up endpoint
:return: list of resources
:rtype: asyncResult
"""
# load query params if set to other than defaults
q = {}
result = asyncResult()
result.endpoint = ep
if noResp or cacheOnly:
q['noResp'] = 'true' if noResp == True else 'false'
q['cacheOnly'] = 'true' if cacheOnly == True else 'false'
# make query
self.log.debug("ep = %s, query=%s",ep,q)
data = self._getURL("/endpoints/"+ep, query=q)
result.fill(data)
# check sucess of call
if data.status_code == 200: # sucess
result.error = False
self.log.debug("getResources sucess, status_code = `%s`, content = `%s`", str(data.status_code),data.content)
else: # fail
result.error = response_codes("get_resources",data.status_code)
self.log.debug("getResources failed with error code `%s`" %str(data.status_code))
result.is_done = True
return result
def putCallback(self,url,headers=""):
'''
Set the callback URL. To be used in place of LongPolling when deploying a webapp.
**note**: make sure you set up a callback URL in your web app
:param str url: complete url, including port, where the callback url is located
:param str headers: Optional - Headers to have Connector send back with all calls
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
payloadToSend = {"url":url}
if headers:
payload['headers':headers]
data = self._putURL(url="/notification/callback",payload=payloadToSend, versioned=False)
if data.status_code == 204: #immediate success
result.error = False
result.result = data.content
else:
result.error = response_codes("put_callback_url",data.status_code)
result.raw_data = data.content
result.status_code = data.status_code
result.is_done = True
return result
def getLimits(self):
"""return limits of account in async result object.
:returns: asyncResult object, populates error and result fields
:rtype: asyncResult
"""
result = asyncResult()
data = self._getURL("/limits")
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("limit",data.status_code)
result.is_done = True
return result
def getLimits(self):
"""return limits of account in async result object.
:returns: asyncResult object, populates error and result fields
:rtype: asyncResult
"""
result = asyncResult()
data = self._getURL("/limits")
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("limit",data.status_code)
result.is_done = True
return result
def getApiVersions(self):
"""
Get the REST API versions that connector accepts.
:returns: :class:asyncResult object, populates error and result fields
:rtype: asyncResult
"""
result = asyncResult()
data = self._getURL("/rest-versions",versioned=False)
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("get_rest_version",data.status_code)
result.is_done = True
return result
def getApiVersions(self):
"""
Get the REST API versions that connector accepts.
:returns: :class:asyncResult object, populates error and result fields
:rtype: asyncResult
"""
result = asyncResult()
data = self._getURL("/rest-versions",versioned=False)
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("get_rest_version",data.status_code)
result.is_done = True
return result
def getConnectorVersion(self):
"""
GET the current Connector version.
:returns: asyncResult object, populates error and result fields
:rtype: asyncResult
"""
result = asyncResult()
data = self._getURL("/",versioned=False)
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("get_mdc_version",data.status_code)
result.is_done = True
return result
def getConnectorVersion(self):
"""
GET the current Connector version.
:returns: asyncResult object, populates error and result fields
:rtype: asyncResult
"""
result = asyncResult()
data = self._getURL("/",versioned=False)
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("get_mdc_version",data.status_code)
result.is_done = True
return result
def _asyncHandler(self, data):
try:
responses = data['async-responses']
for entry in responses:
if entry['id'] in self.database['async-responses'].keys():
result = self.database['async-responses'].pop(
entry['id']) # get the asynch object out of database
# fill in async-result object
if 'error' in entry.keys():
# error happened, handle it
result.error = response_codes(
'async-responses-handler', entry['status'])
result.error.error = entry['error']
result.is_done = True
if result.callback:
result.callback(result)
else:
return result
else:
# everything is good, fill it out
result.result = b64decode(entry['payload'])
result.raw_data = entry
result.status = entry['status']
result.error = False
for thing in entry.keys():
result.extra[thing] = entry[thing]
result.is_done = True
# call associated callback function
if result.callback:
result.callback(result)
else:
self.log.warn("No callback function given")
else:
# TODO : object not found int asynch database
self.log.warn("No asynch entry for '%s' found in databse",
entry['id'])
except:
# TODO error handling here
self.log.error(
"Bad data encountered and failed to elegantly handle it. ")
ex_type, ex, tb = sys.exc_info()
traceback.print_tb(tb)
self.log.error(sys.exc_info())
del tb
return
def deleteAllSubscriptions(self):
'''
Delete all subscriptions on the domain (all endpoints, all resources)
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
data = self._deleteURL("/subscriptions/")
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
else:
result.error = response_codes("unsubscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def deleteAllSubscriptions(self):
'''
Delete all subscriptions on the domain (all endpoints, all resources)
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
data = self._deleteURL("/subscriptions/")
if data.status_code == 204: #immediate success
result.error = False
result.is_done = True
else:
result.error = response_codes("unsubscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def getCallback(self):
'''
Get the callback URL currently registered with Connector.
:return: callback url in ``.result``, error if applicable in ``.error``
:rtype: asyncResult
'''
result = asyncResult()
data = self._getURL("/notification/callback",versioned=False)
if data.status_code == 200: #immediate success
result.error = False
result.result = data.json()
else:
result.error = response_codes("get_callback_url",data.status_code)
result.raw_data = data.content
result.status_code = data.status_code
result.is_done = True
return result
def deleteCallback(self):
'''
Delete the Callback URL currently registered with Connector.
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
data = self._deleteURL("/notification/callback")
if data.status_code == 204: #immediate success
result.result = data.content
result.error = False
else:
result.error = response_codes("delete_callback_url",data.status_code)
result.raw_data = data.content
result.status_code = data.status_code
result.is_done = True
return result
def deleteCallback(self):
'''
Delete the Callback URL currently registered with Connector.
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
data = self._deleteURL("/notification/callback")
if data.status_code == 204: #immediate success
result.result = data.content
result.error = False
else:
result.error = response_codes("delete_callback_url",data.status_code)
result.raw_data = data.content
result.status_code = data.status_code
result.is_done = True
return result
def getCallback(self):
'''
Get the callback URL currently registered with Connector.
:return: callback url in ``.result``, error if applicable in ``.error``
:rtype: asyncResult
'''
result = asyncResult()
data = self._getURL("/notification/callback",versioned=False)
if data.status_code == 200: #immediate success
result.error = False
result.result = data.json()
else:
result.error = response_codes("get_callback_url",data.status_code)
result.raw_data = data.content
result.status_code = data.status_code
result.is_done = True
return result
def getResourceValue(self,
ep,
res,
cbfn="",
noResp=False,
cacheOnly=False):
"""
Get value of a specific resource on a specific endpoint.
:param str ep: name of endpoint
:param str res: name of resource
:param fnptr cbfn: Optional - callback function to be called on completion
:param bool noResp: Optional - specify no response necessary from endpoint
:param bool cacheOnly: Optional - get results from cache on connector, do not wake up endpoint
:return: value of the resource, usually a string
:rtype: asyncResult
"""
q = {}
result = asyncResult(
callback=cbfn) #set callback fn for use in async handler
result.endpoint = ep
result.resource = res
if noResp or cacheOnly:
q['noResp'] = 'true' if noResp == True else 'false'
q['cacheOnly'] = 'true' if cacheOnly == True else 'false'
# make query
data = self._getURL("/endpoints/" + ep + res, query=q)
result.fill(data)
if data.status_code == 200: # immediate success
result.error = False
result.is_done = True
if cbfn:
cbfn(result)
return result
elif data.status_code == 202:
self.database['async-responses'][json.loads(
data.content)["async-response-id"]] = result
else: # fail
result.error = response_codes("resource", data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def getPreSubscription(self):
'''
Get the current pre-subscription data from connector
:return: JSON that represents the pre-subscription data in the ``.result`` field
:rtype: asyncResult
'''
result = asyncResult()
data = self._getURL("/subscriptions")
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
result.result = data.json()
else:
result.error = response_codes("presubscription",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def getPreSubscription(self):
'''
Get the current pre-subscription data from connector
:return: JSON that represents the pre-subscription data in the ``.result`` field
:rtype: asyncResult
'''
result = asyncResult()
data = self._getURL("/subscriptions")
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
result.result = data.json()
else:
result.error = response_codes("presubscription",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def deleteEndpointSubscriptions(self,ep):
'''
Delete all subscriptions on specified endpoint ``ep``
:param str ep: name of endpoint
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
result.endpoint = ep
data = self._deleteURL("/subscriptions/"+ep)
if data.status_code == 204: #immediate success
result.error = False
result.is_done = True
else:
result.error = response_codes("delete_endpoint_subscription",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def deleteEnpointSubscriptions(self,ep):
'''
Delete all subscriptions on specified endpoint ``ep``
:param str ep: name of endpoint
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
result.endpoint = ep
data = self._deleteURL("/subscriptions/"+ep)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
else:
result.error = response_codes("delete_endpoint_subscription",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def _asyncHandler(self,data):
try:
responses = data['async-responses']
for entry in responses:
if entry['id'] in self.database['async-responses'].keys():
result = self.database['async-responses'].pop(entry['id']) # get the asynch object out of database
# fill in async-result object
if 'error' in entry.keys():
# error happened, handle it
result.error = response_codes('async-responses-handler',entry['status'])
result.error.error = entry['error']
result.is_done = True
if result.callback:
result.callback(result)
else:
return result
else:
# everything is good, fill it out
result.result = b64decode(entry['payload'])
result.raw_data = entry
result.status = entry['status']
result.error = False
for thing in entry.keys():
result.extra[thing]=entry[thing]
result.is_done = True
# call associated callback function
if result.callback:
result.callback(result)
else:
self.log.warn("No callback function given")
else:
# TODO : object not found int asynch database
self.log.warn("No asynch entry for '%s' found in databse",entry['id'])
except:
# TODO error handling here
self.log.error("Bad data encountered and failed to elegantly handle it. ")
ex_type, ex, tb = sys.exc_info()
traceback.print_tb(tb)
self.log.error(sys.exc_info())
del tb
return
def getEndpoints(self,typeOfEndpoint=""):
"""
Get list of all endpoints on the domain.
:param str typeOfEndpoint: Optional filter endpoints returned by type
:return: list of all endpoints
:rtype: asyncResult
"""
q = {}
result = asyncResult()
if typeOfEndpoint:
q['type'] = typeOfEndpoint
result.extra['type'] = typeOfEndpoint
data = self._getURL("/endpoints", query = q)
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("get_endpoints",data.status_code)
result.is_done = True
return result
def getEndpointSubscriptions(self,ep):
'''
Get list of all subscriptions on a given endpoint ``ep``
:param str ep: name of endpoint
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
result.endpoint = ep
data = self._getURL("/subscriptions/"+ep)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
result.result = data.content
else:
result.error = response_codes("unsubscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def getEndpointSubscriptions(self,ep):
'''
Get list of all subscriptions on a given endpoint ``ep``
:param str ep: name of endpoint
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
result.endpoint = ep
data = self._getURL("/subscriptions/"+ep)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
result.result = data.content
else:
result.error = response_codes("unsubscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def getEndpoints(self,typeOfEndpoint=""):
"""
Get list of all endpoints on the domain.
:param str typeOfEndpoint: Optional filter endpoints returned by type
:return: list of all endpoints
:rtype: asyncResult
"""
q = {}
result = asyncResult()
if typeOfEndpoint:
q['type'] = typeOfEndpoint
result.extra['type'] = typeOfEndpoint
data = self._getURL("/endpoints", query = q)
result.fill(data)
if data.status_code == 200:
result.error = False
else:
result.error = response_codes("get_endpoints",data.status_code)
result.is_done = True
return result
def deleteResourceSubscription(self,ep,res):
'''
Delete subscription to a resource ``res`` on an endpoint ``ep``
:param str ep: name of endpoint
:param str res: name of resource
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
result.endpoint = ep
result.resource = res
data = self._deleteURL("/subscriptions/"+ep+res)
if data.status_code == 204: #immediate success
result.error = False
result.is_done = True
else:
result.error = response_codes("unsubscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def deleteResourceSubscription(self,ep,res):
'''
Delete subscription to a resource ``res`` on an endpoint ``ep``
:param str ep: name of endpoint
:param str res: name of resource
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult()
result.endpoint = ep
result.resource = res
data = self._deleteURL("/subscriptions/"+ep+res)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
else:
result.error = response_codes("unsubscribe",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def deleteEndpoint(self,ep,cbfn=""):
'''
Send DELETE message to an endpoint.
:param str ep: name of endpoint
:param fnptr cbfn: Optional - callback funtion to call when operation is completed
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult(callback=cbfn)
result.endpoint = ep
data = self._deleteURL("/endpoints/"+ep)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
elif data.status_code == 202:
self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
else:
result.error = response_codes("resource",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def deleteEndpoint(self,ep,cbfn=""):
'''
Send DELETE message to an endpoint.
:param str ep: name of endpoint
:param fnptr cbfn: Optional - callback funtion to call when operation is completed
:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
:rtype: asyncResult
'''
result = asyncResult(callback=cbfn)
result.endpoint = ep
data = self._deleteURL("/endpoints/"+ep)
if data.status_code == 200: #immediate success
result.error = False
result.is_done = True
elif data.status_code == 202:
self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
else:
result.error = response_codes("resource",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
def getResourceValue(self,ep,res,cbfn="",noResp=False,cacheOnly=False):
"""
Get value of a specific resource on a specific endpoint.
:param str ep: name of endpoint
:param str res: name of resource
:param fnptr cbfn: Optional - callback function to be called on completion
:param bool noResp: Optional - specify no response necessary from endpoint
:param bool cacheOnly: Optional - get results from cache on connector, do not wake up endpoint
:return: value of the resource, usually a string
:rtype: asyncResult
"""
q = {}
result = asyncResult(callback=cbfn) #set callback fn for use in async handler
result.endpoint = ep
result.resource = res
if noResp or cacheOnly:
q['noResp'] = 'true' if noResp == True else 'false'
q['cacheOnly'] = 'true' if cacheOnly == True else 'false'
# make query
data = self._getURL("/endpoints/"+ep+res, query=q)
result.fill(data)
if data.status_code == 200: # immediate success
result.error = False
result.is_done = True
if cbfn:
cbfn(result)
return result
elif data.status_code == 202:
self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
else: # fail
result.error = response_codes("resource",data.status_code)
result.is_done = True
result.raw_data = data.content
result.status_code = data.status_code
return result
