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 test_create_barter_record(self):
"""
1. Create a single signed barter record
2. Send signature request from SELF to NODE
3. Add signature and send barter record from NODE to SELF
4. Check database for the new record
"""
community = BarterCommunity.create_community(self._my_member)
address = self._dispersy.socket.get_address()
# create node and ensure that SELF knows the node address
node = BarterNode()
node.init_socket()
node.set_community(community)
node.init_my_member()
yield 0.11
assert self.is_database_empty(community), "Database should be empty (for this community id)"
# send single signed barter record
message = community.create_barter_record(Member.get_instance(node.my_member.public_key), 10, 2)
yield 0.11
# receive signature request
_, message = node.receive_message(addresses=[address], message_names=[u"dispersy-signature-request"])
assert message.payload.message.name == u"barter-record"
assert message.payload.message.authentication.members[0].public_key == community.my_member.public_key
assert message.payload.message.authentication.members[1].public_key == node.my_member.public_key
assert message.payload.message.authentication.signed_members[0][0]
assert not message.payload.message.authentication.is_signed
assert not message.payload.message.authentication.signed_members[1][0]
assert message.payload.message.payload.first_upload == 10
assert message.payload.message.payload.second_upload == 2
# create signature and send data back
message = message.payload.message
first_signature_offset = len(message.packet) - sum(member.signature_length for member in message.authentication.members)
signature = node.my_member.sign(message.packet, length=first_signature_offset)
message.authentication.set_signature(Member.get_instance(node.my_member.public_key), signature)
node.send_message(message, address)
yield 0.11
try:
community._database.execute(u"SELECT 1 FROM record WHERE community = ? AND global_time = ? AND first_member = ? AND second_member = ? AND upload_first_member = ? AND upload_second_member = ?",
(community.database_id, message.distribution.global_time, node.my_member.database_id, community._my_member.database_id, 10, 2)).next()
except StopIteration:
assert False
# cleanup
community.create_dispersy_destroy_community(u"hard-kill")
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 _decode_comment(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "text" in dic:
raise DropPacket("Missing 'text'")
text = dic["text"]
if not (isinstance(text, unicode) and len(text) < 1024):
raise DropPacket("Invalid 'text' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
reply_to_mid = dic.get("reply-to-mid", None)
if reply_to_mid and not (isinstance(reply_to_mid, str) and len(reply_to_mid) == 20):
raise DropPacket("Invalid 'reply-to-mid' type or value")
reply_to_global_time = dic.get("reply-to-global-time", None)
if reply_to_global_time and not isinstance(reply_to_global_time, (int, long)):
raise DropPacket("Invalid 'reply-to-global-time' type")
reply_after_mid = dic.get("reply-after-mid", None)
if reply_after_mid and not (isinstance(reply_after_mid, str) and len(reply_after_mid) == 20):
raise DropPacket("Invalid 'reply-after-mid' type or value")
reply_after_global_time = dic.get("reply-after-global-time", None)
if reply_after_global_time and not isinstance(reply_after_global_time, (int, long)):
raise DropPacket("Invalid 'reply-after-global-time' type")
playlist_mid = dic.get("playlist-mid", None)
if playlist_mid and not (isinstance(playlist_mid, str) and len(playlist_mid) == 20):
raise DropPacket("Invalid 'playlist-mid' type or value")
playlist_global_time = dic.get("playlist-global-time", None)
if playlist_global_time and not isinstance(playlist_global_time, (int, long)):
raise DropPacket("Invalid 'playlist-global-time' type")
if playlist_mid and playlist_global_time:
try:
packet_id, packet, message_name = self._get_message(playlist_global_time, playlist_mid)
playlist = Packet(self._community.get_meta_message(message_name), packet, packet_id)
except DropPacket:
member = Member.get_instance(playlist_mid, public_key_available=False)
raise DelayPacketByMissingMessage(self._community, member, [playlist_global_time])
else:
playlist = None
infohash = dic.get("infohash", None)
if infohash and not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
return offset, placeholder.meta.payload.implement(text, timestamp, reply_to_mid, reply_to_global_time, reply_after_mid, reply_after_global_time, playlist, infohash)
def get_or_create_community(self):
if self._community is None:
master_public_key = "3081a7301006072a8648ce3d020106052b810400270381920004008be5c9f62d949787a3470e3ed610c30eab479ae3f4e97af987ea2c25f68a23ff3754d0e59f22839444479e6d0e4db9e8e46752d067b0764388a6a174511950fb66655a65f819fc065de7c383477a1c2fecdad0d18e529b1ae003a4c6c7abf899bd301da7689dd76ce248042477c441be06e236879af834f1def7c7d9848d34711bf1d1436acf00239f1652ecc7d1cb".decode("HEX")
if False:
# when crypto.py is disabled a public key is slightly
# different...
master_public_key = ";".join(("60", master_public_key[:60].encode("HEX"), ""))
master = Member.get_instance(master_public_key)
self._community = WalktestCommunity.join_community(master, self._my_member)
return self._community
def _decode_playlist_torrent(self, placeholder, offset, data):
if len(data) < offset + 48:
raise DropPacket("Unable to decode the payload")
infohash, playlist_mid, playlist_global_time = unpack_from('!20s20sQ', data, offset)
try:
packet_id, packet, message_name = self._get_message(playlist_global_time, playlist_mid)
except DropPacket:
member = Member.get_instance(playlist_mid, public_key_available=False)
raise DelayPacketByMissingMessage(self._community, member, [playlist_global_time])
playlist = Packet(self._community.get_meta_message(message_name), packet, packet_id)
return offset + 48, placeholder.meta.payload.implement(infohash, playlist)
def __init__(self, callback, statedir, port):
assert isinstance(port, int)
assert 0 <= port
super(TrackerDispersy, self).__init__(callback, statedir)
# logger
overlaylogpostfix = "dp" + str(port) + ".log"
self._logger = OverlayLogger.getInstance(overlaylogpostfix, statedir)
# generate a new my-member
ec = ec_generate_key(u"very-low")
self._my_member = Member.get_instance(ec_to_public_bin(ec), ec_to_private_bin(ec))
callback.register(self._unload_communities, priority=-128)
def get_master_members(cls):
# generated: Fri Nov 25 10:51:27 2011
# curve: high <<< NID_sect571r1 >>>
# len: 571 bits ~ 144 bytes signature
# pub: 170 3081a7301006072a8648ce3d020106052b81040027038192000405548a13626683d4788ab19393fa15c9e9d6f5ce0ff47737747fa511af6c4e956f523dc3d1ae8d7b83b850f21ab157dd4320331e2f136aa01e70d8c96df665acd653725e767da9b5079f25cebea808832cd16015815797906e90753d135ed2d796b9dfbafaf1eae2ebea3b8846716c15814e96b93ae0f5ffaec44129688a38ea35f879205fdbe117323e73076561f112
# pub-sha1 8164f55c2f828738fa779570e4605a81fec95c9d
# -----BEGIN PUBLIC KEY-----
# MIGnMBAGByqGSM49AgEGBSuBBAAnA4GSAAQFVIoTYmaD1HiKsZOT+hXJ6db1zg/0
# dzd0f6URr2xOlW9SPcPRro17g7hQ8hqxV91DIDMeLxNqoB5w2Mlt9mWs1lNyXnZ9
# qbUHnyXOvqgIgyzRYBWBV5eQbpB1PRNe0teWud+6+vHq4uvqO4hGcWwVgU6WuTrg
# 9f+uxEEpaIo46jX4eSBf2+EXMj5zB2Vh8RI=
# -----END PUBLIC KEY-----
master_key = "3081a7301006072a8648ce3d020106052b81040027038192000405548a13626683d4788ab19393fa15c9e9d6f5ce0ff47737747fa511af6c4e956f523dc3d1ae8d7b83b850f21ab157dd4320331e2f136aa01e70d8c96df665acd653725e767da9b5079f25cebea808832cd16015815797906e90753d135ed2d796b9dfbafaf1eae2ebea3b8846716c15814e96b93ae0f5ffaec44129688a38ea35f879205fdbe117323e73076561f112".decode("HEX")
master = Member.get_instance(master_key)
return [master]
def _decode_moderation(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "text" in dic:
raise DropPacket("Missing 'text'")
text = dic["text"]
if not (isinstance(text, unicode) and len(text) < 1024):
raise DropPacket("Invalid 'text' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
if not "severity" in dic:
raise DropPacket("Missing 'severity'")
severity = dic["severity"]
if not isinstance(severity, (int, long)):
raise DropPacket("Invalid 'severity' type or value")
cause_mid = dic.get("cause-mid", None)
if not (isinstance(cause_mid, str) and len(cause_mid) == 20):
raise DropPacket("Invalid 'cause-mid' type or value")
cause_global_time = dic.get("cause-global-time", None)
if not isinstance(cause_global_time, (int, long)):
raise DropPacket("Invalid 'cause-global-time' type")
try:
packet_id, packet, message_name = self._get_message(cause_global_time, cause_mid)
cause_packet = Packet(self._community.get_meta_message(message_name), packet, packet_id)
except DropPacket:
member = Member.get_instance(cause_mid, public_key_available=False)
raise DelayPacketByMissingMessage(self._community, member, [cause_global_time])
return offset, placeholder.meta.payload.implement(text, timestamp, severity, cause_packet)
def __init__(self, callback, statedir, port):
assert isinstance(port, int)
assert 0 <= port
super(TrackerDispersy, self).__init__(callback, statedir)
# non-autoload nodes
self._non_autoload = set()
self._non_autoload.update(host for host, _ in self._bootstrap_candidates.iterkeys())
# leaseweb machines, some are running boosters, they never unload a community
self._non_autoload.update(["95.211.105.65", "95.211.105.67", "95.211.105.69", "95.211.105.71", "95.211.105.73", "95.211.105.75", "95.211.105.77", "95.211.105.79", "95.211.105.81", "85.17.81.36"])
# logger
overlaylogpostfix = "dp" + str(port) + ".log"
self._logger = OverlayLogger.getInstance(overlaylogpostfix, statedir)
self._candidates_status = {}
callback.register(self._candidate_logger, priority=-128)
# generate a new my-member
ec = ec_generate_key(u"very-low")
self._my_member = Member.get_instance(ec_to_public_bin(ec), ec_to_private_bin(ec))
callback.register(self._unload_communities, priority=-128)
def run(self):
ec = ec_generate_key(u"low")
self._my_member = Member.get_instance(ec_to_public_bin(ec), ec_to_private_bin(ec), sync_with_database=True)
self.caller(self.test_incoming_channel)
self.caller(self.test_outgoing_channel)
def run(self):
ec = ec_generate_key(u"low")
self._my_member = Member.get_instance(ec_to_public_bin(ec), ec_to_private_bin(ec))
self._community = None
self.caller(self.scenario)
def get_community(self, cid, load=False, auto_load=True):
try:
return super(TrackerDispersy, self).get_community(cid, True, True)
except KeyError:
self._communities[cid] = TrackerCommunity.join_community(Member.get_instance(cid, public_key_available=False), self._my_member)
return self._communities[cid]