def subtest_receptionOfSUBSTwoRequestsOneAvailable(self): """ Asking for two subtitles while the recipent of the request has only one. The response should contain only the one available subtitle content, plus a bitmask that reflects the contents of the response. """ print >> sys.stderr, time.asctime(),'-', "test: test_subtitles_msgs_2_1 -----------------------" ol_conn = OLConnection(self.my_keypair,'localhost',self.hisport) bitmask = LanguagesProvider.getLanguagesInstance().langCodesToMask(['nld','eng']) binmask = utilities.uintToBinaryString(bitmask, length=4) request = GET_SUBS + \ bencode(( self.anotherpermid, self.testInfohash, binmask )) subshandler = SubtitlesHandler() subshandler.register(ol_conn, self.richMetadata_db, self.session) ol_conn.send(request) subs_data = ol_conn.recv() self.assertEquals(SUBS, subs_data[0]) data = bdecode(subs_data[1:]) print >> sys.stderr, time.asctime(),'-', "test: subtitles_messages : received SUBS repsonse: ", data #check on the format of the response self.assertTrue(isinstance(data,list)) self.assertEquals(4, len(data)) # for fields self.assertEquals(self.mdto.channel,data[0]) self.assertEquals(self.mdto.infohash, data[1]) #the receiver had only one of the two requested subtitles # so I expect a different bitmask bitmask = LanguagesProvider.getLanguagesInstance().langCodesToMask(['nld']) expectedBinarymask = utilities.uintToBinaryString(bitmask, length=4) self.assertEquals(expectedBinarymask, data[2]) self.assertTrue(isinstance(data[3],list)) self.assertEquals(1, len(data[3])) with codecs.open(self.sub1, "rb", "utf-8") as sub: expectedContents = sub.read() self.assertEquals(expectedContents, data[3][0]) ol_conn.close() print >> sys.stderr, time.asctime(),'-', "test: subtitles_messages: received content is valid." print >> sys.stderr, time.asctime(),'-', "End of test_subtitles_msgs_2_1 test --------------------"
def subtest_receptionOfSUBS(self): ''' Asking for the single available subtitle. The response should be a valid SUBS message containing its contents ''' print >> sys.stderr, time.asctime(),'-', "test: test_subtitles_msgs_1_1 -----------------------" ol_conn = OLConnection(self.my_keypair,'localhost',self.hisport) bitmask = LanguagesProvider.getLanguagesInstance().langCodesToMask(['nld']) binmask = utilities.uintToBinaryString(bitmask, length=4) request = GET_SUBS + \ bencode(( self.anotherpermid, self.testInfohash, binmask )) subshandler = SubtitlesHandler() subshandler.register(ol_conn, self.richMetadata_db, self.session) ol_conn.send(request) subs_data = ol_conn.recv() print >> sys.stderr, time.asctime(),'-', "test: subtitles_messages : received SUBS response: len",len(subs_data) self.assertEquals(SUBS, subs_data[0]) data = bdecode(subs_data[1:]) print >> sys.stderr, time.asctime(),'-', "test: subtitles_messages : received SUBS response: ", data #check on the format of the response self.assertTrue(isinstance(data,list)) self.assertEquals(4, len(data)) # for fields self.assertEquals(self.mdto.channel,data[0]) self.assertEquals(self.mdto.infohash, data[1]) self.assertEquals(binmask, data[2]) self.assertTrue(isinstance(data[3],list)) self.assertEquals(1, len(data[3])) with codecs.open(self.sub1, "rb", "utf-8") as sub: expectedContents = sub.read() self.assertEquals(expectedContents, data[3][0]) ol_conn.close() print >> sys.stderr, time.asctime(),'-', "test: subtitles_messages: received content is valid." print >> sys.stderr, time.asctime(),'-', "End of test_subtitles_msgs_1_1 test --------------------"
def set_subtitles_upload_rate(self, value): with self.sesslock: SubtitlesHandler.getInstance().setUploadRate(value) SessionConfigInterface.set_subtitles_uploade_rate(self, value)
def register(self, overlay_bridge, session, launchmany, config, requestPolicy): self.overlay_bridge = overlay_bridge self.launchmany = launchmany self.requestPolicy = requestPolicy self.text_mode = config.has_key('text_mode') # OverlayApps gets all messages, and demultiplexes overlay_bridge.register_recv_callback(self.handleMessage) overlay_bridge.register_conns_callback(self.handleConnection) # Arno, 2010-01-28: Start with crawler support, other mods depend on # that, e.g. BuddyCast i_am_crawler = False if config['crawler']: crawler = Crawler.get_instance(session) self.register_msg_handler([CRAWLER_REQUEST], crawler.handle_request) database_crawler = DatabaseCrawler.get_instance() crawler.register_message_handler(CRAWLER_DATABASE_QUERY, database_crawler.handle_crawler_request, database_crawler.handle_crawler_reply) seeding_stats_crawler = SeedingStatsCrawler.get_instance() crawler.register_message_handler(CRAWLER_SEEDINGSTATS_QUERY, seeding_stats_crawler.handle_crawler_request, seeding_stats_crawler.handle_crawler_reply) friendship_crawler = FriendshipCrawler.get_instance(session) crawler.register_message_handler(CRAWLER_FRIENDSHIP_STATS, friendship_crawler.handle_crawler_request, friendship_crawler.handle_crawler_reply) natcheck_handler = NatCheckMsgHandler.getInstance() natcheck_handler.register(launchmany) crawler.register_message_handler(CRAWLER_NATCHECK, natcheck_handler.gotDoNatCheckMessage, natcheck_handler.gotNatCheckReplyMessage) crawler.register_message_handler(CRAWLER_NATTRAVERSAL, natcheck_handler.gotUdpConnectRequest, natcheck_handler.gotUdpConnectReply) videoplayback_crawler = VideoPlaybackCrawler.get_instance() crawler.register_message_handler(CRAWLER_VIDEOPLAYBACK_EVENT_QUERY, videoplayback_crawler.handle_event_crawler_request, videoplayback_crawler.handle_event_crawler_reply) crawler.register_message_handler(CRAWLER_VIDEOPLAYBACK_INFO_QUERY, videoplayback_crawler.handle_info_crawler_request, videoplayback_crawler.handle_info_crawler_reply) repex_crawler = RepexCrawler.get_instance(session) crawler.register_message_handler(CRAWLER_REPEX_QUERY, repex_crawler.handle_crawler_request, repex_crawler.handle_crawler_reply) puncture_crawler = PunctureCrawler.get_instance() crawler.register_message_handler(CRAWLER_PUNCTURE_QUERY, puncture_crawler.handle_crawler_request, puncture_crawler.handle_crawler_reply) channel_crawler = ChannelCrawler.get_instance() crawler.register_message_handler(CRAWLER_CHANNEL_QUERY, channel_crawler.handle_crawler_request, channel_crawler.handle_crawler_reply) if crawler.am_crawler(): i_am_crawler = True # we will only accept CRAWLER_REPLY messages when we are actully a crawler self.register_msg_handler([CRAWLER_REPLY], crawler.handle_reply) self.register_connection_handler(crawler.handle_connection) if "database" in sys.argv: # allows access to tribler database (boudewijn) crawler.register_crawl_initiator(database_crawler.query_initiator) if "videoplayback" in sys.argv: # allows access to video-playback statistics (boudewijn) crawler.register_crawl_initiator(videoplayback_crawler.query_initiator) if "seedingstats" in sys.argv: # allows access to seeding statistics (Boxun) crawler.register_crawl_initiator(seeding_stats_crawler.query_initiator, frequency=60*30) if "friendship" in sys.argv: # allows access to friendship statistics (Ali) crawler.register_crawl_initiator(friendship_crawler.query_initiator) if "natcheck" in sys.argv: # allows access to nat-check statistics (Lucia) crawler.register_crawl_initiator(natcheck_handler.doNatCheck, 3600) if "repex" in sys.argv: # allows access to RePEX log statistics (Raynor Vliegendhart) crawler.register_crawl_initiator(repex_crawler.query_initiator) if "puncture" in sys.argv: # allows access to UDPPuncture log statistics (Gertjan) crawler.register_crawl_initiator(puncture_crawler.query_initiator) if "channel" in sys.argv: # allows access to tribler channels' database (nitin) crawler.register_crawl_initiator(channel_crawler.query_initiator) else: self.register_msg_handler([CRAWLER_REQUEST, CRAWLER_REPLY], self.handleDisabledMessage) # Create handler for metadata messages in two parts, as # download help needs to know the metadata_handler and we need # to know the download helper handler. # Part 1: self.metadata_handler = MetadataHandler.getInstance() if config['download_help']: # Create handler for messages to dlhelp coordinator self.coord_handler = CoordinatorMessageHandler(launchmany) self.register_msg_handler(HelpHelperMessages, self.coord_handler.handleMessage) # Create handler for messages to dlhelp helper self.help_handler = HelperMessageHandler() self.help_handler.register(session,self.metadata_handler,config['download_help_dir'],config.get('coopdlconfig', False)) self.register_msg_handler(HelpCoordinatorMessages, self.help_handler.handleMessage) # Part 2: self.metadata_handler.register(overlay_bridge, self.help_handler, launchmany, config) self.register_msg_handler(MetadataMessages, self.metadata_handler.handleMessage) # 13-04-2010 Andrea: subtitles collecting if not config['subtitles_collecting'] : self.subtitles_handler = None else: self.subtitles_handler = SubtitlesHandler.getInstance() self.subtitles_handler.register(self.overlay_bridge, self.launchmany.richmetadataDbHandler, self.launchmany.session) self.peersHaveManger = PeersHaveManager.getInstance() if not self.peersHaveManger.isRegistered(): self.peersHaveManger.register(self.launchmany.richmetadataDbHandler, self.overlay_bridge) # I'm not sure if this is the best place to init this self.subtitle_support = SubtitlesSupport.getInstance() keypair = self.launchmany.session.keypair permid = self.launchmany.session.get_permid() self.subtitle_support._register(self.launchmany.richmetadataDbHandler, self.subtitles_handler, self.launchmany.channelcast_db, permid, keypair, self.peersHaveManger, self.overlay_bridge) # cleanup the subtitles database at the first launch self.subtitle_support.runDBConsinstencyRoutine() if not config['torrent_collecting']: self.torrent_collecting_solution = 0 else: self.torrent_collecting_solution = config['buddycast_collecting_solution'] if config['buddycast']: # Create handler for Buddycast messages self.buddycast = BuddyCastFactory.getInstance(superpeer=config['superpeer'], log=config['overlay_log']) # Using buddycast to handle torrent collecting since they are dependent self.buddycast.register(overlay_bridge, launchmany, launchmany.rawserver_fatalerrorfunc, self.metadata_handler, self.torrent_collecting_solution, config['start_recommender'],config['buddycast_max_peers'],i_am_crawler) self.register_msg_handler(BuddyCastMessages, self.buddycast.handleMessage) self.register_connection_handler(self.buddycast.handleConnection) if config['dialback']: self.dialback_handler = DialbackMsgHandler.getInstance() # The Dialback mechanism needs the real rawserver, not the overlay_bridge self.dialback_handler.register(overlay_bridge, launchmany, launchmany.rawserver, config) self.register_msg_handler([DIALBACK_REQUEST], self.dialback_handler.olthread_handleSecOverlayMessage) self.register_connection_handler(self.dialback_handler.olthread_handleSecOverlayConnection) else: self.register_msg_handler([DIALBACK_REQUEST], self.handleDisabledMessage) if config['socnet']: self.socnet_handler = SocialNetworkMsgHandler.getInstance() self.socnet_handler.register(overlay_bridge, launchmany, config) self.register_msg_handler(SocialNetworkMessages,self.socnet_handler.handleMessage) self.register_connection_handler(self.socnet_handler.handleConnection) self.friendship_handler = FriendshipMsgHandler.getInstance() self.friendship_handler.register(overlay_bridge, launchmany.session) self.register_msg_handler(FriendshipMessages,self.friendship_handler.handleMessage) self.register_connection_handler(self.friendship_handler.handleConnection) if config['rquery']: self.rquery_handler = RemoteQueryMsgHandler.getInstance() self.rquery_handler.register(overlay_bridge,launchmany,config,self.buddycast,log=config['overlay_log']) self.register_msg_handler(RemoteQueryMessages,self.rquery_handler.handleMessage) self.register_connection_handler(self.rquery_handler.handleConnection) if config['subtitles_collecting']: hndl = self.subtitles_handler.getMessageHandler() self.register_msg_handler(SubtitleMessages, hndl) self.rtorrent_handler = RemoteTorrentHandler.getInstance() self.rtorrent_handler.register(overlay_bridge,self.metadata_handler,session) self.metadata_handler.register2(self.rtorrent_handler) # Add notifier as connection handler self.register_connection_handler(self.notifier_handles_connection) if config['buddycast']: # Arno: to prevent concurrency between mainthread and overlay # thread where BuddyCast schedules tasks self.buddycast.register2()
def setUp(self): self._session = MockSession() self.ol_bridge = MockOverlayBridge() self.rmdDBHandler = MockMetadataDBHandler() self.underTest = SubtitlesHandler()
class TestSubtitlesHandler(unittest.TestCase): def setUp(self): self._session = MockSession() self.ol_bridge = MockOverlayBridge() self.rmdDBHandler = MockMetadataDBHandler() self.underTest = SubtitlesHandler() def tearDown(self): self.ol_bridge = None # cleanup the mess in collected dir if self.underTest.subs_dir is not None: toDelete = [ os.path.join(self.underTest.subs_dir, entry) for entry in os.listdir(self.underTest.subs_dir) if entry.endswith(".srt") ] for xfile in toDelete: if os.path.isfile(xfile): os.remove(xfile) def testRegisterStuff(self): self.underTest.register(self.ol_bridge, self.rmdDBHandler, self._session) self.assertTrue(self.underTest.registered) self.assertTrue(self.ol_bridge is self.underTest.overlay_bridge) self.assertTrue(self.rmdDBHandler is self.underTest.subtitlesDb) expectedPath = os.path.join( os.path.abspath(os.path.curdir), self._session.get_state_dir(), "subtitles_collecting_dir" ) self.assertEqual(os.path.normpath(expectedPath), self.underTest.subs_dir) # preaparing the mock msg handler self.mockMsgHandler = MockSubsMsgHander() self.underTest._subsMsgHndlr = self.mockMsgHandler def testGetSubtitlesFileRelativeName(self): # subtitles filenames are build from the sha1 hash # of the triple (channel_id, infohash, langCode) name = getSubtitleFileRelativeName(testChannelId, testInfohash, "rus") hasher = sha() for value in (testChannelId, testInfohash, "rus"): hasher.update(value) self.assertEquals(hasher.hexdigest() + ".srt", name) def testSendSubtitleRequestSimple(self): self.testRegisterStuff() self.underTest.sendSubtitleRequest( testDestPermId, testChannelId, testInfohash, ["zho", "rus"], None, OLPROTO_VER_FOURTEENTH ) self.assertEquals(1, self.mockMsgHandler.sendReqCount) def testReceibedGETSUBSNoSubs(self): self.testRegisterStuff() self.underTest.receivedSubsRequest( testDestPermId, (testDestPermId, testChannelId, ["ita", "nld"]), OLPROTO_VER_FOURTEENTH ) self.assertEquals(0, self.mockMsgHandler.sendResCount) def testReceivedGETSUBSTwoSubs(self): self.testRegisterStuff() self.underTest.receivedSubsRequest( testDestPermId, (testChannelId, testInfohash, ["eng", "rus"]), OLPROTO_VER_FOURTEENTH ) eng = u"this is a fake srt\n\nonly needed for testing\n\ncheers :)\n\n" rus = eng + u"asfasgb sagas gba\n\nasfasfas 24214 a \nThe checksum is different yuppy!\n\n" self.assertEquals(1, self.mockMsgHandler.sendResCount) destination, response, selversion = self.mockMsgHandler.sendResParams[0] self.assertEquals(testDestPermId, destination) self.assertEquals(OLPROTO_VER_FOURTEENTH, selversion) channelId, infohash, contentsList = response self.assertEquals(testChannelId, channelId) self.assertEquals(testInfohash, infohash) self.assertEquals(contentsList, {"eng": eng, "rus": rus}) def testReceivedSUBSMessage(self): self.testRegisterStuff() languages = ["eng", "rus"] zho = u"Subtitle Content 1" kor = u"Subtitle Content 2" contentsDict = {"eng": zho, "rus": kor} msg = (testChannelId, testInfohash, contentsDict) simpleCallback = lambda x: x bitmask = LanguagesProvider.getLanguagesInstance().langCodesToMask(["eng", "rus"]) self.underTest.receivedSubsResponse(testDestPermId, msg, [(simpleCallback, bitmask)], OLPROTO_VER_FOURTEENTH) # self.assertEquals(languages,callbackParams) expectedFilename1 = getSubtitleFileRelativeName(testChannelId, testInfohash, "eng") expectedFilename2 = getSubtitleFileRelativeName(testChannelId, testInfohash, "rus") expectedPath1 = os.path.join(self._session.get_state_dir(), self.underTest.subs_dir, expectedFilename1) expectedPath2 = os.path.join(self._session.get_state_dir(), self.underTest.subs_dir, expectedFilename2) self.assertTrue(os.path.isfile(expectedPath1)) self.assertTrue(os.path.isfile(expectedPath2)) with codecs.open(expectedPath1, "rb", "utf-8") as file1: content1 = file1.read() self.assertEquals(zho, content1) with codecs.open(expectedPath2, "rb", "utf-8") as file2: content2 = file2.read() self.assertEquals(kor, content2) self.assertEquals(1, self.ol_bridge.add_task_count) params = self.ol_bridge.add_taskParametersHistory[0] # calling the lambda val = params[0]() self.assertEquals(languages, val) def test_saveSubsOnDisk(self): self.testRegisterStuff() subContent = u"Test Content\nFor a pseudo subtitle file\n\nYo!\n" self.underTest._saveSubOnDisk(testChannelId, testInfohash, "eng", subContent) expectedFilename = getSubtitleFileRelativeName(testChannelId, testInfohash, "eng") expectedPath = os.path.join(self.underTest.subs_dir, expectedFilename) self.assertTrue(os.path.isfile(expectedPath)) # check the contents with codecs.open(expectedPath, "rb", "utf-8") as file: cont = file.read() self.assertEquals(subContent, cont) ##now the file exists. If a new subtitle is saved for the same # channel, infohash, lang but with a different content # the old one should be overwritten newContent = u"I'm the new content! I shall win over the old one!" self.underTest._saveSubOnDisk(testChannelId, testInfohash, "eng", newContent) self.assertTrue(os.path.isfile(expectedPath)) # check the contents with codecs.open(expectedPath, "rb", "utf-8") as file: cont = file.read() self.assertEquals(newContent, cont)