def _encode_moderation(self, message):
dict = {"text":message.payload.text,
"timestamp":message.payload.timestamp,
"severity":message.payload.severity}
dict["cause-mid"] = message.payload.cause_mid
dict["cause-global-time"] = message.payload.cause_global_time
return encode(dict),
def report(self):
if DEBUG: print >> sys.stderr, "TUDelftReporter: report"
events = self.get_events()
if events:
events = [{"name":event.get_name(), "time":event.get_time(), "values":event.get_values()} for event in events]
data = (time(), self.device_id.encode("HEX"), events)
self.post(compress(encode(data)))
else:
if DEBUG: print >> sys.stderr, "TUDelftReporter: Nothing to report"
def _encode_decode(self, encode, decode, message):
result = encode(message)
try:
decode(None, 0, result[0])
except DropPacket:
raise
except:
pass
return result
def _encode_modification(self, message):
modification_on = message.payload.modification_on.load_message()
dict = {"modification-type":message.payload.modification_type,
"modification-value":message.payload.modification_value,
"timestamp":message.payload.timestamp,
"modification-on-mid":modification_on.authentication.member.mid,
"modification-on-global-time":modification_on.distribution.global_time}
prev_modification = message.payload.prev_modification_packet
if prev_modification:
message = prev_modification.load_message()
dict["prev-modification-mid"] = message.authentication.member.mid
dict["prev-modification-global-time"] = message.distribution.global_time
return encode(dict),
def _encode_comment(self, message):
dict = {"text":message.payload.text,
"timestamp":message.payload.timestamp}
playlist_packet = message.payload.playlist_packet
infohash = message.payload.infohash
if message.payload.reply_to_mid:
dict["reply-to-mid"] = message.payload.reply_to_mid
dict["reply-to-global-time"] = message.payload.reply_to_global_time
if message.payload.reply_after_mid:
dict["reply-after-mid"] = message.payload.reply_after_mid
dict["reply-after-global-time"] = message.payload.reply_after_global_time
if playlist_packet:
message = playlist_packet.load_message()
dict["playlist-mid"] = message.authentication.member.mid
dict["playlist-global-time"] = message.distribution.global_time
if infohash:
dict['infohash'] = infohash
return encode(dict),
def _encode_channelsearch_response(self, message):
packet = encode((message.payload.keywords, message.payload.torrents))
return packet,
def _encode_channelsearch(self, message):
packet = encode(message.payload.keywords)
return packet,
def create_msg():
return encode(message.payload.torrents)
@param message The message payload
@param reply_callback Call this function once to send the reply: reply_callback(payload [, error=123])
"""
if DEBUG:
print >> sys.stderr, "usereventlogcrawler: handle_crawler_request", show_permid_short(permid), message
# execute the sql
try:
#has to be execute_read, delete statements are also allowed in this function
cursor = self._sqlite_cache_db.execute_read(message)
except Exception, e:
reply_callback(str(e), error=1)
else:
if cursor:
reply_callback(encode(list(cursor)))
# reply_callback(cPickle.dumps(list(cursor), 2))
else:
reply_callback("error", error=2)
def handle_crawler_reply(self, permid, selversion, channel_id, channel_data, error, message, request_callback):
"""
Received a CRAWLER_USEREVENTLOG_QUERY reply.
@param permid The Crawler permid
@param selversion The overlay protocol version
@param channel_id Identifies a CRAWLER_REQUEST/CRAWLER_REPLY pair
@param error The error value. 0 indicates success.
@param message The message payload
@param request_callback Call this function one or more times to send the requests: request_callback(message_id, payload)
"""
if error:
@param selversion The overlay protocol version
@param channel_id Identifies a CRAWLER_REQUEST/CRAWLER_REPLY pair
@param message The message payload
@param reply_callback Call this function once to send the reply: reply_callback(payload [, error=123])
"""
if DEBUG:
print >> sys.stderr, "repexcrawler: handle_crawler_request", show_permid_short(permid), message
# retrieve repex history
try:
repexhistory = self._repexlog.getHistoryAndCleanup()
except Exception, e:
reply_callback(str(e), error=1)
else:
reply_callback(encode(repexhistory))
# reply_callback(cPickle.dumps(repexhistory, 2))
def handle_crawler_reply(self, permid, selversion, channel_id, channel_data, error, message, request_callback):
"""
Received a CRAWLER_REPEX_QUERY reply.
@param permid The Crawler permid
@param selversion The overlay protocol version
@param channel_id Identifies a CRAWLER_REQUEST/CRAWLER_REPLY pair
@param error The error value. 0 indicates success.
@param message The message payload
@param request_callback Call this function one or more times to send the requests: request_callback(message_id, payload)
"""
if error:
if DEBUG:
print >> sys.stderr, "repexcrawler: handle_crawler_reply", error, message
def create_msg():
normal_msg = pack('!20sQ', message.payload.infohash, message.payload.timestamp), message.payload.name, tuple(files), tuple(trackers)
normal_msg = encode(normal_msg)
return zlib.compress(normal_msg)
def _encode_channel(self, message):
return encode((message.payload.name, message.payload.description)),
def _encode_mark_torrent(self, message):
dict = {"infohash":message.payload.infohash,
"timestamp":message.payload.timestamp,
"type":message.payload.type}
return encode(dict),
def _encode_channelcast(self, message):
packet = encode(message.payload.torrents)
return packet,
