refactor and modernize the native interface

CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required (VERSION 3.1.0 FATAL_ERROR)
+set (PROJECT_NAME "NSFW")
+project (${PROJECT_NAME})
+
+message (STATUS "Running CMake version ${CMAKE_VERSION}")
+
+set (NSFW_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/include")
+
+add_subdirectory (src)

appveyor.yml

@@ -15,7 +15,7 @@ install:
   # Get the latest stable version of Node.js or io.js
   - ps: Install-Product node $env:nodejs_version
   # install modules
-  - npm install --msvs_version=2013
+  - npm install --msvs_version=2015
 
 # Post-install test scripts.
 test_script:

binding.gyp

@@ -2,10 +2,6 @@
     "targets": [{
         "target_name": "nsfw",
 
-        "dependencies": [
-            "openpa/openpa.gyp:openpa"
-        ],
-
         "sources": [
             "src/NSFW.cpp",
             "src/Queue.cpp",
@@ -22,10 +18,10 @@
         "conditions": [
             ["OS=='win'", {
                 "sources": [
-                    "src/win32/ReadLoop.cpp",
-                    "src/win32/ReadLoopRunner.cpp",
-                    "includes/win32/ReadLoop.h",
-                    "includes/win32/ReadLoopRunner.h"
+                    "src/win32/Controller.cpp",
+                    "src/win32/Watcher.cpp",
+                    "includes/win32/Controller.h",
+                    "includes/win32/Watcher.h"
                 ],
                 "msvs_settings": {
                     "VCCLCompilerTool": {
@@ -38,13 +34,18 @@
             }],
             ["OS=='mac'", {
                 "sources": [
-                    "src/Lock.cpp",
                     "src/osx/RunLoop.cpp",
                     "src/osx/FSEventsService.cpp",
-                    "includes/Lock.h",
                     "includes/osx/RunLoop.h",
                     "includes/osx/FSEventsService.h"
                 ],
+                "xcode_settings": {
+                    'MACOSX_DEPLOYMENT_TARGET': '10.7',
+                    "OTHER_CFLAGS": [
+                        "-std=c++11",
+                        "-stdlib=libc++"
+                    ],
+                },
                 "link_settings": {
                     "xcode_settings": {
                         "OTHER_LDFLAGS": [
@@ -58,25 +59,19 @@
             }],
             ["OS=='linux' or OS=='freebsd'", {
                 "sources": [
-                    "src/Lock.cpp",
                     "src/linux/InotifyEventLoop.cpp",
                     "src/linux/InotifyTree.cpp",
                     "src/linux/InotifyService.cpp",
-                    "includes/Lock.h",
                     "includes/linux/InotifyEventLoop.h",
                     "includes/linux/InotifyTree.h",
                     "includes/linux/InotifyService.h"
                 ],
                 "cflags": [
                     "-Wno-unknown-pragmas",
-                    "-std=c++0x"
+                    "-std=c++11"
                 ]
             }],
             ["OS=='win'", {
-                "defines": [
-                    "OPA_HAVE_NT_INTRINSICS=1",
-                    "_opa_inline=__inline"
-                ],
                 "conditions": [
                     ["target_arch=='x64'", {
                         "VCLibrarianTool": {
@@ -95,7 +90,6 @@
             }],
             ["OS=='mac' or OS=='linux' or OS=='freebsd'", {
                 "defines": [
-                    "OPA_HAVE_GCC_INTRINSIC_ATOMICS=1",
                     "HAVE_STDDEF_H=1",
                     "HAVE_STDLIB_H=1",
                     "HAVE_UNISTD_H=1"
@@ -106,16 +100,6 @@
                     "/usr/local/include"
                 ]
             }],
-            ["target_arch=='x64' or target_arch=='arm64'", {
-                "defines": [
-                    "OPA_SIZEOF_VOID_P=8"
-                ]
-            }],
-            ["target_arch=='ia32' or target_arch=='armv7'", {
-                "defines": [
-                    "OPA_SIZEOF_VOID_P=4"
-                ]
-            }]
         ]
     }]
 }

includes/NSFW.h

@@ -5,6 +5,7 @@
 #include <nan.h>
 #include <uv.h>
 #include <vector>
+#include <atomic>
 
 using namespace Nan;
 
@@ -28,7 +29,7 @@ class NSFW : public ObjectWrap {
   bool mInterfaceLockValid;
   std::string mPath;
   uv_thread_t mPollThread;
-  bool mRunning;
+  std::atomic<bool> mRunning;
 private:
   NSFW(uint32_t debounceMS, std::string path, Callback *eventCallback, Callback *errorCallback);
   ~NSFW();
@@ -40,7 +41,7 @@ class NSFW : public ObjectWrap {
 
   struct EventBaton {
     NSFW *nsfw;
-    std::vector<Event *> *events;
+    std::vector<Event*> *events;
   };
 
   static NAN_METHOD(JSNew);

includes/NativeInterface.h

@@ -1,22 +1,33 @@
 #ifndef NSFW_NATIVE_INTERFACE_H
 #define NSFW_NATIVE_INTERFACE_H
 
+#if defined(_WIN32)
+#include "../includes/win32/Controller.h"
+using NativeImplementation = Controller;
+#elif defined(__APPLE_CC__)
+#include "../includes/osx/FSEventsService.h"
+using NativeImplementation = FSEventsService;
+#elif defined(__linux__) || defined(__FreeBSD__)
+#include "../includes/linux/InotifyService.h"
+using NativeImplementation = InotifyService;
+#endif
+
 #include "Queue.h"
 #include <vector>
 
 class NativeInterface {
 public:
-  NativeInterface(std::string path);
+  NativeInterface(const std::string &path);
+  ~NativeInterface();
 
   std::string getError();
-  std::vector<Event *> *getEvents();
+  std::vector<Event*> *getEvents();
   bool hasErrored();
   bool isWatching();
 
-  ~NativeInterface();
 private:
-  EventQueue mQueue;
-  void *mNativeInterface;
+  std::shared_ptr<EventQueue> mQueue;
+  std::unique_ptr<NativeImplementation> mNativeInterface;
 };
 
 #endif

includes/Queue.h

@@ -2,10 +2,10 @@
 #define NSFW_QUEUE_H
 
 #include <string>
-extern "C" {
-#  include <opa_queue.h>
-#  include <opa_primitives.h>
-}
+#include <memory>
+#include <deque>
+#include <vector>
+#include <mutex>
 
 enum EventType {
   CREATED = 0,
@@ -15,32 +15,28 @@ enum EventType {
 };
 
 struct Event {
+  Event(const EventType type, const std::string &directory, const std::string &fileA, const std::string &fileB) :
+      type(type), directory(directory), fileA(fileA), fileB(fileB) {}
   EventType type;
   std::string directory, fileA, fileB;
 };
 
 class EventQueue {
 public:
-  EventQueue();
-  ~EventQueue();
-
   void clear();
-  int count();
-  Event *dequeue(); // Free this pointer when you are done with it
+  std::size_t count();
+  std::unique_ptr<Event> dequeue();
+  std::unique_ptr<std::vector<Event*>> dequeueAll();
   void enqueue(
     EventType type,
-    std::string directory,
-    std::string fileA,
-    std::string fileB = ""
+    const std::string &directory,
+    const std::string &fileA,
+    const std::string &fileB = ""
   );
 
 private:
-  struct EventNode {
-    OPA_Queue_element_hdr_t header;
-    Event *event;
-  };
-  OPA_Queue_info_t mQueue;
-  OPA_int_t mNumEvents;
+  std::deque<std::unique_ptr<Event>> queue;
+  std::mutex mutex;
 };
 
 #endif

includes/SingleshotSemaphore.h

@@ -0,0 +1,67 @@
+#ifndef NSFW_SEMAPHORE_H
+#define NSFW_SEMAPHORE_H
+
+#include <condition_variable>
+#include <mutex>
+
+/**
+ * This is a convenience abstraction around std::condition_variable that allows
+ * for a one-shot synchronization point. Therefore the Semaphore has no way to
+ * reset its state.
+ *
+ * It doesn't matter if the waiting thread calls `wait()` before or after the
+ * signaling thread calls `signal()`. Only in the latter case the `wait()` won't
+ * block.
+ */
+class SingleshotSemaphore {
+public:
+  SingleshotSemaphore() : mState(false) {}
+
+  /**
+   * Blocks the calling thread until the semaphore is signaled asynchronously.
+   * If `signal()` has been called on the semaphore already, this won't block.
+   */
+  void wait() {
+    std::unique_lock<std::mutex> lk(mMutex);
+
+    while (!mState) {
+      mCond.wait(lk);
+    }
+  }
+
+  /**
+   * Blocks the calling thread for a given time period and continues either
+   * when `signal()` was called asynchronously or when the time is up. The
+   * return condition is indicated by the returned boolean.
+   *
+   * \return true if the semaphore was signal()ed; false on timeout reached
+   */
+  bool waitFor(std::chrono::milliseconds ms) {
+    std::unique_lock<std::mutex> lk(mMutex);
+
+    if (mState) {
+      return true;
+    }
+
+    mCond.wait_for(lk, ms);
+    return mState;
+  }
+
+  /**
+   * Unblocks all waiting threads of the semaphore. Note that threads reaching
+   * the `wait()` on this semaphore after `signal()` has been called won't
+   * block but continue immediately.
+   */
+  void signal() {
+    std::unique_lock<std::mutex> lk(mMutex);
+    mState = true;
+    mCond.notify_all();
+  }
+
+private:
+  std::mutex mMutex;
+  std::condition_variable mCond;
+  bool mState;
+};
+
+#endif

includes/linux/InotifyEventLoop.h

@@ -2,14 +2,16 @@
 #define INOTIFY_EVENT_LOOP_H
 
 #include "InotifyService.h"
-#include "../Lock.h"
+#include "../SingleshotSemaphore.h"
+
 #include <sys/inotify.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
 #include <unistd.h>
 #include <sys/select.h>
 #include <string>
+#include <mutex>
 
 class InotifyService;
 class Lock;
@@ -40,7 +42,8 @@ class InotifyEventLoop {
   InotifyService *mInotifyService;
 
   pthread_t mEventLoop;
-  pthread_mutex_t mMutex;
+  std::mutex mMutex;
+  SingleshotSemaphore mLoopingSemaphore;
   bool mStarted;
 };
 

includes/linux/InotifyService.h

@@ -12,7 +12,7 @@ class InotifyTree;
 
 class InotifyService {
 public:
-  InotifyService(EventQueue &queue, std::string path);
+  InotifyService(std::shared_ptr<EventQueue> queue, std::string path);
 
   std::string getError();
   bool hasErrored();
@@ -32,7 +32,7 @@ class InotifyService {
   void renameDirectory(int wd, std::string oldName, std::string newName);
 
   InotifyEventLoop *mEventLoop;
-  EventQueue &mQueue;
+  std::shared_ptr<EventQueue> mQueue;
   InotifyTree *mTree;
   int mInotifyInstance;
 

includes/osx/FSEventsService.h

@@ -24,7 +24,7 @@ class RunLoop;
 
 class FSEventsService {
 public:
-  FSEventsService(EventQueue &queue, std::string path);
+  FSEventsService(std::shared_ptr<EventQueue> queue, std::string path);
 
   friend void FSEventsServiceCallback(
     ConstFSEventStreamRef streamRef,
@@ -50,7 +50,7 @@ class FSEventsService {
 
   std::string mPath;
   RunLoop *mRunLoop;
-  EventQueue &mQueue;
+  std::shared_ptr<EventQueue> mQueue;
 };
 
 #endif