def test_unlink_message_queue(self): """Exercise unlink_message_queue""" mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX) posix_ipc.unlink_message_queue(mq.name) mq.close() self.assertRaises(posix_ipc.ExistentialError, posix_ipc.MessageQueue, mq.name)
def test_unlink_message_queue(self): """Exercise unlink_message_queue""" mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX) posix_ipc.unlink_message_queue(mq.name) mq.close() self.assertRaises(posix_ipc.ExistentialError, posix_ipc.MessageQueue, mq.name)
def catch_send_notification(socketio: SocketIO): try: posix_ipc.unlink_message_queue(config.QUEUE_NAME_UI_NOTIFICATION) except: pass notificationQueue = posix_ipc.MessageQueue( config.QUEUE_NAME_UI_NOTIFICATION, posix_ipc.O_CREX) ui_language = config.UI_LANGUAGE while True: try: notification = notificationQueue.receive(timeout=1) message_name = json.loads(notification[0])["message_name"] message = ui_languages[message_name][ui_language] socketio.emit('notification', { "message_name": message_name, "message": message }, namespace='/broadcast', broadcast=True) except: continue
def closeEvent(self, event): event.accept() #os.system("pkill out1") os.system("pkill streamread") self.mqd.close() self.mqf.close() posix.unlink_message_queue("/mqd") posix.unlink_message_queue("/mqf") os._exit(0)
def __init__(self, socketio: SocketIO, logger: utility.Logger, isAudit: bool, isResume: bool): self.socketio = socketio self.logger = logger self.isAudit = isAudit self.allPath = [] self.isResume = isResume self.detected_plants = dict() self.extracted_plants = dict() msg = f"Audit mode enable : {isAudit}" self.logger.write_and_flush(msg+"\n") print(msg) msg = f"[{self.__class__.__name__}] -> Création queue de message ui main" self.logger.write_and_flush(msg+"\n") print(msg) try: posix_ipc.unlink_message_queue(config.QUEUE_NAME_UI_MAIN) except: pass self.msgQueue = posix_ipc.MessageQueue(config.QUEUE_NAME_UI_MAIN, posix_ipc.O_CREX) self._main_msg_thread_alive = True self._main_msg_thread = threading.Thread(target=self._main_msg_thread_tf, daemon=True) self._main_msg_thread.start() self.statusOfUIObject = { "joystick": False, #True or False "fieldButton": False, #True or False or charging or None "startButton": False, #True or False or charging or None "continueButton": False, #True or False or charging or None "stopButton": True, #True or charging or None "wheelButton": False , #True or False "audit": isAudit, #True or False or use or not-use "slider": 25, #Int for slider value "removeFieldButton": False #True or False } if isAudit: self.statusOfUIObject["audit"] = "use" else: self.statusOfUIObject["audit"] = "not-use" if self.isResume: self.statusOfUIObject["continueButton"] = None else: self.statusOfUIObject["startButton"] = None self.field = None self.lastGpsQuality = "1" msg = f"[{self.__class__.__name__}] -> Lancement main" self.logger.write_and_flush(msg+"\n") print(msg) self.main = startMain() self.timeStartMain = datetime.now(timezone.utc)
def closeEvent(self,event): event.accept() os.system("pkill testread") if self.mqd != "": self.mqd.close() posix.unlink_message_queue("/mqd") self.mqd = "" if self.mqf != "": self.mqf.close() posix.unlink_message_queue("/mqf") self.mqf = "" os._exit(0)
def main(): app = QtGui.QApplication(sys.argv) ui_calibration = Code_Dialog_calibration() ui_calibration.show() ret = app.exec_() ui_calibration.flag.set() ui_calibration.running.clear() #os.system("pkill out1") os.system("pkill streamread") ui_calibration.mqd.close() ui_calibration.mqf.close() posix.unlink_message_queue("/mqd") posix.unlink_message_queue("/mqf") sys.exit(ret)
def main(): app = QtGui.QApplication(sys.argv) ui_main = Code_MainWindow() ui_main.show() ret=app.exec_() os.system("pkill testread") ui_main.flag.set() ui_main.running.clear() if ui_main.mqd != "": ui_main.mqd.close() posix.unlink_message_queue("/mqd") if ui_main.mqf != "": ui_main.mqf.close() posix.unlink_message_queue("/mqf") sys.exit(ret)
def __init__(self): try: unlink_message_queue("/gyro") except: pass self.mqueue = MessageQueue('/gyro', flags=O_CREX, max_messages=MAX_MSG) try: self.gyro = mpu6050(0x68) except: raise Exception("Could not connect to Gyroscope MPU6050") self.angleFront = 0. self.angleSide = 0.
def adjonction(pidC, newEnreg): try: FSC = pos.MessageQueue("/queueFSC" + str(pidC), pos.O_CREAT) #création ou ouverture de la file print( "FSC: Creation/Ouverture de la file de message serveur to client") except pos.ExistentialError: S = pos.unlink_message_queue("/queueFSC" + str(pidC)) #destruction de la file FSC = pos.MessageQueue("/queueFSC" + str(pidC), pos.O_CREAT) #puis redemande newNum = 1 Sadd.acquire() #P(S) try: #on essaye d'ouvrir le fichier with open( nomFichier, "r" ) as fichier: #with permet d'ouvrir le fichier puis le ferme automatiquement, ici on ouvre le fichier en lecture for enregistrement in fichier.readlines( ): #on parcourt tout les enregistrement du fichier newNum = newNum + 1 except: #si il y a echec, on le notifi contenu = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible." try: with open(nomFichier, "a") as fichier: #On ouvre le fichier en ajout fichier.write( str(newNum) + ": " + newEnreg + "\n" ) #On ajoute le nouvel enregistrement au fichier,newNum permet de classer nos enregistrement et "\n" permet de séparé les enregistrements notif = "Enregistrement numero " + str(newNum) + " effectue." except: notif = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible." Sadd.release() #V(S) FSC.send(notif, None, int(pidC))
def modification(pidC,numEnreg,newEnreg): try: FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #création ou ouverture de la file #print("FSC: Creation/Ouverture de la file de message serveur to client") except pos.ExistentialError: S = pos.unlink_message_queue("/queueFSC"+str(pidC)) #destruction de la file FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #puis redemande #On bloque les autres actions possibles Smodif.acquire() Sconsul.acquire() Sadd.acquire() Svisu.acquire() Ssupp.acquire() try: with open(nomFichier, "r") as fichier: #on lis entierement le fichier pour le récuperer listEnregistrements = fichier.readlines() try: with open(nomFichier, "w") as fichier: #puis on le récrit a partir de ce que l'on a recuperer en modifiant ce que l'on cherche for enregistrement in listEnregistrements: if enregistrement.startswith(numEnreg + ": "): #lorsque on a trouvé le bon enregistrement, on le change enregistrement = numEnreg + ": " + newEnreg + "\n" fichier.write(enregistrement) notif = "Modification effectue sur l'enregistrement numero " + numEnreg + "." except: notif = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible." except: notif = "Le fichier " + nomFichier + " est introuvable ou nest pas accessible." #on libere les autres actions Smodif.release() Ssupp.release() #V(S) Sconsul.release() #V(S) Sadd.release() #V(S) Svisu.release() #V(S) FSC.send(notif,None,int(pidC))
def signal_handler(self, signal, frame): """ SignalHandler to unlink the MessageQueue created by this thread. Parameters ---------- signal: currently will always be signal.SIGINT frame: stackframe """ try: logger.info('Unlinking MessageQueue::' + self.display_q_name) unlink_message_queue(self.display_q_name) unlink_message_queue(self.em_q_name) except ExistentialError as e: pass finally: sys.exit(0)
def main(): #--- programme serveur: gère les accès concurents entre les modifications et les suppressions. signal.signal( signal.SIGINT, fermer_serveur ) # SIGINT au Handler fermer_serveur : prévient le SE qu’à l’arrivée du signal ^C il faudra exécuter fermer_programme #Initialisation des deux files FCS et FSC #!!! problème potentiel initialisation, si erreur ça detruit puis ça recreer (perte msg?)? quel erreur ? # a voir avec le tp ConsMessage, la partie except fait surement n'importe quoi !!! #FCS try: FCS = pos.MessageQueue("/queueFCS", pos.O_CREAT) #création ou ouverture de la file print( "FCS: Creation/Ouverture de la file de message client to serveur") except pos.ExistentialError: S = pos.unlink_message_queue("/queueFCS") #destruction de la file FCS = pos.MessageQueue("/queueFCS", pos.O_CREAT) #puis redemande ouvertureServ = True #La partie qui boucle du serveur while ouvertureServ: try: messageClient = FCS.receive( ) # 0 car on prend en FIFO, voir "TP UNIX-Python SEANCE 2016v2 tout à la fin" #!! receive retourne, selon ce même pdf, un tuple de (message,type), comment récupérer juste le msg ? j'ai mis [0] dans le doute, à tester listInfo = messageClient[0].split( "/" ) #ici on split les informations reçu pour les stockés et les utiliser plus tard action = listInfo[0] pidClient = listInfo[1] nomFichier = listInfo[3] numEnregistrement = listInfo[4] #numEnreg peut être "-" parfois nouvelEnreg = listInfo[5] #nouvelEnreg peut être "-" parfois #New thread(split(3), (split 1 et 2)) /*split 1 et 2 correspondent aux autres infos envoyées comme par exemple le pid ou le numéro d’enregistrement*/ #On determine la fonction à exécuter en selon l'action demandé par le client if action == 'consultation': thread.start_new_thread(consultation, (pidClient, numEnregistrement)) elif action == 'modification': thread.start_new_thread( modification, (pidClient, numEnregistrement, nouvelEnreg)) elif action == 'suppression': thread.start_new_thread(suppression, (pidClient, numEnregistrement)) elif action == 'adjonction': thread.start_new_thread(adjonction, (pidClient, nouvelEnreg)) elif action == 'visualisation': thread.start_new_thread(visualisation, (pidClient, )) elif action == 'tempsAttente': tempsAttente() except pos.SignalError: ouvertureServ = False
def main(): #--- programme serveur: gère les accès concurents entre les modifications et les suppressions. signal.signal( signal.SIGINT, fermer_serveur ) # SIGINT au Handler fermer_serveur : prévient le SE qu’à l’arrivée du signal ^C il faudra exécuter fermer_programme #FCS try: FCS = pos.MessageQueue("/queueFCS" + str(nomFichier), pos.O_CREAT) #création ou ouverture de la file print( "FCS: Creation/Ouverture de la file de message client to serveur") except pos.ExistentialError: S = pos.unlink_message_queue("/queueFCS" + str(nomFichier)) #destruction de la file FCS = pos.MessageQueue("/queueFCS" + str(nomFichier), pos.O_CREAT) #puis redemande ouvertureServ = True #La partie qui boucle du serveur while ouvertureServ: try: messageClient = FCS.receive() listInfo = messageClient[0].split( "/" ) #ici on split les informations reçu pour les stockés et les utiliser plus tard action = listInfo[0] pidClient = listInfo[1] nomFichier = listInfo[2] numEnregistrement = listInfo[3] #numEnreg peut être "-" parfois nouvelEnreg = listInfo[4] #nouvelEnreg peut être "-" parfois #New thread(split(3), (split 1 et 2)) /*split 1 et 2 correspondent aux autres infos envoyées comme par exemple le pid ou le numéro d’enregistrement*/ #On determine la fonction à exécuter en selon l'action demandé par le client if action == 'consultation': thread.start_new_thread(consultation, (pidClient, numEnregistrement)) elif action == 'modification': thread.start_new_thread( modification, (pidClient, numEnregistrement, nouvelEnreg)) elif action == 'suppression': thread.start_new_thread(suppression, (pidClient, numEnregistrement)) elif action == 'adjonction': thread.start_new_thread(adjonction, (pidClient, nouvelEnreg)) elif action == 'visualisation': thread.start_new_thread(visualisation, (pidClient, )) elif action == 'tempsAttente': tempsAttente(pidClient) except pos.SignalError: ouvertureServ = False
def visualisation(pidC): try: FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #création ou ouverture de la file #print("FSC: Creation/Ouverture de la file de message serveur to client") except pos.ExistentialError: S = pos.unlink_message_queue("/queueFSC"+str(pidC)) #destruction de la file FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #puis redemande Svisu.acquire() #P(S) try: with open(nomFichier, "r") as fichier: #On ouvre le fichier en lecture contenu = fichier.read() #On récupère entierement le contenu du fichier except: contenu = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible." Svisu.release() #V(S) FSC.send(contenu,None,int(pidC))
def suppression(pidC,numEnreg): try: FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #création ou ouverture de la file #print("FSC: Creation/Ouverture de la file de message serveur to client") except pos.ExistentialError: S = pos.unlink_message_queue("/queueFSC"+str(pidC)) #destruction de la file FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #puis redemande #On bloque les autres actions possibles Ssupp.acquire() Sconsul.acquire() Sadd.acquire() Svisu.acquire() Smodif.acquire() try: with open(nomFichier, "r") as fichier: #on lis entierement le fichier pour le récuperer listEnregistrements = fichier.readlines() try:
def suppression(pidC, numEnreg): try: FSC = pos.MessageQueue("/queueFSC" + str(pidC), pos.O_CREAT) #création ou ouverture de la file print( "FSC: Creation/Ouverture de la file de message serveur to client") except pos.ExistentialError: S = pos.unlink_message_queue("/queueFSC" + str(pidC)) #destruction de la file FSC = pos.MessageQueue("/queueFSC" + str(pidC), pos.O_CREAT) #puis redemande Ssupp.acquire() Sconsul.acquire() Sadd.acquire() Svisu.acquire() Smodif.acquire() time.sleep(5) try: with open(nomFichier, "r") as fichier: listEnregistrements = fichier.readlines() try: with open(nomFichier, "w") as fichier: for enregistrement in listEnregistrements: if not enregistrement.startswith(numEnreg + ": "): numEnr, newEnregis = enregistrement.split(":") if numEnr > numEnreg: numEnr = int(numEnr) - 1 fichier.write(str(numEnr) + ":" + newEnregis) notif = "Suppression effectue sur l'enregistrement numero " + numEnreg + "." except: notif = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible." except: notif = "Le fichier " + nomFichier + " est introuvable ou nest pas accessible." Ssupp.release() #V(S) Smodif.release() Sconsul.release() #V(S) Sadd.release() #V(S) Svisu.release() #V(S) FSC.send(notif, None, int(pidC))
import posix_ipc import utils try: posix_ipc.unlink_message_queue(utils.QUEUE_NAME) s = "message queue %s removed" % utils.QUEUE_NAME print (s) except: print ("queue doesn't need cleanup") print ("\nAll clean!")
#!/usr/bin/env python import logging # 3rd party modules import posix_ipc logging.basicConfig(format='%(asctime)s %(message)s', filename='./log/dronetology.log', level=logging.DEBUG) logging.debug("QUEUE cleanned") try: posix_ipc.unlink_message_queue("/RESULT_QUEUE") except posix_ipc.ExistentialError: logging.info( " No queue exists with the specified name /RESULT_QUEUE......") try: posix_ipc.unlink_message_queue("/INPUT_QUEUE") except posix_ipc.ExistentialError: logging.info(" No queue exists with the specified name /INPUT_QUEUE......") try: posix_ipc.unlink_message_queue("/MISSION_WAYPOINT_QUEUE") except posix_ipc.ExistentialError: logging.info( " No queue exists with the specified name /MISSION_WAYPOINT_QUEUE......" ) try:
mq.close() mq.unlink() print_mem_after() say("Running message queue create/destroy test 2...") print_mem_before() for i in the_range: name = "/" + ''.join(random.sample(NAME_CHARACTERS, NAME_LENGTH)) mq = posix_ipc.MessageQueue(name, posix_ipc.O_CREX) mq.close() posix_ipc.unlink_message_queue(name) print_mem_after() say("Running message queue create/destroy test 3...") print_mem_before() for i in the_range: mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX) mq.close() mq.unlink() print_mem_after()
def unlink_static(name): posix_ipc.unlink_message_queue(name)
s = s.decode() utils.say("Received %s" % s) # What I read must be the md5 of what I wrote or something's # gone wrong. if PY_MAJOR_VERSION > 2: what_i_sent = what_i_sent.encode() try: assert(s == hashlib.md5(what_i_sent).hexdigest()) except AssertionError: utils.raise_error(AssertionError, "Message corruption after %d iterations." % i) # MD5 the reply and write back to Mrs. Conclusion. s = hashlib.md5(s.encode()).hexdigest() utils.say("Sending %s" % s) mq.send(s) what_i_sent = s utils.say("") utils.say("%d iterations complete" % (i + 1)) utils.say("Destroying the message queue.") mq.close() # I could call simply mq.unlink() here but in order to demonstrate # unlinking at the module level I'll do it that way. posix_ipc.unlink_message_queue(params["MESSAGE_QUEUE_NAME"])