def test_basic_timing(self): self.c1.request("lol") self.c3.request("pouet") simu.sleep(4) self.assertTrue(self.c1.latencies[0] > 2 and self.c1.latencies[0] < 3)
def test_add_video_access(self): self.s2.add_video(60, 2048, 2048/60, 'Video', 'A video', 1337) self.c4.request_media(1337, 2) simu.sleep(2) self.assertEqual(self.c4.received_data['payload'], self.video)
def _play_videos(self): """ Automatically consumes videos when the buffer has been filled initially Supposed to be run only in an independant thread. Runs once every simulated second. """ while True: # Infinite loop, not really efficient for id_media in self.media_asked_for: # if the state of the video is "buffering" if self.play_wait_buffer and self.media_asked_for[id_media]['state'] is 'buffer': # if the buffer is filled enough, we update the state to "playing" if self.media_asked_for[id_media]['buffer'] > self.buffer_size: self.media_asked_for[id_media]['state'] = 'play' # if the state of the video is "playing" if self.media_asked_for[id_media]['state'] is 'play': if self.media_asked_for[id_media]['buffer'] >= self.media_asked_for[id_media]['bitrate']: self.media_asked_for[id_media]['buffer'] -= self.media_asked_for[id_media]['bitrate'] else: self.media_asked_for[id_media]['buffer'] = 0 if self.media_asked_for[id_media]['buffer'] is 0: # change the state if we want to wait for the buffer to be filled if self.play_wait_buffer: # only when we want to wait for a buffer refill each time it stops self.media_asked_for[id_media]['state'] = 'buffer' #print("Buffer empty for video "+str(id_media)) self._video_stopped(id_media) percentage = self.media_asked_for[id_media]['buffer']/self.buffer_size*100 #print("Buffer for media "+str(id_media)+" filled at "+str(percentage)+"%") simu.sleep(1)
def test_one_video_access(self): self.s1.add_video(video=self.video2) self.c1.request_media(9001, 1) simu.sleep(2) self.assertEqual(self.c1.received_data['payload'], self.video2)
def test_requests(self): self.c1.request("lol") self.c3.request("pouet") simu.sleep(1) self.assertEqual(self.c1.received_data['payload'], 'There you go: lol') self.assertEqual(self.c3.received_data['payload'], 'There you go: pouet')
def test_video_access(self): self.s2.add_video(video=self.video) self.c4.request_media(1337, 2) simu.sleep(2) self.assertEqual(self.c4.received_data['payload'], self.video) simu.sleep(10)
def run_simulation(self): """ Runs the simulation, either with a scheduler or by waiting to trigger each event. With the event_lock method, we wait of an event to happend with a timeout set to the delay until the next event. The event should be triggered when all current downloads are over, which means that nothing is happening any more in the simulation. This happens only when the skip_inactivity is set to True. With the scheduler method, when not skiping inactivity, we just run the already filled and configured scheduler object. The option to skip inactivity should not be used as it is using a lot of CPU for nothing. """ try: if self.method == 'event_lock': if self.skip_inactivity: simu.action_when_zero = self.signal_sys_inact while not self._events_queue.empty(): event = self._events_queue.get() print("New event: "+str(event)) self._req_event.clear() if not self.skip_inactivity or not simu.no_active_download(): self._req_event.wait(event['delay']) self._clients[event['id_client']].request_media(event['id_video'], event['id_server']) elif self.method == 'scheduler': if self.skip_inactivity: while True: """ Inefficient way to skip the inactivity """ next = self._scheduler.run(False) # have a threshold to avoid testing the inavtivity all the time if next != None: if next/config.speed >= 1: # if it takes more than 1 second in real time if simu.no_active_download(self._clients.values()): simu.add_time(next-1) print("Skiping inactivity!") elif self._scheduler.empty(): return else: simu.sleep(next/2) else: self._scheduler.run() else: print("run_simulation error: no method specified!") except (KeyboardInterrupt, SystemExit): print(' ') print("Simulation interupted. To exit, press ctrl+c again.") print(' ')
def test_queue(self): # by sending two requests one right after the other and having a latency of 1/1 # the first request should take 1+1 sec and the second 1+(1+1) as it has to wait for # the first to be sent self.c1.request("lol") self.c1.request("pouet") simu.sleep(5) self.assertTrue(self.c1.latencies[0] > 2 and self.c1.latencies[0] < 3) self.assertTrue(self.c1.latencies[1] > 3 and self.c1.latencies[0] < 4)
def _worker(self): """ infinite loop running in a thread to simulate the time needed to send the data. the thread gets the data to send from the Queue q, where the items have two fields: - delay, how long the task is supposed to take - data, the data to send, after the delay private """ while True: item = self.q.get() data = item['data'] mode = item['mode'] if mode is 'normal': # we set the chunkId before it is updated in the item (in the if) data['chunkId'] = item['chunkId'] # if the packet is too big, we split it if item['size'] > self.max_chunk: data['chunkSize'] = self.max_chunk item['chunkId'] += 1 item['size'] -= self.max_chunk # and put the rest on the top of the queue, to have a round robin self.q.put(item) # if not, we set the chunkSize to remaining size and don't split it else: data['chunkSize'] = item['size'] data['lastChunk'] = True elif mode is 'forwardchunk': if 'chunkSize' not in data: print("We got a problem with this chunk forwarding!") data['chunkSize'] = item['size'] elif mode is 'donotchunk': data['chunkId'] = 0 data['chunkSize'] = item['size'] data['lastChunk'] = True delay = data['chunkSize']/self.bandwidth if data['chunkId'] is 0: """ only add the latency on the first chunk as the latency is only noticable one time, then all chunks are sent consecutively """ delay += self.latency #print("Delay: "+str(delay)+", ChunkSize: "+str(data['chunkSize'])) simu.sleep(delay) self.peer.received_callback(data) self.q.task_done()
def test_cache_stats(self): self.s1.add_video(video=self.video1) self.c2.request_media(1337, 1) # don't know why but when requesting with c1, it doesn't work. simu.sleep(3) self.c1.request_media(1337, 1) simu.sleep(1) stats = self.p.get_hit_stats() self.assertEqual(stats['byte_hit_ratio'], 0.5) self.assertEqual(stats['byte_cache'], self.video1['size']/8)
def test_caching_benefits(self): self.s1.add_video(video=self.video1) self.c1.set_buffer_size(512) self.c2.set_buffer_size(512) self.c2.request_media(1337, 1) simu.sleep(3) self.c1.request_media(1337, 1) simu.sleep(2) self.assertTrue(self.c2.latencies[0] > self.c1.latencies[0])
def test_transfer_speed(self): bigvideo = {'idVideo': 1, 'duration': 60, 'size': 8192, 'bitrate': 8192/60, 'title': 'Big Video', 'description': 'Big bitrate'} self.s2.add_video(video=bigvideo) self.c4.set_buffer_size(8192) self.c4.request_media(1, 2) simu.sleep(5) print("Latency "+str(self.c4.latencies[0])) # should take 4.2 seconds, latency is 0.1, so 2*0.1, the size 8192 divided by the speed 2048: 2*0.1+8192/2048 = 4.2 self.assertTrue(self.c4.latencies[0] > 4 and self.c4.latencies[0] < 5) bigvideo = {'idVideo': 2, 'duration': 60, 'size': 16384, 'bitrate': 8192/60, 'title': 'Big big Video', 'description': 'Biiiig bitrate'} self.s2.add_video(video=bigvideo) self.c4.request_media(2, 2) simu.sleep(9) # should take two times as much as it is two times as big self.assertTrue(self.c4.latencies[1] > 8 and self.c4.latencies[1] < 9)
def test_wait_vs_nowait(self): bigvideo = {'idVideo': 1, 'duration': 10, 'size': 40960, 'bitrate': 4096, 'title': 'Big Video', 'description': 'Big bitrate'} self.s2.add_video(video=bigvideo) self.c4.set_buffer_size(6144) self.c4.start_video_consumer() self.c4.set_play_wait_buffer(False) self.c4.request_media(1, 2) simu.sleep(10) print(str(self.c4.counter)) counter1 = self.c4.counter self.c4.set_play_wait_buffer(True) self.c4.request_media(1, 2) simu.sleep(10) print(str(self.c4.counter)) counter2 = self.c4.counter - counter1 self.assertGreater(counter1, counter2)
def test_two_videos_buffer_nowait(self): video1 = {'idVideo': 1, 'duration': 10, 'size': 7680, 'bitrate': 768, 'title': 'Video', 'description': 'A video'} video2 = {'idVideo': 2, 'duration': 5, 'size': 7500, 'bitrate': 1500, 'title': 'Video', 'description': 'A video'} self.s1.add_video(video=video1) self.s1.add_video(video=video2) self.c2.set_play_wait_buffer(False) self.c1.set_play_wait_buffer(False) self.c2.start_video_consumer() self.c1.start_video_consumer() self.c1.request_media(1, 1) self.assertEqual(self.c1.counter, 0) simu.sleep(2) self.c2.request_media(2, 1) simu.sleep(10) #print(str(self.c2.counter)) #print(str(self.c1.counter)) self.assertGreater(self.c2.counter, 0) self.assertGreater(self.c1.counter, 0)
def test_buffer_big_bitrate(self): bigvideo = {'idVideo': 1, 'duration': 100, 'size': 409600, 'bitrate': 4096, 'title': 'Big Video', 'description': 'Big bitrate'} self.s2.add_video(video=bigvideo) self.c4.request_media(1, 2) self.c4.start_video_consumer() simu.sleep(2) #self.assertEqual(self.c4.received_data['payload'], self.video) simu.sleep(2) simu.sleep(2) simu.sleep(2) #print(str(self.c4.counter)) self.assertGreater(self.c4.counter, 0)
def test_no_active_download(self): self.s1 = VideoServer(1, "s1") self.c1 = LatenciesClient(1001, "c1") self.c1.set_func_new_dl(simu.inc_nb_dl) self.c1.set_func_end_dl(simu.dec_nb_dl) self.c2 = LatenciesClient(1002, "c2") self.c2.set_func_new_dl(simu.inc_nb_dl) self.c2.set_func_end_dl(simu.dec_nb_dl) # we set the chunk to a big size so that we can determine accurately the download time self.c1.connect_to(self.s1).set_lag(0.1).set_bandwidth(1024).set_max_chunk(32) self.s1.connect_to(self.c1).set_lag(0.1).set_bandwidth(1024).set_max_chunk(32) self.video = {'idVideo': 1337, 'duration': 60, 'size': 2048, 'bitrate': 2048/60, 'title': 'Video', 'description': 'A video'} self.s1.add_video(video=self.video) self.c1.request_media(1337, 2) self.assertFalse(simu.no_active_download((self.c1, self.c2))) simu.sleep(3) self.assertTrue(simu.no_active_download((self.c1, self.c2)))
def test_caching_benefits(self): self.s1.add_video(video=self.video1) self.c1.set_two_in_a_row_protection(False) self.c1.request_media(1337, 1) simu.sleep(3) self.c1.request_media(1337, 1) simu.sleep(2) self.c1.request_media(1337, 1) simu.sleep(2) print(self.c1.latencies) self.assertTrue(self.c1.latencies[0] > self.c1.latencies[1])
def test_sleep(self): start = time.time() speed = config.speed simu.sleep(5) end = (time.time() - start) * speed self.assertAlmostEqual(end, 5, 1)