vous devrez intégrer une base de données, et vous pourrez conserver une trace des fichiers en fonction de la taille, du nom et de l'auteur.

en cas de mise à jour, il y aura un changement dans la taille du fichier, vous pouvez mettre à jour ou ajouter en conséquence

Vous devez enregistrer les modifications quelque part ou écouter l'événement lorsque le contenu du fichier change. Pour ce dernier, vous pouvez utiliser watchdog .

Si vous préférez vraiment cron à la place de vérification incrémentielle des changements (chien de garde), vous devrez stocker les changements dans une base de données. Un exemple de base serait:

from subprocess import Popen, PIPE
diff = Popen(['diff', 'old.txt', 'new.txt']).communicate()[0]
Popen(['patch', 'old.txt'], stdin=PIPE).communicate(input=diff)

puis pour vérifier le diff vous videriez l'état avant cron dans un fichier, exécuteriez un simple diff old.txt new.txt et s'il y a une sortie (c'est-à-dire qu'il y a un changement), vous copieriez soit le fichier entier, soit simplement la sortie du diff seul que vous appliqueriez alors comme un patch au fichier que vous souhaitez écraser.

S'il n'y a pas de sortie diff , il n'y a aucun changement et donc rien à mettre à jour dans le fichier.

Modifier: En fait: D vous pourriez même ne pas avoir besoin d'une base de données si les fichiers sont sur la même machine ... De cette façon, vous pouvez simplement diff + patch directement entre l'ancien et le nouveau fichier.

Exemple:

$ echo 'hello' > old.txt && echo 'hello' > new.txt
$ diff old.txt new.txt                             # empty
$ echo 'how are you' >> new.txt                    # your file changed
$ diff old.txt new.txt > my.patch && cat my.patch  # diff is not empty now
1a2
> how are you

$ patch old.txt < my.patch  # apply the changes to the old file

et en Python avec la même base old.txt et new.txt :

ID | path        | state before cron
1  | /myfile.txt | hello
...| ...         | ...

Une façon consiste à enregistrer une seule ligne dans un fichier pour garder le suivi de la dernière heure (à l'aide de os.path.getctime ) vous avez copié les fichiers et maintenez cette ligne à chaque fois que vous copiez.

Remarque: L'extrait suivant peut être optimisé.

should_copy_files = [filename for filename in list_of_files if os.path.getctime(filename) > float(latest_file_modified_time)]

L'approche consiste à créer un fichier contenant l'horodatage du dernier fichier modifié par le système.

Récupérer tous les fichiers et les trier par heure de modification

latest_file_modified_time = os.path.getctime(list_of_files[0])

Au départ, dans sinon os.path.exists ("track_modifications. txt "): Je vérifie si ce fichier n'existe pas (c'est-à-dire la première fois à copier), puis j'enregistre le plus grand horodatage du fichier dans

list_of_files = sorted(glob.iglob('directory/*.txt'), key=os.path.getctime, reverse=True)

Et je il suffit de copier tous les fichiers donnés et d'écrire cet horodatage dans le fichier track_modifications .

sinon, le fichier existe (c'est-à-dire qu'il y avait des fichiers copiés avant), je vais juste lire cet horodatage et comparer avec la liste des fichiers que j'ai lus dans list_of_files et récupérez tous les fichiers avec un horodatage plus grand (c'est-à-dire créés après le dernier fichier que j'ai copié). C'est dans

import datetime
import glob
import os
import shutil

Info_month = datetime.datetime.now().strftime("%B")
list_of_files = sorted(glob.iglob("/data1/logs/{0}/*/*.txt".format(Info_month)), key=os.path.getctime, reverse=True)
if not os.path.exists("track_modifications.txt"):
    latest_file_modified_time = os.path.getctime(list_of_files[0])
    for filename in list_of_files:
            shutil.copy(filename, "/data2/logs/")
    with open('track_modifications.txt', 'w') as the_file:
        the_file.write(str(latest_file_modified_time))
else:
    with open('track_modifications.txt', 'r') as the_file:
        latest_file_modified_time = the_file.readline()
    should_copy_files = [filename for filename in list_of_files if
                         os.path.getctime(filename) > float(latest_file_modified_time)]
    for filename in should_copy_files:
            shutil.copy(filename, "/data2/logs/")

En fait, le suivi de l'horodatage des derniers fichiers modifiés vous donnerait également l'avantage de copier les fichiers déjà copiés lorsqu'ils sont modifiés :)

