inotify récursivement comment le faire?

J’ai besoin d’imprimer des événements sur un dossier avec plusieurs sous-dossiers. comment le faire récursivement? Veuillez imprimer un code c ++. Je suis coincé !! Chaque fois que le fichier evet est affiché, je dois ouvrir le sous-dossier, prendre le fichier et le copier dans un autre répertoire. Je ne veux pas lister tous les sous-dossiers toutes les 2 secondes et trouver les fichiers s’il y en a. N’est pas efficace Je dois utiliser un dossier de moniteur. S’il vous plaît aider

Le directeur que je veux surveiller a plusieurs sous-dossiers. Chaque sous-dossier a un autre sous-dossier qui pourrait contenir un fichier dans un instant. MainFolder-> Sous-dossiers-> chaque sous-dossier-> sous-dossier -> fichier.

Voici le code que j’ai pour l’instant:

/* */ #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  using namespace std; vector SS; void *print_message_function( void *ptr ); int main(int argc, char **argv ){ pthread_t t1; int fd,fd1,wd,wd1,i=0,i1=0,len=0,len1=0; int length; char pathname[100],buf[1024],buf1[1024]; int data; struct inotify_event *event; char *message1 = "Thread 1"; FILE *fr; // fd=inotify_init1(IN_NONBLOCK);//--rewrite fd = inotify_init(); /* watch /test directory for any activity and report it back to me */ wd=inotify_add_watch(fd,"/home/MainFoder/",IN_ALL_EVENTS); // int flag=0; // char*ev=""; //wd=inotifytools_watch_recursively_with_exclude("/home/MainFolder/",IN_ALL_EVENTS); while(1) { //sleep(30); //read 1024 bytes of events from fd into buf i=0; len=read(fd,buf,1024); while(imask & IN_OPEN) ||(event->mask & IN_CREATE)) { printf("\n %s :was opened\n",event->name); SS.push_back(event->name); } } /* update index to start of next event */ i+=sizeof(struct inotify_event)+event->len; } vector::const_iterator cii; for(cii=SS.begin(); cii!=SS.end(); cii++) { wd1 = watch_from_filename(*ci); } /* vector::const_iterator cii; for(cii=SS.begin(); cii!=SS.end(); cii++) { cout <<"HERE:"<< *cii << endl; } */ int iret1, iret2; /* Create independent threads each of which will execute function */ iret1 = pthread_create( &t1, NULL, print_message_function, (void*) message1); } } void *print_message_function( void *ptr ) { vector::const_iterator cii; for(cii=SS.begin(); cii!=SS.end(); cii++) { cout <<"HERE:"<< *cii << endl; std::string path=exec } }

Cet exemple de travail sur Github fait ce que vous recherchez: inotify-example.cpp

Sur les événements CREATE, le wd (descripteur de surveillance) en cours, plus les composants inotify_event wd et name, sont ajoutés à un object Watch (voir exemple). La classe comprend des méthodes permettant de rechercher wd et les noms de plusieurs manières.

Cet extrait montre comment les événements CREATE / DELETE sont gérés:

  if ( event->mask & IN_CREATE ) { current_dir = watch.get(event->wd); if ( event->mask & IN_ISDIR ) { new_dir = current_dir + "/" + event->name; wd = inotify_add_watch( fd, new_dir.c_str(), WATCH_FLAGS ); watch.insert( event->wd, event->name, wd ); total_dir_events++; printf( "New directory %s created.\n", new_dir.c_str() ); } else { total_file_events++; printf( "New file %s/%s created.\n", current_dir.c_str(), event->name ); } } else if ( event->mask & IN_DELETE ) { if ( event->mask & IN_ISDIR ) { new_dir = watch.erase( event->wd, event->name, &wd ); inotify_rm_watch( fd, wd ); total_dir_events--; printf( "Directory %s deleted.\n", new_dir.c_str() ); } else { current_dir = watch.get(event->wd); total_file_events--; printf( "File %s/%s deleted.\n", current_dir.c_str(), event->name ); } }

Vous pouvez le faire en deux étapes:

