rb-fsevent 0.9.2 → 0.11.1

data/ext/fsevent_watch/defines.h

@@ -0,0 +1,42 @@
+#ifndef fsevent_watch_defines_h
+#define fsevent_watch_defines_h
+
+#define _str(s) #s
+#define _xstr(s) _str(s)
+
+#define COMPILED_AT __DATE__ " " __TIME__
+
+#if defined (__clang__)
+#define COMPILER "clang " __clang_version__
+#elif defined (__GNUC__)
+#define COMPILER "gcc " __VERSION__
+#else
+#define COMPILER "unknown"
+#endif
+
+#if defined(__ppc__)
+#define TARGET_CPU "ppc"
+#elif defined(__ppc64__)
+#define TARGET_CPU "ppc64"
+#elif defined(__i386__)
+#define TARGET_CPU "i386"
+#elif defined(__x86_64__)
+#define TARGET_CPU "x86_64"
+#elif defined(__arm64__)
+#define TARGET_CPU "arm64"
+#else
+#define TARGET_CPU "unknown"
+#endif
+
+#define FLAG_CHECK(flags, flag) ((flags) & (flag))
+
+#define FPRINTF_FLAG_CHECK(flags, flag, msg, fd)  \
+  do {                                            \
+    if (FLAG_CHECK(flags, flag)) {                \
+      fprintf(fd, "%s", msg "\n"); } }            \
+  while (0)
+
+#define FLAG_CHECK_STDERR(flags, flag, msg)       \
+        FPRINTF_FLAG_CHECK(flags, flag, msg, stderr)
+
+#endif /* fsevent_watch_defines_h */

data/ext/fsevent_watch/{fsevent_watch/main.c → main.c}

@@ -1,5 +1,7 @@
 #include "common.h"
+#include "signal_handlers.h"
 #include "cli.h"
+#include "FSEventsFix.h"
 
 // TODO: set on fire. cli.{h,c} handle both parsing and defaults, so there's
 //       no need to set those here. also, in order to scope metadata by path,
@@ -22,7 +24,7 @@ static struct {
   (double) 0.3,
   (CFOptionFlags) kFSEventStreamCreateFlagNone,
   NULL,
-  kFSEventWatchOutputFormatClassic
+  kFSEventWatchOutputFormatOTNetstring
 };
 
 // Prototypes
@@ -34,7 +36,7 @@ static void         callback(FSEventStreamRef streamRef,
                              void* eventPaths,
                              const FSEventStreamEventFlags eventFlags[],
                              const FSEventStreamEventId eventIds[]);
-
+static bool needs_fsevents_fix = false;
 
 // Resolve a path and append it to the CLI settings structure
 // The FSEvents API will, internally, resolve paths using a similar scheme.
@@ -47,48 +49,48 @@ static void append_path(const char* path)
 #endif
 
 #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-  
+
 #ifdef DEBUG
   fprintf(stderr, "compiled against 10.6+, using CFURLCreateFileReferenceURL\n");
 #endif
-  
+
   CFURLRef url = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8*)path, (CFIndex)strlen(path), false);
   CFURLRef placeholder = CFURLCopyAbsoluteURL(url);
   CFRelease(url);
-  
+
   CFMutableArrayRef imaginary = NULL;
-  
+
   // if we don't have an existing url, spin until we get to a parent that
   // does exist, saving any imaginary components for appending back later
   while(!CFURLResourceIsReachable(placeholder, NULL)) {
 #ifdef DEBUG
     fprintf(stderr, "path does not exist\n");
 #endif
-    
+
     CFStringRef child;
-    
+
     if (imaginary == NULL) {
       imaginary = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
     }
-    
+
     child = CFURLCopyLastPathComponent(placeholder);
     CFArrayInsertValueAtIndex(imaginary, 0, child);
     CFRelease(child);
-    
+
     url = CFURLCreateCopyDeletingLastPathComponent(NULL, placeholder);
     CFRelease(placeholder);
     placeholder = url;
-    
+
 #ifdef DEBUG
     fprintf(stderr, "parent: ");
     CFShow(placeholder);
 #endif
   }
