def test_link_request_cold_cache(self, monkeypatch):
yield self._create_servers(2)
# Connect
cb, d = create_callback()
net1_port = self._get_port(1)
node_id = self._get_node_id(1)
self._get_network(0).link_request(node_id, callback=cb)
b = yield d
print b
assert b[1]['status']
self._get_network(0).link_get(b[0][0]).close()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 1
# reason OK
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "OK"
# All done, just a get from cache
cb, d = create_callback()
self._get_network(0).link_request(node_id, callback=cb)
b = yield d
print b
assert b[1]['status']
assert self._get_network(0).link_get(b[0][0])
self._get_network(0).link_get(b[0][0]).close()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 2
# reason OK
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "OK"
yield self._stop_servers()
def test_link_request_one_fail(self, monkeypatch):
yield self._create_servers(2, extra_uris=['calvinip://127.0.0.1:12345'])
# Connect
cb, d = create_callback()
net1_port = self._get_port(1)
node_id = self._get_node_id(1)
cb2, d2 = create_callback()
self._get_network(0).link_request(node_id, callback=cb)
self._get_network(0).link_request(node_id, callback=cb2)
b = yield d
print b[1]
assert b[1]['status']
b2 = yield d2
print b2[1]
assert b2[1]['status']
assert self._get_network(0).link_get(b[0][0])
self._get_network(0).link_get(b[0][0]).close()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 1
# reason OK
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "OK"
yield self._stop_servers()
def _create_servers(self, count, extra_uris=None):
#import logging
#calvinlogger.get_logger().setLevel(logging.DEBUG)
#calvinlogger.get_logger().setLevel(1)
if hasattr(self, '_networks') and self._networks:
raise Exception("Trying to create multiple times without stop!")
if not extra_uris:
extra_uris = []
self._networks = []
self._ports = []
_conf.set('global', 'storage_type', 'test_local')
#_conf.set('global', 'storage_proxy', 'local')
global_storage = storage_factory.get("test_local", None)
for a in range(count):
node1 = create_node(global_storage)
network1 = CalvinNetwork(node1)
cb, d = create_callback()
node1.storage.start(cb=cb)
res = yield d
assert res[0][0]
for fname in ['_join_finished', '_join_failed', '_server_started', '_server_stopped', '_recv_handler', '_peer_connection_failed', '_peer_disconnected']:
_o = getattr(network1, fname)
setattr(network1, fname, snoop_f(_o))
assert network1._server_started.call_count == 0
network1.register(['calvinip'], ['json'])
network1.start_listeners()
# Wait for everything to settle
start = network1._server_started.side_effect_ds[-1]
yield start
#yield threads.deferToThread(time.sleep, .05)
assert network1._server_started.call_count == 1
# get listening ports
net1_port = network1._server_started.call_args[0][1]
node1._set_uris(node1, extra_uris + ["calvinip://127.0.0.1:%s" % net1_port], -1)
cb, d = create_callback()
node1.storage.add_node(node1, cb=CalvinCB(cb))
res = yield d
assert res[1]['value']
self._networks.append(network1)
self._ports.append(net1_port)
def test_link_request_cache_old_dual(self, monkeypatch):
yield self._create_servers(2)
# Connect
cb, d = create_callback()
net1_port = self._get_port(1)
node_id = self._get_node_id(1)
self._get_network(0).link_request(node_id, callback=cb)
b = yield d
print b
assert b[1]['status']
assert self._get_network(0).link_get(b[0][0])
self._get_network(0).link_get(b[0][0]).close()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 1
# reason OK
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "OK"
cb, d = create_callback()
cb2, d2 = create_callback()
# may fail if someone is listening :)
self._get_network(0)._peer_cache[b[0][0]]['uris'] = ['calvinip://127.0.0.1:12345']
self._get_network(0)._peer_cache[b[0][0]]['timestamp'] = time.time() - 30*60
self._get_network(0).link_request(node_id, callback=cb)
self._get_network(0).link_request(node_id, callback=cb2)
b = yield d
print b
assert b[1]['status']
b = yield d2
print b
assert b[1]['status']
assert self._get_network(0).link_get(b[0][0])
self._get_network(0).link_get(b[0][0]).close()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 2
# reason OK
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "OK"
yield self._stop_servers()
def test_link_request_cache_fail_multiple(self, monkeypatch):
yield self._create_servers(2)
# Connect
cb, d = create_callback()
net1_port = self._get_port(1)
node_id = self._get_node_id(1)
self._get_network(0).link_request(node_id, callback=cb)
b = yield d
print b
assert b[1]['status']
assert self._get_network(0).link_get(b[0][0])
self._get_network(0).link_get(b[0][0]).close()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 1
# reason OK
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "OK"
assert self._get_network(0)._peer_disconnected.call_count == 1
# reason OK
assert self._get_network(0)._peer_disconnected.call_args[0][2] == "OK"
cb, d = create_callback()
cb2, d2 = create_callback()
# may fail if someone is listening :)
self._get_network(0)._peer_cache[b[0][0]]['uris'] = ['calvinip://127.0.0.1:12345',
'calvinip://127.0.0.1:12346',
'calvinip://127.0.0.1:12347']
self._get_network(0).link_request(node_id, callback=cb)
self._get_network(0).link_request(node_id, callback=cb2)
# Should fail cache is new but addr is wrong
b = yield d
print b
assert not b[1]['status']
b = yield d2
print b
assert not b[1]['status']
yield self._stop_servers()
def test_connect_failed(self, monkeypatch):
yield self._create_servers(2)
cb, d = create_callback()
#network1.join(["calvinip://127.0.0.1:%s" % net2_port], cb)
self._get_network(0).join(["calvinip://127.0.0.1:12345"], cb)
b = yield d
print b[1]
assert not b[1]['status']
yield self._stop_servers()
def test_connect(self, monkeypatch):
yield self._create_servers(2)
# Connect
cb, d = create_callback()
net1_port = self._get_port(1)
self._get_network(0).join(["calvinip://127.0.0.1:%s" % net1_port], cb)
b = yield d
print b[1]
assert b[1]['status']
yield self._stop_servers()
def prep_node(stype, n):
n.storage = storage.Storage(n)
if stype == "proxy":
try:
n.network = DummyNetwork(n)
n.proto = DummyProto(n)
except:
traceback.print_exc()
if stype != "notstarted" :
cb, d = create_callback(timeout=10, test_part=stype + " start")
n.storage.start(cb=cb)
return d
def prep_node(stype, n):
n.storage = storage.Storage(n)
if stype == "proxy":
try:
n.network = DummyNetwork(n)
n.proto = DummyProto(n)
except:
traceback.print_exc()
if stype != "notstarted":
cb, d = create_callback(timeout=10, test_part=stype + " start")
n.storage.start(cb=cb)
return d
def test_late_start(self):
self.q = Queue.Queue()
self.q2 = Queue.Queue()
def cb(key, value):
self.q2.put({"key": key, "value": value})
def started_cb(started):
self.q.put(started)
cb, d = create_callback()
self.storage = storage.Storage(DummyNode())
self.storage.start('', cb)
self.storage2 = storage.Storage(DummyNode())
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
cb2, d = create_callback()
self.storage2.start('', cb2)
value = yield d
# print value[0][0]
assert value[0][0]
yield wait_for(self.storage.localstore.keys,
condition=lambda x: not x())
assert not self.storage.localstore.keys()
cb, d = create_callback()
self.storage.get("test", "3", cb)
a, kw = yield d
assert a[0] == "3" and a[1] == 3
self.storage.stop()
self.storage2.stop()
def test_late_start(self):
self.q = Queue.Queue()
self.q2 = Queue.Queue()
def cb(key, value):
self.q2.put({"key": key, "value": value})
def started_cb(started):
self.q.put(started)
cb, d = create_callback(timeout=2)
self.storage = storage.Storage(DummyNode())
self.storage.start('', cb)
self.storage2 = storage.Storage(DummyNode())
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
cb2, d = create_callback(timeout=2)
self.storage2.start('', cb2)
value = yield d
# print value
assert value[0][0]
yield wait_for(self.storage.localstore.keys, condition=lambda x: not x())
assert not self.storage.localstore.keys()
cb, d = create_callback()
self.storage.get("test", "3", cb)
a, kw = yield d
assert a[0] == "3" and a[1] == 3
self.storage.stop()
self.storage2.stop()
def teardown():
print "#####TEARDOWN"
all_stopped = []
for ntypes in nodes.values():
for n in ntypes:
cb, d = create_callback(timeout=10)
n.storage.stop(cb=cb)
all_stopped.append(d)
dl = defer.DeferredList(all_stopped)
try:
pytest.blockon(dl)
except:
print "### Some storage plugins might have failed to stopp ###"
traceback.print_exc()
def teardown():
print "#####TEARDOWN"
all_stopped = []
for ntypes in nodes.values():
for n in ntypes:
cb, d = create_callback(timeout=10)
n.storage.stop(cb=cb)
all_stopped.append(d)
dl = defer.DeferredList(all_stopped)
try:
pytest.blockon(dl)
except:
print "### Some storage plugins might have failed to stopp ###"
traceback.print_exc()
def test_connect_disconnect_bad(self, monkeypatch):
yield self._create_servers(2)
# Connect
cb, d = create_callback()
net1_port = self._get_port(1)
self._get_network(0).join(["calvinip://127.0.0.1:%s" % net1_port], cb)
b = yield d
print b[1]
assert b[1]['status']
self._get_network(0).link_get(b[1]['peer_node_id']).transport._transport._proto.transport.abortConnection()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 1
# reason ERROR
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "ERROR"
yield self._stop_servers()
def test_link_request(self, monkeypatch):
#import sys
#from twisted.python import log
#log.startLogging(sys.stdout)
#defer.setDebugging(True)
yield self._create_servers(2)
# Connect
cb, d = create_callback()
net1_port = self._get_port(1)
node_id = self._get_node_id(1)
self._get_network(0).link_request(node_id, callback=cb)
b = yield d
assert b[1]['status']
assert self._get_network(0).link_get(b[0][0])
self._get_network(0).link_get(b[0][0]).close()
disconnect = self._get_network(1)._peer_disconnected.side_effect_ds[0]
yield disconnect
assert self._get_network(1)._peer_disconnected.call_count == 1
# reason OK
assert self._get_network(1)._peer_disconnected.call_args[0][2] == "OK"
yield self._stop_servers()
