def __init__(self, cid, master_public_key):
super(SimpleDispersyTestCommunity, self).__init__(cid, master_public_key)
if __debug__: dprint(self._cid.encode("HEX"))
# ensure that two of the hardcoder members (A, B, or C) has been picked
cluster = self.get_meta_message(u"last-1-subjective-sync").destination.cluster
subjective_set = self.get_subjective_set(self._my_member, cluster)
assert subjective_set
assert self._my_member.public_key in subjective_set
def count():
counter = 0
for name, public_key in self.hardcoded_member_public_keys.iteritems():
if public_key in subjective_set:
if __debug__: dprint("hardcoded member ", name, " found in my subjective set")
counter += 1
return counter
# if (1) we are not one of the hardcoded members and (2) we did not yet pick hardcoded
# members for our subjective set
if not self._my_member.public_key in self.hardcoded_member_public_keys.values() and count() < 2:
assert count() == 0
assert len(self.hardcoded_member_public_keys) == 3
keys = self.hardcoded_member_public_keys.values()
shuffle(keys)
self.create_dispersy_subjective_set(cluster, [self._my_member, self.get_member(keys[0]), self.get_member(keys[1])])
subjective_set = self.get_subjective_set(self._my_member, cluster)
assert count() == 2
self._status = get_status_holder("dispersy-simple-dispersy-test")
self._status.add_reporter(TUDelftReporter(REPORTER_NAME, 300, self._my_member.public_key))
self._status.create_and_add_event("__init__^" + self._cid.encode("HEX"), ["last-1-subjective-sync"])
self._status.create_and_add_event("info^" + self._cid.encode("HEX"), [self._dispersy.info()])
self._status.create_and_add_event("subjective_set^" + self._cid.encode("HEX"), [(name, public_key in subjective_set) for name, public_key in self.hardcoded_member_public_keys.iteritems()])
self._status.report_now()
self._dispersy.callback.register(self._periodically_info, delay=60.0)
def _unload_communities(self):
def is_active(community, now):
# check 1: does the community have any active candidates
if community.update_strikes(now) < 3:
return True
# check 2: does the community have any cached messages waiting to be processed
for meta in self._batch_cache.iterkeys():
if meta.community == community:
return True
# the community is inactive
return False
while True:
yield 180.0
now = time()
inactive = [
community for community in self._communities.itervalues()
if not is_active(community, now)
]
dprint("cleaning ", len(inactive), "/", len(self._communities),
" communities")
for community in inactive:
community.unload_community()
def count():
counter = 0
for name, public_key in self.hardcoded_member_public_keys.iteritems():
if public_key in subjective_set:
if __debug__: dprint("hardcoded member ", name, " found in my subjective set")
counter += 1
return counter
def check_full_sync(self, messages):
if __debug__: dprint(self._cid.encode("HEX"))
for message in messages:
if not self._timeline.check(message):
yield DropMessage(message, "TODO: implement delay by proof")
continue
yield message
def check_permissions(self):
"""
One or more dispersy-authorize messages are required to allow my member to create the
messages for the test. If we can not obtain the authorize messages we will create them.
"""
metas = [self._community.get_meta_message(u"last-1-subjective-sync"), self._community.get_meta_message(u"dispersy-destroy-community")]
sync_meta = self._community.get_meta_message(u"dispersy-sync")
wait = 30
for i in xrange(1, wait + 1):
allowed, proofs = self._community._timeline._check(self._community.my_member, self._community.global_time, [(meta, u"permit") for meta in metas])
if allowed:
dprint("my member is allowed to create messages")
break
messages = [sync_meta.implement(sync_meta.authentication.implement(self._community.my_member),
sync_meta.distribution.implement(self._community.global_time),
sync_meta.destination.implement(),
sync_meta.payload.implement(time_low, time_high, bloom_filter))
for time_low, time_high, bloom_filter
in self._community.dispersy_sync_bloom_filters]
self._dispersy.store_update_forward(messages, False, False, True)
dprint("syncing. ", i, "/", wait, "...")
yield 1.0
else:
# Used in the 3.5.8 and 3.5.9 test
#
# dprint("creating authorizations")
# permission_triplets = []
# for message in self._community.get_meta_messages():
# if not isinstance(message.resolution, PublicResolution):
# for allowed in (u"authorize", u"revoke", u"permit"):
# permission_triplets.append((self._community.my_member, message, allowed))
# if permission_triplets:
# self._community.create_dispersy_authorize(permission_triplets, sign_with_master=True)
wait = 30
for i in xrange(1, wait + 1):
dprint("checking for permissions on disk. ", i, "/", wait, "...")
try:
packet = open(expanduser("~/simpledispersytest_permission_packet"), "r").read()
except:
yield 1.0
else:
dprint("use existing permissions from disk")
self._community.dispersy.on_incoming_packets([(("130.161.158.222", 6711), packet)])
break
else:
dprint("creating authorizations")
permission_triplets = []
for message in self._community.get_meta_messages():
if not isinstance(message.resolution, PublicResolution):
for allowed in (u"authorize", u"revoke", u"permit"):
for public_key in self._community.hardcoded_member_public_keys.itervalues():
permission_triplets.append((Member.get_instance(public_key), message, allowed))
if permission_triplets:
message = self._community.create_dispersy_authorize(permission_triplets, sign_with_master=True)
open(expanduser("~/simpledispersytest_permission_packet"), "w+").write(message.packet)
yield 1.0
def check_last_1_subjective_sync(self, messages):
if __debug__: dprint(self._cid.encode("HEX"))
for message in messages:
allowed, proofs = self._timeline.check(message)
if allowed:
yield message
else:
yield DelayMessageByProof(message)
def check_votecast(self, messages):
for message in messages:
if __debug__: dprint(message)
community = self._get_channel_community(message.payload.cid)
if not community._channel_id:
yield DelayMessageReqChannelMessage(message, community, includeSnapshot = message.payload.vote > 0) #request torrents if positive vote
else:
yield message
def __init__(self, rawserver, dispersy, port, ip="0.0.0.0"):
while True:
if __debug__: dprint("Dispersy listening at ", port)
try:
self.socket = rawserver.create_udpsocket(port, ip)
except socket.error, error:
port += 1
continue
break
def warning(self):
"""
BE CAREFULL! WE CAN NOT UNDO THIS!
"""
wait = 60
for i in xrange(1, wait + 1):
dprint("BE CAREFULL! WE CAN NOT UNDO THIS! ", i, "/", wait, "...")
yield 1.0
yield 1.0
def set_online(self):
""" Restore on_incoming_packets and _send functions of
dispersy back to normal.
This simulates a node coming online, since it's able to send
and receive messages.
"""
dprint("Going online")
self._dispersy.on_incoming_packets = self.original_on_incoming_packets
self._dispersy._send = self.original_send
def filter_non_bootstrap_nodes():
for candidate, packet in packets:
cid = packet[2:22]
if not cid in self._communities and candidate.sock_addr[0] in self._non_autoload:
if __debug__: dprint("drop a ", len(packet), " byte packet (received from non-autoload node) from ", candidate, level="warning", force=1)
self._statistics.drop("_convert_packets_into_batch:from bootstrap node for unloaded community", len(packet))
continue
yield candidate, packet
def create_last_1_sync(self, text):
if __debug__: dprint(self._cid.encode("HEX"))
assert isinstance(text, unicode)
meta = self.get_meta_message(u"last-1-sync")
message = meta.implement(meta.authentication.implement(self._my_member),
meta.distribution.implement(self.claim_global_time()),
meta.destination.implement(),
meta.payload.implement(text))
self._dispersy.store_update_forward([message], True, True, True)
return message
def __init__(self, cid, master_public_key):
super(SimpleDispersyTestCommunity, self).__init__(cid, master_public_key)
if __debug__: dprint(self._cid.encode("HEX"))
self._status = get_status_holder("dispersy-simple-dispersy-test")
self._status.add_reporter(TUDelftReporter(REPORTER_NAME, 300, self._my_member.public_key))
self._status.create_and_add_event("__init__^" + self._cid.encode("HEX"), ["full-sync", "last-1-sync"])
self._status.create_and_add_event("info^" + self._cid.encode("HEX"), [self._dispersy.info()])
self._status.report_now()
self._dispersy.callback.register(self._periodically_info, delay=60.0)
def dispersy_cleanup_community(self, message):
if __debug__: dprint(self._cid.encode("HEX"))
self._status.create_and_add_event("dispersy_cleanup_community^" + self._cid.encode("HEX") , [{"is_soft_kill":message.payload.is_soft_kill, "is_hard_kill":message.payload.is_hard_kill}])
self._status.report_now()
self._status.get_reporter(REPORTER_NAME).stop()
self._status.remove_reporter(REPORTER_NAME)
self._status.add_reporter(NullReporter("Periodically remove all events", 60))
# will reclassify to SoftKilledCommunity or HardKilledCommunity
return super(SimpleDispersyTestCommunity, self).dispersy_cleanup_community(message)
def set_offline(self):
""" Replace on_incoming_packets and _sends functions of
dispersy with dummies
This simulates a node going offline, since it's not able to
send or receive any messages
"""
def dummy_function(*params):
return
dprint("Going offline")
self._dispersy.on_incoming_packets = dummy_function
self._dispersy._send = dummy_function
def _get_channel_community(self, cid):
assert isinstance(cid, str)
assert len(cid) == 20
try:
return self._dispersy.get_community(cid, True)
except KeyError:
if self.auto_join_channel:
if __debug__: dprint("join channel community ", cid.encode("HEX"))
return ChannelCommunity.join_community(Member.get_instance(cid, public_key_available=False), self._my_member, self.integrate_with_tribler)
else:
if __debug__: dprint("join preview community ", cid.encode("HEX"))
return PreviewChannelCommunity.join_community(Member.get_instance(cid, public_key_available=False), self._my_member, self.integrate_with_tribler)
def __init__(self, rawserver, dispersy, port, ip="0.0.0.0"):
while True:
try:
self.socket = rawserver.create_udpsocket(port, ip)
if __debug__: dprint("Dispersy listening at ", port, force=True)
except socket.error:
port += 1
continue
break
self.rawserver = rawserver
self.rawserver.start_listening_udp(self.socket, self)
self.dispersy = dispersy
self.sendqueue = []
def on_signature_response(self, message, request, retry):
""" Handle a newly created double signed message or a timeout while signing
When request for signing times out I just return. When I receive the signature for the
message that I created then I send it to myself and then store and forward it to others of
the community
"""
if __debug__: dprint(message)
if message:
assert message.name == u"barter-record"
assert message.authentication.is_signed
if __debug__: dprint(message)
# store, update, and forward to the community
self._dispersy.store_update_forward([message], True, True, self.barter_forward_record_on_creation)
log("dispersy.log", "created-barter-record") # TODO: maybe move to barter.log
elif retry < 5:
# signature timeout
# retry
if __debug__:
log("barter.log", "barter-community-signature-request-timeout", retry=retry)
dprint("Signature request timeout. Retry!")
self.create_dispersy_signature_request(request, self.on_signature_response, (request, retry + 1))
else:
# close the transfer
if __debug__:
log("barter.log", "barter-community-signature-request-timeout", retry=retry)
dprint("Signature request timeout")
def allow_signature_request(self, message):
""" Decide whether to reply or not to a signature request
Currently I always sign for testing proposes
"""
assert message.name == u"barter-record"
assert not message.authentication.is_signed
if __debug__: dprint(message)
is_signed, other_member = message.authentication.signed_members[0]
if other_member == self._my_member:
if __debug__: dprint("refuse signature: we should be the first signer", level="warning")
return False
if not is_signed:
if __debug__: dprint("refuse signature: the other member did not sign it", level="warning")
return False
my_member = message.authentication.members[1]
if not my_member == self._my_member:
if __debug__: dprint("refuse signature: we should be the second signer")
return False
# todo: decide if we want to use add our signature to this # record
if True:
# recalculate the limits of what we want to upload to member.authentication.members[0]
return True
# we will not add our signature
return False
def create_message_batch(self):
"""
We will create 1000 last-1-sync messages.
"""
meta = self._community.get_meta_message(u"full-sync")
total = 1000
for i in xrange(1, total + 1):
# create a new full-sync message every hour
count, = self._dispersy_database.execute(u"SELECT COUNT(1) FROM sync WHERE community = ? AND user = ? AND name = ?",
(self._community.database_id, self._community.my_member.database_id, meta.database_id)).next()
dprint("there are ", count, " ", meta.name, " messages in our database")
self._community.create_full_sync(u"full-sync; why:batch; start:%f; at:%f; nr:%d" % (self._start_time, time(), count + 1))
yield 0.1
yield 1.0
def on_barter_record(self, messages):
""" I handle received barter records
I create or update a row in my database
"""
if __debug__: dprint("storing ", len(messages), " records")
with self._database as execute:
for message in messages:
if __debug__: log("dispersy.log", "handled-barter-record") # TODO: maybe move to barter.log
# check if there is already a record about this pair
try:
first_member, second_member, global_time = \
execute(u"SELECT first_member, second_member, global_time FROM \
record WHERE (first_member = ? AND second_member = ?) OR \
(first_member = ? AND second_member = ?)",
(message.authentication.members[0].database_id,
message.authentication.members[1].database_id,
message.authentication.members[1].database_id,
message.authentication.members[0].database_id)).next()
except StopIteration:
global_time = -1
first_member = message.authentication.members[0].database_id
second_member = message.authentication.members[1].database_id
if global_time >= message.distribution.global_time:
# ignore the message
if __debug__:
dprint("Ignoring older message")
else:
self._database.execute(u"INSERT OR REPLACE INTO \
record(community, global_time, first_member, second_member, \
upload_first_member, upload_second_member) \
VALUES(?, ?, ?, ?, ?, ?)",
(self._database_id,
message.distribution.global_time,
first_member,
second_member,
message.payload.first_upload,
message.payload.second_upload))
if __debug__:
peer1_id = self._peer_ids.get(message.authentication.members[0].public_key, -1)
peer2_id = self._peer_ids.get(message.authentication.members[1].public_key, -1)
peer1_upload = message.payload.first_upload
peer2_upload = message.payload.second_upload
if peer1_id > peer2_id:
peer1_id, peer2_id = peer2_id, peer1_id
peer1_upload, peer2_upload = peer2_upload, peer1_upload
log("barter.log", "barter-record", first=peer1_id, second=peer2_id, first_upload=peer1_upload, second_upload=peer2_upload)
def __init__(self, cid, master_public_key):
super(GossipLearningCommunity, self).__init__(cid, master_public_key, INITIALDELAY)
if __debug__: dprint('gossiplearningcommunity' + self._cid.encode("HEX"))
# Stats
self._msg_count = 0
# They should be loaded from a database.
# x and y are stored only locally
self._x = None
self._y = None
# Initial model
self._model = AdalinePerceptronModel()
self._model2 = LogisticRegressionModel()
def on_votecast(self, messages):
if self.integrate_with_tribler:
for message in messages:
if __debug__: dprint(message)
dispersy_id = message.packet_id
authentication_member = message.authentication.member
if authentication_member == self._my_member:
peer_id = None
else:
peer_id = self._peer_db.addOrGetPeerID(authentication_member.public_key)
community = self._get_channel_community(message.payload.cid)
self._votecast_db.on_vote_from_dispersy(community._channel_id, peer_id, dispersy_id, message.payload.vote, message.payload.timestamp)
if DEBUG:
print >> sys.stderr, "AllChannelCommunity: got votecast message"
def sync(self):
"""
Perform a few sync cycles, if we end up creating new identity messages this will increase
the chance that they will not clash.
"""
sync_meta = self._community.get_meta_message(u"dispersy-sync")
wait = 10
for i in xrange(1, wait + 1):
messages = [sync_meta.implement(sync_meta.authentication.implement(self._community.my_member),
sync_meta.distribution.implement(self._community.global_time),
sync_meta.destination.implement(),
sync_meta.payload.implement(time_low, time_high, bloom_filter))
for time_low, time_high, bloom_filter
in self._community.dispersy_sync_bloom_filters]
self._dispersy.store_update_forward(messages, False, False, True)
dprint("syncing. ", i, "/", wait, "...")
yield 1.0
yield 1.0
def setup(self):
"""
We either need to join the community or semi-create one.
"""
# we will use the below member identifier to create messages for our test. the private key
# can be found on disk, but will not be submitted to SVN for obvious reasons
assert "hardcoded_member" in self._kargs, ("give --script-args hardcoded_member=A|B|C", self._kargs)
assert self._kargs["hardcoded_member"] in SimpleDispersyTestCommunity.hardcoded_member_public_keys, "give --script-args hardcoded_member=A|B|C"
member_name = self._kargs["hardcoded_member"]
hardcoded_public_key = SimpleDispersyTestCommunity.hardcoded_member_public_keys[member_name]
hardcoded_mid = sha1(hardcoded_public_key).digest()
try:
dprint("load_hardcoded_community")
self._community = SimpleDispersyTestCommunity.load_hardcoded_community()
except ValueError, e:
dprint("failed to load; joining instead [", e, "]")
# COPIED FROM dispersy/community.py:create_community. IF ANYTHING CHANGES THERE IT
# NEEDS TO BE REFLECTED HERE ASWELL
# obtain the hardcoded_private_key for my_member from disk
pem = open(expanduser("~/simpledispersytest_ec_private_key_%s" % member_name), "r").read()
ec = ec_from_private_pem(pem)
private_key = ec_to_private_bin(ec)
my_member = MyMember(hardcoded_public_key, private_key)
# obtain the master_private_key for the master_member from disk
pem = open(expanduser("~/simpledispersytest_ec_master_private_key"), "r").read()
ec = ec_from_private_pem(pem)
master_private_key = ec_to_private_bin(ec)
# insert entries in the dispersy database to join the community
with self._dispersy_database as database:
database.execute(u"INSERT INTO community (user, classification, cid, public_key) VALUES(?, ?, ?, ?)", (my_member.database_id, SimpleDispersyTestCommunity.get_classification(), buffer(SimpleDispersyTestCommunity.hardcoded_cid), buffer(SimpleDispersyTestCommunity.hardcoded_master_public_key)))
database_id = self._dispersy_database.last_insert_rowid
database.execute(u"INSERT INTO user (mid, public_key) VALUES(?, ?)", (buffer(SimpleDispersyTestCommunity.hardcoded_cid), buffer(SimpleDispersyTestCommunity.hardcoded_master_public_key)))
database.execute(u"INSERT INTO key (public_key, private_key) VALUES(?, ?)", (buffer(SimpleDispersyTestCommunity.hardcoded_master_public_key), buffer(master_private_key)))
database.execute(u"INSERT INTO candidate (community, host, port, incoming_time, outgoing_time) SELECT ?, host, port, incoming_time, outgoing_time FROM candidate WHERE community = 0", (database_id,))
self._community = SimpleDispersyTestCommunity.load_community(SimpleDispersyTestCommunity.hardcoded_cid, SimpleDispersyTestCommunity.hardcoded_master_public_key)
def create_messages(self):
"""
We will create a new last-1-sync message every 3 minutes and a new full-sync message every
20 last-1-sync messages.
"""
while True:
# create a new full-sync message every hour
meta = self._community.get_meta_message(u"full-sync")
count, = self._dispersy_database.execute(u"SELECT COUNT(1) FROM sync WHERE community = ? AND user = ? AND name = ?",
(self._community.database_id, self._community.my_member.database_id, meta.database_id)).next()
dprint("there are ", count, " ", meta.name, " messages in our database")
self._community.create_full_sync(u"full-sync; why:periodic; start:%f; at:%f; nr:%d" % (self._start_time, time(), count + 1))
# create a new last-1-sync message every 60 seconds
for i in xrange(20):
self._community.create_last_1_sync(u"last-1-sync; start:%f; at:%f" % (self._start_time, time()))
yield 60.0 * 3
yield 1.0
def filter_non_bootstrap_nodes():
for candidate, packet in packets:
cid = packet[2:22]
if not cid in self._communities and candidate.sock_addr[
0] in self._non_autoload:
if __debug__:
dprint(
"drop a ",
len(packet),
" byte packet (received from non-autoload node) from ",
candidate,
level="warning",
force=1)
self._statistics.drop(
"_convert_packets_into_batch:from bootstrap node for unloaded community",
len(packet))
continue
yield candidate, packet
def _unload_communities(self):
def is_active(community, now):
# check 1: does the community have any active candidates
if community.update_strikes(now) < 3:
return True
# check 2: does the community have any cached messages waiting to be processed
for meta in self._batch_cache.iterkeys():
if meta.community == community:
return True
# the community is inactive
return False
while True:
yield 180.0
now = time()
inactive = [community for community in self._communities.itervalues() if not is_active(community, now)]
dprint("cleaning ", len(inactive), "/", len(self._communities), " communities")
for community in inactive:
community.unload_community()
def check_permissions(self):
"""
One or more dispersy-authorize messages are required to allow my member to create the
messages for the test. If we can not obtain the authorize messages we will create them.
"""
metas = [self._community.get_meta_message(u"full-sync"), self._community.get_meta_message(u"last-1-sync"), self._community.get_meta_message(u"dispersy-destroy-community")]
sync_meta = self._community.get_meta_message(u"dispersy-sync")
wait = 30
for i in xrange(1, wait + 1):
if self._community._timeline._check(self._community.my_member, self._community.global_time, [(meta, u"permit") for meta in metas]):
dprint("my member is allowed to create messages")
break
messages = [sync_meta.implement(sync_meta.authentication.implement(self._community.my_member),
sync_meta.distribution.implement(self._community.global_time),
sync_meta.destination.implement(),
sync_meta.payload.implement(time_low, time_high, bloom_filter))
for time_low, time_high, bloom_filter
in self._community.dispersy_sync_bloom_filters]
self._dispersy.store_update_forward(messages, False, False, True)
dprint("syncing. ", i, "/", wait, "...")
yield 1.0
else:
dprint("creating authorizations")
permission_triplets = []
for message in self._community.get_meta_messages():
if not isinstance(message.resolution, PublicResolution):
for allowed in (u"authorize", u"revoke", u"permit"):
permission_triplets.append((self._community.my_member, message, allowed))
if permission_triplets:
self._community.create_dispersy_authorize(permission_triplets, sign_with_master=True)
yield 1.0
def check_my_member_identity(self):
"""
The dispersy-identity message for my member may already exist. If we can't find it, we can
create it.
"""
meta = self._community.get_meta_message(u"dispersy-identity")
wait = 30
for i in xrange(1, wait + 1):
try:
self._dispersy_database.execute(u"SELECT id FROM sync WHERE community = ? AND user = ? AND name = ?",
(self._community.database_id, self._community.my_member.database_id, meta.database_id)).next()
except StopIteration:
pass
else:
dprint("dispersy-identity for my member is available")
break
dprint("requesting dispersy-identity for my member. ", i, "/", wait, "...")
addresses = [candidate.address for candidate in self._dispersy.yield_mixed_candidates(self._community, 10)]
self._dispersy.create_identity_request(self._community, self._community.my_member.mid, addresses)
yield 1.0
else:
dprint("creating first (or new) dispersy-identity for my member")
self._community.create_dispersy_identity()
yield 1.0
def check_master_identity(self):
"""
The dispersy-identity message for the master member may already exist. If we can't find it,
we can create it.
"""
meta = self._community.get_meta_message(u"dispersy-identity")
wait = 30
for i in xrange(1, wait + 1):
try:
self._dispersy_database.execute(u"SELECT id FROM sync WHERE community = ? AND user = ? AND name = ?",
(self._community.database_id, self._community.master_member.database_id, meta.database_id)).next()
except StopIteration:
pass
else:
dprint("dispersy-identity for the master member is available")
break
dprint("requesting dispersy-identity for the master member. ", i, "/", wait, "...")
addresses = [candidate.address for candidate in self._dispersy.yield_mixed_candidates(self._community, 10)]
self._dispersy.create_identity_request(self._community, self._community.master_member.mid, addresses)
yield 1.0
else:
dprint("creating first (or new) dispersy-identity for the master member")
message = meta.implement(meta.authentication.implement(self._community.master_member),
meta.distribution.implement(self._community.claim_global_time()),
meta.destination.implement(),
meta.payload.implement(("0.0.0.0", 0)))
self._community.dispersy.store_update_forward([message], True, False, True)
yield 1.0
def setup(self):
"""
We either need to join the community or semi-create one.
"""
# we will use the below member identifier to create messages for our test. the private key
# can be found on disk, but will not be submitted to SVN for obvious reasons
hardcoded_mid = "6bc9e18b346d9f879a90bbf51a495f3cb8b32957".decode("HEX")
hardcoded_public_key = "3052301006072a8648ce3d020106052b8104001a033e000400d1f668eb495c76f6a899a46017e8c6ad57c90e85d84fa1524fe7a0e76f0183a3d290a63e80ae14060acc1d1e606f451811bab3f77c8dd318689695".decode("HEX")
try:
dprint("load_hardcoded_community")
self._community = SimpleDispersyTestCommunity.load_hardcoded_community()
except ValueError, e:
dprint("failed to load; joining instead [", e, "]")
# COPIED FROM dispersy/community.py:create_community. IF ANYTHING CHANGES THERE IT
# NEEDS TO BE REFLECTED HERE ASWELL
# obtain the hardcoded_private_key for my_member from disk
pem = open(expanduser("~/simpledispersytest_ec_private_key"), "r").read()
ec = ec_from_private_pem(pem)
private_key = ec_to_private_bin(ec)
my_member = MyMember(hardcoded_public_key, private_key)
# obtain the master_private_key for the master_member from disk
pem = open(expanduser("~/simpledispersytest_ec_master_private_key"), "r").read()
ec = ec_from_private_pem(pem)
master_private_key = ec_to_private_bin(ec)
# insert entries in the dispersy database to join the community
with self._dispersy_database as execute:
execute(u"INSERT INTO community (user, classification, cid, public_key) VALUES(?, ?, ?, ?)", (my_member.database_id, SimpleDispersyTestCommunity.get_classification(), buffer(SimpleDispersyTestCommunity.hardcoded_cid), buffer(SimpleDispersyTestCommunity.hardcoded_master_public_key)))
database_id = self._dispersy_database.last_insert_rowid
execute(u"INSERT INTO user (mid, public_key) VALUES(?, ?)", (buffer(SimpleDispersyTestCommunity.hardcoded_cid), buffer(SimpleDispersyTestCommunity.hardcoded_master_public_key)))
execute(u"INSERT INTO key (public_key, private_key) VALUES(?, ?)", (buffer(SimpleDispersyTestCommunity.hardcoded_master_public_key), buffer(master_private_key)))
execute(u"INSERT INTO candidate (community, host, port, incoming_time, outgoing_time) SELECT ?, host, port, incoming_time, outgoing_time FROM candidate WHERE community = 0", (database_id,))
self._community = SimpleDispersyTestCommunity.load_community(SimpleDispersyTestCommunity.hardcoded_cid, SimpleDispersyTestCommunity.hardcoded_master_public_key)
