RInotify 0.9-i586-linux

data/ext/rinotify.c

@@ -0,0 +1,289 @@
+/*****************************************************
+ * copyright (C) 2007 by Rob Merrell
+ * rob@migrob.com
+ *
+ * ***************************************************/
+
+#include "ruby.h"
+#include "rinotify.h"
+#include "rinotify_event.h"
+
+#include <sys/inotify.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+// extension entry point
+void Init_rinotify() {
+	rb_cRInotify = rb_define_class("RInotify", rb_cObject);	
+	rb_cRInotifyEvent = rb_define_class("RInotifyEvent", rb_cObject);
+	
+	// initialize all of the events
+	rinotify_declare_events(rb_cRInotify);		
+
+
+	// RInotify.new
+	rb_define_alloc_func(rb_cRInotify, rb_rinotify_new);
+	
+	// RInotify.version
+	rb_define_method(rb_cRInotify, "version", rb_rinotify_version, 0);
+
+	// RInotify.close
+	rb_define_method(rb_cRInotify, "close", rb_rinotify_close, 0);
+
+	// RInotify.add_watch
+	rb_define_method(rb_cRInotify, "add_watch", rb_rinotify_add_watch, 2);
+
+	// RInotify.rm_watch
+	rb_define_method(rb_cRInotify, "rm_watch", rb_rinotify_rm_watch, 1);
+
+	// RInotify.wait_for_events
+	rb_define_method(rb_cRInotify, "wait_for_events", rb_rinotify_wait_for_events, 1);
+
+	// RInotify.each_event
+	rb_define_method(rb_cRInotify, "each_event", rb_rinotify_each_event, 0);
+	
+	// RInotify.watch_descriptors
+	rb_define_method(rb_cRInotify, "watch_descriptors", rb_rinotify_watch_descriptors, 0);
+
+	// RInotify.event_queue_size
+	rb_define_method(rb_cRInotify, "event_queue_size", rb_rinotify_queue_size, 0);
+
+
+	/* The following methods are implemented in rinotify_event.c */
+	
+	// RInotifyEvent.name
+	rb_define_method(rb_cRInotifyEvent, "name", rb_rinotify_event_name, 0);
+	
+	// RInotifyEvent.watch_descriptor
+	rb_define_method(rb_cRInotifyEvent, "watch_descriptor", rb_rinotify_event_watch_descriptor, 0);
+	
+	// RInotifyEvent.check_mask
+	rb_define_method(rb_cRInotifyEvent, "check_mask", rb_rinotify_event_check_mask, 1);
+}
+
+
+static VALUE rb_rinotify_new(VALUE klass) {
+	VALUE initialized_class;
+	
+	// initialize inotify
+	int *inotify = NULL;
+	inotify = malloc(sizeof(int));
+	*inotify = inotify_init();
+
+	if (*inotify < 0)
+		rb_sys_fail("inotify_init");	
+	
+	// make sure free is called because we malloc'd above
+	initialized_class = Data_Wrap_Struct(klass, NULL, free, inotify);
+	
+	// initialize all of the instance variables for this class
+	rinotify_declare_instance_vars(initialized_class);
+
+	return initialized_class;
+}
+
+
+static VALUE rb_rinotify_version(VALUE self) {
+	return rb_str_new2(CURRENT_VERSION);	
+}
+
+
+static VALUE rb_rinotify_close(VALUE self) {
+	int *inotify = NULL, close_return;
+	Data_Get_Struct(self, int, inotify);
+
+	// close and clean up inotify
+	close_return = close(*inotify);
+	if (close_return)
+		rb_sys_fail("close");	
+
+	return Qnil;
+}
+
+
+static VALUE rb_rinotify_add_watch(VALUE self, VALUE filename, VALUE event_masks) {
+	int *inotify = NULL, watch_desc;
+	VALUE watch_desc_id, watch_descriptor_list;
+	Data_Get_Struct(self, int, inotify);
+
+	// add the watch
+	watch_desc = inotify_add_watch(*inotify, RSTRING(filename)->ptr, NUM2INT(event_masks));	
+	if (watch_desc < 0)
+		rb_sys_fail("add_watch");
+	
+	watch_desc_id = INT2NUM(watch_desc);
+
+	// add the watch descriptor to our list
+	watch_descriptor_list = rb_iv_get(self, "@watch_descriptors");
+	rb_hash_aset(watch_descriptor_list, watch_desc_id, filename);
+
+	return watch_desc_id;
+}
+
+
+static VALUE rb_rinotify_rm_watch(VALUE self, VALUE watch_desc) {
+	int *inotify = NULL, rm_return;
+	Data_Get_Struct(self, int, inotify);
+
+	// remove the watch
+	rm_return = inotify_rm_watch(*inotify, NUM2INT(watch_desc));
+	if (rm_return < 0)
+		rb_sys_fail("rm_watch");
+
+	return INT2NUM(rm_return);
+}
+
+
+static VALUE rb_rinotify_wait_for_events(VALUE self, VALUE time_value) {
+	struct timeval time;
+	fd_set rfds;
+	int select_ret, *inotify = NULL;	
+
+	Data_Get_Struct(self, int, inotify);
+
+	// set the timout value
+	time.tv_sec = NUM2INT(time_value);
+	time.tv_usec = 0;
+
+	// add inotify to the file descriptor set
+	FD_ZERO(&rfds);
+	FD_SET(*inotify, &rfds);	
+
+	select_ret = rb_thread_select(*inotify + 1, &rfds, NULL, NULL, &time);
+	
+	if (select_ret < 0)
+		rb_sys_fail("select");
+
+	// no events are available and we have timed out
+	else if (!select_ret)
+		return Qfalse;
+
+	// events are available
+	else if (FD_ISSET(*inotify, &rfds))
+		return Qtrue;
+
+	// to keep the compiler happy...
+	return Qfalse;
+}
+
+
+static VALUE rb_rinotify_each_event(VALUE self) {
+	struct inotify_event *event = NULL, *tmp_event = NULL;
+	int *inotify = NULL, i = 0, len;
+	char buffer[BUFFER_SIZE];
+
+	Data_Get_Struct(self, int, inotify);
+
+	len = read(*inotify, buffer, BUFFER_SIZE);	
+
+	// read each event
+	while (i < len) {
+		tmp_event = (struct inotify_event *) &buffer[i];
+
+		// copy the tmp_event into our malloc'd event so that it doesn't
+		// go out of scope after we yield the object
+        event = malloc(EVENT_SIZE + tmp_event->len);
+		memmove(event, tmp_event, EVENT_SIZE + tmp_event->len); 
+
+		// construct the RInotifyEvent object
+		rb_yield(rb_rinotify_event_new(event));
+
+		i += EVENT_SIZE + event->len;
+	}
+
+	return Qnil;
+}
+
+
+static VALUE rb_rinotify_watch_descriptors(VALUE self) {
+	return rb_iv_get(self, "@watch_descriptors");
+}
+
+
+static VALUE rb_rinotify_queue_size(VALUE self) {
+	int *inotify = NULL, return_val;
+	unsigned int queue_size;
+
+	Data_Get_Struct(self, int, inotify);
+
+	// get the queue size
+	return_val = ioctl(*inotify, FIONREAD, &queue_size);
+
+	if (return_val < 0)
+		rb_sys_fail("event_queue_size");
+
+	return UINT2NUM(queue_size);
+}
+
+
+static void rinotify_declare_events(VALUE klass) {
+	// watch events
+	rb_const_set(klass, rb_intern("IN_ACCESS"), INT2NUM(IN_ACCESS));
+	rb_const_set(klass, rb_intern("ACCESS"), INT2NUM(IN_ACCESS));
+
+	rb_const_set(klass, rb_intern("IN_MODIFY"), INT2NUM(IN_MODIFY));
+	rb_const_set(klass, rb_intern("MODIFY"), INT2NUM(IN_MODIFY));
+
+	rb_const_set(klass, rb_intern("IN_ATTRIB"), INT2NUM(IN_ATTRIB));
+	rb_const_set(klass, rb_intern("ATTRIB"), INT2NUM(IN_ATTRIB));
+
+	rb_const_set(klass, rb_intern("IN_CLOSE_WRITE"), INT2NUM(IN_CLOSE_WRITE));
+	rb_const_set(klass, rb_intern("CLOSE_WRITE"), INT2NUM(IN_CLOSE_WRITE));
+
+	rb_const_set(klass, rb_intern("IN_CLOSE_NOWRITE"), INT2NUM(IN_CLOSE_NOWRITE));
+	rb_const_set(klass, rb_intern("CLOSE_NOWRITE"), INT2NUM(IN_CLOSE_NOWRITE));
+
+	rb_const_set(klass, rb_intern("IN_OPEN"), INT2NUM(IN_OPEN));
+	rb_const_set(klass, rb_intern("OPEN"), INT2NUM(IN_OPEN));
+
+	rb_const_set(klass, rb_intern("IN_MOVED_FROM"), INT2NUM(IN_MOVED_FROM));
+	rb_const_set(klass, rb_intern("MOVED_FROM"), INT2NUM(IN_MOVED_FROM));
+
+	rb_const_set(klass, rb_intern("IN_MOVED_TO"), INT2NUM(IN_MOVED_TO));
+	rb_const_set(klass, rb_intern("MOVED_TO"), INT2NUM(IN_MOVED_TO));
+
+	rb_const_set(klass, rb_intern("IN_CREATE"), INT2NUM(IN_CREATE));
+	rb_const_set(klass, rb_intern("CREATE"), INT2NUM(IN_CREATE));
+
+	rb_const_set(klass, rb_intern("IN_DELETE"), INT2NUM(IN_DELETE));
+	rb_const_set(klass, rb_intern("DELETE"), INT2NUM(IN_DELETE));
+
+	rb_const_set(klass, rb_intern("IN_DELETE_SELF"), INT2NUM(IN_DELETE_SELF));
+	rb_const_set(klass, rb_intern("DELETE_SELF"), INT2NUM(IN_DELETE_SELF));
+
+	// sent by any watch
+	rb_const_set(klass, rb_intern("IN_UNMOUNT"), INT2NUM(IN_UNMOUNT));
+	rb_const_set(klass, rb_intern("UNMOUNT"), INT2NUM(IN_UNMOUNT));
+
+	rb_const_set(klass, rb_intern("IN_Q_OVERFLOW"), INT2NUM(IN_Q_OVERFLOW));
+	rb_const_set(klass, rb_intern("Q_OVERFLOW"), INT2NUM(IN_Q_OVERFLOW));
+
+	rb_const_set(klass, rb_intern("IN_IGNORED"), INT2NUM(IN_IGNORED));
+	rb_const_set(klass, rb_intern("IGNORED"), INT2NUM(IN_IGNORED));
+
+	// helper events
+	rb_const_set(klass, rb_intern("IN_CLOSE"), INT2NUM(IN_CLOSE));
+	rb_const_set(klass, rb_intern("CLOSE"), INT2NUM(IN_CLOSE));
+
+	rb_const_set(klass, rb_intern("IN_MOVE"), INT2NUM(IN_MOVE));
+	rb_const_set(klass, rb_intern("MOVE"), INT2NUM(IN_MOVE));
+
+	// special flags
+	rb_const_set(klass, rb_intern("IN_ISDIR"), INT2NUM(IN_ISDIR));
+	rb_const_set(klass, rb_intern("ISDIR"), INT2NUM(IN_ISDIR));
+
+	rb_const_set(klass, rb_intern("IN_ONESHOT"), INT2NUM(IN_ONESHOT));	
+	rb_const_set(klass, rb_intern("ONESHOT"), INT2NUM(IN_ONESHOT));	
+
+	rb_const_set(klass, rb_intern("IN_ALL_EVENTS"), INT2NUM(IN_ALL_EVENTS));
+	rb_const_set(klass, rb_intern("ALL_EVENTS"), INT2NUM(IN_ALL_EVENTS));
+}
+
+
+static void rinotify_declare_instance_vars(VALUE klass) {
+	// Array: holds a listing of all watch descriptors and the filename or directory name
+	// that they happen to be watching
+	VALUE watch_descriptors = rb_hash_new();
+	rb_iv_set(klass, "@watch_descriptors", watch_descriptors);		
+}

