wdm 0.0.2-mingw32

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Maher Sallam
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Windows Directory Monitor (WDM)
+
+Windows Directory Monitor (WDM) is a library which can be used to monitor directories for changes.
+It's mostly implemented in C and uses the Win32 API for a better performance.
+
+**Note:** This is still a work in progress, so it's not advisable to use
+it yet in anything (unless you are testing it, which is very much appreciated :)).
+
+TODO:
+
+- Fix all the TODO's in the source.
+- ~~Enable watching subdirectories.~~
+- ~~Add options to the `watch` method.~~
+- ~~Provide info about the change in the callback.~~
+- ~~Convert \ to / in paths.~~
+- ~~Don't allow directories to be watched while the monitor is running.~~
+- ~~Check if the passed direcoty exists.~~
+- ~~Convert passed directories to absolute paths.~~
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wdm'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wdm
+
+## Compiling the extension for developers
+
+Download the source, then run the following:
+
+	$ rake compile
+
+To get debug messages, you need to enable them in the `global.h` file:
+
+	#define WDM_DEBUG_ENABLED TRUE // This is disabled by default
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Author
+
+[Maher Sallam](https://github.com/Maher4Ever)

data/ext/wdm/entry.c

@@ -0,0 +1,67 @@
+#include "wdm.h"
+
+#include "memory.h"
+#include "entry.h"
+
+// ---------------------------------------------------------
+// Entry user data functions
+// ---------------------------------------------------------
+
+WDM_PEntryUserData
+wdm_entry_user_data_new() {
+    WDM_PEntryUserData user_data;
+
+    user_data = WDM_ALLOC(WDM_EntryUserData);
+
+    user_data->dir = NULL;
+    user_data->watch_childeren = FALSE;
+
+    return user_data;
+}
+
+void
+wdm_entry_user_data_free(WDM_PEntryUserData user_data) {
+    if ( user_data->dir != NULL ) free(user_data->dir);
+    free(user_data);
+}
+
+// ---------------------------------------------------------
+// Entry functions
+// ---------------------------------------------------------
+
+WDM_PEntry
+wdm_entry_new() {
+    WDM_PEntry entry;
+
+    entry = WDM_ALLOC(WDM_Entry);
+
+    entry->user_data = wdm_entry_user_data_new();
+    entry->dir_handle = INVALID_HANDLE_VALUE;
+    entry->next = NULL;
+
+    ZeroMemory(&entry->buffer, WDM_BUFFER_SIZE);
+    ZeroMemory(&entry->event_container, sizeof(OVERLAPPED));
+
+    return entry;
+}
+
+void
+wdm_entry_free(WDM_PEntry entry) {
+    if ( entry->dir_handle != INVALID_HANDLE_VALUE ) {
+        CancelIo(entry->dir_handle); // Stop monitoring changes
+        CloseHandle(entry->dir_handle);
+    }
+    wdm_entry_user_data_free(entry->user_data);
+    free(entry);
+}
+
+void
+wdm_entry_list_free(WDM_PEntry entry) {
+    WDM_PEntry tmp;
+
+    while(entry != NULL) {
+        tmp = entry;
+        entry = entry->next;
+        wdm_entry_free(tmp);
+    }
+}

data/ext/wdm/entry.h

@@ -0,0 +1,47 @@
+#include <Windows.h>
+#include <ruby.h>
+
+#ifndef WDM_ENTRY_H
+#define WDM_ENTRY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// ---------------------------------------------------------
+// Types
+// ---------------------------------------------------------
+
+typedef struct {
+    LPWSTR dir;                             // Name of directory to watch
+    VALUE callback;                         // Proc object to call when there are changes
+    BOOL watch_childeren;                   // Watch sub-directories
+    DWORD flags;                            // Flags for the type of changes to report
+} WDM_EntryUserData, *WDM_PEntryUserData;
+
+typedef struct WDM_Entry {
+    WDM_PEntryUserData user_data;           // User-supplied data
+    HANDLE dir_handle;                      // IO handle of the directory
+    BYTE buffer[WDM_BUFFER_SIZE];           // Buffer for the results
+    OVERLAPPED event_container;             // Async IO event container
+    struct WDM_Entry* next;                 // Well, this is a linked list, so this is self-explanatory :)
+} WDM_Entry, *WDM_PEntry;
+
+// ---------------------------------------------------------
+// Prototypes
+// ---------------------------------------------------------
+
+WDM_PEntryUserData wdm_entry_user_data_new();
+void wdm_entry_user_data_free(WDM_PEntryUserData);
+
+WDM_PEntry wdm_entry_new();
+void wdm_entry_free(WDM_PEntry);
+void wdm_entry_list_free(WDM_PEntry);
+
+// ---------------------------------------------------------
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // WDM_ENTRY_H

data/ext/wdm/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+if have_library("kernel32") and
+   have_header("windows.h") and
+   have_header("ruby.h")    and
+   have_const('HAVE_RUBY_ENCODING_H')
+then
+    create_makefile("wdm")
+end

data/ext/wdm/memory.c

@@ -0,0 +1,27 @@
+#include "wdm.h"
+
+#include "memory.h"
+
+void *
+wdm_memory_malloc (size_t size)
+{
+  void *memory = malloc(size);
+
+  if ( memory == NULL ) {
+    rb_fatal("failed to allocate memory");
+  }
+
+  return memory;
+}
+
+void *
+wdm_memory_realloc (void *ptr, size_t size)
+{
+  void *memory = realloc(ptr, size);
+
+  if ( memory == NULL ) {
+    rb_fatal("failed to re-allocate memory");
+  }
+
+  return memory;
+}

data/ext/wdm/memory.h

@@ -0,0 +1,32 @@
+#ifndef WDM_MEMORY_H
+#define WDM_MEMORY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// ---------------------------------------------------------
+// Prototypes
+// ---------------------------------------------------------
+
+void *
+wdm_memory_malloc (size_t);
+
+void *
+wdm_memory_realloc (void *, size_t);
+
+// ---------------------------------------------------------
+// Macros
+// ---------------------------------------------------------
+
+#define WDM_ALLOC_N(type,n) ((type*)wdm_memory_malloc((n) * sizeof(type)))
+#define WDM_ALLOC(type) ((type*)wdm_memory_malloc(sizeof(type)))
+#define WDM_REALLOC_N(var,type,n) ((var)=(type*)wdm_memory_realloc((void*)(var), (n) * sizeof(type)))
+
+// ---------------------------------------------------------
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // WDM_MEMORY_H

data/ext/wdm/monitor.c

@@ -0,0 +1,70 @@
+#include "wdm.h"
+
+#include "memory.h"
+#include "entry.h"
+#include "queue.h"
+
+#include "monitor.h"
+
+WDM_PMonitor
+wdm_monitor_new() {
+    WDM_PMonitor monitor;
+
+    monitor = WDM_ALLOC(WDM_Monitor);
+
+    monitor->running = FALSE;
+
+    monitor->head = NULL;
+    monitor->monitoring_thread = INVALID_HANDLE_VALUE;
+
+    monitor->changes = wdm_queue_new();
+
+    monitor->process_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+    monitor->stop_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+    if ( ! InitializeCriticalSectionAndSpinCount(&monitor->lock,
+            0x00000400) ) // TODO: look into the best value for spinning.
+    {
+        rb_raise(eWDM_Error, "Can't create a lock for the monitor");
+    }
+
+    return monitor;
+}
+
+void
+wdm_monitor_free(WDM_PMonitor monitor) {
+    if ( monitor->monitoring_thread != INVALID_HANDLE_VALUE ) CloseHandle(monitor->monitoring_thread);
+
+    wdm_entry_list_free(monitor->head);
+    wdm_queue_free(monitor->changes);
+    DeleteCriticalSection(&monitor->lock);
+    CloseHandle(monitor->process_event); // TODO: Look into why this crashes the app when exiting!
+    CloseHandle(monitor->stop_event);
+
+    free(monitor);
+}
+
+void
+wdm_monitor_update_head(WDM_PMonitor monitor, WDM_PEntry new_head) {
+    EnterCriticalSection(&monitor->lock);
+        new_head->next = monitor->head;
+        monitor->head = new_head;
+    LeaveCriticalSection(&monitor->lock);
+}
+
+WDM_PMonitorCallbackParam
+wdm_monitor_callback_param_new(WDM_PMonitor monitor, WDM_PEntry entry) {
+    WDM_PMonitorCallbackParam param;
+
+    param = WDM_ALLOC(WDM_MonitorCallbackParam);
+
+    param->monitor = monitor;
+    param->entry = entry;
+
+    return param;
+}
+
+void
+wdm_monitor_callback_param_free(WDM_PMonitorCallbackParam param) {
+    free(param);
+}

data/ext/wdm/monitor.h

@@ -0,0 +1,50 @@
+#include <Windows.h>
+
+#include "entry.h"
+#include "queue.h"
+
+#ifndef WDM_MONITOR_H
+#define WDM_MONITOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// ---------------------------------------------------------
+// Types
+// ---------------------------------------------------------
+
+typedef struct {
+    BOOL running;
+    WDM_PEntry head;
+    WDM_PQueue changes;
+    CRITICAL_SECTION lock;
+    HANDLE monitoring_thread;
+    HANDLE process_event;
+    HANDLE stop_event;
+} WDM_Monitor, *WDM_PMonitor;
+
+typedef struct {
+    WDM_PEntry entry;
+    WDM_PMonitor monitor;
+} WDM_MonitorCallbackParam, *WDM_PMonitorCallbackParam;
+
+// ---------------------------------------------------------
+// Prototypes
+// ---------------------------------------------------------
+
+WDM_PMonitor wdm_monitor_new();
+void wdm_monitor_free(WDM_PMonitor);
+
+void wdm_monitor_update_head(WDM_PMonitor, WDM_PEntry);
+
+WDM_PMonitorCallbackParam wdm_monitor_callback_param_new(WDM_PMonitor, WDM_PEntry);
+void wdm_monitor_callback_param_free(WDM_PMonitorCallbackParam);
+
+// ---------------------------------------------------------
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // WDM_MONITOR_H

data/ext/wdm/queue.c

@@ -0,0 +1,108 @@
+#include "wdm.h"
+
+#include "memory.h"
+#include "queue.h"
+
+// ---------------------------------------------------------
+// Queue item functions
+// ---------------------------------------------------------
+
+WDM_PQueueItem
+wdm_queue_item_new() {
+    WDM_PQueueItem item;
+
+    item = WDM_ALLOC(WDM_QueueItem);
+    item->user_data = NULL;
+    item->previous    = NULL;
+    item->next        = NULL;
+
+    ZeroMemory(&item->buffer, WDM_BUFFER_SIZE);
+
+    return item;
+}
+
+void
+wdm_queue_item_free(WDM_PQueueItem item) {
+    // We can't really do anything to the prev pointer nor the next pointer,
+    // because we might break any linking the user has established.
+    free(item);
+}
+
+// ---------------------------------------------------------
+// Queue functions
+// ---------------------------------------------------------
+
+WDM_PQueue
+wdm_queue_new() {
+    WDM_PQueue queue;
+
+    queue = WDM_ALLOC(WDM_Queue);
+    queue->front = NULL;
+    queue->rear  = NULL;
+
+    if ( ! InitializeCriticalSectionAndSpinCount(&queue->lock,
+            0x00000400) ) // TODO: look into the best value for spinning.
+    {
+        rb_raise(eWDM_Error, "Can't create a lock for the queue");
+    }
+
+    return queue;
+}
+
+void
+wdm_queue_free(WDM_PQueue queue) {
+    wdm_queue_empty(queue);
+    free(queue);
+}
+
+void
+wdm_queue_enqueue(WDM_PQueue queue, WDM_PQueueItem item) {
+    EnterCriticalSection(&queue->lock);
+
+    if ( queue->rear == NULL && queue->front == NULL )  {
+        queue->front = queue->rear = item;
+    }
+    else {
+        queue->rear->next = item;
+        item->previous = queue->rear;
+        queue->rear = item;
+    }
+
+    LeaveCriticalSection(&queue->lock);
+}
+
+WDM_PQueueItem
+wdm_queue_dequeue(WDM_PQueue queue) {
+    WDM_PQueueItem item;
+
+    EnterCriticalSection(&queue->lock);
+
+    if ( queue->rear == NULL && queue->front == NULL ) {
+        item = NULL;
+    }
+    else {
+        item = queue->front;
+        queue->front = queue->front->next;
+
+        // Reset the rear when the queue is empty
+        if ( queue->front == NULL ) queue->rear = NULL;
+
+        // Don't allow the user to mess with the queue
+        item->previous = item->next = NULL;
+    }
+
+    LeaveCriticalSection(&queue->lock);
+
+    return item;
+}
+
+void wdm_queue_empty(WDM_PQueue queue) {
+    while( ! wdm_queue_is_empty(queue) ) {
+        wdm_queue_item_free(wdm_queue_dequeue(queue));
+    }
+}
+
+BOOL
+wdm_queue_is_empty(WDM_PQueue queue) {
+    return queue->front == NULL && queue->rear == NULL;
+}