[Python] Controllo esistenza file semaforo

[fermat]

ciao!

avrei bisogno di un consiglio.
allora, lancio una funzione e creo un file semaforo dentro ad una specifica cartella.
quando viene creato questo file parte una procedura di un altro programma (non creato da me).
questo programma cancellerà questo file semaforo.
al momento della cancellazione, devo rilanciare un'altra procedura che rifarà la stessa cosa.

come faccio a controllare il momento in cui viene cancellato suddetto file??

[optime]

come ti accorgi che il file è creato?
1. con un polling? --> allo stesso modo vedi se quel file NON c'è
2. chi crea lancia un altro processo? --> a sua volta, chi cancella lancia un ulteriore altro processo

[fermat]

ho visto che potrei usare watchdog per controllare l'esistenza del file.

quindi potrei:
- lanciare la procedura che crea il file semaforo
- lanciare una funzione con watchdog per controllare fino a quando il file semaforo c'è
- quando viene cancellato (c'è un evento apposito) fermare watchdog e lanciare la seconda procedura
- ricominciare il giro

sulla carta mi sembra funzionare!
faccio qualche prova e vi dico!

[optime]

optime!

[fermat]

allora, ho fatto qualcosa, ovviamente simulato tutto su pc.
in teoria poi saranno solo da cambiare i path.

cmq, questa la classe handler per watchdog:

from watchdog.events import FileSystemEventHandler

class MonitorFile(FileSystemEventHandler):

    def on_deleted(self, event):
        print(event.src_path, event.event_type)

poi lancio tutto così:

import shutil
import time
from watchdog.observers import Observer

from MonitorFile import MonitorFile

def crea_semaforo(file):
    file_semaforo = './test_semaforo/semaforo'
    shutil.move('./csv/' + file, './test_file/' + file)
    f = open(file_semaforo, "a")
    f.write("")
    f.close()

def start_monitor(dir):
    event_handler = MonitorFile()
    observer = Observer()
    observer.schedule(event_handler, path=dir, recursive=False)
    print("Monitoring started")
    observer.start()

    try:
        while (True):
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        observer.join()

e poi lancio tutto così:

if __name__ == '__main__':
    fatture()
    crea_semaforo(get_first_file('./csv'))

    time.sleep(2)
    dir_semaforo = './test_semaforo'
    start_monitor(dir_semaforo)

- lancio la funzione fatture() --> ok
- lo spostamento del file, da cui deriva tutto, funziona
- la creazione del file semaforo funziona
- il monitor parte correttamente
- quando cancello il semaforo, vedo che l'evento viene intercettato

quello che mi manca è stoppare il monitor e ricominciare diciamo.
quindi, quando quello specifico file viene cancellato dovrei:
- stoppare il monitor
- rilanciare la crea_semaforo

[optime]

ma i monitor stanno sempre accesi per intercettare presenza e assenza del file

[fermat]

ma i monitor stanno sempre accesi per intercettare presenza e assenza del file

ah ok, quindi mi dici di rilanciare la funzione nell'on_delete direttamente, giusto?

[optime]

non conosco Python così bene, ho giusto scritto qualcosa per diletto stavo solo ragionando a livello funzionale

[fermat]

ho fatto un bel pò di modifiche:

import sys
import time
import shutil
from watchdog.events import FileSystemEventHandler
from utils import get_first_file

class MonitorFile(FileSystemEventHandler):

    def crea_semaforo(self):
        file = get_first_file('./csv')

        if file != 'ND':
            shutil.move('./csv/' + file, './test_file/' + file)
            time.sleep(2)

            f = open('./test_semaforo/semaforo', "a")
            f.write("")
            f.close()
        else:
            exit() --> FUNZIONA

    def on_deleted(self, event):
        if event.src_path == './test_semaforo\semaforo':
            print('CANCELLATO')
            file = get_first_file('./csv')
            print(file)
            if file != 'ND':
                self.crea_semaforo()
            else:
                exit() --> NON FUNZIONA

e lancio tutto così:

if __name__ == '__main__':
    # fatture()

    event_handler = MonitorFile()
    event_handler.crea_semaforo()

    observer = Observer()
    observer.schedule(event_handler, path='./test_semaforo', recursive=False)
    observer.start()

    try:
        while (True):
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        observer.join()

funziona tutto tranne l'exit.
cioè, quando arrivo che file è uguale ad ND, lui deve uscire proprio dal programma.
perchè la procedura è finita, ed è inutile che rimane un processo attivo.
però rimane tutto attivo.

[fermat]

ho fatto una serie di modifiche seguendo anche altri tutorial.
ho spostato l'Observer direttamente dentro al "monitor", in modo da avere accesso diretto:

import time
import shutil
from watchdog.events import FileSystemEventHandler
from watchdog.observers import Observer
from utils import get_first_file

class MonitorFile(FileSystemEventHandler):

    observer = Observer()

    def crea_semaforo(self):
        file = get_first_file('./csv')

        if file != 'ND':
            shutil.move('./csv/' + file, './test_file/' + file)
            time.sleep(1)

            f = open('./test_semaforo/semaforo', "a")
            f.write("")
            f.close()
        else:
            self.observer.stop()
            time.sleep(1)
            print("ESCO") # VIENE VISUALIZZATO
            exit(0) # PROCESSO RIMANE ATTIVO

    def run_observer(self):
        self.observer.schedule(self, path='./test_semaforo', recursive=False)
        self.observer.start()

        try:
            while (True):
                time.sleep(1)
        except (KeyboardInterrupt, SystemExit):
            self.observer.stop()
            time.sleep(1)

        self.observer.join()

    def on_deleted(self, event):
        if event.src_path == './test_semaforo\semaforo':
            self.crea_semaforo()

poi richiamo tutto così:

if __name__ == '__main__':
    fatture()

    event_handler = MonitorFile()
    event_handler.crea_semaforo()
    event_handler.run_observer()

come già messo nel commento, il print ESCO viene visualizzato.
quindi intercetta correttamente il valore ND.
solo che non esce dal programma e sembra rimanere appeso li.

qualche idea??