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"])
