def __init__(self, binpath, workdir, zerostatedir, listenport, httpgwport,
cmdgwport, connhandler):
# Called by any thread, assume sessionlock is held
self.splock = NoDispersyRLock()
self.binpath = binpath
self.workdir = workdir
self.zerostatedir = zerostatedir
InstanceConnection.__init__(self, None, connhandler,
self.i2ithread_readlinecallback)
# Main UDP listen socket
if listenport is None:
self.listenport = random.randint(10001, 10999)
else:
self.listenport = listenport
# NSSA control socket
if cmdgwport is None:
self.cmdport = random.randint(11001, 11999)
else:
self.cmdport = cmdgwport
# content web server
if httpgwport is None:
self.httpport = random.randint(12001, 12999)
else:
self.httpport = httpgwport
# Security: only accept commands from localhost, enable HTTP gw,
# no stats/webUI web server
args = []
args.append(str(self.binpath))
# Arno, 2012-05-29: Hack. Win32 getopt code eats first arg when Windows app
# instead of CONSOLE app.
args.append("-j")
args.append("-l") # listen port
args.append("0.0.0.0:" + str(self.listenport))
args.append("-c") # command port
args.append("127.0.0.1:" + str(self.cmdport))
args.append("-g") # HTTP gateway port
args.append("127.0.0.1:" + str(self.httpport))
args.append("-w")
if zerostatedir is not None:
args.append("-e")
args.append(zerostatedir)
#args.append("-B") # DEBUG Hack
if DEBUG:
print >> sys.stderr, "SwiftProcess: __init__: Running", args, "workdir", workdir
if sys.platform == "win32":
creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
else:
creationflags = 0
self.popen = subprocess.Popen(args,
close_fds=True,
cwd=workdir,
creationflags=creationflags)
self.roothash2dl = {}
self.donestate = DONE_STATE_WORKING # shutting down
def __init__(self, session, sdef):
self.dllock = NoDispersyRLock()
self.session = session
self.sdef = sdef
self.old_metadir = self.session.get_swift_meta_dir()
# just enough so error saving and get_state() works
self.error = None
# To be able to return the progress of a stopped torrent, how far it got.
self.progressbeforestop = 0.0
# SwiftProcess performing the actual download.
self.sp = None
# spstatus
self.dlstatus = DLSTATUS_WAITING4HASHCHECK
self.dynasize = 0
self.progress = 0.0
self.curspeeds = {DOWNLOAD: 0.0, UPLOAD: 0.0} # bytes/s
self.numleech = 0
self.numseeds = 0
self.contentbytes = {DOWNLOAD: 0, UPLOAD: 0} # bytes
self.done = False # when set it means this download is being removed
self.midict = {}
self.time_seeding = [0, None]
self.total_up = 0
self.total_down = 0
self.lm_network_vod_event_callback = None
self.askmoreinfo = False
def __init__(self, trsession, ignore_singleton=False):
if not ignore_singleton:
if LibtorrentMgr.__single:
raise RuntimeError("LibtorrentMgr is singleton")
LibtorrentMgr.__single = self
self.trsession = trsession
settings = lt.session_settings()
settings.user_agent = 'Tribler/' + version_id
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(int,
version_id.split('-')[0].split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
self.ltsession = lt.session(lt.fingerprint(*fingerprint), flags=1)
self.ltsession.set_settings(settings)
self.ltsession.set_alert_mask(
lt.alert.category_t.stats_notification
| lt.alert.category_t.error_notification
| lt.alert.category_t.status_notification
| lt.alert.category_t.storage_notification
| lt.alert.category_t.performance_warning
| lt.alert.category_t.debug_notification)
self.ltsession.listen_on(self.trsession.get_listen_port(),
self.trsession.get_listen_port() + 10)
self.set_upload_rate_limit(-1)
self.set_download_rate_limit(-1)
self.upnp_mapper = self.ltsession.start_upnp()
print >> sys.stderr, "LibtorrentMgr: listening on %d" % self.ltsession.listen_port(
)
# Start DHT
self.dht_ready = False
try:
dht_state = open(
os.path.join(self.trsession.get_state_dir(),
DHTSTATE_FILENAME)).read()
self.ltsession.start_dht(lt.bdecode(dht_state))
except:
print >> sys.stderr, "LibtorrentMgr: could not restore dht state, starting from scratch"
self.ltsession.start_dht(None)
self.ltsession.add_dht_router('router.bittorrent.com', 6881)
self.ltsession.add_dht_router('router.utorrent.com', 6881)
self.ltsession.add_dht_router('router.bitcomet.com', 6881)
self.torlock = NoDispersyRLock()
self.torrents = {}
self.metainfo_requests = {}
self.metainfo_lock = threading.RLock()
self.metainfo_cache = {}
self.trsession.lm.rawserver.add_task(self.process_alerts, 1)
self.trsession.lm.rawserver.add_task(self.reachability_check, 1)
self.trsession.lm.rawserver.add_task(self.monitor_dht, 5)
self.upnp_mappings = {}
def setUp(self, annotate=True):
TriblerCoreTest.setUp(self, annotate=annotate)
self.lm = TriblerLaunchMany()
self.lm.sesslock = NoDispersyRLock()
self.lm.session = MockObject()
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
def __init__(self,
config=None,
ignore_singleton=False,
autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param ignore_singleton: for testing purposes only. Enables the existence of multiple
Session instances.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
if not ignore_singleton:
if Session.__single:
raise RuntimeError("Session is singleton")
Session.__single = self
self._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.session_lock = NoDispersyRLock()
self.config = config or TriblerConfig()
self.get_ports_in_config()
self.create_state_directory_structure()
if not config.get_megacache_enabled():
config.set_torrent_checking_enabled(False)
self.selected_ports = config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.sqlite_db = None
self.upgrader = None
self.dispersy_member = None
self.autoload_discovery = autoload_discovery
def setUp(self, annotate=True):
TriblerCoreTest.setUp(self, annotate=annotate)
self.lm = TriblerLaunchMany()
self.lm.session_lock = NoDispersyRLock()
self.lm.session = MockObject()
self.lm.session.config = MockObject()
self.lm.session.config.get_max_upload_rate = lambda: 100
self.lm.session.config.get_max_download_rate = lambda: 100
self.lm.session.config.get_default_number_hops = lambda: 0
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
def __init__(self, session, tdef):
super(LibtorrentDownloadImpl, self).__init__()
self._logger = logging.getLogger(self.__class__.__name__)
self.dllock = NoDispersyRLock()
self.session = session
self.tdef = tdef
self.handle = None
self.vod_index = None
self.orig_files = None
self.finished_callback = None
self.finished_callback_already_called = False
# To be able to return the progress of a stopped torrent, how far it got.
self.progressbeforestop = 0.0
self.filepieceranges = []
# Libtorrent session manager, can be None at this point as the core could have
# not been started. Will set in create_engine wrapper
self.ltmgr = None
# Libtorrent status
self.lt_status = None
self.error = None
self.done = False
self.pause_after_next_hashcheck = False
self.checkpoint_after_next_hashcheck = False
self.tracker_status = {} # {url: [num_peers, status_str]}
self.prebuffsize = 5 * 1024 * 1024
self.endbuffsize = 0
self.vod_seekpos = 0
self.max_prebuffsize = 5 * 1024 * 1024
self.pstate_for_restart = None
self.cew_scheduled = False
self.askmoreinfo = False
self.correctedinfoname = u""
self._checkpoint_disabled = False
self.deferreds_resume = []
self.deferreds_handle = []
self.deferred_added = Deferred()
self.deferred_removed = Deferred()
self.handle_check_lc = self.register_task("handle_check", LoopingCall(self.check_handle))
def __init__(self, trsession, utility):
if LibtorrentMgr.__single:
raise RuntimeError, "LibtorrentMgr is singleton"
LibtorrentMgr.__single = self
self.utility = utility
self.trsession = trsession
settings = lt.session_settings()
settings.user_agent = 'Tribler/' + version_id
fingerprint = ['TL'] + map(int, version_id.split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
self.ltsession = lt.session(lt.fingerprint(*fingerprint), flags=1)
self.ltsession.set_settings(settings)
self.ltsession.set_alert_mask(
lt.alert.category_t.stats_notification
| lt.alert.category_t.error_notification
| lt.alert.category_t.status_notification
| lt.alert.category_t.storage_notification
| lt.alert.category_t.performance_warning)
self.ltsession.listen_on(self.trsession.get_listen_port(),
self.trsession.get_listen_port() + 10)
self.set_upload_rate_limit(-1)
self.set_download_rate_limit(-1)
self.ltsession.start_upnp()
# Start DHT
try:
dht_state = open(
os.path.join(self.trsession.get_state_dir(),
DHTSTATE_FILENAME)).read()
self.ltsession.start_dht(lt.bdecode(dht_state))
except:
print >> sys.stderr, "LibtorrentMgr: could not restore dht state, starting from scratch"
self.ltsession.start_dht(None)
self.ltsession.add_dht_router('router.bittorrent.com', 6881)
self.ltsession.add_dht_router('router.utorrent.com', 6881)
self.ltsession.add_dht_router('router.bitcomet.com', 6881)
self.torlock = NoDispersyRLock()
self.torrents = {}
self.trsession.lm.rawserver.add_task(self.process_alerts, 1)
self.trsession.lm.rawserver.add_task(self.reachability_check, 1)
def __init__(self, config=None, autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
self._logger = logging.getLogger(self.__class__.__name__)
self.session_lock = NoDispersyRLock()
self.config = config or TriblerConfig()
self.get_ports_in_config()
self.create_state_directory_structure()
if not self.config.get_megacache_enabled():
self.config.set_torrent_checking_enabled(False)
self.selected_ports = self.config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
def __init__(self, session, tdef):
self.dllock = NoDispersyRLock()
self.session = session
self.tdef = tdef
self.handle = None
# Just enough so error saving and get_state() works
self.error = None
# To be able to return the progress of a stopped torrent, how far it got.
self.progressbeforestop = 0.0
self.filepieceranges = []
# Libtorrent session manager
self.ltmgr = LibtorrentMgr.getInstance()
# Libtorrent status
self.dlstates = [DLSTATUS_WAITING4HASHCHECK, DLSTATUS_HASHCHECKING, DLSTATUS_METADATA, DLSTATUS_DOWNLOADING, DLSTATUS_SEEDING, DLSTATUS_SEEDING, DLSTATUS_ALLOCATING_DISKSPACE, DLSTATUS_HASHCHECKING]
self.dlstate = DLSTATUS_WAITING4HASHCHECK
self.length = 0L
self.progress = 0.0
self.bufferprogress = 0.0
self.curspeeds = {DOWNLOAD:0.0,UPLOAD:0.0} # bytes/s
self.all_time_upload = 0.0
self.all_time_download = 0.0
self.finished_time = 0.0
self.done = False
self.pause_after_next_hashcheck = False
self.checkpoint_after_next_hashcheck = False
self.prebuffsize = 5*1024*1024
self.queue_position = -1
self.vod_readpos = 0
self.vod_pausepos = 0
self.vod_status = ""
self.lm_network_vod_event_callback = None
self.pstate_for_restart = None
self.cew_scheduled = False
def __init__(self, session, sdef):
self.dllock = NoDispersyRLock()
self.session = session
self.sdef = sdef
# just enough so error saving and get_state() works
self.error = None
# To be able to return the progress of a stopped torrent, how far it got.
self.progressbeforestop = 0.0
# SwiftProcess performing the actual download.
self.sp = None
# spstatus
self.dlstatus = DLSTATUS_WAITING4HASHCHECK
self.dynasize = 0L
self.progress = 0.0
self.curspeeds = {DOWNLOAD: 0.0, UPLOAD: 0.0} # bytes/s
self.numleech = 0
self.numseeds = 0
self.done = False
self.midict = {}
self.lm_network_vod_event_callback = None
def __init__(self,scfg=None,ignore_singleton=False):
"""
A Session object is created which is configured following a copy of the
SessionStartupConfig scfg. (copy constructor used internally)
@param scfg SessionStartupConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new SessionStartupConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
In the current implementation only a single session instance can exist
at a time in a process. The ignore_singleton flag is used for testing.
"""
# ProxyService 90s Test_
# self.start_time = time.time()
# _ProxyService 90s Test
if not ignore_singleton:
if Session.__single:
raise RuntimeError, "Session is singleton"
Session.__single = self
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
try:
# Then try to read from default location
state_dir = Session.get_default_state_dir()
cfgfilename = Session.get_default_config_filename(state_dir)
scfg = SessionStartupConfig.load(cfgfilename)
except:
# If that fails, create a fresh config with factory defaults
print_exc()
scfg = SessionStartupConfig()
self.sessconfig = scfg.sessconfig
else: # overrides any saved config
# Work from copy
self.sessconfig = copy.copy(scfg.sessconfig)
#Niels: 11/05/2012, turning off overlay
self.sessconfig['overlay'] = 0
self.sessconfig['crawler'] = 0
# Create dir for session state, if not exist
state_dir = self.sessconfig['state_dir']
if state_dir is None:
state_dir = Session.get_default_state_dir()
self.sessconfig['state_dir'] = state_dir
if not os.path.isdir(state_dir):
os.makedirs(state_dir)
collected_torrent_dir = self.sessconfig['torrent_collecting_dir']
if not collected_torrent_dir:
collected_torrent_dir = os.path.join(self.sessconfig['state_dir'], STATEDIR_TORRENTCOLL_DIR)
self.sessconfig['torrent_collecting_dir'] = collected_torrent_dir
collected_subtitles_dir = self.sessconfig.get('subtitles_collecting_dir',None)
if not collected_subtitles_dir:
collected_subtitles_dir = os.path.join(self.sessconfig['state_dir'], STATEDIR_SUBSCOLL_DIR)
self.sessconfig['subtitles_collecting_dir'] = collected_subtitles_dir
if not os.path.exists(collected_torrent_dir):
os.makedirs(collected_torrent_dir)
if not self.sessconfig['peer_icon_path']:
self.sessconfig['peer_icon_path'] = os.path.join(self.sessconfig['state_dir'], STATEDIR_PEERICON_DIR)
# PERHAPS: load default TorrentDef and DownloadStartupConfig from state dir
# Let user handle that, he's got default_state_dir, etc.
# Core init
#print >>sys.stderr,'Session: __init__ config is', self.sessconfig
if GOTM2CRYPTO:
permidmod.init()
#
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = os.path.join(self.sessconfig['state_dir'],'ec.pem')
if self.sessconfig['eckeypairfilename'] is None:
self.sessconfig['eckeypairfilename'] = pairfilename
if os.access(self.sessconfig['eckeypairfilename'],os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(self.sessconfig['eckeypairfilename'])
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'],'ecpub.pem')
permidmod.save_keypair(self.keypair,pairfilename)
permidmod.save_pub_key(self.keypair,pubfilename)
# 2. Downloads persistent state dir
dlpstatedir = os.path.join(self.sessconfig['state_dir'],STATEDIR_DLPSTATE_DIR)
if not os.path.isdir(dlpstatedir):
os.mkdir(dlpstatedir)
# 3. tracker
trackerdir = self.get_internal_tracker_dir()
if not os.path.exists(trackerdir):
os.mkdir(trackerdir)
if self.sessconfig['tracker_dfile'] is None:
self.sessconfig['tracker_dfile'] = os.path.join(trackerdir,'tracker.db')
if self.sessconfig['tracker_allowed_dir'] is None:
self.sessconfig['tracker_allowed_dir'] = trackerdir
if self.sessconfig['tracker_logfile'] is None:
if sys.platform == "win32":
# Not "Nul:" but "nul" is /dev/null on Win32
sink = 'nul'
else:
sink = '/dev/null'
self.sessconfig['tracker_logfile'] = sink
# 4. superpeer.txt and crawler.txt
if self.sessconfig['superpeer_file'] is None:
self.sessconfig['superpeer_file'] = os.path.join(self.sessconfig['install_dir'],LIBRARYNAME,'Core','superpeer.txt')
if 'crawler_file' not in self.sessconfig or self.sessconfig['crawler_file'] is None:
self.sessconfig['crawler_file'] = os.path.join(self.sessconfig['install_dir'], LIBRARYNAME,'Core','Statistics','crawler.txt')
# 5. peer_icon_path
if self.sessconfig['peer_icon_path'] is None:
self.sessconfig['peer_icon_path'] = os.path.join(self.sessconfig['state_dir'],STATEDIR_PEERICON_DIR)
if not os.path.isdir(self.sessconfig['peer_icon_path']):
os.mkdir(self.sessconfig['peer_icon_path'])
# 6. Poor man's versioning of SessionConfig, add missing
# default values. Really should use PERSISTENTSTATE_CURRENTVERSION
# and do conversions.
for key,defvalue in sessdefaults.iteritems():
if key not in self.sessconfig:
self.sessconfig[key] = defvalue
# 7. proxyservice_dir
if self.sessconfig['overlay']: #NIELS: proxyservice_on/off is set at runtime, always make sure proxyservice_ and self.sessconfig['proxyservice_status'] == PROXYSERVICE_ON:
if self.sessconfig['proxyservice_dir'] is None:
self.sessconfig['proxyservice_dir'] = os.path.join(get_default_dest_dir(), PROXYSERVICE_DESTDIR)
# Jelle: under linux, default_dest_dir can be /tmp. Then proxyservice_dir can be deleted in between
# sessions.
if not os.path.isdir(self.sessconfig['proxyservice_dir']):
os.makedirs(self.sessconfig['proxyservice_dir'])
if not 'live_aux_seeders' in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig['live_aux_seeders'] = sessdefaults['live_aux_seeders']
if not 'nat_detect' in self.sessconfig:
self.sessconfig['nat_detect'] = sessdefaults['nat_detect']
if not 'puncturing_internal_port' in self.sessconfig:
self.sessconfig['puncturing_internal_port'] = sessdefaults['puncturing_internal_port']
if not 'stun_servers' in self.sessconfig:
self.sessconfig['stun_servers'] = sessdefaults['stun_servers']
if not 'pingback_servers' in self.sessconfig:
self.sessconfig['pingback_servers'] = sessdefaults['pingback_servers']
if not 'mainline_dht' in self.sessconfig:
self.sessconfig['mainline_dht'] = sessdefaults['mainline_dht']
# SWIFTPROC
if self.sessconfig['swiftpath'] is None:
if sys.platform == "win32":
self.sessconfig['swiftpath'] = os.path.join(self.sessconfig['install_dir'],"swift.exe")
else:
self.sessconfig['swiftpath'] = os.path.join(self.sessconfig['install_dir'],"swift")
# Checkpoint startup config
self.save_pstate_sessconfig()
# Create handler for calling back the user via separate threads
self.uch = UserCallbackHandler(self)
# Create engine with network thread
self.lm = TriblerLaunchMany()
self.lm.register(self,self.sesslock)
self.lm.start()
def __init__(self,
scfg=None,
ignore_singleton=False,
autoload_discovery=True):
"""
A Session object is created which is configured following a copy of the
SessionStartupConfig scfg. (copy constructor used internally)
@param scfg SessionStartupConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new SessionStartupConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
In the current implementation only a single session instance can exist
at a time in a process. The ignore_singleton flag is used for testing.
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
if not ignore_singleton:
if Session.__single:
raise RuntimeError("Session is singleton")
Session.__single = self
self._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
scfg = SessionStartupConfig.load()
else: # overrides any saved config
# Work from copy
scfg = SessionStartupConfig(copy.copy(scfg.sessconfig))
def create_dir(fullpath):
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
def set_and_create_dir(dirname, setter, default_dir):
if dirname is None:
setter(default_dir)
create_dir(dirname or default_dir)
state_dir = scfg.get_state_dir()
set_and_create_dir(state_dir, scfg.set_state_dir, state_dir)
set_and_create_dir(
scfg.get_torrent_store_dir(), scfg.set_torrent_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_TORRENT_STORE_DIR))
# metadata store
set_and_create_dir(
scfg.get_metadata_store_dir(), scfg.set_metadata_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_METADATA_STORE_DIR))
set_and_create_dir(
scfg.get_peer_icon_path(), scfg.set_peer_icon_path,
os.path.join(scfg.get_state_dir(), STATEDIR_PEERICON_DIR))
create_dir(os.path.join(scfg.get_state_dir(), u"sqlite"))
create_dir(os.path.join(scfg.get_state_dir(), STATEDIR_DLPSTATE_DIR))
if GOTM2CRYPTO:
permidmod.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = scfg.get_permid_keypair_filename()
if os.path.exists(pairfilename):
self.keypair = permidmod.read_keypair(pairfilename)
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(scfg.get_state_dir(), 'ecpub.pem')
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
multichain_pairfilename = scfg.get_multichain_permid_keypair_filename(
)
if os.path.exists(multichain_pairfilename):
self.multichain_keypair = permidmod.read_keypair_multichain(
multichain_pairfilename)
else:
self.multichain_keypair = permidmod.generate_keypair_multichain(
)
# Save keypair
multichain_pubfilename = os.path.join(scfg.get_state_dir(),
'ecpub_multichain.pem')
permidmod.save_keypair_multichain(self.multichain_keypair,
multichain_pairfilename)
permidmod.save_pub_key_multichain(self.multichain_keypair,
multichain_pubfilename)
if not scfg.get_megacache():
scfg.set_torrent_checking(0)
self.sessconfig = scfg.sessconfig
self.sessconfig.lock = self.sesslock
self.selected_ports = scfg.selected_ports
# Claim all random ports
self.get_listen_port()
self.get_dispersy_port()
self.get_mainline_dht_listen_port()
self.get_videoserver_port()
self.get_anon_listen_port()
self.get_tunnel_community_socks5_listen_ports()
# Create handler for calling back the user via separate threads
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
# Checkpoint startup config
self.save_session_config()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
self.tribler_config = TriblerConfig(self)
self.setup_tribler_gui_config()
def __init__(self, scfg=None, ignore_singleton=False, autoload_discovery=True):
"""
A Session object is created which is configured following a copy of the
SessionStartupConfig scfg. (copy constructor used internally)
@param scfg SessionStartupConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new SessionStartupConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
In the current implementation only a single session instance can exist
at a time in a process. The ignore_singleton flag is used for testing.
"""
if not ignore_singleton:
if Session.__single:
raise RuntimeError("Session is singleton")
Session.__single = self
self._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
scfg = SessionStartupConfig.load()
else: # overrides any saved config
# Work from copy
scfg = SessionStartupConfig(copy.copy(scfg.sessconfig))
def create_dir(fullpath):
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
def set_and_create_dir(dirname, setter, default_dir):
if dirname is None:
setter(default_dir)
create_dir(dirname or default_dir)
state_dir = scfg.get_state_dir()
set_and_create_dir(state_dir, scfg.set_state_dir, state_dir)
set_and_create_dir(scfg.get_torrent_store_dir(),
scfg.set_torrent_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_TORRENT_STORE_DIR))
# metadata store
set_and_create_dir(scfg.get_metadata_store_dir(),
scfg.set_metadata_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_METADATA_STORE_DIR))
set_and_create_dir(scfg.get_peer_icon_path(), scfg.set_peer_icon_path,
os.path.join(scfg.get_state_dir(), STATEDIR_PEERICON_DIR))
create_dir(os.path.join(scfg.get_state_dir(), u"sqlite"))
create_dir(os.path.join(scfg.get_state_dir(), STATEDIR_DLPSTATE_DIR))
# Reset the nickname to something not related to the host name, it was
# really silly to have this default on the first place.
# TODO: Maybe move this to the upgrader?
if socket.gethostname() in scfg.get_nickname():
scfg.set_nickname("Tribler user")
if GOTM2CRYPTO:
permidmod.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = scfg.get_permid_keypair_filename()
if os.access(pairfilename, os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(pairfilename)
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(scfg.get_state_dir(), 'ecpub.pem')
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
if not scfg.get_megacache():
scfg.set_torrent_checking(0)
self.sessconfig = scfg.sessconfig
self.sessconfig.lock = self.sesslock
self.selected_ports = scfg.selected_ports
# Claim all random ports
self.get_listen_port()
self.get_dispersy_port()
self.get_mainline_dht_listen_port()
self.get_videoplayer_port()
self.get_anon_listen_port()
self.get_tunnel_community_socks5_listen_ports()
# Create handler for calling back the user via separate threads
self.lm = TriblerLaunchMany()
self.notifier = Notifier(use_pool=True)
# Checkpoint startup config
self.save_pstate_sessconfig()
self.sqlite_db = None
self.autoload_discovery = autoload_discovery
def __init__(self, scfg=None, ignore_singleton=False):
"""
A Session object is created which is configured following a copy of the
SessionStartupConfig scfg. (copy constructor used internally)
@param scfg SessionStartupConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new SessionStartupConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
In the current implementation only a single session instance can exist
at a time in a process. The ignore_singleton flag is used for testing.
"""
if not ignore_singleton:
if Session.__single:
raise RuntimeError("Session is singleton")
Session.__single = self
self.ignore_singleton = ignore_singleton
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
try:
# Then try to read from default location
state_dir = Session.get_default_state_dir()
cfgfilename = Session.get_default_config_filename(state_dir)
scfg = SessionStartupConfig.load(cfgfilename)
except:
# If that fails, create a fresh config with factory defaults
print_exc()
scfg = SessionStartupConfig()
self.sessconfig = scfg.sessconfig
else: # overrides any saved config
# Work from copy
self.sessconfig = copy.copy(scfg.sessconfig)
def create_dir(fullpath):
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
def set_and_create_dir(config, name, default_dir):
dirname = config.get(name, None)
if dirname is None:
config[name] = default_dir
create_dir(config[name])
set_and_create_dir(self.sessconfig, 'state_dir', Session.get_default_state_dir())
set_and_create_dir(self.sessconfig, 'torrent_collecting_dir', os.path.join(self.sessconfig['state_dir'], STATEDIR_TORRENTCOLL_DIR))
set_and_create_dir(self.sessconfig, 'swiftmetadir', os.path.join(self.sessconfig['state_dir'], STATEDIR_SWIFTRESEED_DIR))
set_and_create_dir(self.sessconfig, 'peer_icon_path', os.path.join(self.sessconfig['state_dir'], STATEDIR_PEERICON_DIR))
create_dir(os.path.join(self.sessconfig['state_dir'], STATEDIR_DLPSTATE_DIR))
# Poor man's versioning of SessionConfig, add missing
# default values. Really should use PERSISTENTSTATE_CURRENTVERSION
# and do conversions.
for key, defvalue in sessdefaults.iteritems():
if key not in self.sessconfig:
self.sessconfig[key] = defvalue
if self.sessconfig['nickname'] == '__default_name__':
self.sessconfig['nickname'] = socket.gethostname()
# SWIFTPROC
if self.sessconfig['swiftpath'] is None:
if sys.platform == "win32":
self.sessconfig['swiftpath'] = os.path.join(self.sessconfig['install_dir'], "swift.exe")
else:
self.sessconfig['swiftpath'] = os.path.join(self.sessconfig['install_dir'], "swift")
if GOTM2CRYPTO:
permidmod.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = os.path.join(self.sessconfig['state_dir'], 'ec.pem')
if self.sessconfig['eckeypairfilename'] is None:
self.sessconfig['eckeypairfilename'] = pairfilename
if os.access(self.sessconfig['eckeypairfilename'], os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(self.sessconfig['eckeypairfilename'])
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'], 'ecpub.pem')
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
# Checkpoint startup config
self.save_pstate_sessconfig()
def __init__(self, binpath, workdir, zerostatedir, listenport, httpgwport,
cmdgwport, spmgr):
# Called by any thread, assume sessionlock is held
self.splock = NoDispersyRLock()
self.binpath = binpath
self.workdir = workdir
self.zerostatedir = zerostatedir
self.spmgr = spmgr
# Main UDP listen socket
if listenport is None:
self.listenport = random.randint(10001, 10999)
else:
self.listenport = listenport
# NSSA control socket
if cmdgwport is None:
self.cmdport = random.randint(11001, 11999)
else:
self.cmdport = cmdgwport
# content web server
if httpgwport is None:
self.httpport = random.randint(12001, 12999)
else:
self.httpport = httpgwport
# Security: only accept commands from localhost, enable HTTP gw,
# no stats/webUI web server
args = []
# Arno, 2012-07-09: Unicode problems with popen
args.append(self.binpath.encode(sys.getfilesystemencoding()))
# Arno, 2012-05-29: Hack. Win32 getopt code eats first arg when Windows app
# instead of CONSOLE app.
args.append("-j")
args.append("-l") # listen port
args.append("0.0.0.0:" + str(self.listenport))
args.append("-c") # command port
args.append("127.0.0.1:" + str(self.cmdport))
args.append("-g") # HTTP gateway port
args.append("127.0.0.1:" + str(self.httpport))
args.append("-w")
if zerostatedir is not None:
if sys.platform == "win32":
# Swift on Windows expects command line arguments as UTF-16.
# popen doesn't allow us to pass params in UTF-16, hence workaround.
# Format = hex encoded UTF-8
args.append("-3")
zssafe = binascii.hexlify(zerostatedir.encode("UTF-8"))
args.append(zssafe) # encoding that swift expects
else:
args.append("-e")
args.append(zerostatedir)
args.append("-T") # zero state connection timeout
args.append("180") # seconds
#args.append("-B") # Enable debugging on swift
if True or DEBUG:
print >> sys.stderr, "SwiftProcess: __init__: Running", args, "workdir", workdir
if sys.platform == "win32":
creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
else:
creationflags = 0
# See also SwiftDef::finalize popen
self.popen = subprocess.Popen(args,
close_fds=True,
cwd=workdir,
creationflags=creationflags)
self.roothash2dl = {}
self.donestate = DONE_STATE_WORKING # shutting down
self.fastconn = None
# callbacks for when swift detect a channel close
self._channel_close_callbacks = defaultdict(list)