def _base_handler(additional_functions=None, ctx=None, data=None, loop=None):
"""This function routes calls to sub-functions, thereby allowing
a single function to stay hot for longer. If you want
to add additional functions then add them via the
'additional_functions' argument. This should accept 'function'
and 'args', returning some output if the function is found,
or 'None' if the function is not available
Args:
additional_functions (function): function to be routed
ctx: currently unused
data (str): to be passed as arguments to other functions
TODO - expand this
loop: currently unused
Returns:
dict: JSON serialisable dict
"""
# Make sure we set the flag to say that this code is running
# as part of a service
from Acquire.Service import push_is_running_service, \
pop_is_running_service, unpack_arguments, \
get_service_private_key, pack_return_value, \
create_return_value
push_is_running_service()
result = None
try:
(function, args, keys) = unpack_arguments(data,
get_service_private_key)
except Exception as e:
function = None
args = None
result = e
keys = None
if result is None:
try:
result = _handle(function=function,
additional_functions=additional_functions,
args=args)
except Exception as e:
result = e
result = create_return_value(payload=result)
try:
result = pack_return_value(payload=result, key=keys)
except Exception as e:
result = pack_return_value(payload=create_return_value(e))
pop_is_running_service()
return result
def test_json_keys():
privkey = PrivateKey()
pubkey = privkey.public_key()
args = {
"message": "Hello, this is a message",
"status": 0,
"long": [random.random() for _ in range(1000)]
}
packed = pack_arguments(args)
crypted = pubkey.encrypt(packed)
uncrypted = privkey.decrypt(crypted)
unpacked = unpack_arguments(uncrypted)
assert (args == unpacked)
async def handler(ctx, data=None, loop=None):
"""This function routes calls to sub-functions, thereby allowing
a single accounting function to stay hot for longer"""
try:
pr = start_profile()
except:
pass
try:
args = unpack_arguments(data, get_service_private_key)
except Exception as e:
result = {"status": -1,
"message": "Cannot unpack arguments: %s" % e}
return json.dumps(result)
except:
result = {"status": -1,
"message": "Cannot unpack arguments: Unknown error!"}
return json.dumps(result)
try:
function = str(args["function"])
except:
function = None
try:
if function is None:
from root import run as _root
result = _root(args)
elif function == "create_account":
from create_account import run as _create_account
result = _create_account(args)
elif function == "deposit":
from deposit import run as _deposit
result = _deposit(args)
elif function == "get_account_uids":
from get_account_uids import run as _get_account_uids
result = _get_account_uids(args)
elif function == "get_info":
from get_info import run as _get_info
result = _get_info(args)
elif function == "perform":
from perform import run as _perform
result = _perform(args)
elif function == "setup":
from setup import run as _setup
result = _setup(args)
else:
result = {"status": -1,
"message": "Unknown function '%s'" % function}
except Exception as e:
result = {"status": -1,
"message": "Error %s: %s" % (e.__class__, str(e))}
try:
end_profile(pr, result)
except:
pass
try:
return pack_return_value(result, args)
except Exception as e:
message = {"status": -1,
"message": "Error packing results: %s" % e}
return json.dumps(message)
except:
message = {"status": -1,
"message": "Error packing results: Unknown error"}
return json.dumps(message)
async def handler(ctx, data=None, loop=None):
"""This function routes calls to sub-functions, thereby allowing
a single identity function to stay hot for longer"""
try:
pr = start_profile()
except:
pass
try:
args = unpack_arguments(data, get_service_private_key)
except Exception as e:
result = {"status": -1,
"message": "Cannot unpack arguments: %s" % e}
return json.dumps(result)
except:
result = {"status": -1,
"message": "Cannot unpack arguments: Unknown error!"}
return json.dumps(result)
try:
function = str(args["function"])
except:
function = None
try:
if function is None:
from root import run as _root
result = _root(args)
elif function == "request_login":
from request_login import run as _request_login
result = _request_login(args)
elif function == "get_keys":
from get_keys import run as _get_keys
result = _get_keys(args)
elif function == "get_status":
from get_status import run as _get_status
result = _get_status(args)
elif function == "login":
from login import run as _login
result = _login(args)
elif function == "logout":
from logout import run as _logout
result = _logout(args)
elif function == "register":
from register import run as _register
result = _register(args)
elif function == "request_login":
from request_login import run as _request_login
result = _request_login(args)
elif function == "setup":
from setup import run as _setup
result = _setup(args)
elif function == "whois":
from whois import run as _whois
result = _whois(args)
elif function == "test":
from test import run as _test
result = _test(args)
else:
result = {"status": -1,
"message": "Unknown function '%s'" % function}
except Exception as e:
result = {"status": -1,
"message": "Error %s: %s" % (e.__class__, str(e))}
try:
end_profile(pr, result)
except:
pass
try:
return pack_return_value(result, args)
except Exception as e:
message = {"status": -1,
"message": "Error packing results: %s" % e}
return json.dumps(message)
except:
message = {"status": -1,
"message": "Error packing results: Unknown error"}
return json.dumps(message)
def test_pack_unpack_args_returnvals():
privkey = get_private_key("testing")
pubkey = privkey.public_key()
args = {"message": "Hello, this is a message",
"status": 0,
"long": [random.random() for _ in range(2)]}
func = "test_function"
packed = pack_arguments(function=func, args=args)
crypted = pubkey.encrypt(packed)
uncrypted = privkey.decrypt(crypted)
(f, unpacked, keys) = unpack_arguments(args=uncrypted)
print(keys)
assert(args == unpacked)
assert(f == func)
packed = pack_arguments(function=func, args=args,
key=pubkey, response_key=pubkey,
public_cert=pubkey)
data = json.loads(packed.decode("utf-8"))
assert(data["encrypted"])
assert(data["fingerprint"] == privkey.fingerprint())
payload = privkey.decrypt(string_to_bytes(data["data"]))
payload = json.loads(payload)
assert(payload["sign_with_service_key"] == privkey.fingerprint())
assert(payload["encryption_public_key"] == bytes_to_string(pubkey.bytes()))
assert(payload["payload"] == args)
(f, unpacked, keys) = unpack_arguments(function=func, args=packed,
key=privkey)
message = {"message": "OK"}
return_value = create_return_value(message)
packed_result = pack_return_value(function=func,
payload=return_value, key=keys,
private_cert=privkey)
result = json.loads(packed_result.decode("utf-8"))
assert(result["fingerprint"] == privkey.fingerprint())
assert(result["encrypted"])
data = string_to_bytes(result["data"])
sig = string_to_bytes(result["signature"])
pubkey.verify(signature=sig, message=data)
data = json.loads(privkey.decrypt(data))
assert(data["payload"]["return"] == message)
result = unpack_return_value(return_value=packed_result,
key=privkey, public_cert=pubkey)
assert(result == message)
try:
return_value = create_return_value(_foo())
except Exception as e:
return_value = create_return_value(e)
packed_result = pack_return_value(function=func,
payload=return_value, key=keys,
private_cert=privkey)
with pytest.raises(PermissionError):
result = unpack_return_value(function=func, return_value=packed_result,
key=privkey, public_cert=pubkey)