def __init__(self):
super(XXXFilter, self).__init__()
self._logger = logging.getLogger(self.__class__.__name__)
termfilename = os.path.join(get_lib_path(), 'Core', 'Category',
'filter_terms.filter')
self.xxx_terms, self.xxx_searchterms = self.initTerms(termfilename)
def start_database(self):
"""
Start the SQLite database.
"""
db_path = os.path.join(self.get_state_dir(), DB_FILE_RELATIVE_PATH)
db_script_path = os.path.join(get_lib_path(), DB_SCRIPT_NAME)
self.sqlite_db = SQLiteCacheDB(db_path, db_script_path)
self.sqlite_db.initialize()
self.sqlite_db.initial_begin()
def register(self, session, session_lock):
assert isInIOThread()
if not self.registered:
self.registered = True
self.session = session
self.session_lock = session_lock
self.tracker_manager = TrackerManager(self.session)
# On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root
# certificates provided by the system trust store.
if sys.platform == 'darwin':
os.environ['SSL_CERT_FILE'] = os.path.join(
get_lib_path(), 'root_certs_mac.pem')
if self.session.config.get_video_server_enabled():
self.video_server = VideoServer(
self.session.config.get_video_server_port(), self.session)
self.video_server.start()
# IPv8
if self.session.config.get_ipv8_enabled():
from Tribler.pyipv8.ipv8.configuration import get_default_configuration
ipv8_config = get_default_configuration()
ipv8_config['port'] = self.session.config.get_ipv8_port()
ipv8_config['address'] = self.session.config.get_ipv8_address()
ipv8_config['overlays'] = []
ipv8_config['keys'] = [] # We load the keys ourselves
if self.session.config.get_ipv8_bootstrap_override():
import Tribler.pyipv8.ipv8.community as community_file
community_file._DEFAULT_ADDRESSES = [
self.session.config.get_ipv8_bootstrap_override()
]
community_file._DNS_ADDRESSES = []
self.ipv8 = IPv8(ipv8_config,
enable_statistics=self.session.config.
get_ipv8_statistics())
self.session.config.set_anon_proxy_settings(
2, ("127.0.0.1",
self.session.config.
get_tunnel_community_socks5_listen_ports()))
if not self.initComplete:
self.init()
self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER,
[NTFY_STARTED])
self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None)
return self.startup_deferred
def setUp(self):
yield super(AbstractDB, self).setUp()
self.setUpPreSession()
self.session = Session(self.config, ignore_singleton=True)
tar = tarfile.open(os.path.join(TESTS_DATA_DIR, 'bak_new_tribler.sdb.tar.gz'), 'r|gz')
tar.extractall(self.session_base_dir)
db_path = os.path.join(self.session_base_dir, 'bak_new_tribler.sdb')
db_script_path = os.path.join(get_lib_path(), DB_SCRIPT_NAME)
self.sqlitedb = SQLiteCacheDB(db_path, db_script_path, busytimeout=BUSYTIMEOUT)
self.sqlitedb.initialize()
self.session.sqlite_db = self.sqlitedb
def __init__(self, ffEnabled=False):
self._logger = logging.getLogger(self.__class__.__name__)
filename = os.path.join(get_lib_path(), u'Core', u'Category', CATEGORY_CONFIG_FILE)
try:
self.category_info = getCategoryInfo(filename)
self.category_info.sort(cmp_rank)
except (MissingSectionHeaderError, ParsingError, IOError):
self.category_info = []
self._logger.critical('', exc_info=True)
self.xxx_filter = XXXFilter()
self._logger.debug("category: Categories defined by user: %s", self.getCategoryNames())
self.ffEnabled = ffEnabled
self.set_family_filter(None)
def __init__(self, ffEnabled=False):
self._logger = logging.getLogger(self.__class__.__name__)
filename = os.path.join(get_lib_path(), 'Core', 'Category', CATEGORY_CONFIG_FILE)
try:
self.category_info = getCategoryInfo(filename)
self.category_info.sort(cmp_rank)
except (MissingSectionHeaderError, ParsingError, IOError):
self.category_info = []
self._logger.critical('', exc_info=True)
self.xxx_filter = XXXFilter()
self._logger.debug("category: Categories defined by user: %s", self.getCategoryNames())
self.ffEnabled = ffEnabled
self.set_family_filter(None)
def patch_iom_methods():
try:
sys.path.append(os.path.join(get_lib_path(), 'internetofmoney'))
get_symmetric_key = lambda _: get_keyring_password('internetofmoney', 'symmetric_key')
set_symmetric_key = lambda _, password: set_keyring_password('internetofmoney', 'symmetric_key', password)
from Tribler.internetofmoney.Managers.ABN.ABNManager import ABNManager
ABNManager.get_symmetric_key = get_symmetric_key
ABNManager.set_symmetric_key = set_symmetric_key
from Tribler.internetofmoney.Managers.PayPal.PayPalManager import PayPalManager
PayPalManager.get_symmetric_key = get_symmetric_key
PayPalManager.set_symmetric_key = set_symmetric_key
from Tribler.internetofmoney.Managers.Rabo.RaboManager import RaboManager
RaboManager.get_symmetric_key = get_symmetric_key
RaboManager.set_symmetric_key = set_symmetric_key
except ImportError:
pass
def __init__(self):
super(XXXFilter, self).__init__()
self._logger = logging.getLogger(self.__class__.__name__)
termfilename = os.path.join(get_lib_path(), 'Core', 'Category', 'filter_terms.filter')
self.xxx_terms, self.xxx_searchterms = self.initTerms(termfilename)
def register(self, session, session_lock):
assert isInIOThread()
if not self.registered:
self.registered = True
self.session = session
self.session_lock = session_lock
# On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root
# certificates provided by the system trust store.
if sys.platform == 'darwin':
os.environ['SSL_CERT_FILE'] = os.path.join(
get_lib_path(), 'root_certs_mac.pem')
if self.session.config.get_torrent_store_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.torrent_store = LevelDbStore(
self.session.config.get_torrent_store_dir())
if self.session.config.get_metadata_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.metadata_store = LevelDbStore(
self.session.config.get_metadata_store_dir())
# torrent collecting: RemoteTorrentHandler
if self.session.config.get_torrent_collecting_enabled():
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
self.rtorrent_handler = RemoteTorrentHandler(self.session)
# TODO(emilon): move this to a megacache component or smth
if self.session.config.get_megacache_enabled():
from Tribler.Core.CacheDB.SqliteCacheDBHandler import (
PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler,
VoteCastDBHandler, ChannelCastDBHandler)
from Tribler.Core.Category.Category import Category
self._logger.debug('tlm: Reading Session state from %s',
self.session.config.get_state_dir())
self.category = Category()
# create DBHandlers
self.peer_db = PeerDBHandler(self.session)
self.torrent_db = TorrentDBHandler(self.session)
self.mypref_db = MyPreferenceDBHandler(self.session)
self.votecast_db = VoteCastDBHandler(self.session)
self.channelcast_db = ChannelCastDBHandler(self.session)
# initializes DBHandlers
self.peer_db.initialize()
self.torrent_db.initialize()
self.mypref_db.initialize()
self.votecast_db.initialize()
self.channelcast_db.initialize()
from Tribler.Core.Modules.tracker_manager import TrackerManager
self.tracker_manager = TrackerManager(self.session)
if self.session.config.get_video_server_enabled():
self.video_server = VideoServer(
self.session.config.get_video_server_port(), self.session)
self.video_server.start()
# Dispersy
self.tftp_handler = None
if self.session.config.get_dispersy_enabled():
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import StandaloneEndpoint
# set communication endpoint
endpoint = StandaloneEndpoint(
self.session.config.get_dispersy_port())
working_directory = unicode(
self.session.config.get_state_dir())
self.dispersy = Dispersy(endpoint, working_directory)
# register TFTP service
from Tribler.Core.TFTP.handler import TftpHandler
self.tftp_handler = TftpHandler(self.session,
endpoint,
"fffffffd".decode('hex'),
block_size=1024)
self.tftp_handler.initialize()
if self.session.config.get_torrent_search_enabled(
) or self.session.config.get_channel_search_enabled():
self.search_manager = SearchManager(self.session)
self.search_manager.initialize()
if not self.initComplete:
self.init()
self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER,
[NTFY_STARTED])
self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None)
return self.startup_deferred
from base64 import encodestring, decodestring
from threading import currentThread, RLock
from twisted.python.threadable import isInIOThread
from Tribler.Core.CacheDB.db_versions import LATEST_DB_VERSION
from Tribler.Core.Utilities.install_dir import get_lib_path
from Tribler.pyipv8.ipv8.taskmanager import TaskManager
from Tribler.pyipv8.ipv8.util import blocking_call_on_reactor_thread
DB_SCRIPT_NAME = "schema_sdb_v%s.sql" % str(LATEST_DB_VERSION)
DB_DIR_NAME = u"sqlite"
DB_FILE_NAME = u"tribler.sdb"
DB_FILE_RELATIVE_PATH = os.path.join(DB_DIR_NAME, DB_FILE_NAME)
DB_SCRIPT_ABSOLUTE_PATH = os.path.join(get_lib_path(), 'Core', 'CacheDB',
DB_SCRIPT_NAME)
DEFAULT_BUSY_TIMEOUT = 10000
forceDBThread = blocking_call_on_reactor_thread
forceAndReturnDBThread = blocking_call_on_reactor_thread
class CorruptedDatabaseError(Exception):
pass
def bin2str(bin_data):
return encodestring(bin_data).replace("\n", "")
import os
from configobj import ConfigObj
from validate import Validator
from Tribler.Core.Utilities.install_dir import get_lib_path
from Tribler.Core.simpledefs import STATEDIR_CONFIG
CONFIGSPEC_PATH = os.path.join(get_lib_path(), 'Core', 'Config', 'config.spec')
class TriblerConfig(object):
def __init__(self, session):
config_path = os.path.join(session.get_state_dir(), STATEDIR_CONFIG)
self.config = ConfigObj(config_path, configspec=CONFIGSPEC_PATH)
validator = Validator()
self.config.validate(validator, copy=True)
self.config.write()
if "user_download_states" not in self.config:
self.config["user_download_states"] = {}
#
# General
#
def set_family_filter_enabled(self, value):
self.config['general']['family_filter'] = value
self.config.write()
def get_family_filter_enabled(self):
return self.config['general']['family_filter']
from configobj import ConfigObj
from six import text_type
from validate import Validator
from Tribler.Core.DownloadConfig import get_default_dest_dir
from Tribler.Core.Utilities.install_dir import get_lib_path
from Tribler.Core.Utilities.network_utils import get_random_port
from Tribler.Core.exceptions import InvalidConfigException
from Tribler.Core.osutils import get_appstate_dir
FILENAME = 'triblerd.conf'
SPEC_FILENAME = 'config.spec'
CONFIG_SPEC_PATH = os.path.join(get_lib_path(), 'Core', 'Config', SPEC_FILENAME)
class TriblerConfig(object):
"""
Holds all Tribler Core configurable variables.
This class is a wrapper around a ConfigObj. It has a specification of it's configuration sections and fields,
their allowed values and default value in `config.spec`.
"""
def __init__(self, config=None):
"""
Create a new TriblerConfig instance.
:param config: a ConfigObj instance
# written by Fabian van der Werf, Arno Bakker
# Modified by Raul Jimenez to integrate KTH DHT
# see LICENSE.txt for license information
import os
import sys
import logging
from Tribler.Core.Utilities.install_dir import get_lib_path
logger = logging.getLogger(__name__)
# Add the pymdht directory to the sys path
sys.path.append(os.path.join(get_lib_path(), 'Core', 'DecentralizedTracking'))
DEBUG = False
DHT_IMPORTED = False
try:
import Tribler.Core.DecentralizedTracking.pymdht.core.pymdht as pymdht
import Tribler.Core.DecentralizedTracking.pymdht.core.node as node
import Tribler.Core.DecentralizedTracking.pymdht.plugins.routing_nice_rtt as routing_mod
import Tribler.Core.DecentralizedTracking.pymdht.plugins.lookup_a4 as lookup_mod
import Tribler.Core.DecentralizedTracking.pymdht.core.exp_plugin_template as experimental_m_mod
DHT_IMPORTED = True
except ImportError:
logger.exception(u"Could not import pymdht")
def init(addr, conf_path):
if DEBUG:
log_level = logging.DEBUG
# written by Fabian van der Werf, Arno Bakker
# Modified by Raul Jimenez to integrate KTH DHT
# see LICENSE for license information
import logging
import os
import sys
from Tribler.Core.Utilities.install_dir import get_lib_path
logger = logging.getLogger(__name__)
# Add the pymdht directory to the sys path
sys.path.append(os.path.join(get_lib_path(), 'Core', 'DecentralizedTracking'))
DHT_IMPORTED = False
try:
import Tribler.Core.DecentralizedTracking.pymdht.core.pymdht as pymdht
import Tribler.Core.DecentralizedTracking.pymdht.core.node as node
import Tribler.Core.DecentralizedTracking.pymdht.plugins.routing_nice_rtt as routing_mod
import Tribler.Core.DecentralizedTracking.pymdht.plugins.lookup_a4 as lookup_mod
import Tribler.Core.DecentralizedTracking.pymdht.core.exp_plugin_template as experimental_m_mod
DHT_IMPORTED = True
except ImportError:
logger.exception(u"Could not import pymdht")
def init(addr, conf_path):
logger.debug(u"DHT initialization %s", DHT_IMPORTED)
if DHT_IMPORTED:
my_node = node.Node(addr, None, version=pymdht.VERSION_LABEL)
Author(s): Jelle Roozenburg
"""
from __future__ import absolute_import
import logging
import os
import re
from six.moves import xrange
from Tribler.Core.Utilities.install_dir import get_lib_path
WORDS_REGEXP = re.compile('[a-zA-Z0-9]+')
termfilename = os.path.join(get_lib_path(), 'Core', 'Category', 'filter_terms.filter')
def initTerms(filename):
terms = set()
searchterms = set()
try:
f = open(filename, 'r')
lines = f.read().lower().splitlines()
for line in lines:
if line.startswith('*'):
searchterms.add(line[1:])
else:
terms.add(line)
import sys
from distutils.spawn import find_executable
from Tribler.Core.Utilities.install_dir import get_lib_path
from configobj import ConfigObj
from validate import Validator
from Tribler.Core.CreditMining.BoostingPolicy import CreationDatePolicy
from Tribler.Core.CreditMining.BoostingPolicy import RandomPolicy, SeederRatioPolicy
from Tribler.Core.Utilities.network_utils import get_random_port
from Tribler.Core.exceptions import InvalidConfigException
from Tribler.Core.osutils import get_appstate_dir, is_android
FILENAME = 'triblerd.conf'
SPEC_FILENAME = 'config.spec'
CONFIG_SPEC_PATH = os.path.join(get_lib_path(), 'Core', 'Config',
SPEC_FILENAME)
class TriblerConfig(object):
"""
Holds all Tribler Core configurable variables.
This class is a wrapper around a ConfigObj. It has a specification of it's configuration sections and fields,
their allowed values and default value in `config.spec`.
"""
def __init__(self, config=None):
"""
Create a new TriblerConfig instance.
:param config: a ConfigObj instance
def register(self, session, session_lock):
assert isInIOThread()
if not self.registered:
self.registered = True
self.session = session
self.session_lock = session_lock
# On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root
# certificates provided by the system trust store.
if sys.platform == 'darwin':
os.environ['SSL_CERT_FILE'] = os.path.join(
get_lib_path(), 'root_certs_mac.pem')
if self.session.config.get_torrent_store_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.torrent_store = LevelDbStore(
self.session.config.get_torrent_store_dir())
if not self.torrent_store.get_db():
raise RuntimeError(
"Torrent store (leveldb) is None which should not normally happen"
)
if self.session.config.get_metadata_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.metadata_store = LevelDbStore(
self.session.config.get_metadata_store_dir())
if not self.metadata_store.get_db():
raise RuntimeError(
"Metadata store (leveldb) is None which should not normally happen"
)
# torrent collecting: RemoteTorrentHandler
if self.session.config.get_torrent_collecting_enabled():
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
self.rtorrent_handler = RemoteTorrentHandler(self.session)
# TODO(emilon): move this to a megacache component or smth
if self.session.config.get_megacache_enabled():
from Tribler.Core.CacheDB.SqliteCacheDBHandler import (
PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler,
VoteCastDBHandler, ChannelCastDBHandler)
from Tribler.Core.Category.Category import Category
self._logger.debug('tlm: Reading Session state from %s',
self.session.config.get_state_dir())
self.category = Category()
# create DBHandlers
self.peer_db = PeerDBHandler(self.session)
self.torrent_db = TorrentDBHandler(self.session)
self.mypref_db = MyPreferenceDBHandler(self.session)
self.votecast_db = VoteCastDBHandler(self.session)
self.channelcast_db = ChannelCastDBHandler(self.session)
# initializes DBHandlers
self.peer_db.initialize()
self.torrent_db.initialize()
self.mypref_db.initialize()
self.votecast_db.initialize()
self.channelcast_db.initialize()
from Tribler.Core.Modules.tracker_manager import TrackerManager
self.tracker_manager = TrackerManager(self.session)
if self.session.config.get_video_server_enabled():
self.video_server = VideoServer(
self.session.config.get_video_server_port(), self.session)
self.video_server.start()
# IPv8
if self.session.config.get_ipv8_enabled():
from Tribler.pyipv8.ipv8.configuration import get_default_configuration
ipv8_config = get_default_configuration()
ipv8_config['port'] = self.session.config.get_dispersy_port()
ipv8_config['address'] = self.session.config.get_ipv8_address()
ipv8_config['overlays'] = []
ipv8_config['keys'] = [] # We load the keys ourselves
if self.session.config.get_ipv8_bootstrap_override():
import Tribler.pyipv8.ipv8.deprecated.community as community_file
community_file._DEFAULT_ADDRESSES = [
self.session.config.get_ipv8_bootstrap_override()
]
community_file._DNS_ADDRESSES = []
self.ipv8 = IPv8(ipv8_config)
self.session.config.set_anon_proxy_settings(
2, ("127.0.0.1",
self.session.config.
get_tunnel_community_socks5_listen_ports()))
# Dispersy
self.tftp_handler = None
if self.session.config.get_dispersy_enabled():
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import MIMEndpoint
from Tribler.dispersy.endpoint import IPv8toDispersyAdapter
# set communication endpoint
if self.session.config.get_ipv8_enabled():
dispersy_endpoint = IPv8toDispersyAdapter(
self.ipv8.endpoint)
else:
dispersy_endpoint = MIMEndpoint(
self.session.config.get_dispersy_port())
working_directory = unicode(
self.session.config.get_state_dir())
self.dispersy = Dispersy(dispersy_endpoint, working_directory)
self.dispersy.statistics.enable_debug_statistics(False)
# register TFTP service
from Tribler.Core.TFTP.handler import TftpHandler
self.tftp_handler = TftpHandler(self.session,
dispersy_endpoint,
"fffffffd".decode('hex'),
block_size=1024)
self.tftp_handler.initialize()
# Torrent search
if self.session.config.get_torrent_search_enabled(
) or self.session.config.get_channel_search_enabled():
self.search_manager = SearchManager(self.session)
self.search_manager.initialize()
if not self.initComplete:
self.init()
self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER,
[NTFY_STARTED])
self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None)
return self.startup_deferred
def register(self, session, session_lock):
assert isInIOThread()
if not self.registered:
self.registered = True
self.session = session
self.session_lock = session_lock
# On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root
# certificates provided by the system trust store.
if sys.platform == 'darwin':
os.environ['SSL_CERT_FILE'] = os.path.join(get_lib_path(), 'root_certs_mac.pem')
if self.session.config.get_torrent_store_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.torrent_store = LevelDbStore(self.session.config.get_torrent_store_dir())
if not self.torrent_store.get_db():
raise RuntimeError("Torrent store (leveldb) is None which should not normally happen")
if self.session.config.get_metadata_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.metadata_store = LevelDbStore(self.session.config.get_metadata_store_dir())
if not self.metadata_store.get_db():
raise RuntimeError("Metadata store (leveldb) is None which should not normally happen")
# torrent collecting: RemoteTorrentHandler
if self.session.config.get_torrent_collecting_enabled() and self.session.config.get_dispersy_enabled():
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
self.rtorrent_handler = RemoteTorrentHandler(self.session)
# TODO(emilon): move this to a megacache component or smth
if self.session.config.get_megacache_enabled():
from Tribler.Core.CacheDB.SqliteCacheDBHandler import (PeerDBHandler, TorrentDBHandler,
MyPreferenceDBHandler, VoteCastDBHandler,
ChannelCastDBHandler)
from Tribler.Core.Category.Category import Category
self._logger.debug('tlm: Reading Session state from %s', self.session.config.get_state_dir())
self.category = Category()
# create DBHandlers
self.peer_db = PeerDBHandler(self.session)
self.torrent_db = TorrentDBHandler(self.session)
self.mypref_db = MyPreferenceDBHandler(self.session)
self.votecast_db = VoteCastDBHandler(self.session)
self.channelcast_db = ChannelCastDBHandler(self.session)
# initializes DBHandlers
self.peer_db.initialize()
self.torrent_db.initialize()
self.mypref_db.initialize()
self.votecast_db.initialize()
self.channelcast_db.initialize()
from Tribler.Core.Modules.tracker_manager import TrackerManager
self.tracker_manager = TrackerManager(self.session)
if self.session.config.get_video_server_enabled():
self.video_server = VideoServer(self.session.config.get_video_server_port(), self.session)
self.video_server.start()
# IPv8
if self.session.config.get_ipv8_enabled():
from Tribler.pyipv8.ipv8.configuration import get_default_configuration
ipv8_config = get_default_configuration()
ipv8_config['port'] = self.session.config.get_dispersy_port()
ipv8_config['address'] = self.session.config.get_ipv8_address()
ipv8_config['overlays'] = []
ipv8_config['keys'] = [] # We load the keys ourselves
if self.session.config.get_ipv8_bootstrap_override():
import Tribler.pyipv8.ipv8.deprecated.community as community_file
community_file._DEFAULT_ADDRESSES = [self.session.config.get_ipv8_bootstrap_override()]
community_file._DNS_ADDRESSES = []
self.ipv8 = IPv8(ipv8_config, enable_statistics=self.session.config.get_ipv8_statistics())
self.session.config.set_anon_proxy_settings(2, ("127.0.0.1",
self.session.
config.get_tunnel_community_socks5_listen_ports()))
# Dispersy
self.tftp_handler = None
if self.session.config.get_dispersy_enabled():
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import MIMEndpoint
from Tribler.dispersy.endpoint import IPv8toDispersyAdapter
# set communication endpoint
if self.session.config.get_ipv8_enabled():
dispersy_endpoint = IPv8toDispersyAdapter(self.ipv8.endpoint)
else:
dispersy_endpoint = MIMEndpoint(self.session.config.get_dispersy_port())
working_directory = unicode(self.session.config.get_state_dir())
self.dispersy = Dispersy(dispersy_endpoint, working_directory)
self.dispersy.statistics.enable_debug_statistics(False)
# register TFTP service
from Tribler.Core.TFTP.handler import TftpHandler
self.tftp_handler = TftpHandler(self.session, dispersy_endpoint, "fffffffd".decode('hex'),
block_size=1024)
self.tftp_handler.initialize()
# Torrent search
if self.session.config.get_torrent_search_enabled() or self.session.config.get_channel_search_enabled():
self.search_manager = SearchManager(self.session)
self.search_manager.initialize()
if not self.initComplete:
self.init()
self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER, [NTFY_STARTED])
self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None)
return self.startup_deferred