def start_transmission(self): if self.client_mode == MainWindow.RECEIVER_MODE: foldername = self.path_line_edit.text() if foldername == '': foldername = '.' self.worker = Receiver(foldername, self.SIGNALS) if self.client_mode == MainWindow.SENDER_MODE: filename = self.path_line_edit.text() parameters = self.parameters() self.worker = Sender(filename, parameters, self.SIGNALS) self.log_signal.connect(self.log) self.on_finish_signal.connect(self.on_finish) dispatcher.connect(self.trigger_log_signal, self.LOG_SIGNAL, weak=False) dispatcher.connect(self.trigger_on_finish_signal, self.FINISH_SIGNAL, weak=False) self.worker.start() self.stacked_widget.setCurrentIndex(MainWindow.LOG_PAGE)
def onRecAppendEntriesRPCReply(message): if(not message.success): Leader.setMatchIndex(message.followerId, message.matchIndex) Leader.setMatchSuccess(message.followerId, False) Leader.decrementNextIndex(message.followerId) #print("Retry AppendEntriesRPC "+str(State.nextIndex[message.followerId])+" to: "+str(message.followerId)) print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): '+'Datacenter '+str(message.followerId)+' unmatched! '+'Retry Entry '+str(State.nextIndex[message.followerId])) sender=Sender('AppendEntriesRPC',Leader.heartbeat(message.followerId)) sender.setConn(State.dc_list[message.followerId]) sender.start() Leader.setPeriod(message.followerId) else: if(not State.matchSuccess[message.followerId]): #print('matched the case!!!!') pass else: Leader.incrementNextIndex(message.followerId) if(message.matchIndex==State.matchIndex[message.followerId]): pass else: print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): '+'Datacenter '+str(message.followerId)+' matched with Entry '+str(message.matchIndex)) #print('matched') Leader.setMatchIndex(message.followerId,message.matchIndex) Leader.setMatchSuccess(message.followerId, True) if(message.matchIndex>State.commitIndex): Leader.checkCommit(message.matchIndex)
def start_test(chosen_algorithm, control_method, probability, windows_size, packet_size, model, P01, P10): img = Image.open("test.jpg") receiver = Receiver() sender = Sender(receiver, control_method, windows_size, packet_size) sender.set_ts_interference(probability, model, P01, P10) img_array = np.asarray(img) sender.data_to_binary(img_array) sender.split_array() sender.send_frames(chosen_algorithm) error_counter = 0 ber = 0 for j in range(0, len(receiver.result)): final_pack = receiver.result[j].astype(np.uint8) start_pack = sender.packets[j] for i in range(0, packet_size): if start_pack[i] != final_pack[i]: error_counter += 1 j += 1 ber = error_counter / (len(receiver.result) * packet_size) * 100 final_img = receiver.finalize_img() return receiver.numberOfAcceptedPackets, receiver.numberOfRejectedPackets, ber
def sendFile(file, url='localhost', queue='default'): s = Sender(url) text = os.path.basename(file) + '?\n' with open(file, 'r') as f: text += f.read() s.send(text, queue)
def malware_train(line): global malware_train_nb if (mta.check_if_link_is_in_downloaded_file(line) is False): pcap_file_name = mta.download_pcap([line]) for pcap in pcap_file_name: if (pcap is not None): if (check_if_already_trained(pcap) is False): attacker = AttackerCalc(pcap=mta.get_folder_name() + "/" + pcap) ip_to_consider = attacker.compute_attacker() flow_type = "malware" filter_1.set_ip_whitelist_filter(ip_to_consider) filter_2.set_ip_whitelist_filter(ip_to_consider) filter_3.set_ip_whitelist_filter(ip_to_consider) featuresCalc = FeaturesCalc(flow_type=flow_type, min_window_size=5) csv = CSV(file_name="features_" + flow_type, folder_name="Features") csv.create_empty_csv() csv.add_row(featuresCalc.get_features_name()) argument = { "features_calc": featuresCalc, "packets": [], 'filter': [filter_1, filter_2, filter_3], 'csv_obj': csv } sniffer = Sniffer(iface_sniffer, callback_prn=callback_sniffer, callback_prn_kwargs=argument) sniffer.start() while (sniffer.get_started_flag() is False): pass try: sender = Sender(iface_sender, fast=False, verbose=False, time_to_wait=10) sender.send(mta.get_folder_name() + "/" + pcap) sniffer.stop() except Exception as e: print(e) csv.close_csv() env.set_csv(csv.get_folder_name() + "/" + csv.get_current_file_name()) agent.train_agent( steps=csv.get_number_of_rows() - 1, log_interval=csv.get_number_of_rows() - 1, verbose=2, nb_max_episode_steps=csv.get_number_of_rows() - 1) malware_train_nb -= 1 trained_file.write(pcap + "\n") else: print("\nPcap gia' utilizzato in passato. Saltato.\n") else: pass else: pass
def request_post(self, number, addr): try: post = self.to_view[-number] except IndexError: raise exception.NonExistingPost sender = Sender(self, post, addr) sender.start() print(self.ans_sock) return self.ans_sock
def updateStats(): global sessionId stater = Stater(sessionId) sender = Sender(sessionId) while True: sender.sendRequests(stater.getCurrentService()) time.sleep(sender.getPoll()) if sessionId == None: break
def testSenderSend(self, mock_pika, mock_dec, mock_print): s = Sender() mock_pika.BasicProperties.return_value = '' s.send("some message") mock_pika.BlockingConnection.return_value.channel.return_value.basic_publish.assert_called_with( body="some message", exchange='', properties='', routing_key='default')
def initialise_connection(self): self.local_socket = socket.socket() self.local_socket.bind((self.address, self.port)) self.local_socket.listen(5) if self.address == 'localhost': self.address = '127.0.0.1' self.address_list.append(self.address + ':' + str(self.port)) self.sender = Sender(self.local_socket, self.addresses) self.sender.start()
def onRecAppendEntriesRPC(self, message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive AppendEntriesRPC from: '+\ #str(message.leaderId)+" term"+str(message.term)) if (StateController.eql(State.state, 'follower')): reply = Follower.onRecAppendEntriesRPC(message) else: reply = Receiver.onRecAppendEntriesRPC(message) sender = Sender('AppendEntriesRPCReply', reply) sender.send(self.dc_list[message.leaderId])
def onRecAppendEntriesRPC(self,message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive AppendEntriesRPC from: '+\ #str(message.leaderId)+" term"+str(message.term)) if(StateController.eql(State.state,'follower')): reply=Follower.onRecAppendEntriesRPC(message) else: reply=Receiver.onRecAppendEntriesRPC(message) sender=Sender('AppendEntriesRPCReply',reply) sender.send(self.dc_list[message.leaderId])
def get_info(self, _method, _url, _params): _params = self._loc_f.format_input(_params) __data, __cookie = self._loc_f.deal_params(_params) _sender = Sender() _sender.send(_method, _url, __data, __cookie) self.status_code = _sender.status_code self.feed_back = _sender.feedback self.error_msg = _sender.error_msg self.cookie = _sender.cookie if self.error_msg: Errors(self.error_msg)
def set_threads(self, manager): self.ts = Sender(self.client.multicast_addr, self.client.port, self.client.pvt_port) self.ts.start() self.tr = Receiver(self.client.multicast_addr, self.client.port, manager) self.tr.start() self.trp = Receiver_pvt(manager) self.trp.start() self.tl = Listener(manager) self.tl.start()
class UserInterface(threading.Thread): def __init__(self, Debug=False): self.debug = Debug threading.Thread.__init__(self) self.setName("GUI") self.fenetre = Tk() self.fenetre.title("Commande") self.senderbox = Frame(self.fenetre) self.senderbox.pack(side="left", expand=False, padx=5, pady=5) self.sender = Sender(self, self.senderbox, Debug=self.debug) self.receiverbox = Frame(self.fenetre) self.receiverbox.pack(side="right", expand=True, fill="x", padx=5, pady=5) self.receiver = Receiver(self.receiverbox, Debug=self.debug) self.start() def run(self): if self.debug is True: print("[GUI] : GUI >> Interface Graphique operationnel") self.fenetre.mainloop() def quitter(self): self.fenetre.quit() def setConnexion(self, conn): self.sender.setConnexion(conn) def log(self, provenance, message): provenance = provenance+"/GUI" try: self.receiver.log(provenance, message) except: if self.debug is True: print("[GUI] : GUI >> Attention connexion avec le logger non existant !") print("message: " + message)
def __init__(s,x,y): #Dane: Sender.__init__(s) s.__x,s.__y=x,y s.__X,s.__Y=x,y s.__visible=1 s.__exist=1 s.__selected=0 #Definicje: s.create() s.show() s.select()
def __init__(s, todo, master, text, x, y): #Dane: Sender.__init__(s) s.__noteM = NoteManager() s.__todo = todo s.__master = master s.__text = text s.__x, s.__y = x, y s.__h = 20 s.__selected = 0 s.__visible = 1 s.__exist = 1
def onRecReqVoteRPC(self,message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive ReqVoteRPC from: '+\ #str(message.candidateId)+" term"+str(message.term)) if(StateController.eql(State.state,'follower')): reply=Follower.onRecReqVoteRPC(message) else: reply=Receiver.onRecReqVoteRPC(message) #print(reply.voteGranted) sender=Sender('RequestVoteRPCReply',reply) sender.send(self.dc_list[message.candidateId])
def onRecReqVoteRPC(self, message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive ReqVoteRPC from: '+\ #str(message.candidateId)+" term"+str(message.term)) if (StateController.eql(State.state, 'follower')): reply = Follower.onRecReqVoteRPC(message) else: reply = Receiver.onRecReqVoteRPC(message) #print(reply.voteGranted) sender = Sender('RequestVoteRPCReply', reply) sender.send(self.dc_list[message.candidateId])
def __init__(self, filename, timer): Sender.__init__(self, filename) self.fwdr_actions = { ('1', '1'): self.run_oneFwdr_oneImage, ('1', 'n'): self.run_oneFwdr_manyImages } if timer is None: self._timer = int(self.get_timer()) else: self._timer = int(timer) self._aux_publisher = self.get_publisher('AUX_PUB', 'AUX_PUB')
def sendReqVoteRPC(dcNum): lastLogIndex=State.log.getLastIndex() lastLogTerm=State.log.getLastTerm() reqRPC=RequestVoteRPC(State.currentTerm,State.dc_ID,lastLogIndex,lastLogTerm) if(State.receiverList[dcNum]): #print("Send ReqVoteRPC to: "+str(dcNum)) print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Send Request to datacenter '+str(dcNum)) sender=Sender('RequestVoteRPC',reqRPC) sender.setConn(State.dc_list[dcNum]) sender.start()
def test_sender_negative(self): sample_input_json = { "date": "2020-08-09", "name": "cycle1", "components": { "frame": ["top_tube", "down_tube", "seat_tube"], "wheel": ["spokes", "hub", "rim"], "seat": ["saddle"], "handlebar": ["handlebar_grip", "fork"], "chain": ["chain", "chain_rings"] } } S = Sender() self.assertEqual(S.test_fetch(sample_input_json).status_code, 500)
def sale(self) -> None: while True: req = self.input_request() profit, node = self.caculate_profit(req) if profit > 0: self.lock.acquire() req.offtime = time.time() + req.duration heapq.heappush(self.requests, req) self.lock.release() self.reply_customers() msg = Sender().makeSFCMsg(req) Sender().sendsfc(node.addr, msg) print(msg) if not config.FLAG: break
class PyToPyChat: def __init__(self): self.sender = Sender() self.listener = Listener(event_handler=self) self.peers = [] def launch(self, port): """Launch the threads and get the user's name""" self.name = input('What is your name? ') # Prepare the threads listener_thread = threading.Thread(target=self.listener.launch, args=(port, )) listener_thread.daemon = True ui_thread = threading.Thread(target=self.user_input) # Start the threads listener_thread.start() ui_thread.start() self.user_input() def add_peer(self, location): """Add a peer for broadcasting. Should be done prior to launch""" self.peers.append(location) def broadcast(self, message): """Broadcast to all added peers""" # Don't send an empty message if message is '': return # Package up so everyone knows your name payload = {'name': self.name,'content': message} # Now send to everyone for peer in self.peers: self.sender.send(payload, peer) def user_input(self): """Wait for the user to input a message, then broadcast""" text_to_send = '' while text_to_send != '/exit': self.broadcast(text_to_send) text_to_send = input('') def handle_message(self, message): """event_handler method""" decoded = json.loads(message.decode('utf-8'))['message'] print('{0}: {1}'.format(decoded['name'],decoded['content']))
def __init__(self, line: str): self.line = line self.command = "" self.sender = None self.params = [] if line == "": return if line[0] == ':': line = line[1:] words = line.split(maxsplit=1) self.sender = Sender(words.pop(0)) if len(words) == 0: # this is actually a malformed message return line = words[0] words = line.split(maxsplit=1) self.command = words.pop(0) if len(words) == 0: return # want to preserve whitespace in :params words = words[0].split(" ") while len(words) > 0: if not words[0]: words.pop(0) continue if words[0][0] == ":": self.params.append(" ".join(words)[1:]) break else: self.params.append(words.pop(0))
def sendAppendEntriesRPC(dcNum): if(Leader.isSelf(dcNum)): return if(State.matchSuccess[dcNum]): #print("Send AppendEntriesRPC Entry"+str(State.nextIndex[dcNum])+" to: "+str(dcNum)) sender=Sender('AppendEntriesRPC',Leader.entry(dcNum)) sender.setConn(State.dc_list[dcNum]) sender.start() else: #print("Send AppendEntriesRPC Heartbeat"+str(State.nextIndex[dcNum])+" to: "+str(dcNum)) sender=Sender('AppendEntriesRPC',Leader.heartbeat(dcNum)) sender.setConn(State.dc_list[dcNum]) sender.start()
def __createSender__(self): """ Initializes the sender object. Used by the constructor. """ # Sender is not a new thread, so it does not need a lock params = {} params["addresses"] = self.addresses params["port"] = "8030" if hasattr(self.myconfig.RemoteMsg, "senderPort"): params["port"] = self.myconfig.RemoteMsg.senderPort params["service"] = "msg" if hasattr(self.myconfig.RemoteMsg, "senderService"): params["service"] = self.myconfig.RemoteMsg.senderService params["user"] = None if hasattr(self.myconfig.RemoteMsg, "senderUser"): params["user"] = self.myconfig.RemoteMsg.senderUser params["pwd"] = None if hasattr(self.myconfig.RemoteMsg, "senderPwd"): params["pwd"] = self.myconfig.RemoteMsg.senderPwd params["realm"] = "RemoteMsg" if hasattr(self.myconfig.RemoteMsg, "realm"): params["realm"] = self.myconfig.RemoteMsg.senderRealm self.sender = Sender(self.msgQueue, params)
def test_server(): # Message class should process leading : s = "Prothid.CA.US.GameSurge.net" sender = Sender(s) assert sender.full == s assert sender.host == "" assert sender.nick == s assert sender.ident == ""
def test_chatter(): s = "Bruk!~Bruk@Bruk_.user.gamesurge" sender = Sender(s) assert sender.full == s assert sender.nick == "Bruk" assert sender.ident == "~Bruk" assert sender.host == "Bruk_.user.gamesurge" sender = Sender("knivey") assert sender.full == "knivey" assert sender.nick == "knivey" assert sender.ident == "" assert sender.host == "" sender = Sender("foo!bar") assert sender.nick == "foo" assert sender.ident == "bar" assert sender.host == ""
def test_mask(): s = "Bruk!~Bruk@Bruk_.user.gamesurge" sender = Sender(s) assert sender.hostmask_match("*!*@*") assert sender.hostmask_match("*!?*@*") assert sender.hostmask_match("*") assert sender.hostmask_match("*!?bruk@*") assert False == sender.hostmask_match("*!?bruk@*k")
def verify_hacker(): for name, cipher in cipher_list.items(): key_encrypt, key_decrypt = cipher.generate_keys() sender = Sender(cipher=cipher, key=key_encrypt) receiver = Receiver(cipher=cipher, key=key_decrypt) hacker = Hacker(cipher=cipher) clear_text = "Hello World" encrypted_message = sender.send_message(clear_text) decrypted_message = receiver.receive_message(encrypted_message) decrypted_hacker = hacker.receive_message(encrypted_message) print(" ") print(f"Current cipher: {name}") print("Clear text: ", clear_text) print("Hacked: ", decrypted_hacker)
def legitimate_train(line): global legitimate_train_nb if (check_if_already_trained(line) is False): flow_type = "legitimate" filter_1.set_ip_whitelist_filter([]) filter_2.set_ip_whitelist_filter([]) filter_3.set_ip_whitelist_filter([]) featuresCalc = FeaturesCalc(flow_type=flow_type, min_window_size=5) csv = CSV(file_name="features_" + flow_type, folder_name="Features") csv.create_empty_csv() csv.add_row(featuresCalc.get_features_name()) argument = { "features_calc": featuresCalc, "packets": [], 'filter': [filter_1, filter_2, filter_3], 'csv_obj': csv } sniffer = Sniffer(iface_sniffer, callback_prn=callback_sniffer, callback_prn_kwargs=argument) sniffer.start() while (sniffer.get_started_flag() is False): pass try: sender = Sender(iface_sender, fast=False, verbose=False, time_to_wait=10) sender.send(lg.get_folder_name() + "/" + line) sniffer.stop() except Exception as e: print(e) csv.close_csv() env.set_csv(csv.get_folder_name() + "/" + csv.get_current_file_name()) agent.train_agent(steps=csv.get_number_of_rows() - 1, log_interval=csv.get_number_of_rows() - 1, verbose=2, nb_max_episode_steps=csv.get_number_of_rows() - 1) legitimate_train_nb -= 1 trained_file.write(line + "\n") else: print("\nPcap gia' utilizzato in passato. Saltato.\n")
def SR_Sender(sock, receiverIP, receiverPort, payload, debug, parent): #create filepath to parent's (Server/Client) sending temp file fileName = 'temp.txt' fileTemp = os.path.join(os.getcwd(), parent, "Data", "Sender") file = os.path.join(os.getcwd(), fileTemp, fileName) #write payload to temp file that will be read on a per packet basis with open(file, "w") as f: f.write(payload) #initialize sender object sender = Sender(sock, debug, parent) #send payload contained in temp file via selective repeat try: sender.send(fileName, receiverIP, receiverPort) except Exception as e: print("Exception Occured: " + str(e)) #delete temp file os.remove(file)
def main(system): # Filename of the "clues", full path and filename for the log, logging level, #scp or rcp, User name under which to send "clues", Machine where to send the "clues" (clues_name, logname, log_level, copying, user, host) = sys.argv[1:] # Enable logging logger = Logger(logname, log_level, "CCS") logger = logger.getLogger() logger.info("Beginning of CCS program (system %s) on " % (system) + str(localhost)) if system == 'PDS': # Obtain infos ("clues") from the PDS on which this software is running manager = PDSManager("CCS") manager.makeClientDict() # Clues about PDS clients manager.makeInputDirDict() # Clues about input directories elif system == 'PX': # Obtain infos ("clues") from the PX on which this software is running manager = NCSManager("CCS") manager.makeCircuitDict() # Clues about PX # Useful printing for debugging purpose if (DEBUG and system == 'PDS'): print manager.printClientDict() print manager.printInputDirDict() # Serialization of the clues clues_filename = CLUES + "/" + clues_name + '.' + manager.machine manager.archiveInfos(clues_filename) # Sending of the clues to the CIR host sender = Sender('CCS') sender.send(copying, user, host, clues_filename, INPUT_CLUES) logger.info("Ending of CCS program (system %s) on " % (system) + str(localhost))
def __init__(self, buff_size, serve_per_timestep, ttl, sender_num, long_time, path): self.log = open(path, "w") self.dest = Receiver(self, buff_size, serve_per_timestep) self.senders = [ Sender(self, self.dest, long_time, ttl, i, ttl / sender_num) for i in range(sender_num) ] # self.senders += [CompetitiveSender(self, self.dest, long_time, ttl, i + sender_num, ttl/sender_num) # for i in range(sender_num)] self.messages = deque() self.ttl = ttl self.time = 0
class TextHandler(object): sendBot = Sender() # name # job def process(self, message, phoneNumber): newMessage = ' '.join(message.split()[1:]) if message.split()[0].lower() == "name:": TextHandler.processName(self, newMessage, phoneNumber) elif message.split()[0].lower() == "jobs:": TextHandler.processJobs(self, newMessage, phoneNumber) else: TextHandler.processDescription(self, message, phoneNumber) # name def processName(self, message, phoneNumber): messageItem = Message() messageItem.senderName = message messageItem.senderNo = phoneNumber # responds TextHandler.sendBot.send( "Hi " + messageItem.senderName + "(" + messageItem.senderNo + "). What Jobs are you interested in?", messageItem.senderNo) return messageItem def processJobs(self, message, phoneNumber): messageItem = Message() messageItem.senderNo = phoneNumber messageItem.jobs = message.split() # responds TextHandler.sendBot.send( "You are interested in: " + ', '.join(messageItem.jobs), messageItem.senderNo) return messageItem def processDescription(self, message, phoneNumber): messageItem = Message() messageItem.senderNo = phoneNumber messageItem.description = message # responds TextHandler.sendBot.send( "Your profile: " + messageItem.description, messageItem.senderNo) return messageItem
def main(self): command_helper = InputHelper( ["caesar", "multiplicative", "affine", "unbreakable", "rsa", "exit"] ) try: next_command = command_helper.get_legal_input("Please enter a command: \n") sender = Sender() receiver = Receiver() hacker = Hacker() cipher_algorithm = None if next_command == "caesar": cipher_algorithm = Caesar() if next_command == "multiplicative": cipher_algorithm = Multiplicative() if next_command == "affine": cipher_algorithm = Affine() if next_command == "unbreakable": cipher_algorithm = Unbreakable() if next_command == "rsa": cipher_algorithm = RSA() hacker = None if next_command == "exit": sys.exit(0) sender.set_cipher_algorithm(cipher_algorithm) receiver.set_cipher_algorithm(cipher_algorithm) keys = cipher_algorithm.generate_keys() self.__logger.info(f"Keyset: {keys}") sender.set_key(keys["encryption"]) receiver.set_key(keys["decryption"]) message = input("Please input a message to be encrypt:\n") encrypted_text = sender.operate_cipher(message) if hacker is not None: hacker.set_cipher_algorithm(cipher_algorithm) self.__logger.info( f"Hackerman found: {hacker.hack(encrypted_text, next_command)}" ) decrypted_text = receiver.operate_cipher(encrypted_text) self.__logger.info( f"{message} => {encrypted_text} => {decrypted_text} (Success={cipher_algorithm.verify(sender.get_key(), receiver.get_key(),message)})" ) except KeyboardInterrupt: return self.main()
def simulate(self): self.sender = Sender(self.source_size, self.distribution) self.receiver = Receiver(self.source_size, self.error_rate, fast_mode=self.fast_mode) successful_decode = False successful_send = False while not self.receiver.decoded: # Send a packet and attempt to decode if it is received if not successful_decode: successful_send = self.send_packet() if successful_send: successful_decode = self.decode(pckt1_sent=self.packet_len_1_sent) self.packet_len_1_sent = False # print(self.receiver.result_message) # print(self.receiver.total_received) return self.receiver.total_received
def sendReqVoteRPC(dcNum): lastLogIndex = State.log.getLastIndex() lastLogTerm = State.log.getLastTerm() reqRPC = RequestVoteRPC(State.currentTerm, State.dc_ID, lastLogIndex, lastLogTerm) if (State.receiverList[dcNum]): #print("Send ReqVoteRPC to: "+str(dcNum)) print("(" + str(State.dc_ID) + "," + State.state + "," + str(State.currentTerm) + '): Send Request to datacenter ' + str(dcNum)) sender = Sender('RequestVoteRPC', reqRPC) sender.setConn(State.dc_list[dcNum]) sender.start()
def __init__(self, Debug=False): self.debug = Debug threading.Thread.__init__(self) self.setName("GUI") self.fenetre = Tk() self.fenetre.title("Commande") self.senderbox = Frame(self.fenetre) self.senderbox.pack(side="left", expand=False, padx=5, pady=5) self.sender = Sender(self, self.senderbox, Debug=self.debug) self.receiverbox = Frame(self.fenetre) self.receiverbox.pack(side="right", expand=True, fill="x", padx=5, pady=5) self.receiver = Receiver(self.receiverbox, Debug=self.debug) self.start()
def main(): args = get_args() path = args.file interval = args.interval if not os.path.exists(path): print('{} does not exist.'.format(path)) sys.exit(1) # MIDIファイルからMIDIイベントを読み込む events = MidiEvents(path) # MIDIイベントを送信 sender = Sender() sender.send_events(events, interval) # 送信したMIDIイベントと送信時刻を表示 sender.show_send_events_and_times()
def send(self): sender=Sender('TestMessage','Hello') sender.send(('0.0.0.0',12345))
class RemoteMsg(object): """ _RemoteMsg_ Main interface of the RemoteMsg module. Clients wishing to use the RemoteMsg should instantiate an object of this class and interface it using the public methods declared by it. """ def __init__(self, config, addresses=[], queue=True): """ Constructor. Requires a WMCore.Configuration object with configuration information. The addresses of recipients and the flag for queue/handling mode can be set with setAdress or setQueue methods also (have a look at their docstring for further help). The listener for messages needs to be started with the startListener method, meanwhile only publication capabilities are available. """ self.myconfig = config sections = self.myconfig.listSections_() if not "RemoteMsg" in sections: msg = "Cannot create RemoteMsg object without " msg += "RemoteMsg section in config file" raise Exception(msg) self.mylogger = None self.logMsg = None self.__setLogging__() self.mylogger.info("\n\n>>>>>RemoteMsg object being created <<<<<<\n") self.myComp = None if hasattr(self.myconfig.RemoteMsg, "inComponent"): self.myComp = self.myconfig.RemoteMsg.inComponent self.queueMode = queue self.addresses = addresses self.user = None self.passwd = None self.msgLock = threading.Lock() self.handlerLock = threading.Lock() self.factory = WMFactory("RemoteMsg") # If this is instantiated by a WMCore component, get its DB interface if self.myComp: # Get a reference to our invoking component's DB factory myThread = threading.currentThread() self.dbFactory = myThread.dbFactory self.dialect = myThread.dialect # TODO: Our msg queue is just in memo for now, but it might be in a DB # We already have the DB interface, but we would need our own Create # and Queries modules (in principle, different from those of the comp) # self.factory = WMFactory("threadPool", "WMCore.ThreadPool."+ \ # myThread.dialect) # self.queries = factory.loadObject(self.myComp+"Database"+ \ # myThread.dialect+"Queries") self.msgQueue = [] self.handlerMap = {} # Formatter for responses (change only if in synchronous mode) formatter = "RemoteMsgComp.DefaultFormatter" if hasattr(self.myconfig.RemoteMsg, "formatter"): formatter = self.myconfig.RemoteMsg.formatter formatterObj = self.factory.loadObject(formatter) params = { "msgQueue": self.msgQueue, "handlerMap": self.handlerMap, "msgLock": self.msgLock, "formatter": formatterObj, "queueMode": self.queueMode, } if self.myComp: params["component"] = self.myComp params["dbFactory"] = self.dbFactory params["dialect"] = self.dialect self.httpTree = HttpTree(params) self.sender = None self.__createSender__() self.listener = None def __del__(self): # Tell cherrypy to die self.mylogger.info("Asking listener to die") if self.listener: self.listener.terminate() self.listener.join() def __setLogging__(self): """ Initializes logging. Use by the constructor. """ compSect = self.myconfig.RemoteMsg # Logging if not hasattr(compSect, "logFile"): compSect.logFile = os.path.join(compSect.RemoteMsgDir, "remoteMsg.log") print("Log file is: " + compSect.logFile) if not hasattr(compSect, "listenerLogFile"): compSect.listenerLogFile = os.path.join(compSect.RemoteMsgDir, "listener.log") print("Listener log file is: " + compSect.listenerLogFile) logHandler = RotatingFileHandler(compSect.logFile, "a", 1000000, 3) logFormatter = logging.Formatter("%(asctime)s:%(levelname)s:%(filename)s:%(message)s") logHandler.setFormatter(logFormatter) self.mylogger = logging.getLogger("RemoteMsg") self.mylogger.addHandler(logHandler) self.mylogger.setLevel(logging.INFO) # map log strings to integer levels: self.logMsg = { "DEBUG": logging.DEBUG, "ERROR": logging.ERROR, "NOTSET": logging.NOTSET, "CRITICAL": logging.CRITICAL, "WARNING": logging.WARNING, "INFO": logging.INFO, } ## 'SQLDEBUG' : logging.SQLDEBUG } if hasattr(compSect, "logLevel") and compSect.logLevel in self.logMsg.keys(): self.mylogger.setLevel(self.logMsg[compSect.logLevel]) def __createSender__(self): """ Initializes the sender object. Used by the constructor. """ # Sender is not a new thread, so it does not need a lock params = {} params["addresses"] = self.addresses params["port"] = "8030" if hasattr(self.myconfig.RemoteMsg, "senderPort"): params["port"] = self.myconfig.RemoteMsg.senderPort params["service"] = "msg" if hasattr(self.myconfig.RemoteMsg, "senderService"): params["service"] = self.myconfig.RemoteMsg.senderService params["user"] = None if hasattr(self.myconfig.RemoteMsg, "senderUser"): params["user"] = self.myconfig.RemoteMsg.senderUser params["pwd"] = None if hasattr(self.myconfig.RemoteMsg, "senderPwd"): params["pwd"] = self.myconfig.RemoteMsg.senderPwd params["realm"] = "RemoteMsg" if hasattr(self.myconfig.RemoteMsg, "realm"): params["realm"] = self.myconfig.RemoteMsg.senderRealm self.sender = Sender(self.msgQueue, params) def startListener(self): """ Starts a listener for incoming remote messages. The method will refuse to create a listener if there is already one """ if not self.listener: self.mylogger.info("Starting listener") self.listener = Listener(self.httpTree, self.myconfig) self.listener.start() else: msg = "Refusing to start listener (there is already one)." self.mylogger.info(msg) def setAddress(self, addresses): """ Sets the addresses of the remote ends. Argument should be a list of IPs or hostnames. The publish method will send messages to all members of this list. """ self.addresses = addresses self.sender.setAddress(self.addresses) def setAuthentication(self, user, passwd): """ Sets the user/password for authentication with the remote application. Has to be done before sending a message. """ self.mylogger.debug("Setting user and passwd") self.user = user self.passwd = passwd def setQueue(self, value): """ This is an option that either allows messages that are being received to be put in a local queue (so a get method can retrieve them), or if set to False messages are handled directly through the handler framework. """ self.queueMode = value self.httpTree.setQueue(self.queueMode) def get(self): """ Gets messages from the local buffer (those not handled as explained in the setQueue method). The first message of the queue is retrieved and returned. This method is only used when the queue is set to True. If queue is set to False or there are no stored messages, None is returned. """ if self.queueMode: self.msgLock.acquire() if self.msgQueue: result = self.msgQueue.pop(0) else: result = None self.msgLock.release() return result else: return None def publish(self, msgType, payload, sync=False): """ Sends a message to the remote end. If sync is set to True, the remote server will complete the message handling before replying with some generated data. Otherwise, the remote end will immediately reply with some "Message received" indication and execute the handler asynchronously (if the remote end is in queue mode, there is no handler execution, so this flag is meaningless). In any case, the response of the message (e.g. a json string product of the handling of the HTTP request) is returned. Can throw an HTTP exception in case of error connecting with the remote end. """ return self.sender.send(msgType, payload, sync) def setHandler(self, msgType, handler): """ Maps the specified handler to the indicated message type. The handler must be the name of a class which can be called (e.g. RemoteMsg.SimpleHandler). The handler will only be called if queue mode is set to False. """ msg = "Setting new handler %s for msgType %s" % (handler, msgType) self.mylogger.debug(msg) # Factory to dynamically load handlers params = {} if self.myComp: params["component"] = self.myComp newHandler = self.factory.loadObject(handler, params) self.handlerLock.acquire() self.handlerMap[msgType] = newHandler self.handlerLock.release()
results_filename = RESULTS + "/" + results_name merger.archiveResults(results_filename) logger.debug("Results have been put by CIR in: " + results_filename) # Creation of log files that will contain errors that will be displayed by CS # and also of errors logs that will be used by Wams if system == 'PDS': merger.logPDSErrors() elif system == 'PX': merger.auditCircuit(errorLogger, errorLog, wamsLogFile) # Checks for error and log them ############################################################################################# # 3) Send the merged infos to ColumboShow Host (as defined in the config. file) ############################################################################################# sender = Sender('CIR') # log to 'CIR' logger sender.send(copying, user, host, results_filename, INPUT_RESULTS) logger.info("Ending of CIR program (system %s)" % system) logger.info("") #logger.removeHandler(hdlr) ############################################################################################# # 4) Special section for PX: Do the jobs of step 2 and 3 for the frontend ############################################################################################# if system == 'PX' and frontend: machines = [frontend.split(".")[0]] # Only the frontend merger = CircuitMerger(logger, machines)
def __init__(self): self.sender = Sender() self.listener = Listener(event_handler=self) self.peers = []
############################################################################################# # 1) Obtain infos (listing) concerning a running PDS ############################################################################################# clientDir = DirectoryLister(pathname, startDate, endDate, regex, maxFiles) logger.info("Listing: " + clientName + ", " + startDate + ", " + endDate + ", " + regex) myDict = clientDir.getNameTimeDict() manager = Manager("CCS") archiveName = CLUES + '/' + clientName + "_listing." + manager.machine clientDir.archiveInfos(archiveName) ############################################################################################# # 2) Send the infos (listing) to CIR Host ############################################################################################# sender = Sender('CCS') sender.send(copying, user, host, archiveName, INPUT_CLUES) logger.info("Ending of DirectoryLister program on " + str(localhost)) if DEBUG: for file in myDict.keys(): print "%30s : %d %s " % (file, myDict[file][0], myDict[file][1]) print pathname print clientDir.startDate, epochFormatted(clientDir.startDate) print clientDir.endDate, epochFormatted(clientDir.endDate) print regex print clientDir.maxFiles
def __init__(s): #Dane: Sender.__init__(s) s.__dominator=None s.__saveString="" s.__noteF=NoteFactory()