-  
+
 #ifdef DEBUG
   fprintf(stderr, "path exists\n");
 #endif
-  
+
   // realpath() doesn't always return the correct case for a path, so this
   // is a funky workaround that converts a path into a (volId/inodeId) pair
   // and asks what the path should be for that. since it looks at the actual
@@ -98,12 +100,12 @@ static void append_path(const char* path)
   CFRelease(placeholder);
   placeholder = CFURLCreateFilePathURL(NULL, url, NULL);
   CFRelease(url);
-  
+
 #ifdef DEBUG
   fprintf(stderr, "path resolved to: ");
   CFShow(placeholder);
 #endif
-  
+
   // if we stripped off any imaginary path components, append them back on
   if (imaginary != NULL) {
     CFIndex count = CFArrayGetCount(imaginary);
@@ -119,30 +121,39 @@ static void append_path(const char* path)
     }
     CFRelease(imaginary);
   }
-  
+
 #ifdef DEBUG
   fprintf(stderr, "result: ");
   CFShow(placeholder);
 #endif
-  
+
   CFStringRef cfPath = CFURLCopyFileSystemPath(placeholder, kCFURLPOSIXPathStyle);
+  CFRelease(placeholder);
+
+  char cPath[PATH_MAX];
+  if (CFStringGetCString(cfPath, cPath, PATH_MAX, kCFStringEncodingUTF8)) {
+    FSEventsFixRepairStatus status = FSEventsFixRepairIfNeeded(cPath);
+    if (status == FSEventsFixRepairStatusFailed) {
+      needs_fsevents_fix = true;
+    }
+  }
+
   CFArrayAppendValue(config.paths, cfPath);
   CFRelease(cfPath);
-  CFRelease(placeholder);
-  
+
 #else
-  
+
 #ifdef DEBUG
   fprintf(stderr, "compiled against 10.5, using realpath()\n");
 #endif
-  
+
   char fullPath[PATH_MAX + 1];
-  
+
   if (realpath(path, fullPath) == NULL) {
 #ifdef DEBUG
     fprintf(stderr, "  realpath not directly resolvable from path\n");
 #endif
-    
+
     if (path[0] != '/') {
 #ifdef DEBUG
       fprintf(stderr, "  passed path is not absolute\n");
@@ -162,18 +173,18 @@ static void append_path(const char* path)
       strlcpy(fullPath, path, sizeof(fullPath));
     }
   }
-  
+
 #ifdef DEBUG
   fprintf(stderr, "  resolved path to: %s\n", fullPath);
   fprintf(stderr, "\n");
 #endif
-  
+
   CFStringRef pathRef = CFStringCreateWithCString(kCFAllocatorDefault,
                                                   fullPath,
                                                   kCFStringEncodingUTF8);
   CFArrayAppendValue(config.paths, pathRef);
   CFRelease(pathRef);
-  
+
 #endif
 }
 
@@ -234,6 +245,15 @@ static inline void parse_cli_settings(int argc, const char* argv[])
     }
   }
 
+  if (args_info.mark_self_flag) {
+    if ((osMajorVersion == 10) & (osMinorVersion >= 9)) {
+      config.flags |= kFSEventStreamCreateFlagMarkSelf;
+    } else {
+      fprintf(stderr, "MacOSX 10.9 or later required for --mark-self\n");
+      exit(EXIT_FAILURE);
+    }
+  }
+
   if (args_info.inputs_num == 0) {
     append_path(".");
   } else {
@@ -249,7 +269,7 @@ static inline void parse_cli_settings(int argc, const char* argv[])
   fprintf(stderr, "config.latency      %f\n", config.latency);
 
 // STFU clang
-#if __LP64__
+#if defined(__LP64__)
   fprintf(stderr, "config.flags        %#.8x\n", config.flags);
 #else
   fprintf(stderr, "config.flags        %#.8lx\n", config.flags);
@@ -330,18 +350,54 @@ static void tstring_output_format(size_t numEvents,
                        false);
     CFDictionarySetValue(event, CFSTR("path"), path);
 
-    CFNumberRef flags = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &eventFlags[i]);
-    CFDictionarySetValue(event, CFSTR("flags"), flags);
-
     CFNumberRef ident = CFNumberCreate(kCFAllocatorDefault, kCFNumberLongLongType, &eventIds[i]);
     CFDictionarySetValue(event, CFSTR("id"), ident);
 
