def get_externally_reachable(self):
from ACEStream.Core.NATFirewall.DialbackMsgHandler import DialbackMsgHandler
return DialbackMsgHandler.getInstance().isConnectable()
def handle_events(self, events):
for sock, event in events:
s = self.servers.get(sock)
if s:
if event & (POLLHUP | POLLERR) != 0:
if DEBUG2:
log('SocketHandler::handle_events: got event, close server socket')
self.poll.unregister(s)
del self.servers[sock]
else:
try:
newsock, addr = s.accept()
if not self.btengine_said_reachable:
try:
from ACEStream.Core.NATFirewall.DialbackMsgHandler import DialbackMsgHandler
dmh = DialbackMsgHandler.getInstance()
dmh.network_btengine_reachable_callback()
except ImportError:
if DEBUG:
print_exc()
self.btengine_said_reachable = True
count_sockets = len(self.single_sockets)
if DEBUG2:
log('SocketHandler::handle_events: got incoming connection: from', newsock.getpeername(), 'count_sockets', count_sockets, 'max_connects', self.max_connects)
if count_sockets >= self.max_connects:
if DEBUG2:
log('SocketHandler::handle_events: too many connects, close remote socket: count_sockets', count_sockets, 'max_connects', self.max_connects)
newsock.close()
elif self.white_list is not None and addr[0] not in self.white_list:
if DEBUG2:
log('SocketHandler::handle_events: not in the white list, close remote socket: addr', addr)
newsock.close()
else:
newsock.setblocking(0)
nss = SingleSocket(self, newsock, self.handler)
self.single_sockets[newsock.fileno()] = nss
self.poll.register(newsock, POLLIN)
self.handler.external_connection_made(nss)
except socket.error as e:
if DEBUG:
log('SocketHandler::handle_events: SocketError while accepting new connection')
print_exc()
self._sleep()
continue
s = self.udp_sockets.get(sock)
if s:
packets = []
try:
while True:
data, addr = s.socket.recvfrom(65535)
if not data:
if DEBUG2:
log('SocketHandler: UDP no-data', addr)
break
else:
if DEBUG2:
log('SocketHandler: Got UDP data', addr, 'len', len(data))
packets.append((addr, data))
except socket.error as e:
if DEBUG:
log('SocketHandler: UDP Socket error')
print_exc()
finally:
s.handler.data_came_in(packets)
continue
s = self.single_sockets.get(sock)
if s:
if event & (POLLHUP | POLLERR):
if DEBUG2:
log('SocketHandler::handle_events: got event, connect socket got error: ip', s.ip, 'port', s.port)
self._close_socket(s)
continue
if event & POLLIN:
try:
s.last_hit = clock()
if s.socket is None:
data = None
else:
data = s.socket.recv(100000)
if not data:
if DEBUG:
log('SocketHandler::handle_events: no-data closing connection', s.get_ip(), s.get_port())
self._close_socket(s)
else:
if hasattr(s, 'data_received'):
s.data_received += len(data)
s.handler.data_came_in(s, data)
except socket.error as e:
if DEBUG:
log('SocketHandler::handle_events: socket error', str(e))
code, msg = e
if code != SOCKET_BLOCK_ERRORCODE:
if DEBUG:
log('SocketHandler::handle_events: closing connection because not WOULDBLOCK', s.get_ip(), 'error', code)
self._close_socket(s)
continue
if event & POLLOUT and s.socket and not s.is_flushed():
s.connected = True
s.try_write()
if s.is_flushed():
s.handler.connection_flushed(s)
def get_externally_reachable(self):
from ACEStream.Core.NATFirewall.DialbackMsgHandler import DialbackMsgHandler
return DialbackMsgHandler.getInstance().isConnectable()
def handle_events(self, events):
for sock, event in events:
s = self.servers.get(sock)
if s:
if event & (POLLHUP | POLLERR) != 0:
if DEBUG2:
log('SocketHandler::handle_events: got event, close server socket'
)
self.poll.unregister(s)
del self.servers[sock]
else:
try:
newsock, addr = s.accept()
if not self.btengine_said_reachable:
try:
from ACEStream.Core.NATFirewall.DialbackMsgHandler import DialbackMsgHandler
dmh = DialbackMsgHandler.getInstance()
dmh.network_btengine_reachable_callback()
except ImportError:
if DEBUG:
print_exc()
self.btengine_said_reachable = True
count_sockets = len(self.single_sockets)
if DEBUG2:
log(
'SocketHandler::handle_events: got incoming connection: from',
newsock.getpeername(), 'count_sockets',
count_sockets, 'max_connects',
self.max_connects)
if count_sockets >= self.max_connects:
if DEBUG2:
log(
'SocketHandler::handle_events: too many connects, close remote socket: count_sockets',
count_sockets, 'max_connects',
self.max_connects)
newsock.close()
elif self.white_list is not None and addr[
0] not in self.white_list:
if DEBUG2:
log(
'SocketHandler::handle_events: not in the white list, close remote socket: addr',
addr)
newsock.close()
else:
newsock.setblocking(0)
nss = SingleSocket(self, newsock, self.handler)
self.single_sockets[newsock.fileno()] = nss
self.poll.register(newsock, POLLIN)
self.handler.external_connection_made(nss)
except socket.error as e:
if DEBUG:
log('SocketHandler::handle_events: SocketError while accepting new connection'
)
print_exc()
self._sleep()
continue
s = self.udp_sockets.get(sock)
if s:
packets = []
try:
while True:
data, addr = s.socket.recvfrom(65535)
if not data:
if DEBUG2:
log('SocketHandler: UDP no-data', addr)
break
else:
if DEBUG2:
log('SocketHandler: Got UDP data', addr, 'len',
len(data))
packets.append((addr, data))
except socket.error as e:
if DEBUG:
log('SocketHandler: UDP Socket error')
print_exc()
finally:
s.handler.data_came_in(packets)
continue
s = self.single_sockets.get(sock)
if s:
if event & (POLLHUP | POLLERR):
if DEBUG2:
log(
'SocketHandler::handle_events: got event, connect socket got error: ip',
s.ip, 'port', s.port)
self._close_socket(s)
continue
if event & POLLIN:
try:
s.last_hit = clock()
if s.socket is None:
data = None
else:
data = s.socket.recv(100000)
if not data:
if DEBUG:
log(
'SocketHandler::handle_events: no-data closing connection',
s.get_ip(), s.get_port())
self._close_socket(s)
else:
if hasattr(s, 'data_received'):
s.data_received += len(data)
s.handler.data_came_in(s, data)
except socket.error as e:
if DEBUG:
log('SocketHandler::handle_events: socket error',
str(e))
code, msg = e
if code != SOCKET_BLOCK_ERRORCODE:
if DEBUG:
log(
'SocketHandler::handle_events: closing connection because not WOULDBLOCK',
s.get_ip(), 'error', code)
self._close_socket(s)
continue
if event & POLLOUT and s.socket and not s.is_flushed():
s.connected = True
s.try_write()
if s.is_flushed():
s.handler.connection_flushed(s)
def register(self, session, sesslock):
self.session = session
self.sesslock = sesslock
self.downloads = {DLTYPE_TORRENT: {},
DLTYPE_DIRECT: {}}
config = session.sessconfig
self.locally_guessed_ext_ip = self.guess_ext_ip_from_local_info()
self.upnp_ext_ip = None
self.dialback_ext_ip = None
self.yourip_ext_ip = None
self.udppuncture_handler = None
self.sessdoneflag = Event()
self.hashcheck_queue = []
self.sdownloadtohashcheck = None
self.upnp_thread = None
self.upnp_type = config['upnp_nat_access']
self.nat_detect = config['nat_detect']
self.rawserver = RawServer(self.sessdoneflag, config['timeout_check_interval'], config['timeout'], ipv6_enable=config['ipv6_enabled'], failfunc=self.rawserver_fatalerrorfunc, errorfunc=self.rawserver_nonfatalerrorfunc, max_socket_connects=config['max_socket_connects'])
self.rawserver.add_task(self.rawserver_keepalive, 1)
self.listen_port = self.rawserver.find_and_bind(0, config['minport'], config['maxport'], config['bind'], reuse=True, ipv6_socket_style=config['ipv6_binds_v4'], randomizer=config['random_port'])
if DEBUG:
log('LM::register: got listen port', self.listen_port)
self.multihandler = MultiHandler(self.rawserver, self.sessdoneflag)
self.shutdownstarttime = None
if config['megacache']:
cachedb.init(config, self.rawserver_fatalerrorfunc)
self.my_db = MyDBHandler.getInstance()
self.torrent_db = TorrentDBHandler.getInstance()
torrent_collecting_dir = os.path.abspath(config['torrent_collecting_dir'])
self.torrent_db.register(Category.getInstance(), torrent_collecting_dir)
self.url2torrent_db = Url2TorrentDBHandler.getInstance()
self.adid2infohash_db = AdID2InfohashDBHandler.getInstance()
self.tsplayers_db = TsPlayersDBHandler.getInstance()
self.tsmetadata_db = TsMetadataDBHandler.getInstance()
self.user_profile_db = UserProfileDBHandler.getInstance()
self.peer_db = None
self.mypref_db = None
self.pref_db = None
self.superpeer_db = None
self.crawler_db = None
self.seedingstats_db = None
self.seedingstatssettings_db = None
self.friendship_statistics_db = None
self.friend_db = None
self.bartercast_db = None
self.votecast_db = None
self.channelcast_db = None
self.mm = None
self.richmetadataDbHandler = None
else:
config['overlay'] = 0
config['torrent_checking'] = 0
self.my_db = None
self.peer_db = None
self.torrent_db = None
self.mypref_db = None
self.pref_db = None
self.superpeer_db = None
self.crawler_db = None
self.seedingstats_db = None
self.seedingstatssettings_db = None
self.friendship_statistics_db = None
self.friend_db = None
self.bartercast_db = None
self.votecast_db = None
self.channelcast_db = None
self.mm = None
self.richmetadataDbHandler = None
self.url2torrent_db = None
if config['overlay']:
raise RuntimeError, 'Overlay should not be enabled'
from ACEStream.Core.Overlay.SecureOverlay import SecureOverlay
from ACEStream.Core.Overlay.OverlayThreadingBridge import OverlayThreadingBridge
from ACEStream.Core.Overlay.OverlayApps import OverlayApps
from ACEStream.Core.RequestPolicy import FriendsCoopDLOtherRQueryQuotumCrawlerAllowAllRequestPolicy
self.secure_overlay = SecureOverlay.getInstance()
self.secure_overlay.register(self, config['overlay_max_message_length'])
self.overlay_apps = OverlayApps.getInstance()
policy = FriendsCoopDLOtherRQueryQuotumCrawlerAllowAllRequestPolicy(self.session)
self.overlay_bridge = OverlayThreadingBridge.getInstance()
self.overlay_bridge.register_bridge(self.secure_overlay, self.overlay_apps)
self.overlay_apps.register(self.overlay_bridge, self.session, self, config, policy)
self.overlay_bridge.start_listening()
if config['multicast_local_peer_discovery']:
self.setup_multicast_discovery()
else:
self.secure_overlay = None
self.overlay_apps = None
config['buddycast'] = 0
config['download_help'] = 0
config['socnet'] = 0
config['rquery'] = 0
try:
some_dialback_handler = DialbackMsgHandler.getInstance()
some_dialback_handler.register_yourip(self)
except:
if DEBUG:
log_exc()
if config['megacache'] or config['overlay']:
Category.getInstance(config['install_dir'])
self.internaltracker = None
if config['internaltracker']:
self.internaltracker = Tracker(config, self.rawserver)
if self.session.app_http_handler is None:
self.httphandler = HTTPHandler(self.internaltracker.get, config['tracker_min_time_between_log_flushes'])
else:
self.session.app_http_handler.set_default_http_handler(self.internaltracker.get)
self.httphandler = HTTPHandler(self.session.app_http_handler.get, config['tracker_min_time_between_log_flushes'])
elif self.session.app_http_handler is not None:
self.httphandler = HTTPHandler(self.session.app_http_handler.get, 60)
else:
self.httphandler = DummyHTTPHandler()
self.multihandler.set_httphandler(self.httphandler)
if config['mainline_dht']:
mainlineDHT.init(('127.0.0.1', self.listen_port), config['state_dir'])
if config['torrent_checking']:
if config['mainline_dht']:
from ACEStream.Core.DecentralizedTracking.mainlineDHTChecker import mainlineDHTChecker
c = mainlineDHTChecker.getInstance()
c.register(mainlineDHT.dht)
self.torrent_checking_period = config['torrent_checking_period']
self.rawserver.add_task(self.run_torrent_check, self.torrent_checking_period)
if config['magnetlink']:
MagnetHandler.get_instance(self.rawserver)
self.dispersy = None
self.session.dispersy_member = None
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")
overlay_bridge.register_recv_callback(self.handleMessage)
overlay_bridge.register_conns_callback(self.handleConnection)
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
)
usereventlog_crawler = UserEventLogCrawler.get_instance()
crawler.register_message_handler(
CRAWLER_USEREVENTLOG_QUERY,
usereventlog_crawler.handle_crawler_request,
usereventlog_crawler.handle_crawler_reply,
)
if crawler.am_crawler():
i_am_crawler = True
self.register_msg_handler([CRAWLER_REPLY], crawler.handle_reply)
self.register_connection_handler(crawler.handle_connection)
if "database" in sys.argv:
crawler.register_crawl_initiator(database_crawler.query_initiator)
if "videoplayback" in sys.argv:
crawler.register_crawl_initiator(videoplayback_crawler.query_initiator)
if "seedingstats" in sys.argv:
crawler.register_crawl_initiator(seeding_stats_crawler.query_initiator, frequency=1800)
if "friendship" in sys.argv:
crawler.register_crawl_initiator(friendship_crawler.query_initiator)
if "natcheck" in sys.argv:
crawler.register_crawl_initiator(natcheck_handler.doNatCheck, 3600)
if "repex" in sys.argv:
crawler.register_crawl_initiator(repex_crawler.query_initiator)
if "puncture" in sys.argv:
crawler.register_crawl_initiator(puncture_crawler.query_initiator)
if "channel" in sys.argv:
crawler.register_crawl_initiator(channel_crawler.query_initiator)
if "usereventlog" in sys.argv:
crawler.register_crawl_initiator(usereventlog_crawler.query_initiator)
else:
self.register_msg_handler([CRAWLER_REQUEST, CRAWLER_REPLY], self.handleDisabledMessage)
self.metadata_handler = MetadataHandler.getInstance()
if config["download_help"]:
self.coord_handler = CoordinatorMessageHandler(launchmany)
self.register_msg_handler(HelpHelperMessages, self.coord_handler.handleMessage)
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)
self.metadata_handler.register(overlay_bridge, self.help_handler, launchmany, config)
self.register_msg_handler(MetadataMessages, self.metadata_handler.handleMessage)
config["subtitles_collecting"] = False
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)
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,
)
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"]:
self.buddycast = BuddyCastFactory.getInstance(superpeer=config["superpeer"], log=config["overlay_log"])
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()
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)
if config["torrent_collecting"]:
self.rtorrent_handler = RemoteTorrentHandler.getInstance()
self.rtorrent_handler.register(overlay_bridge, self.metadata_handler, session)
self.metadata_handler.register2(self.rtorrent_handler)
self.register_connection_handler(self.notifier_handles_connection)
if config["buddycast"]:
self.buddycast.register2()
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')
overlay_bridge.register_recv_callback(self.handleMessage)
overlay_bridge.register_conns_callback(self.handleConnection)
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)
usereventlog_crawler = UserEventLogCrawler.get_instance()
crawler.register_message_handler(CRAWLER_USEREVENTLOG_QUERY, usereventlog_crawler.handle_crawler_request, usereventlog_crawler.handle_crawler_reply)
if crawler.am_crawler():
i_am_crawler = True
self.register_msg_handler([CRAWLER_REPLY], crawler.handle_reply)
self.register_connection_handler(crawler.handle_connection)
if 'database' in sys.argv:
crawler.register_crawl_initiator(database_crawler.query_initiator)
if 'videoplayback' in sys.argv:
crawler.register_crawl_initiator(videoplayback_crawler.query_initiator)
if 'seedingstats' in sys.argv:
crawler.register_crawl_initiator(seeding_stats_crawler.query_initiator, frequency=1800)
if 'friendship' in sys.argv:
crawler.register_crawl_initiator(friendship_crawler.query_initiator)
if 'natcheck' in sys.argv:
crawler.register_crawl_initiator(natcheck_handler.doNatCheck, 3600)
if 'repex' in sys.argv:
crawler.register_crawl_initiator(repex_crawler.query_initiator)
if 'puncture' in sys.argv:
crawler.register_crawl_initiator(puncture_crawler.query_initiator)
if 'channel' in sys.argv:
crawler.register_crawl_initiator(channel_crawler.query_initiator)
if 'usereventlog' in sys.argv:
crawler.register_crawl_initiator(usereventlog_crawler.query_initiator)
else:
self.register_msg_handler([CRAWLER_REQUEST, CRAWLER_REPLY], self.handleDisabledMessage)
self.metadata_handler = MetadataHandler.getInstance()
if config['download_help']:
self.coord_handler = CoordinatorMessageHandler(launchmany)
self.register_msg_handler(HelpHelperMessages, self.coord_handler.handleMessage)
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)
self.metadata_handler.register(overlay_bridge, self.help_handler, launchmany, config)
self.register_msg_handler(MetadataMessages, self.metadata_handler.handleMessage)
config['subtitles_collecting'] = False
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)
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)
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']:
self.buddycast = BuddyCastFactory.getInstance(superpeer=config['superpeer'], log=config['overlay_log'])
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()
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)
if config['torrent_collecting']:
self.rtorrent_handler = RemoteTorrentHandler.getInstance()
self.rtorrent_handler.register(overlay_bridge, self.metadata_handler, session)
self.metadata_handler.register2(self.rtorrent_handler)
self.register_connection_handler(self.notifier_handles_connection)
if config['buddycast']:
self.buddycast.register2()