data/ext/rinotify.h

@@ -0,0 +1,163 @@
+/*****************************************************
+ * copyright (C) 2007 by Rob Merrell
+ * rob@migrob.com
+ *
+ * ***************************************************/
+
+#ifndef RINOTIFY_H
+#define RINOTIFY_H
+
+#include "ruby.h"
+#include <sys/inotify.h>
+
+#define CURRENT_VERSION "0.9"
+#define EVENT_SIZE sizeof(struct inotify_event)
+#define BUFFER_SIZE 16384
+
+// RInotify class
+static VALUE rb_cRInotify;
+
+/* Non Ruby-implimented Prototypes */
+
+// declare the inotify events as constants
+static void rinotify_declare_events(VALUE);
+
+// declare any instance variables we will need
+static void rinotify_declare_instance_vars(VALUE);
+
+
+
+/* Ruby Prototypes */
+
+/*
+ * call-seq:
+ *	RInotify.new -> RInotify
+ *
+ *	Returns a new RInotify object.
+ *
+ *	Example Usage:
+ *	@rinotify = RInotify.new
+ */
+static VALUE rb_rinotify_new(VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotify.version -> String
+ *
+ *	Returns the current version.
+ *
+ *	Example Usage:
+ *	@rinotify.version => "0.1.0"
+ */
+static VALUE rb_rinotify_version(VALUE);
+
+
+/*
+ * call-seq:
+ *		RInotify.close -> nil
+ *
+ *	Clean up and close inotify.
+ *
+ *	Example Usage:
+ *	@rinotify.close
+ */
+static VALUE rb_rinotify_close(VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotify.add_watch(filename, event masks) -> watch descriptor
+ *
+ *	Adds a watch on a file or directory.
+ *
+ *	The event masks are simple a bitmask and should be joined like:
+ *	RInotify::OPEN | RInotify::MODIFY
+ *
+ *	Example Usage:
+ *	@rinotify = RInotify.new
+ *	@rinotify.add_watch("/home/rob/Desktop/my_file.txt", RInotify::MODIFY | RInotify::DELETE_SELF | RInotify::OPEN)
+ */
+static VALUE rb_rinotify_add_watch(VALUE, VALUE, VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotify.rm_watch(watch descriptor) -> closed watch descriptor
+ *
+ *	Remove a watch descriptor.  Note that this is not a necessary step
+ *	when closing inotify.
+ *
+ *	Example Usage:
+ *	@rinotify = RInotify.new
+ *	wd = @rinotify.add_watch("/home/rob/Desktop/my_file.txt", RInotify::MODIFY | RInotify::DELETE_SELF | RInotify::OPEN)
+ *	@rinotify.rm_watch(wd)
+ */
+static VALUE rb_rinotify_rm_watch(VALUE, VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotify.wait_for_events(seconds to time out) -> true or false 
+ *
+ *	Waits for events to be received from inotify.
+ *	Returns true when there are events waiting in the queue
+ *	and false if not.
+ *
+ *	Example Usage:
+ *	@rinotify = RInotify.new
+ *	@rinotify.add_watch("/home/rob/Desktop/my_file.txt", RInotify::MODIFY | RInotify::DELETE_SELF | RInotify::OPEN)
+ *
+ *	# set time out at 5 seconds
+ *	has_events = @rinotify.wait_for_events(5)
+ */
+static VALUE rb_rinotify_wait_for_events(VALUE, VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotify.each_event -> RInotifyEvent
+ *
+ *	Yields an RInotifyEvent object in a block
+ *
+ *	Example Usage:
+ *	has_events = @rinotify.wait_for_events(5)
+ *	if has_events
+ *		@rinotify.each_event {|revent|
+ *			...
+ *		}
+ *	end
+ */
+static VALUE rb_rinotify_each_event(VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotify.watch_descriptors -> Hash(watch descriptor, file name)
+ *
+ *	Returns a hash of all watch_descriptors and file name of each file or directory
+ *	being watched.
+ *
+ *	Example Usage:
+ *	@rinotify.watch_descriptors => [1, "/home/rob/Desktop/my_file.txt"]
+ */
+static VALUE rb_rinotify_watch_descriptors(VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotify.event_queue_size -> Fixnum
+ *
+ *	Returns the current size of the event queue.  This is useful if you want to throttle
+ *	your event checks
+ *
+ *	Example Usage:
+ *	while (queue_size < 128)
+ *		if @rinotify.wait_for_events(5)
+ *			queue_size = @rinotify.event_queue_size
+ *		end
+ *	end	
+ */
+static VALUE rb_rinotify_queue_size(VALUE);
+
+#endif

data/ext/rinotify_event.c

@@ -0,0 +1,55 @@
+#include "ruby.h"
+#include "rinotify_event.h"
+
+#include <sys/inotify.h>
+
+VALUE rb_rinotify_event_new(struct inotify_event *event) {
+	VALUE rinotify_event;
+
+	// initialize the object
+	rinotify_event = Data_Wrap_Struct(rb_cRInotifyEvent, NULL, free, event);
+	rb_obj_call_init(rinotify_event, 0, NULL);
+
+	return rinotify_event;
+}
+
+
+VALUE rb_rinotify_event_name(VALUE self) {
+	VALUE name;
+	struct inotify_event *event;	
+	Data_Get_Struct(self, struct inotify_event, event);
+
+	// if watching for events in a directory inotify will tell us the name
+	if (event->len) {
+		name = rb_str_new2(event->name);	
+	} else {
+	// watching a single file doesn't waste space with a filename so return nil
+		name = Qnil;
+	}
+
+	return name;
+}
+
+
+VALUE rb_rinotify_event_watch_descriptor(VALUE self) {
+	struct inotify_event *event;	
+	Data_Get_Struct(self, struct inotify_event, event);
+
+	return INT2NUM(event->wd);
+}
+
+
+VALUE rb_rinotify_event_check_mask(VALUE self, VALUE masks) {
+	VALUE return_val;
+	struct inotify_event *event;	
+	Data_Get_Struct(self, struct inotify_event, event);
+
+	// check if the mask is part of the event
+	if (event->mask & NUM2INT(masks))
+		return_val = Qtrue;
+	else 
+		return_val = Qfalse;
+
+	return return_val;
+}
+

data/ext/rinotify_event.h

@@ -0,0 +1,60 @@
+/*****************************************************
+ * copyright (C) 2007 by Rob Merrell
+ * rob@migrob.com
+ *
+ * ***************************************************/
+
+#ifndef RINOTIFY_EVENT_H
+#define RINOTIFY_EVENT_H
+
+#include "ruby.h"
+#include <sys/inotify.h>
+
+// RInotifyEvent class
+VALUE rb_cRInotifyEvent;
+
+/* Ruby Prototypes */
+
+// returns a new RInotifyEvent object.  This method should only be called by RInotify.each_event
+VALUE rb_rinotify_event_new(struct inotify_event*);
+
+
+/*
+ * call-seq:
+ *	RInotifyEvent.name -> event name
+ *
+ *	Returns the name of the event if the watched file is a directory.  If it is a file
+ *	nil is returned.  In this case the event name can be found by looking the watch descriptor
+ *	up using RInotify.watch_descriptors.
+ *
+ *	Example Usage:
+ *	rinotify_event.name -> "/home/rob/desktop/tmp/test"
+ */
+VALUE rb_rinotify_event_name(VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotifyEvent.watch_descriptor -> event watch descriptor
+ *
+ *	Returns the watch descriptor that the event belongs to.
+ *
+ *	Example Usage:
+ *	rinotify_event.watch_descriptor -> 1
+ */
+VALUE rb_rinotify_event_watch_descriptor(VALUE);
+
+
+/*
+ * call-seq:
+ *	RInotifyEvent.check_mask(mask) -> boolean
+ *
+ *	Returns true or false if the current event contains the mask(s)
+ *
+ *	Example Usage:
+ *	rinotify_event->check_mask(RInotify::MODIFY) -> true
+ *	rinotify_event->check_mask(RInotify::DELETE_SELF) -> false
+ */
+VALUE rb_rinotify_event_check_mask(VALUE, VALUE);
+
+#endif

data/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('rinotify', 'ext')

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: RInotify
+version: !ruby/object:Gem::Version 
+  version: "0.9"
+date: 2007-04-17 00:00:00 -06:00
+summary: A Ruby wrapper for Linux's inotify
+require_paths: 
+- .
+email: rob@migrob.com
+homepage: http://rinotify.migrob.com
+rubyforge_project: 
+description: 
+autorequire: RInotify
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: i586-linux
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Rob Merrell
+files: 
+- ext/rinotify_event.c
+- ext/rinotify.c
+- ext/rinotify_event.h
+- ext/rinotify.h
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- extconf.rb
+requirements: []
+
+dependencies: []
+