diff options
| -rw-r--r-- | server/src/Makefile.am | 1 | ||||
| -rw-r--r-- | server/src/inotify.cc | 372 | ||||
| -rw-r--r-- | server/src/inotify.h | 40 | ||||
| -rw-r--r-- | server/src/macrolist.cc | 116 | ||||
| -rw-r--r-- | server/src/macrolist.h | 8 |
5 files changed, 465 insertions, 72 deletions
diff --git a/server/src/Makefile.am b/server/src/Makefile.am index 8d6e347..efe1413 100644 --- a/server/src/Makefile.am +++ b/server/src/Makefile.am @@ -59,6 +59,7 @@ macrotool_SOURCES = \ configurationparser.cc \ database.cc \ exception.cc \ + inotify.cc \ log.cc \ macroheaderparser.cc \ macrolist.cc \ diff --git a/server/src/inotify.cc b/server/src/inotify.cc index e1d47d1..7834327 100644 --- a/server/src/inotify.cc +++ b/server/src/inotify.cc @@ -27,15 +27,21 @@ */ #include "inotify.h" +#include "debug.h" + #include <sys/stat.h> #include <errno.h> #include <stdio.h> #include <unistd.h> #include <sys/socket.h> #include <fcntl.h> +#include <stdlib.h> +#include <dirent.h> +#include <string.h> #define TEST(x, m) ((x & m) == m) +#ifdef WITH_DEBUG #define STEST(x, m) (TEST(x, m)?#m" ":"") static std::string mask2asc(uint32_t mask) @@ -54,13 +60,16 @@ static std::string mask2asc(uint32_t mask) str += STEST(mask, IN_MOVED_FROM); str += STEST(mask, IN_MOVED_TO); str += STEST(mask, IN_OPEN); + str += STEST(mask, IN_ALL_EVENTS); str += STEST(mask, IN_CLOSE); str += STEST(mask, IN_MOVE); + str += STEST(mask, IN_DONT_FOLLOW); str += STEST(mask, IN_MASK_ADD); str += STEST(mask, IN_ONESHOT); str += STEST(mask, IN_ONLYDIR); + str += STEST(mask, IN_IGNORED); str += STEST(mask, IN_ISDIR); str += STEST(mask, IN_Q_OVERFLOW); @@ -68,6 +77,7 @@ static std::string mask2asc(uint32_t mask) return str; } +#endif static inline bool isdir(const char *name) { @@ -76,13 +86,23 @@ static inline bool isdir(const char *name) return S_ISDIR(s.st_mode); } -INotify::Event::Event(std::string name, uint32_t mask) +INotify::Event::Event(struct inotify_event *event, std::string name) { this->_name = name; - this->_mask = mask; + if(event) { + this->_mask = event->mask; + this->_file = event->name; + } else { + this->_mask = 0; + this->_file = ""; + } - printf("[%s]\n", mask2asc(_mask).c_str()); + PRACRO_DEBUG(inotify, "Event [%s] %s (%s)\n", + mask2asc(_mask).c_str(), + _name.c_str(), + _file.c_str()); } + bool INotify::Event::isAttributeChangeEvent() { return TEST(_mask, IN_ATTRIB); @@ -90,12 +110,27 @@ bool INotify::Event::isAttributeChangeEvent() bool INotify::Event::isCloseEvent() { - return TEST(_mask, IN_CLOSE_WRITE) || TEST(_mask, IN_CLOSE_NOWRITE); + return isCloseWriteEvent() || isCloseNoWriteEvent(); +} + +bool INotify::Event::isCloseWriteEvent() +{ + return TEST(_mask, IN_CLOSE_WRITE); +} + +bool INotify::Event::isCloseNoWriteEvent() +{ + return TEST(_mask, IN_CLOSE_NOWRITE); +} + +bool INotify::Event::isCreateEvent() +{ + return TEST(_mask, IN_CREATE); } bool INotify::Event::isOpenEvent() { - return TEST(_mask, IN_OPEN) || TEST(_mask, IN_CREATE); + return TEST(_mask, IN_OPEN); } bool INotify::Event::isModifyEvent() @@ -103,9 +138,39 @@ bool INotify::Event::isModifyEvent() return TEST(_mask, IN_MODIFY); } +bool INotify::Event::isAccessEvent() +{ + return TEST(_mask, IN_ACCESS); +} + bool INotify::Event::isDeleteEvent() { - return TEST(_mask, IN_DELETE) || TEST(_mask, IN_DELETE_SELF); + return TEST(_mask, IN_DELETE); +} + +bool INotify::Event::isDeleteSelfEvent() +{ + return TEST(_mask, IN_DELETE_SELF); +} + +bool INotify::Event::isIgnoredEvent() +{ + return TEST(_mask, IN_IGNORED); +} + +bool INotify::Event::isMoveSelfEvent() +{ + return TEST(_mask, IN_MOVE_SELF); +} + +bool INotify::Event::isMovedFromEvent() +{ + return TEST(_mask, IN_MOVED_FROM); +} + +bool INotify::Event::isMovedToEvent() +{ + return TEST(_mask, IN_MOVED_TO); } std::string INotify::Event::name() @@ -113,6 +178,11 @@ std::string INotify::Event::name() return _name; } +std::string INotify::Event::file() +{ + return _file; +} + uint32_t INotify::Event::mask() { return _mask; @@ -120,8 +190,8 @@ uint32_t INotify::Event::mask() INotify::INotify() { - fd = inotify_init1(O_NONBLOCK); - if(fd == -1) { + ifd = inotify_init1(O_NONBLOCK); + if(ifd == -1) { perror("Inotify init failed.\n"); return; } @@ -129,10 +199,10 @@ INotify::INotify() INotify::~INotify() { - if(fd != -1) close(fd); + if(ifd != -1) close(ifd); } -void INotify::add(std::string name, uint32_t mask) +void INotify::addFile(std::string name, uint32_t mask) { // Extra mask bitflags: //IN_DONT_FOLLOW (since Linux 2.6.15) @@ -145,24 +215,132 @@ void INotify::add(std::string name, uint32_t mask) //IN_ONLYDIR (since Linux 2.6.15) // Only watch pathname if it is a directory. - int _fd = inotify_add_watch(fd, name.c_str(), mask); - if(_fd == -1) { + int wd = inotify_add_watch(ifd, name.c_str(), mask); + if(wd == -1) { perror("INotify: Add watch failed!"); return; } - // dirmap[fd] = name; + + Watch w; + w.mask = mask; + w.name = name; + w.depth = WATCH_SINGLE; + dirmap[wd] = w; } -void INotify::addRecursive(std::string name, uint32_t mask) +static inline bool isdir(std::string name) { - /* - int fd = this->add(name, mask); - return fd; - */ + struct stat s; + stat(name.c_str(), &s); + return S_ISDIR(s.st_mode); +} + +void INotify::addDirectory(std::string name, depth_t depth, uint32_t mask) +{ + PRACRO_DEBUG(inotify, "Adding dir: %s\n", name.c_str()); + + int depth_mask = 0; + if(depth == WATCH_DEEP || depth == WATCH_DEEP_FOLLOW) { + depth_mask = IN_CREATE; // We need to watch for create in order to catch + // creation of new subdirs. + + DIR *dir = opendir(name.c_str()); + if(!dir) { + PRACRO_ERR(inotify, "Could not open directory: %s - %s\n", + name.c_str(), strerror(errno)); + return; + } + + struct dirent *dirent; + while( (dirent = readdir(dir)) != NULL ) { + + if(std::string(dirent->d_name) == "." || std::string(dirent->d_name) == "..") + continue; + + PRACRO_DEBUG(inotify, "Add entry?: %s\n", dirent->d_name); + + if(isdir(name+"/"+dirent->d_name)) addDirectory(name+"/"+dirent->d_name, depth, mask); + } + + closedir(dir); + } + + int wd = inotify_add_watch(ifd, name.c_str(), mask | IN_ONLYDIR | depth_mask); + if(wd == -1) { + perror("INotify: Add watch failed!"); + return; + } + + Watch w; + w.mask = mask; + w.name = name; + w.depth = depth; + dirmap[wd] = w; +} + +void INotify::remove(int wd) +{ + if(inotify_rm_watch(ifd, wd) == -1) { + perror("inotify_rm_watch failed"); + return; + } + dirmap.erase(wd); +} + +void INotify::remove(std::string name) +{ + std::map<int, Watch>::iterator i = dirmap.begin(); + while(i != dirmap.end()) { + Watch w = i->second; + if(w.name == name) this->remove(i->first); + i++; + } +} + +void INotify::readEvents() +{ + size_t size = 64; + char *buf = (char*)malloc(size); + + ssize_t r; + while( ((r = read(ifd, buf, size)) == -1 && errno == EINVAL) || r == 0 ) { + fprintf(stderr, "Doubling buffer size: %d\n", size); + size *= 2; + buf = (char*)realloc(buf, size); + } + + int p = 0; + while(p < r) { + struct inotify_event *event = (struct inotify_event*)(buf + p); + p += sizeof(struct inotify_event) + event->len; + + // TODO: We need to figure out what the new filename/destination is... + if(TEST(event->mask, IN_MOVE_SELF)) dirmap[event->wd].name = "????????"; + + if(dirmap[event->wd].depth == WATCH_DEEP_FOLLOW && + TEST(event->mask, IN_CREATE) && + TEST(event->mask, IN_ISDIR)) + addDirectory(dirmap[event->wd].name + "/" + event->name, + dirmap[event->wd].depth, dirmap[event->wd].mask); + + if(TEST(event->mask, IN_CREATE) && !TEST(dirmap[event->wd].mask, IN_CREATE)) { + // Ignore this event, it was not requested by the user. + } else { + eventlist.push_back(INotify::Event(event, dirmap[event->wd].name)); + } + + if(TEST(event->mask, IN_IGNORED)) dirmap.erase(event->wd); + } + + free(buf); } bool INotify::hasEvents() { + readEvents(); + return eventlist.size() > 0; + +#if 0 struct timeval tv; tv.tv_sec = 0; tv.tv_usec = 0; @@ -170,8 +348,8 @@ bool INotify::hasEvents() fd_set fset; int ret; FD_ZERO(&fset); - FD_SET(fd, &fset); - ret = select (fd+1, &fset, NULL, NULL, &tv); + FD_SET(ifd, &fset); + ret = select (ifd+1, &fset, NULL, NULL, &tv); switch(ret) { case -1: if(errno == EINTR) { @@ -184,23 +362,36 @@ bool INotify::hasEvents() break; default: - if(FD_ISSET(fd, &fset)) { + if(FD_ISSET(ifd, &fset)) { // Ready read return true; } } return false; +#endif } INotify::Event INotify::getNextEvent() { - char buf[1024]; - ssize_t r = read(fd, buf, sizeof(struct inotify_event)); + readEvents(); + if(eventlist.size() == 0) return Event(NULL, ""); + Event e = eventlist.front(); + eventlist.pop_front(); + return e; + +#if 0 + struct inotify_event event; + ssize_t r = read(ifd, &event, sizeof(struct inotify_event)); + if(r != sizeof(struct inotify_event) && r != -1) if(r == sizeof(struct inotify_event)) { - struct inotify_event *event = (struct inotify_event *)buf; - if(event->len) read(fd, buf + sizeof(struct inotify_event), event->len); - switch(event->mask) { + char *name = NULL; + if(event.len) { + name = (char*)malloc(event.len); + if(read(ifd, name, event.len) != (int)event.len) printf("\n\nFUXK!\n\n"); + } + + switch(event.mask) { case IN_IGNORED: //Watch was removed explicitly (inotify_rm_watch(2)) or automatically // (file was deleted, or file system was unmounted). @@ -215,19 +406,13 @@ INotify::Event INotify::getNextEvent() break; } - return Event(event->name, event->mask); + if(TEST(event.mask, IN_IGNORED)) dirmap.erase(event.wd); + Event e((name!=NULL)?name:"", event.mask); + if(name) free(name); + return e; } return Event("", 0); -} - -void INotify::remove(int fd) -{ - inotify_rm_watch(this->fd, fd); -} - -void INotify::remove(std::string name) -{ - // this->remove(rlookup(map, name)) +#endif } #ifdef TEST_INOTIFY @@ -238,25 +423,45 @@ void INotify::remove(std::string name) #include <stdio.h> -#define _DIR "/tmp" -#define _FILE _DIR"/inotify_test" +#define _BASEDIR "/tmp" +#define _DIR _BASEDIR"/inotify_test_dir" +#define _FILE _BASEDIR"/inotify_test" TEST_BEGIN; +pracro_debug_parse("+all"); + INotify inotify; // Create file FILE *fp = fopen(_FILE, "w"); -TEST_NOTEQUAL(fp, NULL, "Testing if able to write file"); +if(!fp) TEST_FATAL("Unable to write to the file"); fprintf(fp, "something"); fclose(fp); -inotify.add(_FILE); +inotify.addFile(_FILE); + +TEST_MSG("Positive tests on file watch."); + +// Append to file +fp = fopen(_FILE, "r"); +if(!fp) TEST_FATAL("Unable to read from the file"); +TEST_TRUE(inotify.hasEvents(), "Test if the open event was triggered."); +TEST_TRUE(inotify.getNextEvent().isOpenEvent(), "Test if the event was an open event."); + +char buf[32]; +fread(buf, sizeof(buf), 1, fp); +TEST_TRUE(inotify.hasEvents(), "Test if the read event was triggered."); +TEST_TRUE(inotify.getNextEvent().isAccessEvent(), "Test if the event was a access event."); + +fclose(fp); +TEST_TRUE(inotify.hasEvents(), "Test if the close event was triggered."); +TEST_TRUE(inotify.getNextEvent().isCloseNoWriteEvent(), "Test if the event was a close-nowrite event."); // Append to file fp = fopen(_FILE, "a"); -TEST_NOTEQUAL(fp, NULL, "Testing if able to write file"); +if(!fp) TEST_FATAL("Unable to write to the file"); TEST_TRUE(inotify.hasEvents(), "Test if the open event was triggered."); TEST_TRUE(inotify.getNextEvent().isOpenEvent(), "Test if the event was an open event."); @@ -266,12 +471,12 @@ TEST_TRUE(inotify.getNextEvent().isModifyEvent(), "Test if the event was a modif fclose(fp); TEST_TRUE(inotify.hasEvents(), "Test if the close event was triggered."); -TEST_TRUE(inotify.getNextEvent().isCloseEvent(), "Test if the event was a close event."); +TEST_TRUE(inotify.getNextEvent().isCloseWriteEvent(), "Test if the event was a close event."); // Overwrite file fp = fopen(_FILE, "w"); -TEST_NOTEQUAL(fp, NULL, "Testing if able to write file"); +if(!fp) TEST_FATAL("Unable to write to the file"); // Open for write initially empties the file content, thus provoking a changed event. TEST_TRUE(inotify.hasEvents(), "Test if the modified event was triggered."); @@ -286,19 +491,86 @@ TEST_TRUE(inotify.getNextEvent().isModifyEvent(), "Test if the event was a modif fclose(fp); TEST_TRUE(inotify.hasEvents(), "Test if the close event was triggered."); -TEST_TRUE(inotify.getNextEvent().isCloseEvent(), "Test if the event was a close event."); +TEST_TRUE(inotify.getNextEvent().isCloseWriteEvent(), "Test if the event was a close event."); +// Rename file +rename(_FILE, _FILE"2"); +TEST_TRUE(inotify.hasEvents(), "Test if the rename event was triggered."); +TEST_TRUE(inotify.getNextEvent().isMoveSelfEvent(), "Test if the event was a move self event."); // Delete file -unlink(_FILE); +unlink(_FILE"2"); // Unlink initially counts down the link counter, which provokes an attributes changed event. -TEST_EQUAL(inotify.hasEvents(), true, "Test if the delete event was triggered."); -TEST_EQUAL(inotify.getNextEvent().isAttributeChangeEvent(), true, "Test if the event was an attribute change event."); +TEST_TRUE(inotify.hasEvents(), "Test if the delete event was triggered."); +TEST_TRUE(inotify.getNextEvent().isAttributeChangeEvent(), "Test if the event was an attribute change event."); // Since the linkcount should now be zero, the file should be deleted. -TEST_EQUAL(inotify.hasEvents(), true, "Test if the delete event was triggered."); -TEST_EQUAL(inotify.getNextEvent().isDeleteEvent(), true, "Test if the event was a delete event."); +TEST_TRUE(inotify.hasEvents(), "Test if the delete event was triggered."); +TEST_TRUE(inotify.getNextEvent().isDeleteSelfEvent(), "Test if the event was a delete self event."); + +// Watch is removed upon delete. +//inotify.remove(_FILE); + +TEST_TRUE(inotify.hasEvents(), "Test if the delete event triggered an ignored event."); +TEST_TRUE(inotify.getNextEvent().isIgnoredEvent(), "Test if the event was an ignored event."); + +// Create file again +fp = fopen(_FILE, "w"); +if(!fp) TEST_FATAL("Unable to write to the file"); +fprintf(fp, "something"); +fclose(fp); + +inotify.addFile(_FILE); +inotify.remove(_FILE); + +TEST_TRUE(inotify.hasEvents(), "Test if the call to remove triggered an ignored event."); +TEST_TRUE(inotify.getNextEvent().isIgnoredEvent(), "Test if the event was an ignored event."); + +// Delete file +unlink(_FILE); +inotify.getNextEvent(); +TEST_FALSE(inotify.hasEvents(), "Test if the delete event was ignored."); + +TEST_FALSE(inotify.hasEvents(), "Test if the event queue is now empty."); + +TEST_MSG("Positive tests on directory watch."); + +if(mkdir(_DIR, 0777) == -1) TEST_FATAL("Could not create test dir."); +inotify.addDirectory(_DIR, WATCH_DEEP_FOLLOW); + +// Create file again +fp = fopen(_DIR"/file1", "w"); +if(!fp) TEST_FATAL("Unable to write to the file"); +fprintf(fp, "something"); +fclose(fp); + +TEST_TRUE(inotify.hasEvents(), "Test if the file creation triggered events."); +TEST_TRUE(inotify.getNextEvent().isCreateEvent(), "..."); +TEST_TRUE(inotify.getNextEvent().isOpenEvent(), "..."); +TEST_TRUE(inotify.getNextEvent().isModifyEvent(), "..."); +TEST_TRUE(inotify.getNextEvent().isCloseWriteEvent(), "..."); + +rename(_DIR"/file1", _DIR"/file2"); +TEST_TRUE(inotify.hasEvents(), "Test if the file renaming triggered events."); +TEST_TRUE(inotify.getNextEvent().isMovedFromEvent(), "..."); +TEST_TRUE(inotify.getNextEvent().isMovedToEvent(), "..."); + +unlink(_DIR"/file2"); + +if(mkdir(_DIR"/dir", 0777) == -1) TEST_FATAL("Could not create test dir."); + +if(mkdir(_DIR"/dir/anotherdir", 0777) == -1) TEST_FATAL("Could not create test dir."); + +while(inotify.hasEvents()) inotify.getNextEvent(); + +rmdir(_DIR"/dir/anotherdir"); + +rmdir(_DIR"/dir"); + +rmdir(_DIR); + +while(inotify.hasEvents()) inotify.getNextEvent(); TEST_END; diff --git a/server/src/inotify.h b/server/src/inotify.h index a2503b3..5199055 100644 --- a/server/src/inotify.h +++ b/server/src/inotify.h @@ -35,42 +35,70 @@ #include <map> #include <list> +typedef enum { + WATCH_SINGLE, // Watch only the specified directory. + WATCH_DEEP, // Watch all current subdirs as well + WATCH_DEEP_FOLLOW // Watch all current subdir as well as subdirs + // being created after the watch is initiated +} depth_t; + + class INotify { public: class Event { public: - Event(std::string name, uint32_t mask); + Event(struct inotify_event *event, std::string name); bool isAttributeChangeEvent(); + bool isCreateEvent(); bool isOpenEvent(); bool isCloseEvent(); + bool isCloseWriteEvent(); + bool isCloseNoWriteEvent(); bool isModifyEvent(); + bool isAccessEvent(); bool isDeleteEvent(); + bool isDeleteSelfEvent(); + bool isIgnoredEvent(); + bool isMoveSelfEvent(); + bool isMovedFromEvent(); + bool isMovedToEvent(); std::string name(); + std::string file(); uint32_t mask(); private: std::string _name; + std::string _file; uint32_t _mask; }; INotify(); ~INotify(); - void add(std::string name, uint32_t mask = IN_ALL_EVENTS); + void addFile(std::string name, uint32_t mask = IN_ALL_EVENTS); + void addDirectory(std::string name, + depth_t depth = WATCH_SINGLE, + uint32_t mask = IN_ALL_EVENTS); void remove(std::string name); void remove(int fd); - void addRecursive(std::string name, uint32_t mask = IN_ALL_EVENTS); - bool hasEvents(); Event getNextEvent(); private: + class Watch { + public: + std::string name; + uint32_t mask; + depth_t depth; + }; + void readEvents(); - int fd; - std::map<int, std::string> dirmap; + + int ifd; + std::map<int, Watch> dirmap; std::list<Event> eventlist; }; diff --git a/server/src/macrolist.cc b/server/src/macrolist.cc index 0d0916d..89abfe8 100644 --- a/server/src/macrolist.cc +++ b/server/src/macrolist.cc @@ -33,6 +33,24 @@ #include "debug.h" #include "macroheaderparser.h" +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> + +static inline bool isdir(std::string name) +{ + struct stat s; + stat(name.c_str(), &s); + return S_ISDIR(s.st_mode); +} + +static inline bool isfile(std::string name) +{ + struct stat s; + stat(name.c_str(), &s); + return S_ISREG(s.st_mode); +} + static std::vector<std::string> listdir(std::string path) { std::vector<std::string> files; @@ -45,11 +63,21 @@ static std::vector<std::string> listdir(std::string path) struct dirent *d; while((d = readdir(dir)) != 0) { - //if(d->d_type == DT_DIR) { - std::string name = d->d_name; - if(name.length() >= 4 && name.substr(name.length() - 4) == ".xml") - files.push_back(name); - //} + if(std::string(d->d_name) == "." || std::string(d->d_name) == "..") continue; + + PRACRO_DEBUG(macrolist, "d_name: %s - d_type: %d\n", d->d_name, d->d_type); + + if(isdir(path + "/" + d->d_name)) { + std::vector<std::string> sub = listdir(path + "/" + d->d_name); + files.insert(files.end(), sub.begin(), sub.end()); + continue; + } + + if(isfile(path + "/" + d->d_name)) { + std::string name = d->d_name; + if(name.length() >= 4 && name.substr(name.length() - 4) == ".xml") + files.push_back(path + "/" + name); + } } closedir(dir); @@ -60,18 +88,16 @@ MacroList::MacroList(std::string macropath) { MutexAutolock lock(mutex); + inotify.addDirectory(macropath, WATCH_DEEP_FOLLOW, + IN_CLOSE_WRITE | + IN_MOVED_FROM | IN_MOVED_TO | IN_MOVE_SELF | + IN_DELETE | IN_DELETE_SELF); + this->macropath = macropath; std::vector<std::string> macros = listdir(macropath); std::vector<std::string>::iterator i = macros.begin(); while(i != macros.end()) { - MacroHeaderParser parser(macropath + "/" + *i); - try { - parser.parse(); - Macro *macro = parser.getMacro(); - (*this)[macro->attributes["name"]][VersionStr(macro->attributes["version"])] = *i; - } catch(Exception &e) { - PRACRO_WARN(macrolist, "Skipping %s: %s\n", i->c_str(), e.what()); - } + addFile(*i); i++; } @@ -91,19 +117,77 @@ MacroList::MacroList(std::string macropath) } } +bool MacroList::removeFile(std::string file) +{ + // Check if the file is already in the tree. + iterator i = begin(); + while(i != end()) { + MacroListItem::iterator j = i->second.begin(); + while(j != i->second.end()) { + if(file == j->second) { + PRACRO_DEBUG(macrolist, "Removing file: %s\n", file.c_str()); + i->second.erase(j->first); + /* + if(i->second.size() == 0) erase(i->first); + */ + return true; + } + j++; + } + i++; + } + + return false; +} + +void MacroList::addFile(std::string file) +{ + PRACRO_DEBUG(macrolist, "Adding file: %s\n", file.c_str()); + MacroHeaderParser parser(file); + try { + parser.parse(); + Macro *macro = parser.getMacro(); + (*this)[macro->attributes["name"]][VersionStr(macro->attributes["version"])] = file; + } catch(Exception &e) { + PRACRO_WARN(macrolist, "Skipping %s: %s\n", file.c_str(), e.what()); + } +} + +void MacroList::updateFile(std::string file) +{ + removeFile(file); + addFile(file); +} + +void MacroList::updateList() +{ + while(inotify.hasEvents()) { + INotify::Event event = inotify.getNextEvent(); + if(event.isCloseWriteEvent()) updateFile(event.name()+"/"+event.file()); + if(event.isMovedFromEvent()) removeFile(event.name()+"/"+event.file()); + if(event.isMovedToEvent()) updateFile(event.name()+"/"+event.file()); + if(event.isDeleteEvent()) removeFile(event.name()+"/"+event.file()); + + if(event.isMoveSelfEvent()) {/* TODO: what to do here? */} + if(event.isDeleteSelfEvent()) {/* TODO: what to do here? */} + } +} + std::string MacroList::getLatestVersion(std::string macro) throw(Exception) { MutexAutolock lock(mutex); + updateList(); + if(find(macro) == end()) throw Exception("Macro ["+macro+"] does not exist"); MacroListItem mli = (*this)[macro]; - if(mli.size() == 0) return ""; + if(mli.size() == 0) throw Exception("Macro ["+macro+"] does not exist"); PRACRO_DEBUG(macrolist, "Search for %s - found %s v%s\n", macro.c_str(), - (macropath + "/" + mli.begin()->second).c_str(), + mli.begin()->second.c_str(), ((std::string)mli.begin()->first).c_str()); - return macropath + "/" + mli.begin()->second; + return mli.begin()->second; } #ifdef TEST_MACROLIST diff --git a/server/src/macrolist.h b/server/src/macrolist.h index 6460f8b..4c73ded 100644 --- a/server/src/macrolist.h +++ b/server/src/macrolist.h @@ -33,6 +33,8 @@ #include "versionstr.h" #include "mutex.h" +#include "inotify.h" + #include "exception.h" /** @@ -67,7 +69,13 @@ public: std::string getLatestVersion(std::string macro) throw(Exception); private: + bool removeFile(std::string file); + void addFile(std::string file); + void updateFile(std::string file); + void updateList(); + Mutex mutex; + INotify inotify; std::string macropath; }; |