+    CFNumberRef cflags = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &eventFlags[i]);
+    CFDictionarySetValue(event, CFSTR("cflags"), cflags);
+
+    CFMutableArrayRef flags = CFArrayCreateMutable(kCFAllocatorDefault,
+                              0, &kCFTypeArrayCallBacks);
+
+#define FLAG_ADD_NAME(flagsnum, flagnum, flagname, flagarray)   \
+  do {                                                          \
+    if (FLAG_CHECK(flagsnum, flagnum)) {                        \
+      CFArrayAppendValue(flagarray, CFSTR(flagname)); } }       \
+  while(0)
+
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagMustScanSubDirs,     "MustScanSubDirs", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagUserDropped,         "UserDropped", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagKernelDropped,       "KernelDropped", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagEventIdsWrapped,     "EventIdsWrapped", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagHistoryDone,         "HistoryDone", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagRootChanged,         "RootChanged", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagMount,               "Mount", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagUnmount,             "Unmount", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemCreated,         "ItemCreated", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemRemoved,         "ItemRemoved", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemInodeMetaMod,    "ItemInodeMetaMod", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemRenamed,         "ItemRenamed", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemModified,        "ItemModified", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemFinderInfoMod,   "ItemFinderInfoMod", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemChangeOwner,     "ItemChangeOwner", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemXattrMod,        "ItemXattrMod", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemIsFile,          "ItemIsFile", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemIsDir,           "ItemIsDir", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemIsSymlink,       "ItemIsSymlink", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagOwnEvent,            "OwnEvent", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemIsHardlink,      "ItemIsHardLink", flags);
+    FLAG_ADD_NAME(eventFlags[i], kFSEventStreamEventFlagItemIsLastHardlink,  "ItemIsLastHardLink", flags);
+
+    CFDictionarySetValue(event, CFSTR("flags"), flags);
+
+
     CFArrayAppendValue(events, event);
 
     CFRelease(event);
     CFRelease(path);
-    CFRelease(flags);
     CFRelease(ident);
+    CFRelease(cflags);
+    CFRelease(flags);
   }
 
   CFMutableDictionaryRef meta = CFDictionaryCreateMutable(kCFAllocatorDefault,
@@ -382,7 +438,7 @@ static void callback(__attribute__((unused)) FSEventStreamRef streamRef,
     fprintf(stderr, "  event ID: %llu\n", eventIds[i]);
 
 // STFU clang
-#if __LP64__
+#if defined(__LP64__)
     fprintf(stderr, "  event flags: %#.8x\n", eventFlags[i]);
 #else
     fprintf(stderr, "  event flags: %#.8lx\n", eventFlags[i]);
@@ -426,7 +482,10 @@ static void callback(__attribute__((unused)) FSEventStreamRef streamRef,
                       "    Item is a directory");
     FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemIsSymlink,
                       "    Item is a symbolic link");
-
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemIsHardlink,
+                      "    Item is a hard link");
+    FLAG_CHECK_STDERR(eventFlags[i], kFSEventStreamEventFlagItemIsLastHardlink,
+                      "    Item is the last hard link");
     fprintf(stderr, "  event path: %s\n", paths[i]);
     fprintf(stderr, "\n");
   }