Détectez toutes les modifications qui vous intéressent dans le répertoire racine, plus les créations (si elles ne sont pas déjà incluses) ( IN_CREATE ).
Si la création est un répertoire, faites l’algorithme complet.

J’ai écrit le code pour vous. Maintenant, vous ne devez effectuer qu’un seul changement dans ce code. Donnez simplement le chemin de votre répertoire dans la fonction principale.

 #include  #include  #include  #include  #include  #include  #include #include #include #include #include #define MAX_EVENTS 1024 /*Max. number of events to process at one go*/ #define LEN_NAME 16 /*Assuming that the length of the filename won't exceed 16 bytes*/ #define EVENT_SIZE ( sizeof (struct inotify_event) ) /*size of one event*/ #define BUF_LEN ( MAX_EVENTS * ( EVENT_SIZE + LEN_NAME )) /*buffer to store the data of events*/ void monitor(char *); int evnt_mon(char *); void main() { if(fork()==0) evnt_mon("./usssb");// give path of your directory which you want to monitor monitor("./usssb");// give path of your directory which you want to monitor while(1); } void monitor(char * rt_dir) { struct stat st; DIR *dirp; struct dirent *dp; char str[100][100]={ }; char temp[100]; char str1[500]=" "; int i=0,j=0,src_ret=9,src_ret1=9; strcpy(str1,rt_dir); dirp=opendir(str1); if(dirp==NULL) { perror("opendir"); return; } while(1) { dp=readdir(dirp); if(dp==NULL) break; if((strcmp(dp->d_name,".\0")==0) || (strcmp(dp->d_name,"..")==0)) continue; if((dp->d_type==DT_DIR)&&((strcmp(dp->d_name,".")!=0)&&(strcmp(dp->d_name,"..")!=0))) { strcat(str[i],str1); strcat(str[i],"/"); strcat(str[i],dp->d_name); if(fork()==0) { evnt_mon(str[i]); } i++; } } closedir(dirp); if(i>0) { for(j=0;jlen ) { if ( event->mask & IN_CREATE) { if (event->mask & IN_ISDIR) { printf( "The directory %s was Created in %s.\n", event->name,argv ); if(fork()==0) { char p[100]=" "; strcpy(p,argv); strcat(p,"/"); strcat(p,event->name); evnt_mon(p); } } else printf( "The file %s was Created with WD %d\n", event->name, event->wd ); } if ( event->mask & IN_MODIFY) { if (event->mask & IN_ISDIR) printf( "The directory %s was modified.\n", event->name ); else printf( "The file %s was modified with WD %d\n", event->name, event->wd ); } if ( event->mask & IN_DELETE) { if (event->mask & IN_ISDIR) printf( "The directory %s was deleted from %s.\n", event->name,argv ); else printf( "The file %s was deleted with WD %d\n", event->name, event->wd ); } i += EVENT_SIZE + event->len; } } } /* Clean up*/ inotify_rm_watch( fd, wd ); close( fd ); return 0; }

Pour résoudre le problème énoncé par ribram (le «trou» :)). Une solution possible est que nous pouvons combiner «interroger le répertoire» et «utiliser inotify» … C’est-à-dire chaque fois qu’un répertoire est détecté (répertoire uniquement, ne le faites pas pour les fichiers):

append un sharepoint surveillance pour le répertoire nouvellement détecté à inotify
‘poll’ (ou ‘scan’) le répertoire nouvellement détecté (man readdir ()) pour voir s’il existe déjà des éléments (fichiers, répertoires) créés. Ce sont peut-être ceux qui manquent.

Notez que pour créer un cas «hermétique», l’ordre des étapes ci-dessus est important. vous devez d’abord append le sharepoint contrôle plutôt que le scan … Cela garantira qu’un élément est capté soit par “scan”, soit par inotify ou les deux. Dans ce cas, vous devrez peut-être aussi connaître les dups. c’est-à-dire que le même élément peut être à la fois généré par le scan et l’inotify

Vous pouvez utiliser l’API fanotify. Il vous permet de surveiller un assembly complet. Le seul inconvénient est que vous devez être root.