def __init__(self,
host,
port,
callbacks=None,
proto=None,
node_name=None,
server_node_name=None,
*args,
**kwargs):
super(TwistedCalvinTransportClient, self).__init__(host,
port,
callbacks=callbacks)
self._jid = host
self._token = port
self._proto = proto
self._uri = proto._uri
self._factory = None
self._node_name = node_name
self._server_node_name = server_node_name
self._runtime_credentials = None
self._is_connected = False
if proto:
proto.callback_register('connected', CalvinCB(self._connected))
proto.callback_register('disconnected',
CalvinCB(self._disconnected))
proto.callback_register('data', CalvinCB(self._data))
self._callbacks = callbacks
self.sendConnected()
def init(self,
address,
port,
connection_type,
mode="raw",
delimiter="\r\n"):
self.connection = None
self.data = b""
if connection_type == "TCP":
connection_factory = client_connection.TCPClientProtocolFactory(
mode=mode,
delimiter=delimiter,
server_node_name=None,
callbacks={'data_received': [CalvinCB(self._data_received)]})
elif connection_type == "UDP":
connection_factory = client_connection.UDPClientProtocolFactory(
callbacks={'data_received': [CalvinCB(self._data_received)]})
connection_factory.callback_register(
'connected', CalvinCB(self._connected, connection_factory))
connection_factory.callback_register('disconnected',
CalvinCB(self._disconnected))
connection_factory.callback_register(
'connection_failed',
CalvinCB(self._connection_failed, connection_factory))
connection_factory.connect(address, port)
def __init__(self, rt_id, remote_uri, callbacks, transport, proto=None):
"""docstring for __init__"""
super(CalvinTransport, self).__init__(rt_id,
remote_uri,
callbacks=callbacks)
self._rt_id = rt_id
self._remote_rt_id = None
self._coder = None
self._transport = transport(self._uri.hostname,
self._uri.port,
callbacks,
proto=proto)
self._rtt = 2000 # Init rt in ms
# TODO: This should be incoming param
self._verify_client = lambda x: True
self._incoming = proto is not None
if self._incoming:
# TODO: Set timeout
# Incomming connection timeout if no join
self._transport.callback_register("disconnected",
CalvinCB(self._disconnected))
self._transport.callback_register("data",
CalvinCB(self._data_received))
def test_application_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
application = appmanager.Application(
calvinuuid.uuid('APP'), "test_app",
[calvinuuid.uuid('ACTOR'),
calvinuuid.uuid('ACTOR')], calvinuuid.uuid("NODE"), None)
self.storage.add_application(application, cb=CalvinCB(cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
# print value
self.storage.get_application(application.id, cb=CalvinCB(func=cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
# print value
assert value["key"] == application.id and value["value"][
"name"] == application.name
self.storage.delete_application(application.id, cb=CalvinCB(func=cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
assert application.id not in self.storage.localstore
def __init__(self, host, port, callbacks=None, proto=None, node_name=None, server_node_name=None, *args, **kwargs):
super(TwistedCalvinTransport, self).__init__(host, port, callbacks=callbacks)
self._host_ip = host
self._host_port = port
self._proto = proto
self._factory = None
self._node_name = node_name
self._server_node_name=server_node_name
self._runtime_credentials = None
# Server created us already have a proto
if proto:
proto.callback_register('connected', CalvinCB(self._connected))
proto.callback_register('disconnected', CalvinCB(self._disconnected))
proto.callback_register('data', CalvinCB(self._data))
self._callbacks = callbacks
#If TLS is chosen, ensure that a node_name and a server_node_name are set
runtime_to_runtime_security = _conf.get("security","runtime_to_runtime_security")
if (runtime_to_runtime_security=="tls"):
if self._node_name==None or self._server_node_name==None:
_log.error("For TLS, both node_name and server_node_name must be given as input"
"\n\tself._node_name={}"
"\n\tself._server_node_name={}".format(self._node_name, self._server_node_name))
raise Exception("For TLS, both node_name and server_node_name must be given as input")
def get_callbacks(self):
return {
'peer_disconnected': [CalvinCB(self._peer_disconnected)],
'peer_connection_failed': [CalvinCB(self._connection_failed)],
'join_failed': [CalvinCB(self._join_failed)],
'peer_connected': [CalvinCB(self._peer_connected)]
}
def test_node_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
node = calvin.tests.TestNode(["127.0.0.1:5000"])
self.storage.add_node(node)
self.storage.get_node(node_id=node.id, cb=CalvinCB(func=cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
assert value["key"] == node.id and value["value"] == {
u'attributes': {
u'indexed_public': [],
u'public': {}
},
u'control_uris': [u'127.0.0.1:5000'],
'uris': node.uris
}
self.storage.delete_node(node, cb=CalvinCB(func=cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
assert value
assert node.id not in self.storage.localstore
def test_late_start(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
def started_cb(started):
self.q.put(started)
self.storage = storage.Storage()
self.storage.set("test", "1", 1, None)
self.storage.set("test", "2", 2, None)
self.storage.set("test", "3", 3, None)
assert "test1" in self.storage.localstore
assert "test2" in self.storage.localstore
assert "test3" in self.storage.localstore
yield threads.defer_to_thread(self.storage.start, CalvinCB(started_cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value
assert "test1" not in self.storage.localstore
assert "test2" not in self.storage.localstore
assert "test3" not in self.storage.localstore
yield threads.defer_to_thread(self.storage.get, "test", "3",
CalvinCB(func=cb))
value = self.q.get(timeout=0.2)
assert value["value"] == 3
yield threads.defer_to_thread(self.storage.stop)
def test_application_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
application = appmanager.Application(
calvinuuid.uuid('APP'), "test_app",
[calvinuuid.uuid('ACTOR'),
calvinuuid.uuid('ACTOR')], calvinuuid.uuid("NODE"), None)
self.storage.add_application(application, cb=CalvinCB(cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
assert isinstance(value["value"], calvinresponse.CalvinResponse
) and value["value"] == calvinresponse.OK
self.storage.get_application(application.id, cb=CalvinCB(cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
assert value["value"]["name"] == application.name
self.storage.delete_application(application.id, cb=CalvinCB(cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
assert isinstance(value["value"], calvinresponse.CalvinResponse
) and value["value"] == calvinresponse.OK
self.storage.get_application(application.id, cb=CalvinCB(cb))
yield wait_for(self.q.empty, condition=lambda x: not x())
value = self.q.get(timeout=.001)
assert isinstance(value["value"], calvinresponse.CalvinResponse
) and value["value"] == calvinresponse.NOT_FOUND
def destroy_with_disconnect(self,
actor_id,
terminate=DISCONNECT.TERMINATE,
callback=None):
if actor_id not in self.actors:
self._actor_not_found(actor_id)
if terminate == DISCONNECT.EXHAUST:
actor = self.actors[actor_id]
actor.exhaust(
CalvinCB(self._destroy_with_disconnect_exhausted,
actor_id=actor_id,
terminate=terminate,
callback=callback))
# Exhaust first disconnects all inports then all outports after inports exhausted
self.node.pm.disconnect(callback=CalvinCB(
self._destroy_with_disconnect_in_cb,
terminate=terminate,
callback=callback),
actor_id=actor_id,
port_dir="in",
terminate=terminate)
else:
self.node.pm.disconnect(callback=CalvinCB(
self._destroy_with_disconnect_cb, callback=callback),
actor_id=actor_id,
terminate=terminate)
def test_append_multi_getconcat(self, setup):
""" Test that appending multiple values returns OK and get_concat returns the unique values (set) in a list """
self.nodes = setup.get("nodes")
storage_types = self.verify_started()
for stype in storage_types:
for i in [("aa", "aa"), ("bb", 2, "ff"), (True, ""), (False, True)
]: # values must be hashable (i.e. not list or dict)
key = str(i)
for y in range(3):
self.done = False
self.get_ans = None
self.nodes[stype][y].storage.append(
"test4-", key + str(y), i, CalvinCB(self.cb))
yield wait_for(self._test_done, timeout=10)
# Verify response is CalvinResponse object with OK status
print "append response", self.get_ans, stype, key, y
assert isinstance(self.get_ans,
calvinresponse.CalvinResponse
) and self.get_ans == calvinresponse.OK
for x in range(3):
if stype == "notstarted" and x != y:
# Not started storage is never connected to other nodes storage
continue
self.done = False
self.get_ans = None
self.nodes[stype][x].storage.get_concat(
"test4-", key + str(y), CalvinCB(self.cb))
yield wait_for(self._test_done, timeout=10)
print "get_concat response", self.get_ans, stype, key, x
# Verify we read what is written
assert set(self.get_ans) == set(i)
def test_set_get(self, setup):
""" Test that set returns OK and get returns value set """
self.nodes = setup.get("nodes")
storage_types = self.verify_started()
for stype in storage_types:
for i in [
"aa", "bb", "", None, True, False, 0, 1, 2, [0, 1], {
"xx": 10
}
]:
key = str(i)
for y in range(3):
self.done = False
self.get_ans = None
self.nodes[stype][y].storage.set("test1-", key + str(y), i,
CalvinCB(self.cb))
yield wait_for(self._test_done, timeout=10)
# Verify response is CalvinResponse object with OK status
print "set response", self.get_ans, stype, key, y
assert isinstance(self.get_ans,
calvinresponse.CalvinResponse
) and self.get_ans == calvinresponse.OK
for x in range(3):
if stype == "notstarted" and x != y:
# Not started storage is never connected to other nodes storage
continue
self.done = False
self.get_ans = None
self.nodes[stype][x].storage.get(
"test1-", key + str(y), CalvinCB(self.cb))
yield wait_for(self._test_done, timeout=10)
print "get response", self.get_ans, stype, key, x
# Verify we read what is written
assert self.get_ans == i
def start(self):
# These should come from us
self._transport.callback_register('server_started', CalvinCB(self._started))
self._transport.callback_register('server_stopped', CalvinCB(self._stopped))
self._transport.callback_register('client_connected', CalvinCB(self._client_connected))
# Start the server
self._port = self._transport.start()
def get_callbacks(self):
return {
'server_started': [CalvinCB(self._server_started)],
'server_stopped': [CalvinCB(self._server_stopped)],
'join_failed': [CalvinCB(self._join_failed)],
'peer_disconnected': [CalvinCB(self._peer_disconnected)],
'peer_connected': [CalvinCB(self._peer_connected)]
}
def __init__(self, node, actor):
_log.info("Started HTTPClientHandler")
self._actor = actor
self._node = node
callbacks = {'receive-headers': [CalvinCB(self._receive_headers)],
'receive-body': [CalvinCB(self._receive_body)]}
self._client = http_client.HTTPClient(callbacks)
self._requests = {}
def _got_link(self, master_id, org_cb):
_log.debug("_got_link %s, %s" % (master_id, org_cb))
self.master_id = master_id
self.tunnel = self.node.proto.tunnel_new(self.master_id, 'storage', {})
self.tunnel.register_tunnel_down(
CalvinCB(self.tunnel_down, org_cb=org_cb))
self.tunnel.register_tunnel_up(CalvinCB(self.tunnel_up, org_cb=org_cb))
self.tunnel.register_recv(self.tunnel_recv_handler)
def connect(self, status=None, port_meta=None):
# TODO: status & port_meta unused
tunnel = None
if self.peer_port_meta.node_id not in self.token_tunnel.tunnels.iterkeys(
):
# No tunnel to peer, get one first
_log.analyze(self.node.id,
"+ GET TUNNEL",
self.peer_port_meta,
peer_node_id=self.peer_port_meta.node_id)
tunnel = self.node.proto.tunnel_new(self.peer_port_meta.node_id,
'token', {})
tunnel.register_tunnel_down(
CalvinCB(self.token_tunnel.tunnel_down, tunnel))
tunnel.register_tunnel_up(
CalvinCB(self.token_tunnel.tunnel_up, tunnel))
tunnel.register_recv(
CalvinCB(self.token_tunnel.tunnel_recv_handler, tunnel))
self.token_tunnel.tunnels[self.peer_port_meta.node_id] = tunnel
else:
tunnel = self.token_tunnel.tunnels[self.peer_port_meta.node_id]
if tunnel.status == CalvinTunnel.STATUS.PENDING:
if self.peer_port_meta.node_id not in self.token_tunnel.pending_tunnels:
self.token_tunnel.pending_tunnels[
self.peer_port_meta.node_id] = []
# call _connect_via_tunnel when we get the response of the tunnel
self.token_tunnel.pending_tunnels[
self.peer_port_meta.node_id].append(
CalvinCB(self._connect_via_tunnel))
return
elif tunnel.status == CalvinTunnel.STATUS.TERMINATED:
# TODO should we retry at this level?
if self.callback:
self.callback(status=response.CalvinResponse(
response.INTERNAL_ERROR),
actor_id=self.port.owner.id,
port_name=self.port.name,
port_id=self.port.id,
peer_node_id=self.peer_port_meta.node_id,
peer_actor_id=self.peer_port_meta.actor_id,
peer_port_name=self.peer_port_meta.port_name,
peer_port_id=self.peer_port_meta.port_id)
return
_log.analyze(
self.node.id,
"+ HAD TUNNEL", {
'local_port':
self.port,
'peer_port':
self.peer_port_meta,
'tunnel_status':
self.token_tunnel.tunnels[self.peer_port_meta.node_id].status
},
peer_node_id=self.peer_port_meta.node_id)
self._connect_via_tunnel(status=response.CalvinResponse(True))
def test_append_delete_append_get_concat(self, setup):
""" Test that append returns OK, delete return OK and get returns second append """
self.nodes = setup.get("nodes")
storage_types = self.verify_started()
for stype in storage_types:
for i in ["aa"]:
for y in range(3):
key = "t3" + str(i)
self.done = False
self.get_ans = None
self.nodes[stype][y].storage.append(
"test7-", key + str(y), [i], CalvinCB(self.cb))
yield wait_for(self._test_done,
timeout=10,
test_part="append" + key + str(y))
# Verify response is CalvinResponse object with OK status
assert isinstance(self.get_ans,
calvinresponse.CalvinResponse
) and self.get_ans == calvinresponse.OK
print "append response", self.get_ans, stype, i, y
self.done = False
self.get_ans = None
self.nodes[stype][y].storage.delete(
"test7-", key + str(y), CalvinCB(self.cb))
yield wait_for(self._test_done,
timeout=10,
test_part="delete" + key + str(y))
# Verify response is CalvinResponse object with OK status
assert isinstance(self.get_ans,
calvinresponse.CalvinResponse
) and self.get_ans == calvinresponse.OK
print "delete response", self.get_ans, stype, i, y
self.done = False
self.get_ans = None
self.nodes[stype][y].storage.append(
"test7-", key + str(y), [i + "2"], CalvinCB(self.cb))
yield wait_for(self._test_done,
timeout=10,
test_part="append2" + key + str(y))
# Verify response is CalvinResponse object with OK status
assert isinstance(self.get_ans,
calvinresponse.CalvinResponse
) and self.get_ans == calvinresponse.OK
print "append2 response", self.get_ans, stype, i, y
for x in range(3):
if stype == "notstarted" and x != y:
# Not started storage is never connected to other nodes storage
continue
self.done = False
self.get_ans = None
self.nodes[stype][x].storage.get_concat(
"test7-", key + str(y), CalvinCB(self.cb))
yield wait_for(self._test_done,
timeout=10,
test_part="get_concat" + key + str(y))
print "get_concat response", self.get_ans, stype, i, x
# Verify the response is second appended value
assert self.get_ans == [i + "2"]
def get_authorization_decision(self,
callback,
actor_id=None,
requires=None,
element_dict=None,
decision_from_migration=None):
"""Get authorization decision using the authorization procedure specified in config."""
# _log.debug("Security: get_authorization_decision:\n\tcallback={}\n\tactor_id={}\n\trequires={}\n\telement_dict={}\n\tdecision_from_migration={}".format(callback, actor_id, requires, element_dict, decision_from_migration))
if decision_from_migration:
try:
_log.debug("Authorization decision from migration")
# Decode JSON Web Token, which contains the authorization response.
decode_jwt(
decision_from_migration["jwt"],
decision_from_migration["cert_name"], self.node, actor_id,
CalvinCB(self._get_authorization_decision_jwt_decoded_cb,
callback=callback))
return
except Exception as e:
_log.error("Security: JWT decoding error - %s" % str(e))
self._return_authorization_decision("indeterminate", [],
callback)
return
else:
request = {}
request["subject"] = self.get_subject_attributes()
if element_dict is not None:
request["subject"].update(element_dict)
request["resource"] = {"node_id": self.node.id}
if requires is not None:
request["action"] = {"requires": requires}
_log.debug("Security: authorization request: %s" % request)
# Check if the authorization server is local (the runtime itself) or external.
if 'authorization' in self.sec_conf and 'procedure' in self.sec_conf[
'authorization']:
if self.sec_conf['authorization']['procedure'] == "external":
if not HAS_JWT:
_log.error(
"Security: Install JWT to use external server as authorization method.\n"
+ "Note: NO AUTHORIZATION USED")
return False
_log.debug(
"Security: external authorization method chosen")
self.authorize_using_external_server(
request, callback, actor_id)
else:
_log.debug("Security: local authorization method chosen")
# Authorize access using a local Policy Decision Point (PDP).
self.node.authorization.pdp.authorize(
request,
CalvinCB(self._handle_local_authorization_response,
callback=callback))
else:
_log.error(
"This should have already been caught, raise exception")
raise ("No authorization procedure configured")
def tunnel_request_handles(self, tunnel):
""" Incoming tunnel request for token transport """
# TODO check if we want a tunnel first
self.tunnels[tunnel.peer_node_id] = tunnel
tunnel.register_tunnel_down(CalvinCB(self.tunnel_down, tunnel))
tunnel.register_tunnel_up(CalvinCB(self.tunnel_up, tunnel))
tunnel.register_recv(CalvinCB(self.tunnel_recv_handler, tunnel))
# We accept it by returning True
return True
def __init__(self, config):
super(KubeCtl, self).__init__()
self._config = config
self._api_base = str(config["api-base"])
if not self._api_base.endswith("/"):
self._api_base += "/"
self._httpclient = http_client.HTTPClient({'receive_headers' : [CalvinCB(self._receive_headers)],
'receive-body': [CalvinCB(self._receive_body)]})
self._requests = {}
def handle_actor_migrate(self, handle, connection, match, data, hdr):
"""
POST /actor/{actor-id}/migrate
Migrate actor to (other) node, either explicit node_id or by updated requirements
Body: {"peer_node_id": <node-id>}
Alternative body:
Body:
{
"requirements": [ {"op": "<matching rule name>",
"kwargs": {<rule param key>: <rule param value>, ...},
"type": "+" or "-" for set intersection or set removal, respectively
}, ...
],
"extend": True or False # defaults to False, i.e. replace current requirements
"move": True or False # defaults to False, i.e. when possible stay on the current node
}
For further details about requirements see application deploy.
Response status code: OK, BAD_REQUEST, INTERNAL_ERROR or NOT_FOUND
Response: none
"""
status = calvinresponse.OK
actor_id = match.group(1)
if 'peer_node_id' in data:
if actor_id in self.node.am.list_actors():
try:
self.node.am.migrate(actor_id,
data['peer_node_id'],
callback=CalvinCB(self.actor_migrate_cb,
handle, connection))
except:
_log.exception("Migration failed")
status = calvinresponse.INTERNAL_ERROR
else:
self.node.storage.get_actor(
actor_id,
CalvinCB(func=self.handle_actor_migrate_lookup_peer_cb,
handle=handle,
connection=connection,
actor_id=actor_id,
peer_node_id=data['peer_node_id']))
elif 'requirements' in data:
try:
self.node.am.update_requirements(
match.group(1),
data['requirements'],
extend=data['extend'] if 'extend' in data else False,
move=data['move'] if 'move' in data else False,
callback=CalvinCB(self.actor_migrate_cb, handle, connection))
except:
_log.exception("Migration failed")
status = calvinresponse.INTERNAL_ERROR
else:
status = calvinresponse.BAD_REQUEST
if status != calvinresponse.OK:
self.send_response(handle, connection, None, status=status)
def get_concat(self, key, cb=None):
"""
Gets a value from the storage
"""
_log.debug("SQL get_concat %s" % (key,))
key_sql = key.replace("'", r"\'")
d = self.dbpool.runQuery(QUERY_GETCONCAT.format(keystr=key_sql))
d.addCallbacks(CalvinCB(self._getconcat_cb, cb=cb, key=key), CalvinCB(self._getconcat_fail_cb, cb=cb, key=key))
_log.debug("SQL get_concat %s requested" % (key,))
def _start_link_cb(self, status, uri, peer_node_id):
if status == "NACK":
return
# Got link set up tunnel
master_id = peer_node_id
self.tunnel = self.calvincontrol.node.proto.tunnel_new(master_id, 'control', {})
self.tunnel.register_tunnel_down(CalvinCB(self.tunnel_down))
self.tunnel.register_tunnel_up(CalvinCB(self.tunnel_up))
self.tunnel.register_recv(self.tunnel_recv_handler)
def connect(self, timeout=10):
if self._transport.is_connected():
raise Exception("Transport already connected")
self._transport.callback_register("connected", CalvinCB(self._send_join))
self._transport.callback_register("disconnected", CalvinCB(self._disconnected))
self._transport.callback_register("data", CalvinCB(self._data_recieved))
# TODO: set timeout
self._transport.join()
def test_add_remove_get_index(self, setup):
""" Test that add_index returns OK, remove_index returns OK and get_index returns appended value in list for index hierarchies """
self.nodes = setup.get("nodes")
storage_types = self.verify_started()
for stype in storage_types:
for y in range(3):
for i in [(["aa", "bb", "", "dd"], ["xx", "kk", "ll"], "+"),
(["aa", "bb", "", "ee"], ["yy", "kk", "ll"], "+"),
(["aa", "bb"], ["zz", "mm", "oo"], "+"),
(["aa", "ff", "", "dd"], ["xx"], "+"),
(["aa", "bb", "", "dd"], ["kk", "ll"], "-"),
(["aa", "bb", "", "ee"], ["yy", "kk", "ll"], "-"),
(["aa", "bb"], ["oo"], "-"),
(["aa", "gg", "", "dd"], ["xx"], "-")]:
self.done = False
self.get_ans = None
index = copy.copy(i[0])
index[0] = "test2" + index[0] + str(y)
# root_prefix_level is default 2 hence 2 first are combined
if i[2] == "+":
self.nodes[stype][y].storage.add_index(index,
i[1],
cb=CalvinCB(
self.cb2))
else:
self.nodes[stype][y].storage.remove_index(
index, i[1], cb=CalvinCB(self.cb2))
yield wait_for(self._test_done, timeout=10)
# Verify response is CalvinResponse object with OK status
print "add" if i[
2] == "+" else "remove", " response", self.get_ans, stype, index, y
assert isinstance(self.get_ans,
calvinresponse.CalvinResponse
) and self.get_ans == calvinresponse.OK
for x in range(3):
if stype == "notstarted" and x != y:
# Not started storage is never connected to other nodes storage
continue
for i in [(["aa"], []), (["gg"], []), (["aa", "gg"], []),
(["aa", "bb"], ["xx", "zz", "mm"]),
(["aa", "bb", ""], ["xx"]), (["aa",
"ff"], ["xx"]),
(["aa", "bb", "", "dd"], ["xx"]),
(["aa", "bb", "", "ee"], []),
(["aa", "ff", "", "dd"], ["xx"])]:
self.done = False
self.get_ans = None
index = copy.copy(i[0])
index[0] = "test2" + index[0] + str(y)
self.nodes[stype][x].storage.get_index(index,
cb=CalvinCB(
self.cb2))
yield wait_for(self._test_done, timeout=10)
print "get_index response", self.get_ans, stype, index, x
# Verify we read what is written if too short prefix or not existing we should get [].
assert set(self.get_ans) == set(i[1])
def test_calvin_cb_group():
func1 = Mock()
func2 = Mock()
cb1 = CalvinCB(func1)
cb2 = CalvinCB(func2)
cbs = CalvinCBGroup([cb1, cb2])
cbs(1, 2, a=3)
func1.assert_called_with(1, 2, a=3)
func2.assert_called_with(1, 2, a=3)
def tunnel_request_handles(self, tunnel):
""" Incoming tunnel request for storage proxy server"""
# TODO check if we want a tunnel first
_log.analyze(self.node.id, "+ SERVER", {'tunnel_id': tunnel.id})
self.tunnel[tunnel.peer_node_id] = tunnel
tunnel.register_tunnel_down(CalvinCB(self.tunnel_down, tunnel))
tunnel.register_tunnel_up(CalvinCB(self.tunnel_up, tunnel))
tunnel.register_recv(CalvinCB(self.tunnel_recv_handler, tunnel))
# We accept it by returning True
return True
def peersetup(self, peers, cb=None):
""" Sets up a RT to RT communication channel, only needed if the peer can't be found in storage.
peers: a list of peer uris, e.g. ["calvinip://127.0.0.1:5001"]
"""
_log.debug("peersetup(%s)" % (peers))
peers_copy = peers[:]
peer_node_ids = {}
self.network.join(peers,
callback=CalvinCB(self.logging_callback, preamble="peersetup cb") if cb is None else
CalvinCB(self.peersetup_collect_cb, peers=peers_copy, peer_node_ids=peer_node_ids, org_cb=cb))
def _remove_cb(self, result, **kwargs):
_log.debug("SQL remove OK")
cb = kwargs.pop('cb', None)
key = kwargs.pop('key', None)
_log.debug("SQL remove OK %s" % str(result))
if cb is not None:
if key is None:
async.DelayedCall(0, CalvinCB(cb, calvinresponse.CalvinResponse(status=True)))
else:
async.DelayedCall(0, CalvinCB(cb, key, calvinresponse.CalvinResponse(status=True)))
def test_calvin_cb_class():
func = Mock()
cb = CalvinCB(func)
func2 = Mock()
cb2 = CalvinCB(func2)
cb = CalvinCBClass(callbacks={"f": [cb]})
assert "f" in cb.callback_valid_names()
cb.callback_register("f2", cb2)
assert "f2" in cb.callback_valid_names()
cb.callback_unregister(cb2.id)
assert "f2" not in cb.callback_valid_names()
cb._callback_execute("f", 1, 2, a=3)
func.assert_called_with(1, 2, a=3)
def test_kwargs_update():
func = Mock()
cb = CalvinCB(func, 1, b=2)
cb.kwargs_update(c=3)
cb()
func.assert_called_with(1, b=2, c=3)
def test_args_update():
func = Mock()
cb = CalvinCB(func, 1, 2)
cb.args_append(3)
cb()
func.assert_called_with(1, 2, 3)
def test_calvin_cb_class():
func = Mock()
cb = CalvinCB(func)
func2 = Mock()
cb2 = CalvinCB(func2)
cb = CalvinCBClass(callbacks={'f': [cb]})
assert 'f' in cb.callback_valid_names()
cb.callback_register('f2', cb2)
assert 'f2' in cb.callback_valid_names()
cb.callback_unregister(cb2._id)
assert 'f2' not in cb.callback_valid_names()
cb._callback_execute('f', 1, 2, a=3)
func.assert_called_with(1, 2, a=3)