@@ -451,37 +510,13 @@ static void callback(__attribute__((unused)) FSEventStreamRef streamRef,
 
 int main(int argc, const char* argv[])
 {
-  /*
-   * a subprocess will initially inherit the process group of its parent. the
-   * process group may have a control terminal associated with it, which would
-   * be the first tty device opened by the group leader. typically the group
-   * leader is your shell and the control terminal is your login device. a
-   * subset of signals triggered on the control terminal are sent to all members
-   * of the process group, in large part to facilitate sane and consistent
-   * cleanup (ex: control terminal was closed).
-   *
-   * so why the overly descriptive lecture style comment?
-   *   1. SIGINT and SIGQUIT are among the signals with this behavior
-   *   2. a number of applications gank the above for their own use
-   *   3. ruby's insanely useful "guard" is one of these applications
-   *   4. despite having some level of understanding of POSIX signals and a few
-   *      of the scenarios that might cause problems, i learned this one only
-   *      after reading ruby 1.9's process.c
-   *   5. if left completely undocumented, even slightly obscure bugfixes
-   *      may be removed as cruft by a future maintainer
-   *
-   * hindsight is 20/20 addition: if you're single-threaded and blocking on IO
-   * with a subprocess, then handlers for deferrable signals might not get run
-   * when you expect them to. In the case of Ruby 1.8, that means making use of
-   * IO::select, which will preserve correct signal handling behavior.
-   */
-  if (setpgid(0,0) < 0) {
-    fprintf(stderr, "Unable to set new process group.\n");
-    return 1;
-  }
-
+  install_signal_handlers();
   parse_cli_settings(argc, argv);
 
+  if (needs_fsevents_fix) {
+    FSEventsFixEnable();
+  }
+
   FSEventStreamContext context = {0, NULL, NULL, NULL, NULL};
   FSEventStreamRef stream;
   stream = FSEventStreamCreate(kCFAllocatorDefault,
@@ -497,6 +532,10 @@ int main(int argc, const char* argv[])
   fprintf(stderr, "\n");
 #endif
 
+  if (needs_fsevents_fix) {
+    FSEventsFixDisable();
+  }
+
   FSEventStreamScheduleWithRunLoop(stream,
                                    CFRunLoopGetCurrent(),
                                    kCFRunLoopDefaultMode);

data/ext/fsevent_watch/signal_handlers.c

@@ -0,0 +1,66 @@
+#include "signal_handlers.h"
+#include <fcntl.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+
+#define PPID_ALARM_INTERVAL 2 // send SIGALRM every this seconds
+
+
+static pid_t orig_ppid;
+
+
+static void signal_handler(int _) {
+  exit(EXIT_FAILURE);
+}
+
+static void check_ppid(void) {
+  if (getppid() != orig_ppid) {
+    exit(EXIT_FAILURE);
+  }
+}
+
+static void check_stdout_open(void) {
+  if (fcntl(STDOUT_FILENO, F_GETFD) < 0) {
+    exit(EXIT_FAILURE);
+  }
+}
+
+static void alarm_handler(int _) {
+  check_ppid();
+  check_stdout_open();
+  alarm(PPID_ALARM_INTERVAL);
+  signal(SIGALRM, alarm_handler);
+}
+
+static void die(const char *msg) {
+  fprintf(stderr, "\nFATAL: %s\n", msg);
+  abort();
+}
+
+static void install_signal_handler(int sig, void (*handler)(int)) {
+  if (signal(sig, handler) == SIG_ERR) {
+    die("Could not install signal handler");
+  }
+}
+
+void install_signal_handlers(void) {
+  // check pipe is still connected
+  check_stdout_open();
+
+  // watch getppid() every PPID_ALARM_INTERVAL seconds 
+  orig_ppid = getppid();
+  if (orig_ppid <= 1) {
+    die("prematurely zombied");
+  }
+  install_signal_handler(SIGALRM, alarm_handler);
+  alarm(PPID_ALARM_INTERVAL);
+
+  // be sure to exit on SIGHUP, SIGPIPE
+  install_signal_handler(SIGHUP,  signal_handler);
+  install_signal_handler(SIGPIPE, signal_handler);
+}
+

data/ext/fsevent_watch/signal_handlers.h

@@ -0,0 +1,16 @@
+/**
+ * @headerfile signal_handlers.h
+ * Signal handlers to stop the zombie hordes
+ *
+ * Catch and handle signals better so that we die faster like a good meat puppet.
+ */
+
+
+#ifndef fsevent_watch_signal_handlers_h
+#define fsevent_watch_signal_handlers_h
+
+
+void install_signal_handlers(void);
+
+
+#endif // fsevent_watch_signal_handlers_h