zeus 0.10.0.pre2 → 0.10.0.pre3

data/ext/inotify-wrapper/inotify-wrapper.cpp

@@ -9,24 +9,50 @@
 #include <sys/types.h>
 #include <sys/inotify.h>
 
+#include <errno.h>
+
 #define EVENT_SIZE (sizeof (struct inotify_event))
 #define EVENT_BUF_LEN (1024 * (EVENT_SIZE + 16))
 
 using namespace std;
 
 static int _inotify_fd;
-static map<int, char*> _WatchedFiles;
-static map<char*, bool> _FileIsWatched;
+static map<int, string> _WatchedFiles;
+static map<string, bool> _FileIsWatched;
 
+// static int inotifyFlags = IN_ATTRIB | IN_MODIFY | IN_MOVE_SELF | IN_DELETE_SELF;
 static int inotifyFlags = IN_ATTRIB | IN_MODIFY | IN_MOVE_SELF | IN_DELETE_SELF;
 
-void maybeAddFileToWatchList(char *file)
+void maybeAddFileToWatchList(string file)
 {
   if (_FileIsWatched[file]) return;
 
-  _FileIsWatched[file] = true;
-  int wd = inotify_add_watch(_inotify_fd, file, inotifyFlags);
-  _WatchedFiles[wd] = file;
+  int wd = inotify_add_watch(_inotify_fd, file.c_str(), inotifyFlags);
+  int attempts = 0;
+  // Files are momentarily inaccessible when they are rewritten. I couldn't
+  // find a good way to deal with this, so we poll 'deleted' files for 0.25s or so
+  // to see if they reappear.
+  while (wd == -1 && errno == ENOENT) {
+    usleep(10000);
+    wd = inotify_add_watch(_inotify_fd, file.c_str(), inotifyFlags);
+    if (attempts++ == 25) break; // try for at most about a quarter of a second
+  }
+  if (wd != -1) {
+    _WatchedFiles[wd] = file;
+    _FileIsWatched[file] = true;
+  }
+}
+
+// This essentially removes a file from the watchlist then
+// immediately re-adds it. This is because when a file is rewritten,
+// as so many editors love to do, the watchdescriptor no longer refers to
+// the file, so re must re-watch the path.
+void replaceFileInWatchList(int wd, string file)
+{
+  _FileIsWatched.erase(file);
+  _WatchedFiles.erase(wd);
+  inotify_rm_watch(_inotify_fd, wd);
+  maybeAddFileToWatchList(file);
 }
 
 void handleStdin()
@@ -35,7 +61,7 @@ void handleStdin()
   if (fgets(line, sizeof(line), stdin) == NULL) return;
   line[strlen(line)-1] = 0;
 
-  maybeAddFileToWatchList(line);
+  maybeAddFileToWatchList(string(line));
 }
 
 void handleInotify()
@@ -50,8 +76,12 @@ void handleInotify()
 
   while (i < length) {
     struct inotify_event *event = (struct inotify_event *) &buffer[i];
-    printf("%s\n", _WatchedFiles[event->wd]);
-    fflush(stdout);
+    string file = _WatchedFiles[event->wd];
+    if (file != "") {
+      printf("%s\n", file.c_str());
+      fflush(stdout);
+      replaceFileInWatchList(event->wd, file);
+    }
 
     i += EVENT_SIZE + event->len;
   }

data/lib/zeus.rb

@@ -44,17 +44,6 @@ module Zeus
       end
     end
 
-    def handle_dead_children(sock)
-      # TODO: It would be nice if it were impossible for this
-      # to interfere with the identifer -> IO thing.
-      loop do
-        pid = Process.wait(-1, Process::WNOHANG)
-        break if pid.nil?
-        # sock.send("D:#{pid}")
-      end
-    rescue Errno::ECHILD
-    end
-
     def go(identifier=:boot)
       identifier = identifier.to_sym
       $0 = "zeus slave: #{identifier}"
@@ -63,10 +52,12 @@ module Zeus
       master = UNIXSocket.for_fd(fd)
 
       # I need to give the master a way to talk to me exclusively
-      local, remote = UNIXSocket.pair(:DGRAM)
+      local, remote = UNIXSocket.pair(:STREAM)
+
       master.send_io(remote)
 
       # Now I need to tell the master about my PID and ID
+      File.open("a.log","a") { |f| f.puts identifier}
       local.write "P:#{Process.pid}:#{identifier}\0"
 
       # Now we run the action and report its success/fail status to the master.
@@ -79,12 +70,13 @@ module Zeus
 
       # We are now 'connected'. From this point, we may receive requests to fork.
       loop do
-        new_identifier = local.recv(1024)
-        new_identifier.chomp!("\0")
-        if new_identifier =~ /^S:/
-          fork { plan.after_fork ; go(new_identifier.sub(/^S:/,'')) }
-        else
-          fork { plan.after_fork ; command(new_identifier.sub(/^C:/,''), local) }
+        messages = local.recv(1024)
+        messages.split("\0").each do |new_identifier|
+          if new_identifier =~ /^S:/
+            fork { plan.after_fork ; go(new_identifier.sub(/^S:/,'')) }
+          else
+            fork { plan.after_fork ; command(new_identifier.sub(/^C:/,''), local) }
+          end
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeus
 version: !ruby/object:Gem::Version
-  version: 0.10.0.pre2
+  version: 0.10.0.pre3
   prerelease: 7
 platform: ruby
 authors: