def create_torrent(file, port, try_vod = True):
'''
Creates a torrent for the given file. Returns a string representing the
path to the torrent file.
If try_vod is True try to add the playtime to the torrent making it "streamable".
'''
# generate torrent
tdef = TorrentDef()
url = "http://localhost:%s/announce/" % port
tdef.set_tracker(url)
#tdef.set_create_merkle_torrent(True)
#tdef.set_piece_length(self._pieceSize)
if try_vod:
torrent_name = FileUtils.get_relative_filename(file) + constants.TORRENT_VOD_EXT
# set playtime
playtime = videostats_via_ffmpeg(file)['playtime']
print "playtime", playtime
else:
torrent_name = FileUtils.get_relative_filename(file) + constants.TORRENT_DOWNLOAD_EXT
playtime = None
print "Create a non-streamable torrent"
tdef.add_content(file, playtime=playtime)
tdef.finalize()
torrent_dir = os.getcwd()
torrent = os.path.join(torrent_dir, torrent_name)
tdef.save(torrent)
print "created torrent file: %s" % torrent
print "Tracker uses the announce URL: %s" % tdef.get_tracker()
return tdef
def _cleanup(self, signal=None, func=None):
if self._config.get_delete_directories():
FileUtils.remove_directory_recursively(
self._config.get_directory())
FileUtils.remove_directory_recursively(
self._config.get_state_directory())
self._logger.warn("Removed directories %s and %s" %
(self._config.get_directory(),
self._config.get_state_directory()))
def _copy_files_to_client(self, from_dir, to_dir, is_seeder=False):
from_files = [ from_dir + os.path.normcase('/') + self.FILE_RELATIVE + constants.TORRENT_DOWNLOAD_EXT ]
if is_seeder:
from_files.append(from_dir + os.path.normcase('/') + self.FILE_RELATIVE)
for file in from_files:
shutil.copy(file, to_dir + os.path.normcase('/') + \
FileUtils.get_relative_filename(file))
def spawn_headless(ulrate):
global seeder_proc, __TORRENT__, __DOWNLOAD__, __HEADLESS_SCRIPT__
os.makedirs('basic_scenario_seeder')
shutil.copyfile(__TORRENT__, os.path.join('basic_scenario_seeder', __TORRENT__))
shutil.copyfile(__DOWNLOAD__, os.path.join('basic_scenario_seeder', FileUtils.get_relative_filename(__DOWNLOAD__)))
shellcmd = 'python %s -p 50000 -d basic_scenario_seeder -x %i --single_torrent=%s' % (
__HEADLESS_SCRIPT__, ulrate, os.path.join('basic_scenario_seeder', __TORRENT__))
seeder_proc = Popen(shellcmd.split(' '), shell=__USE_SHELL__)
def _copy_files_to_client(self, from_dir, to_dir, is_seeder=False):
from_files = [
from_dir + os.path.normcase('/') + self.FILE_RELATIVE +
constants.TORRENT_DOWNLOAD_EXT
]
if is_seeder:
from_files.append(from_dir + os.path.normcase('/') +
self.FILE_RELATIVE)
for file in from_files:
shutil.copy(file, to_dir + os.path.normcase('/') + \
FileUtils.get_relative_filename(file))
def create_torrent(file, port, try_vod=True):
'''
Creates a torrent for the given file. Returns a string representing the
path to the torrent file.
If try_vod is True try to add the playtime to the torrent making it "streamable".
'''
# generate torrent
tdef = TorrentDef()
url = "http://localhost:%s/announce/" % port
tdef.set_tracker(url)
#tdef.set_create_merkle_torrent(True)
#tdef.set_piece_length(self._pieceSize)
if try_vod:
torrent_name = FileUtils.get_relative_filename(
file) + constants.TORRENT_VOD_EXT
# set playtime
playtime = videostats_via_ffmpeg(file)['playtime']
print "playtime", playtime
else:
torrent_name = FileUtils.get_relative_filename(
file) + constants.TORRENT_DOWNLOAD_EXT
playtime = None
print "Create a non-streamable torrent"
tdef.add_content(file, playtime=playtime)
tdef.finalize()
torrent_dir = os.getcwd()
torrent = os.path.join(torrent_dir, torrent_name)
tdef.save(torrent)
print "created torrent file: %s" % torrent
print "Tracker uses the announce URL: %s" % tdef.get_tracker()
return tdef
def __init__(self, client_config):
self._config = client_config
self._logger = logging.getLogger(self._get_name())
self._local_reporter = None
if self._config.get_logfile() is not None:
logfile_directory = FileUtils.get_path_from_full_filename(self._config.get_logfile())
if self._config.get_logfile().find(os.path.normcase('/')) > -1 and \
not os.access(logfile_directory, os.F_OK):
os.mkdir(logfile_directory)
torrent_file = self._config.get_single_torrent()
if torrent_file is not None:
if not os.access(torrent_file, os.F_OK):
self._logger.error("The specified torrent file %s does not exist." % torrent_file)
self._on_exit()
def main():
global __TORRENT__, __TORRENT_NEW__, __DOWNLOAD__, active_procs
if len(sys.argv[1:]) != 1:
print >>sys.stderr, 'Usage: %s <full download>' % sys.argv[0]
sys.exit(1)
__DOWNLOAD__ = sys.argv[1]
__TORRENT__ = FileUtils.get_relative_filename(__DOWNLOAD__) + constants.TORRENT_DOWNLOAD_EXT
__TORRENT_NEW__ = __TORRENT__ + '-new'
check_dependencies()
prepare_scenario()
start_ts = time.time()
last_vodclient_spawned = time.time()-30.0
print >>sys.stderr, 'Spawning tracker process...'
spawn_tracker()
time.sleep(10)
print >>sys.stderr, 'Fetching torrent from tracker...'
shutil.copyfile(os.path.join('basic_scenario_tracker', __TORRENT__), __TORRENT__)
print >>sys.stderr, 'Adding playtime information to %s' % __TORRENT__
add_playtime_to_torrent(__TORRENT__)
tdef = TorrentDef.load(__TORRENT_NEW__)
bitrate = tdef.get_bitrate()
print >>sys.stderr, 'Bitrate is: %i' % bitrate
print >>sys.stderr, 'Spawning seeder process...'
spawn_headless(bitrate*4)
FINISH_TIME = 90 # experiment duration in seconds
count = 0
while (time.time() - start_ts <= FINISH_TIME):
if count == 10:
count = 0
print >>sys.stderr, 'Scenario progress '+str(time.time() - start_ts)
count+=1
# remove finished vodclient processes
active_procs = [p for p in active_procs if p.poll() == None]
# check if we have to spawn a new vodclient
ts = time.time()
if ts - last_vodclient_spawned >= 30.0 and len(active_procs) < 2:
print >>sys.stderr, '%s: Spawning new vod client... experiment progress is %f' % (str(ts), ts/start_ts*100)
spawn_vodclient(bitrate/4, bitrate)
last_vodclient_spawned = ts
time.sleep(1.0)
print >>sys.stderr, 'Emulation finished, finish and exit...'
cleanup()
os._exit(0)
def __init__(self, client_config):
self._config = client_config
self._logger = logging.getLogger(self._get_name())
self._local_reporter = None
if self._config.get_logfile() is not None:
logfile_directory = FileUtils.get_path_from_full_filename(
self._config.get_logfile())
if self._config.get_logfile().find(os.path.normcase('/')) > -1 and \
not os.access(logfile_directory, os.F_OK):
os.mkdir(logfile_directory)
torrent_file = self._config.get_single_torrent()
if torrent_file is not None:
if not os.access(torrent_file, os.F_OK):
self._logger.error(
"The specified torrent file %s does not exist." %
torrent_file)
self._on_exit()
def cleanup():
global vodclient_dirs, tracker_proc, active_procs, seeder_proc
print >>sys.stderr, 'Killing remaining processes...'
tracker_proc.kill()
seeder_proc.kill()
seeder_proc.terminate()
for vodclient_proc in active_procs:
vodclient_proc.kill()
print >>sys.stderr, 'Removing directories...'
FileUtils.remove_directory_recursively('basic_scenario_tracker')
FileUtils.remove_directory_recursively('basic_scenario_seeder')
FileUtils.remove_directory_recursively('basic_scenario_files')
for dir in vodclient_dirs:
os.removedirs(dir)
os.unlink(__TORRENT_NEW__)
def tearDown(self):
FileUtils.remove_directory_recursively(self.DIRECTORY_TRACKER)
FileUtils.remove_directory_recursively(self.DIRECTORY_LEECHER)
FileUtils.remove_directory_recursively(self.DIRECTORY_SEEDER)
def prepare_scenario():
global __DOWNLOAD__
os.makedirs('basic_scenario_files')
shutil.copyfile(__DOWNLOAD__, os.path.join('basic_scenario_files', FileUtils.get_relative_filename(__DOWNLOAD__)))
def _cleanup(self, signal=None, func=None):
if self._config.get_delete_directories():
FileUtils.remove_directory_recursively(self._config.get_directory())
FileUtils.remove_directory_recursively(self._config.get_state_directory())
self._logger.warn("Removed directories %s and %s" % (self._config.get_directory(),
self._config.get_state_directory()))
def tearDown(self):
FileUtils.remove_directory_recursively(self.DIRECTORY_TRACKER)
FileUtils.remove_directory_recursively(self.DIRECTORY_LEECHER)
FileUtils.remove_directory_recursively(self.DIRECTORY_SEEDER)
class TerminationTest(unittest.TestCase):
DIRECTORY_TRACKER = "test/termination_tracker"
DIRECTORY_SEEDER = "test/termination_seeder"
DIRECTORY_LEECHER = "test/termination_leecher"
FILE = FileUtils.get_current_script_directory(__file__) + \
os.path.normcase('/') + "reports_large.zip"
FILE_RELATIVE = FileUtils.get_relative_filename(FILE)
_start_tracker = "sh tracker.sh -f " + DIRECTORY_TRACKER + \
" -u http://localhost:8859/announce -d " + DIRECTORY_TRACKER
_start_client = "sh client.sh -d %s %s"
_cmd_grep_tracker_pid = "ps -AF | grep tracker.sh"
_cmd_grep_client_pid = "ps -AF | grep client.sh"
def setUp(self):
os.mkdir(self.DIRECTORY_TRACKER)
os.mkdir(self.DIRECTORY_SEEDER)
os.mkdir(self.DIRECTORY_LEECHER)
shutil.copyfile(self.FILE, self.DIRECTORY_TRACKER + \
os.path.normcase('/') + self.FILE_RELATIVE)
def tearDown(self):
FileUtils.remove_directory_recursively(self.DIRECTORY_TRACKER)
FileUtils.remove_directory_recursively(self.DIRECTORY_LEECHER)
FileUtils.remove_directory_recursively(self.DIRECTORY_SEEDER)
def suite(self):
suite = unittest.TestSuite()
suite.addTest(TerminationTest("testTerminateAfterDownload"))
#suite.addTest(TerminationTest("testTerminateAfterPlayback"))
#suite.addTest(TerminationTest("testTerminateAfterSeeding"))
return suite
def _copy_files_to_client(self, from_dir, to_dir, is_seeder=False):
from_files = [
from_dir + os.path.normcase('/') + self.FILE_RELATIVE +
constants.TORRENT_DOWNLOAD_EXT
]
if is_seeder:
from_files.append(from_dir + os.path.normcase('/') +
self.FILE_RELATIVE)
for file in from_files:
shutil.copy(file, to_dir + os.path.normcase('/') + \
FileUtils.get_relative_filename(file))
def testTerminateAfterDownload(self):
start = time.time()
pid_tracker = Popen(self._start_tracker, shell=True)
time.sleep(5)
self._copy_files_to_client(self.DIRECTORY_TRACKER,
self.DIRECTORY_LEECHER,
is_seeder=False)
self._copy_files_to_client(self.DIRECTORY_TRACKER,
self.DIRECTORY_SEEDER,
is_seeder=True)
pid_seeder = Popen(self._start_client % (self.DIRECTORY_SEEDER, ""),
shell=True)
pid_leecher = Popen(self._start_client %
(self.DIRECTORY_LEECHER, "-e download -y 100"),
shell=True)
# wait for the leecher to terminate
pid_leecher.wait()
diff = time.time() - start
self.assertTrue(diff < 60)
os.system("kill -9 %i" % (pid_tracker.pid + 2))
os.system("kill -9 %i" % (pid_seeder.pid + 2))
os.system("kill -9 %i" % (pid_tracker.pid + 1))
os.system("kill -9 %i" % (pid_seeder.pid + 1))
os.system("kill -9 %i" % (pid_seeder.pid + 0))
def testTerminateAfterPlayback(self):
start = time.time()
pid_tracker = Popen(self._start_tracker, shell=True)
time.sleep(5)
self._copy_files_to_client(self.DIRECTORY_TRACKER,
self.DIRECTORY_LEECHER,
is_seeder=False)
self._copy_files_to_client(self.DIRECTORY_TRACKER,
self.DIRECTORY_SEEDER,
is_seeder=True)
pid_seeder = Popen(self._start_client % (self.DIRECTORY_SEEDER, ""),
shell=True)
pid_leecher = Popen(self._start_client %
(self.DIRECTORY_LEECHER, "-e playback -y 100"),
shell=True)
# wait for the leecher to terminate
pid_leecher.wait()
diff = time.time() - start
self.assertTrue(diff < 120)
print >> sys.stderr, "############### DIFF: %i" % diff
os.system("kill -9 %i" % (pid_tracker.pid + 2))
os.system("kill -9 %i" % (pid_seeder.pid + 2))
os.system("kill -9 %i" % (pid_tracker.pid + 1))
os.system("kill -9 %i" % (pid_seeder.pid + 1))
os.system("kill -9 %i" % (pid_seeder.pid + 0))
def testTerminateAfterSeeding(self):
start = time.time()
pid_tracker = Popen(self._start_tracker, shell=True)
time.sleep(5)
self._copy_files_to_client(self.DIRECTORY_TRACKER,
self.DIRECTORY_LEECHER,
is_seeder=False)
self._copy_files_to_client(self.DIRECTORY_TRACKER,
self.DIRECTORY_SEEDER,
is_seeder=True)
pid_seeder = Popen(self._start_client % (self.DIRECTORY_SEEDER, ""),
shell=True)
pid_leecher = Popen(self._start_client %
(self.DIRECTORY_LEECHER, "-e seeding 20 -y 100"),
shell=True)
# wait for the leecher to terminate
pid_leecher.wait()
diff = time.time() - start
self.assertTrue(diff < 60)
self.assertTrue(diff >= 20)
os.system("kill -9 %i" % (pid_tracker.pid + 2))
os.system("kill -9 %i" % (pid_seeder.pid + 2))
os.system("kill -9 %i" % (pid_tracker.pid + 1))
os.system("kill -9 %i" % (pid_seeder.pid + 1))
os.system("kill -9 %i" % (pid_seeder.pid + 0))