Vous pouvez utiliser le correctif de correspondance des différences de Google (vous pouvez l'installer avec pip install diff-match-patch ) pour créer un diff et appliquer un patch de celui-ci:

import diff_match_patch as dmp_module

#...
if not os.path.exists("/data2/logs/" + os.path.basename(filename)):
    shutil.copy(filename, "/data2/logs/")
else:
    with open(filename) as src, open("/data2/logs/" + os.path.basename(filename),
                                                                        'r+') as dst:
        dmp = dmp_module.diff_match_patch()

        src_text = src.read()
        dst_text = dst.read()

        diff = dmp.diff_main(dst_text, src_text)

        if len(diff) == 1 and diff[0][0] == 0:
            # No changes
            continue

        #make patch
        patch = dmp.patch_make(dst_text, diff)
        #apply it
        result = dmp.patch_apply(patch, dst_text)

        #write
        dst.seek(0)
        dst.write(result[0])
        dst.truncate()

Il y a des idées très intéressantes dans ce fil, mais je vais essayer de proposer de nouvelles idées.

Idée no. 1: Meilleure façon de suivre les mises à jour

Selon votre question, il est clair que vous utilisez une tâche cron pour suivre le fichier mis à jour.

Si vous essayez de surveiller un petite quantité de fichiers / répertoires, je proposerais une approche différente qui vous simplifiera la vie.

Vous pouvez utiliser le mécanisme Linux inotify , qui vous permet de surveiller des fichiers / répertoires spécifiques et soyez averti chaque fois qu'un fichier est écrit.

Pro : Vous connaissez chaque écriture immédiatement, sans avoir besoin de vérifier les modifications. Vous pouvez bien sûr écrire un gestionnaire qui ne met pas à jour la destination pour chaque écriture, mais un dans X minutes.

Voici un exemple qui utilise le package python inotify (pris depuis la page du package ):

import inotify.adapters

def _main():
    i = inotify.adapters.Inotify()

    i.add_watch('/tmp')

    with open('/tmp/test_file', 'w'):
        pass

    for event in i.event_gen(yield_nones=False):
        (_, type_names, path, filename) = event

        print("PATH=[{}] FILENAME=[{}] EVENT_TYPES={}".format(
              path, filename, type_names))

if __name__ == '__main__':
    _main()

Idée no. 2: Copier uniquement les modifications

Si vous décidez d'utiliser le mécanisme inotify , il sera trivial de garder une trace de votre état.

Ensuite, là il existe deux possibilités:

1. Le nouveau contenu est TOUJOURS ajouté

Si tel est le cas, vous pouvez simplement copier n'importe quoi depuis votre dernier décalage jusqu'à la fin du fichier.

2 . Les nouveaux contenus sont écrits à des emplacements aléatoires.

Dans ce cas, je recommanderais également une méthode proposée par d'autres réponses: Utiliser des correctifs de diff. C'est de loin la solution la plus élégante à mon avis.

Voici quelques options:

• diff-match-patch
• diff-and-patch

L'un des avantages de rsync est qu'il ne copie que les différences entre les fichiers. À mesure que les fichiers deviennent énormes, cela réduit considérablement les E / S.

Il existe une pléthore d'implémentations et de wrappers de type rsync autour du programme original dans PyPI. Ce article de blog décrit comment mettre en œuvre rsync en Python d'une très bonne manière, et peut être utilisé tel quel.

Quant à vérifier s'il est nécessaire de faire la synchronisation, vous pouvez utiliser filecmp.cmp () . Dans sa variante peu profonde, il ne vérifie que la signature os.stat () .

Comme mentionné ci-dessus, rsync est un meilleur moyen de faire ce genre de travail où vous devez effectuer une liste de fichiers incrémentielle ou dire delta des données Donc, je préférerais le faire avec rsync et < code> sous-processus tout au long du module.

Cependant, vous pouvez également attribuer une variable Curr_date_month pour obtenir la date, le mois et l'année actuels en tant que votre condition pour simplement copier les fichiers de l'actuel Dossier mois et jour. aussi vous pouvez définir la variable source et destination juste pour la facilité de les écrire dans le code.

Deuxièmement, bien que vous ayez une vérification de la taille du fichier avec getsize mais Je voudrais ajouter un paramètre d'option rsync --min-size = pour m'assurer de ne pas copier le fichier de zéro octet.

Votre code final se trouve ici.