def consultation(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 global contenu find=False Sconsul.acquire() #P(S) on bloque l'acces au fichier pour les autres threads rep = u"/" fichier = u"fichier.txt" chemin = cherchefichier(fichier,rep) b=chemin [0:-1] if b != '/': chemin =chemin +'/' cheminObs = chemin + nomFichier try: #on essaye d'ouvrir le fichier with open(cheminObs, "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 if enregistrement.startswith(numEnreg + ": "): #On cherche l'enregistrement qui correpond au numero rechercher find = True contenu = enregistrement.strip('\n') if find == False: contenu = "l'enregistrement que vous cherchez n'existe pas" except: #si il y a echec, on le notifi contenu = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible." Sconsul.release() #V(S) on libère le fichier FSC.send(contenu,None,int(pidC)) #On met dans la file FSC le contenu rechercher pour le client
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 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 run(): while True: print "gobatch: En attente d'une commande" # Le processus est bloqué tant qu'aucune commande pgcycl n'est arrivée S.acquire() # gobatch attend de reçevoir un message de pgcycl : try: filmess = pos.MessageQueue("/queue", pos.O_CREAT) # ouvre la file except pos.ExistentialError: pos.unlink_message_queue("/queue") # détruit la file filmess = pos.MessageQueue( "/queue", pos.O_CREAT) # puis redemande la création (message, priorite) = filmess.receive() # retire le message en tête de file print "gobatch : Le message reçu est : {}, de priorité {}".format( message, priorite) # Type d'action en fonction de la priorité (type) du message if priorite == 1: # Action : lecture du fichier fbatch lectureFichier() elif priorite == 2: # Action : suppression de la commande spécifiée supprimerThread(message) elif priorite == 3: # Action : écriture dans le fichier fbatch creationThread()
def __init__(self): txq_name, rxq_name = self.load_config() self.rxq = ipc.MessageQueue('/' + rxq_name, ipc.O_CREAT) self.txq = ipc.MessageQueue('/' + txq_name, ipc.O_CREAT, max_messages=10, max_message_size=2048) self.txq.block = False self.rxq.block = False
def __init__(self): self.status = False self.shutdown = False self.rx_mq = posix_ipc.MessageQueue(AGENT_TO_JUPYTER, posix_ipc.O_CREAT) self.tx_mq = posix_ipc.MessageQueue(JUPYTER_TO_AGENT, posix_ipc.O_CREAT)
def start_to_capture(self): if self.lineEdit_sensor1_location.text() == "": result = QtGui.QMessageBox.warning( self, "warning", "please input sensor1's location first") return if self.lineEdit_sensor2_location.text() == "": result = QtGui.QMessageBox.warning( self, "warning", "please input sensor2's location first") return if self.lineEdit_source_location.text() == "": result = QtGui.QMessageBox.warning( self, "warning", "please input source's location first") return self.sensor1_loc = float(self.lineEdit_sensor1_location.text()) self.sensor2_loc = float(self.lineEdit_sensor2_location.text()) self.source_loc = float(self.lineEdit_source_location.text()) self.lineEdit_sensor1_location.setEnabled(False) self.lineEdit_sensor2_location.setEnabled(False) self.lineEdit_source_location.setEnabled(False) self.running = threading.Event() self.flag = threading.Event() self.running.set() self.flag.clear() self.receive_thread = threading.Thread( name="datareceiver", target=self.receive_message_queue) self.receive_thread.start() self.pushButton_start_to_capture.setEnabled(False) self.pushButton_stop_to_capture.setEnabled(True) self.mqd = posix.MessageQueue("/mqd", flags=posix.O_CREAT, mode=0o644) self.mqf = posix.MessageQueue("/mqf", flags=posix.O_CREAT, mode=0o644) self.start_capture()
def __init__(self): self.mq_recv = posix_ipc.MessageQueue('/simu_IPC_reply', posix_ipc.O_CREAT) self.mq_recv.block = False # non-blocking recv , send self.mq_send = posix_ipc.MessageQueue('/simu_IPC_cmd', posix_ipc.O_CREAT) self.mq_send.block = False # non-blocking recv , send
def __init__(self, callback): self.thread = None self.isStop = False self.rx_mq = posix_ipc.MessageQueue(JUPYTER_TO_AGENT, posix_ipc.O_CREAT) self.tx_mq = posix_ipc.MessageQueue(AGENT_TO_JUPYTER, posix_ipc.O_CREAT) self.callback = callback
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 make_queues(task_name, instance_id, is_clear=False): q_name_b2t = '/broker_to_' + task_name + ':' + str(instance_id) q_name_t2b = '/' + task_name + ':' + str(instance_id) + '_to_broker' q_b2t = posix_ipc.MessageQueue(q_name_b2t, posix_ipc.O_CREAT) q_t2b = posix_ipc.MessageQueue(q_name_t2b, posix_ipc.O_CREAT) if is_clear: clear(q_b2t) clear(q_t2b) return (q_b2t, q_t2b)
def __init__(self, config, index): import posix_ipc prefix = f'nsh_{index}' max_message_size = config.getint('nsh', 'max_message_size') self.sender = posix_ipc.MessageQueue(f'/{prefix}.g2e', flags=posix_ipc.O_CREAT, max_message_size=max_message_size) self.receiver = posix_ipc.MessageQueue( f'/{prefix}.e2g', flags=posix_ipc.O_CREAT, max_message_size=max_message_size)
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 demander_modifier(idEnr): ''' Etapes pour procéder à une modification : 1 lecture 2 affichage 3 edit interactif 4 écriture coté serveur ''' #Demande de lecture spéciale pour contenir le délai requete = "MODIFLEC:" + str(monPid) + ":" + str(idEnr) fileVersServeur.send( requete, priority=1) #Priorité plus elevée car c'est une modification print("Demande de lecture envoyée...") # Maintenant on attend la réponse sur une file crée grâce au pid du client try: fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid), pos.O_CREAT | pos.O_EXCL) except pos.ExistentialError: print("/fileVersClient{} déjà existante".format(monPid)) fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid), pos.O_CREAT) reponse = fileVersClient.receive()[0] if (reponse == "ENREGISTREMENT INTROUVABLE"): print("Cet enregistrement n'existe pas/plus sur le serveur.") else: #Notre réponse serveur est sous cette forme : #delai:Enregistrement ==> On découpe le string en deux parties reponse = reponse.split(":") delai = int(reponse[0]) #On joint le texte à partir de la case 1 au cas où l'enregistrement contient des double points #Il ne s'agit que d'une précaution pour ne pas juste utiliser reponse[1] texte = ''.join(reponse[1:]) signal.alarm(delai) try: #on modifie interactivement le texte envoi = input_interactif( "Procédez à la modification dans les {} secondes: \n".format( delai), texte) requete = "MODIFIER:" + str(monPid) + ":" + str( idEnr) + ":" + envoi print("Demande de modification envoyée...") fileVersServeur.send( requete, priority=1) # Priorité plus elevée car c'est une modification except Alarm: print("\nTemps écoulé.\n") signal.alarm(0) fileVersClient.unlink()
def cree_file(): global fileVersServeur global fileVersClient global fileReponseSup try: fileVersServeur = pos.MessageQueue("/fileVersServeur") except: print("File vers serveur non existant! veuillez lancer servfic") sys.exit(2) try: fileReponseSup = pos.MessageQueue("/reponseSup") except pos.ExistentialError: print("fileConfirmationSup pas existante(pas normal)")
def start(self): self._helper = subprocess.Popen([helperExe, "--with_ui"], stdin=subprocess.PIPE, stdout=sys.stdout) time.sleep(3) try: self.mq = {} self.mq["send"] = posix_ipc.MessageQueue("/cmd") self.mq["receive"] = posix_ipc.MessageQueue("/resp") except sysv_ipc.ExistentialError as e: DBG("ERROR: message queue creation failed " % str(e)) raise self.thread_init()
def demander_visualiser(): requete = "VISUALISER:" + str(monPid) fileVersServeur.send(requete) try: fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid), pos.O_CREAT | pos.O_EXCL) except pos.ExistentialError: print("/fileVersClient{} déjà existante".format(monPid)) fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid), pos.O_CREAT) reponse = fileVersClient.receive()[0] print(reponse) fileVersClient.unlink()
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 __init__(self, config, index): import posix_ipc prefix = f'nsh_{index}' try: os.remove(os.path.join('/dev/mqueue', prefix)) except FileNotFoundError: pass max_message_size = config.getint('nsh', 'max_message_size') self.sender = posix_ipc.MessageQueue(f'/{prefix}.e2g', flags=posix_ipc.O_CREAT, max_message_size=max_message_size) self.receiver = posix_ipc.MessageQueue( f'/{prefix}.g2e', flags=posix_ipc.O_CREAT, max_message_size=max_message_size)
def receive(): params = {} line1 = "ITERATIONS=10" line2 = "MESSAGE_QUEUE_NAME=/mq_test" name, value = line1.split('=') name = name.upper().strip() if name == "PERMISSIONS": value = int(value, 8) elif "NAME" in name: # This is a string; leave it alone. pass else: value = int(value) params[name] = value name, value = line2.split('=') name = name.upper().strip() if name == "PERMISSIONS": value = int(value, 8) elif "NAME" in name: # This is a string; leave it alone. pass else: value = int(value) params[name] = value mq = posix_ipc.MessageQueue(params["MESSAGE_QUEUE_NAME"]) s, _ = mq.receive() s = s.decode() print(s)
def __init__(self, mq_name): self.queue = ipc.MessageQueue(name=mq_name, flags=ipc.O_CREAT) while True: try: self.queue.receive(0) except ipc.BusyError: break
def setSendQueue(self, qname=None): """ Name of a queue, where all messages will be sent should be specified in first use After that, the queue will be set to appropriate one which comes in 'response' key in message dict Might be changed with appopriate function call """ if qname is not None: qname = '/' + qname self.queues[1][0] = qname try: if ((qname is None) and (self.queues[1][0]) is not None): qname = self.queues[1][0] """ Setting receiver message queue if exist in order to send messages """ self.queues[1][1] = posix.MessageQueue(qname) return True except ValueError as error: if __debug__: log.error(error) log.error('Queue name should be specified') return False except posix.ExistentialError: if __debug__: log.error('Cannot open queue %s', qname) return False return False
def test_read_flag_new_queue(self): """test that the read flag is respected on a new queue""" mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX, read=False) mq.send('foo') self.assertRaises(posix_ipc.PermissionsError, mq.receive) mq.close() mq.unlink()
def test_block_flag_false(self): """test blocking behavior when flag is false""" mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX, max_messages=3) mq.block = False # Queue is empty, so receive() should immediately raise BusyError start = time.time() self.assertRaises(posix_ipc.BusyError, mq.receive, 10) elapsed = time.time() - start # Not only should receive() have raised BusyError, it should have # done so "immediately". I don't insist on extreme precision since # OS-level task switching might mean that elapsed time is not # vanishingly small as one might expect under most circumstances. self.assertTrue(elapsed < 1.0) # Now test send() the same way. mq.send(' ') mq.send(' ') mq.send(' ') # Queue is now full. start = time.time() self.assertRaises(posix_ipc.BusyError, mq.send, ' ', 10) elapsed = time.time() - start self.assertTrue(elapsed < 1.0) mq.close() mq.unlink()
def __init__(self,ip,port): # global flyermmap print(posix_ipc.MESSAGE_QUEUES_SUPPORTED) print(posix_ipc.QUEUE_MESSAGES_MAX_DEFAULT) print(posix_ipc.QUEUE_MESSAGE_SIZE_MAX_DEFAULT) self.model_pub = rospy.Publisher("/gazebo/set_model_state",ModelState,queue_size=1) self.bridge = CvBridge() #self.image_sub = rospy.Subscriber("/mycam/image_raw",Image,self.callback) self.image_sub = rospy.Subscriber("/multisense/camera/left/image_raw",Image,self.callback) self.imageflag = 0 self.imagecnt = 0 self.key = 0 firstFoot = Foot([0,-0.1,0],Foot.RIGHT) standingFoot = Foot([0,0.1,0],Foot.LEFT) self.list = Steplist(firstFoot,standingFoot) self.height = 1.6 self.tilt = 0.0 memory = posix_ipc.SharedMemory("flyermmap", posix_ipc.O_CREAT, size=8*Mib) self.sem = posix_ipc.Semaphore("flyersem", posix_ipc.O_CREAT) self.memmap = mmap.mmap(memory.fd, memory.size) # flyermmap = self.memmap memory.close_fd() self.queue = posix_ipc.MessageQueue("/flyerqueue", posix_ipc.O_CREAT) #self.wsproc = prc.Popen('python flyerws.py', shell=True ) self.wsproc = prc.Popen('python -u flyerws.py --ip %s --port %s' % (ip,port), shell=True ) self.writecnt = 0 self.loc = (0,0,0) self.walker = Walker() self.walker.init()
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 test_max_messages(self): """test that the max_messages param is respected""" mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX, max_messages=1) mq.send('foo') self.assertRaises(posix_ipc.BusyError, mq.send, 'bar', timeout=0) mq.close() mq.unlink()
def openQueue(): # Open, or create, the Queue that leads to the Database. global queue queue = ipc.MessageQueue( '/netmToDB', flags=ipc.O_CREAT, )
def __init__(self, id=0): BBSimInterface.__init__(self, id) self.ang = ipc.MessageQueue("/bbsim_out1-{}".format(id), max_messages=1) self.pos = ipc.MessageQueue("/bbsim_out2-{}".format(id), max_messages=1) self.write = ipc.MessageQueue("/bbsim_in-{}".format(id), max_messages=1) self._reset = ipc.MessageQueue("/bbsim_reset-{}".format(id), max_messages=1) # Provides the possibility to read the state perfectly self.x2 = ipc.MessageQueue("/bbsim_ballspeed-{}".format(id), max_messages=1) self.angle = 0 self.position = 0 self.ballspeed = 0