$search

fam.cpp

Go to the documentation of this file.

/***************************************************************************
 *  fam.h - File Alteration Monitor
 *
 *  Created: Fri May 23 11:38:41 2008
 *  Copyright  2006-2010  Tim Niemueller [www.niemueller.de]
 *             2010       Carnegie Mellon University
 *             2010       Intel Labs Pittsburgh
 ****************************************************************************/

/*  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Library General Public License for more details.
 *
 *  Read the full text in the LICENSE.GPL file in the doc directory.
 */

#include <lua_utils/fam.h>

#ifndef USE_ROS
#  include <core/exception.h>
#else
#  include <ros/common.h>
#  if ROS_VERSION_MAJOR > 1 || ROS_VERSION_MAJOR == 1 && ROS_VERSION_MINOR >= 2
#    include <ros/exception.h>
#  else
#    include <ros/exceptions.h>
#  endif
using ros::Exception;
#endif

#ifdef HAVE_INOTIFY
#  include <sys/inotify.h>
#  include <sys/stat.h>
#  include <poll.h>
#  include <dirent.h>
#  include <unistd.h>
#  include <cstring>
#endif
#include <cerrno>
#include <cstdlib>
#include <cstdio>

namespace fawkes {

/* Supported events suitable for MASK parameter of INOTIFY_ADD_WATCH.  */
const unsigned int FamListener::FAM_ACCESS        = 0x00000001;
const unsigned int FamListener::FAM_MODIFY        = 0x00000002;
const unsigned int FamListener::FAM_ATTRIB        = 0x00000004;
const unsigned int FamListener::FAM_CLOSE_WRITE   = 0x00000008;
const unsigned int FamListener::FAM_CLOSE_NOWRITE = 0x00000010;
const unsigned int FamListener::FAM_CLOSE         = (FAM_CLOSE_WRITE | FAM_CLOSE_NOWRITE);
const unsigned int FamListener::FAM_OPEN          = 0x00000020;
const unsigned int FamListener::FAM_MOVED_FROM    = 0x00000040;
const unsigned int FamListener::FAM_MOVED_TO      = 0x00000080;
const unsigned int FamListener::FAM_MOVE          = (FAM_MOVED_FROM | FAM_MOVED_TO);
const unsigned int FamListener::FAM_CREATE        = 0x00000100;
const unsigned int FamListener::FAM_DELETE        = 0x00000200;
const unsigned int FamListener::FAM_DELETE_SELF   = 0x00000400;
const unsigned int FamListener::FAM_MOVE_SELF     = 0x00000800;

/* Events sent by the kernel.  */
const unsigned int FamListener::FAM_UNMOUNT       = 0x00002000;
const unsigned int FamListener::FAM_Q_OVERFLOW    = 0x00004000;
const unsigned int FamListener::FAM_IGNORED       = 0x00008000;

/* Special flags.  */
const unsigned int FamListener::FAM_ONLYDIR       = 0x01000000;
const unsigned int FamListener::FAM_DONT_FOLLOW   = 0x02000000;
const unsigned int FamListener::FAM_MASK_ADD      = 0x20000000;
const unsigned int FamListener::FAM_ISDIR         = 0x40000000;
const unsigned int FamListener::FAM_ONESHOT       = 0x80000000;

const unsigned int FamListener::FAM_ALL_EVENTS     = (FAM_ACCESS | FAM_MODIFY | FAM_ATTRIB | FAM_CLOSE_WRITE \
                                                      | FAM_CLOSE_NOWRITE | FAM_OPEN | FAM_MOVED_FROM \
                                                      | FAM_MOVED_TO | FAM_CREATE | FAM_DELETE \
                                                      | FAM_DELETE_SELF | FAM_MOVE_SELF);


FileAlterationMonitor::FileAlterationMonitor()
{
#ifdef HAVE_INOTIFY
  if ( (__inotify_fd = inotify_init()) == -1 ) {
    throw Exception("Failed to initialize inotify");
  }

  // from http://www.linuxjournal.com/article/8478
  __inotify_bufsize = 1024 * (sizeof(struct inotify_event) + 16);
  __inotify_buf     = (char *)malloc(__inotify_bufsize);
#endif

  __interrupted   = false;
  __interruptible = (pipe(__pipe_fds) == 0);

  __regexes.clear();
}


FileAlterationMonitor::~FileAlterationMonitor()
{
  for (__rxit = __regexes.begin(); __rxit != __regexes.end(); ++__rxit) {
    regfree(*__rxit);
    free(*__rxit);
  }

#ifdef HAVE_INOTIFY
  for (__inotify_wit = __inotify_watches.begin(); __inotify_wit != __inotify_watches.end(); ++__inotify_wit) {
    inotify_rm_watch(__inotify_fd, __inotify_wit->first);
  }
  close(__inotify_fd);
  if ( __inotify_buf ) {
    free(__inotify_buf);
    __inotify_buf = NULL;
  }
#endif
}


void
FileAlterationMonitor::watch_dir(const char *dirpath)
{
#ifdef HAVE_INOTIFY
  DIR *d = opendir(dirpath);
  if ( d == NULL ) {
    throw Exception(std::string("Failed to open dir ") + dirpath);
  }

  uint32_t mask = IN_MODIFY | IN_MOVE | IN_CREATE | IN_DELETE | IN_DELETE_SELF;
  int iw;

  //LibLogger::log_debug("FileAlterationMonitor", "Adding watch for %s", dirpath);
  if ( (iw = inotify_add_watch(__inotify_fd, dirpath, mask)) >= 0) {
    __inotify_watches[iw] = dirpath;

    dirent de, *res;
    while ( (readdir_r(d, &de, &res) == 0) && (res != NULL) ) {
      std::string fp = std::string(dirpath) + "/" + de.d_name;
      struct stat st;
      if ( stat(fp.c_str(), &st) == 0 ) {
        if ( (de.d_name[0] != '.') && S_ISDIR(st.st_mode) ) {
          try {
            watch_dir(fp.c_str());
          } catch (Exception &e) {
            closedir(d);
            throw;
          }
        //} else {
          //LibLogger::log_debug("SkillerExecutionThread", "Skipping file %s", fp.c_str());       
        }
      } else {
        //LibLogger::log_debug("FileAlterationMonitor",
        //                   "Skipping watch on %s, cannot stat (%s)",
        //                   fp.c_str(), strerror(errno));
      }
    }
  } else {
    throw Exception(std::string("Cannot add watch for ") + dirpath);
  }

  closedir(d);
#endif
}

void
FileAlterationMonitor::watch_file(const char *filepath)
{
#ifdef HAVE_INOTIFY
  uint32_t mask = IN_MODIFY | IN_MOVE | IN_CREATE | IN_DELETE | IN_DELETE_SELF;
  int iw;

  //LibLogger::log_debug("FileAlterationMonitor", "Adding watch for %s", dirpath);
  if ( (iw = inotify_add_watch(__inotify_fd, filepath, mask)) >= 0) {
    __inotify_watches[iw] = filepath;
  } else {
    throw Exception(std::string("Cannot add watch for file ") + filepath);
  }
#endif
}


void
FileAlterationMonitor::add_filter(const char *regex)
{
  int regerr = 0;
  regex_t *rx = (regex_t *)malloc(sizeof(regex_t));
  if ( (regerr = regcomp(rx, regex, REG_EXTENDED)) != 0 ) {
    char errtmp[1024];
    regerror(regerr, rx, errtmp, sizeof(errtmp));
    free(rx);
    throw Exception(std::string("Failed to compile lua file regex: ") + errtmp);
  }
  __regexes.push_back(rx);
}


void
FileAlterationMonitor::add_listener(FamListener *listener)
{
  __listeners.push_back(listener);
}


void
FileAlterationMonitor::remove_listener(FamListener *listener)
{
  __listeners.remove(listener);
}


void
FileAlterationMonitor::process_events(int timeout)
{
#ifdef HAVE_INOTIFY
  // Check for inotify events
  __interrupted = false;
  pollfd ipfd[2];
  ipfd[0].fd = __inotify_fd;
  ipfd[0].events = POLLIN;
  ipfd[0].revents = 0;
  ipfd[1].fd = __pipe_fds[0];
  ipfd[1].events = POLLIN;
  ipfd[1].revents = 0;
  int prv = poll(ipfd, 2, timeout);
  if ( prv == -1 ) {
    if ( errno != EINTR ) {
#ifndef USE_ROS
      LibLogger::log_error("FileAlterationMonitor",
                           "inotify poll failed: %s (%i)",
                           strerror(errno), errno);
#else
      printf("FileAlterationMonitor: inotify poll failed: %s (%i)\n",
             strerror(errno), errno);
#endif
    } else {
      __interrupted = true;
    }
  } else while ( !__interrupted && (prv > 0) ) {
    // Our fd has an event, we can read
    if ( ipfd[0].revents & POLLERR ) {      
      //LibLogger::log_error("FileAlterationMonitor", "inotify poll error");
    } else if (__interrupted) {
      // interrupted
      return;
    } else {
      // must be POLLIN
      int bytes = 0, i = 0;
      if ((bytes = read(__inotify_fd, __inotify_buf, __inotify_bufsize)) != -1) {
        while (!__interrupted && (i < bytes)) {
          struct inotify_event *event = (struct inotify_event *) &__inotify_buf[i];

          bool valid = true;
          if (! (event->mask & IN_ISDIR)) {
            for (__rxit = __regexes.begin(); __rxit != __regexes.end(); ++__rxit) {
              if (event->len > 0 && regexec(*__rxit, event->name, 0, NULL, 0) == REG_NOMATCH ) {
                //LibLogger::log_debug("FileAlterationMonitor", "A regex did not match for %s", event->name);
                valid = false;
                break;
              }
            }
          }

          /*
          if (event->mask & IN_MODIFY) {
            printf("FileAlterationMonitor: %s has been modified\n", event->len > 0 ? event->name : "?");
          }
          if (event->mask & IN_MOVE) {
            printf("FileAlterationMonitor: %s has been moved\n", event->len > 0 ? event->name : "?");
          }
          if (event->mask & IN_DELETE) {
            printf("FileAlterationMonitor: %s has been deleted\n", event->len > 0 ? event->name : "?");
          }
          if (event->mask & IN_CREATE) {
            printf("FileAlterationMonitor: %s has been created\n", event->len > 0 ? event->name : "?");
          }
          */

          if ( valid ) {
            for (__lit = __listeners.begin(); __lit != __listeners.end(); ++__lit) {
              (*__lit)->fam_event(event->len > 0 ? event->name : "?", event->mask);
            }
          }

          if (event->mask & IN_DELETE_SELF) {
            //LibLogger::log_debug("FileAlterationMonitor", "Watched %s has been deleted", event->name);
            __inotify_watches.erase(event->wd);
            inotify_rm_watch(__inotify_fd, event->wd);
          }

          if (event->mask & IN_CREATE && event->len > 0) {
            // Check if it is a directory, if it is, watch it
            std::string fp = __inotify_watches[event->wd] + "/" + event->name;
            if (  (event->mask & IN_ISDIR) && (event->name[0] != '.') ) {
              /*
              LibLogger::log_debug("FileAlterationMonitor",
                                   "Directory %s has been created, "
                                   "adding to watch list", event->name);
              */
              try {
                watch_dir(fp.c_str());
              } catch (Exception &e) {
                //LibLogger::log_warn("FileAlterationMonitor", "Adding watch for %s failed, ignoring.", fp.c_str());
                //LibLogger::log_warn("FileAlterationMonitor", e);
              }
            }
          }

          i += sizeof(struct inotify_event) + event->len;
        }
      } else {
        //LibLogger::log_error("FileAlterationMonitor", "inotify failed to read any bytes");
      }
    }

    prv = poll(ipfd, 2, 0);
  }
#else
  //LibLogger::log_error("FileAlterationMonitor",
  //                   "inotify support not available, but "
  //                   "process_events() was called. Ignoring.");
#endif
}


void
FileAlterationMonitor::interrupt()
{
  if (__interruptible) {
    __interrupted = true;
    char tmp = 0;
    if (write(__pipe_fds[1], &tmp, 1) != 1) {
      throw Exception("Failed to interrupt file alteration monitor,"
                      " failed to write to pipe");
    }
  } else {
    throw Exception("Currently not interruptible");
  }
}


FamListener::~FamListener()
{
}

} // end of namespace fawkes

---

lua_utils
Author(s): Tim Niemueller
autogenerated on Tue Mar 5 12:26:30 2013