def test_Caching(testfiles): logging.basicConfig(level=logging.DEBUG) name = testfiles["h5100"] # name = "/home/george/msc/workspaces/PyCharmWorkspace/TimeSeriesCorrelation/test_resources/h5100.db" pm = PruningMatrix(name) pm.compute_pruning_matrix(1, 0.7, disable_store=True) c = Caching(pm.pruning_matrix, name, 20) c.calculate_batches() for b in c.batches: print(b) assert True
def __init__(self,client): self.client=client self.cache_dic={} self.cache=Caching() self.cache_filepath='' self.is_playing=False self.is_paused=False self.is_sending=False self.sender_instance_list={} # self.filepipeline = gst.Pipeline("fileserver") self.is_playing_locally=False pass
class Player(): def __init__(self,client): self.client=client self.cache_dic={} self.cache=Caching() self.cache_filepath='' self.is_playing=False self.is_paused=False self.is_sending=False self.sender_instance_list={} # self.filepipeline = gst.Pipeline("fileserver") self.is_playing_locally=False pass def receiver_init(self,ip,port,song_seq_num, owner_key, owner_song_seq_num): self.cache_filepath=self.get_plain_cachefilepath(song_seq_num) #print "cache location is " ,self.cache_filepath self.pipeline = gst.Pipeline("server") self.tcpsrc = gst.element_factory_make("tcpserversrc", "source") self.tcpsrc.set_property("host", str(ip)) self.tcpsrc.set_property("port", int(port)+10) #50001+10=50011 self.decode = gst.element_factory_make("decodebin", "decode") self.decode.connect("new-decoded-pad", self.new_decode_pad) self.convert = gst.element_factory_make("audioconvert", "convert") self.sink = gst.element_factory_make("alsasink", "sink") self.pipeline.add(self.tcpsrc,self.decode,self.convert,self.sink) gst.element_link_many(self.tcpsrc,self.decode) gst.element_link_many(self.convert,self.sink) self.filepipeline = gst.Pipeline("fileserver") self.tcpsrc1 = gst.element_factory_make("tcpserversrc", "source1") self.tcpsrc1.set_property("host", str(ip)) self.tcpsrc1.set_property("port", int(port)+11) self.decode1 = gst.element_factory_make("decodebin", "decode1") self.decode1.connect("new-decoded-pad", self.new_decode_pad_file) self.convert1 = gst.element_factory_make("audioconvert", "convert1") self.filesink = gst.element_factory_make("filesink") self.filesink.set_property("location", self.cache_filepath) self.filepipeline.add(self.tcpsrc1,self.filesink) gst.element_link_many(self.tcpsrc1,self.filesink) print "receive filesink address is ",str(ip),':',int(port)+11 self.pipeline.set_state(gst.STATE_PLAYING) self.filepipeline.set_state(gst.STATE_PLAYING) self.is_playing = True gobject.threads_init() self.bus = self.pipeline.get_bus() self.bus.add_signal_watch() self.bus.connect("message", self.message_handler) print "I am prepare to play" thread.start_new_thread(self.song_loop, ()) # self.thread_song_play=threading.Thread(target=self.song_loop) # self.thread_song_play.start() self.thread_caching_song=threading.Thread(target=self.cache_song,args=(self.cache_filepath,song_seq_num, owner_key, owner_song_seq_num)) self.thread_caching_song.start() def message_handler(self, bus, message): msgType = message.type # print "+++++++++++++++++msg is forever",msgType # print self.pipeline.get_state() # print self.pipeline.continue_state() # print "self.pipeline.is_locked_state()",self.pipeline.is_locked_state() # print "self.pipeline.is_locked_state()",self.sink.is_locked_state() # print "self.pipeline.is_locked_state()",self.tcpsrc.is_locked_state() # print self.pipeline.freeze_notify() if msgType == gst.MESSAGE_ERROR: self.pipeline.set_state(gst.STATE_NULL) self.filepipeline.set_state(gst.STATE_NULL) self.is_playing = False self.evt_loop.quit() #print "\n Unable to play audio. Error: ", message.parse_error() elif msgType == gst.MESSAGE_EOS: self.evt_loop.quit() self.pipeline.set_state(gst.STATE_NULL) self.filepipeline.set_state(gst.STATE_NULL) self.is_playing = False print "the audio is over" # elif msgType == gst.MESSAGE_STATE_CHANGED: # oldstate, newstate, pending = message.parse_state_changed() # print("MESSAGE_STATE_CHANGED: %s --> %s" % (oldstate.value_nick, newstate.value_nick)) def check_cache_dic(self,song_num): if song_num in self.cache_dic.keys(): self.play_locally(song_num) return True else: return False def play_locally(self,song_num): filepath=self.traverse_cache_dic(song_num) #play_path=self.cache.decrypt_file(filepath) self.play(filepath) def traverse_cache_dic(self,song_num): for key in self.cache_dic.keys(): if key==song_num: return self.cache_dic[key] def song_loop(self): self.evt_loop = gobject.MainLoop() self.evt_loop.run() #print "loop finished" def get_plain_cachefilepath(self,song_seq_num): path='/tmp/' if os.path.exists(path): filepath=path+str(song_seq_num) else: try: os.makedirs(path) except: print "Directories cannot be created" filepath=path+str(song_seq_num) return filepath def new_decode_pad(self,dbin, pad, islast): pad.link(self.convert.get_pad("sink")) def new_decode_pad_file(self,dbin, pad, islast): pad.link(self.convert.get_pad("sink")) def cache_song(self,filepath,song_seq_num, owner_key, owner_song_seq_num): compare_size=0 size=0 self.file_stream=False while True: #print "I am checking cache now" compare_size=size try: size=os.path.getsize(filepath) except: pass if size-compare_size==0 and size!=0: self.file_stream=True else: pass if self.file_stream and os.path.isfile(filepath): #............For temp file............... temp_filepath=self.cache.temp_file(filepath) self.file_stream=False cache_seq = self.client.add_cache(filepath) self.client.file_table[cache_seq] = temp_filepath self.client.patch_music_table_rep(owner_key, owner_song_seq_num, self.client.listening_addr, cache_seq) self.client.send_rep(owner_key, owner_song_seq_num, cache_seq) print "Caching is finished :",self.cache_dic os.remove(filepath) break time.sleep(1) #............For encrypted file............... # self.cache.encrypt_file(filepath) # print "Caching is finished" # self.file_stream=False # self.cache_dic[song_seq_num]=os.path.splitext(filepath)[0]+'.enc' # print self.cache_dic # os.remove(filepath) # break #decrypt_file(key,en_filepath) #print "dencryption is finished" def sender_init(self,ip,port,filepath): if port not in self.sender_instance_list.keys(): self.sender_instance_list[port]=Sender(ip,port,filepath) else: self.sender_instance_list[port].sender_init(ip,port,filepath) def play(self,filepath): commandpath="filesrc location=\"%s\" ! mad ! audioconvert ! alsasink"%filepath self.pipeline = gst.parse_launch(commandpath) self.pipeline.set_state(gst.STATE_PLAYING) print "Play the song locally" self.is_playing=True self.is_playing_locally=True self.thread_song_play=threading.Thread(target=self.song_loop) self.thread_song_play.start() def resume(self): if self.is_paused == True : self.pipeline.set_state(gst.STATE_PLAYING) self.is_paused = False def stop(self): if self.is_playing == True : self.is_playing = False self.is_paused = False self.pipeline.set_state(gst.STATE_NULL) if self.is_playing_locally: self.is_playing_locally=False else: self.filepipeline.set_state(gst.STATE_NULL) self.evt_loop.quit() def pause(self): if self.is_playing == True : self.pipeline.set_state(gst.STATE_PAUSED) self.is_paused = True def replay(self): pass #.........................For test only.......................... def seek(self): self.position = (self.pipeline.query_position(gst.FORMAT_TIME,None)[0])/gst.SECOND dur_int = self.pipeline.query_duration(gst.FORMAT_TIME, None)[0] print "dur_time",dur_int print "pos is ",self.position print "last time",self.pipeline.get_last_stream_time() print "last time",self.pipeline.get_last_stream_time() self.pipeline.seek_simple(gst.FORMAT_TIME,gst.SEEK_FLAG_FLUSH,(self.position-5)) self.pipeline.set_state(gst.STATE_PAUSED) self.pipeline.set_new_stream_time(self.position-5) print "\n starting playback in 2 seconds.." time.sleep(2) self.pipeline.set_state(gst.STATE_PLAYING) def runloop(self): print "I am running" d = IODriver(self.run) print "I am running too" self.loop.run() def play_loop(self): while self.is_playing: time.sleep(1) print "loop leaves" self.evt_loop.quit() def on_tag(self,bus, msg): taglist = msg.parse_tag() print 'on_tag:' for key in taglist.keys(): print '\t%s = %s' % (key, taglist[key])