launch 1.0

data.tar.gz.sig

@@ -0,0 +1 @@
+d�(4�äQIm�v��H��
�����Pp6f��#��P�Ob�JњL��.t�K2>���;��j��[�<v�I?7v���
̸$D{C<���&7۲���L��M[WO�� �����ԋkU�)X^)?SƋ��6s'K,ǝ�o~D�ub��PN}�l���(�]/��7��t�|vy�Yr��3N��:����)�H}�������;dSš��a���ǵ���?�r`'��s`@�un�+��A}b����J|%[�U

data/.autotest

@@ -0,0 +1,8 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = 'minitest/autorun'
+end
+

data/History.txt

@@ -0,0 +1,5 @@
+=== 1.0 / 2011-02-26
+
+* Major enhancements
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,11 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+ext/launch/extconf.rb
+ext/launch/launch.c
+lib/launch.rb
+lib/launch/webrick.rb
+sample/echo.rb
+test/test_launch.rb

data/README.txt

@@ -0,0 +1,72 @@
+= launch
+
+* https://github.com/drbrain/launch
+* http://docs.seattlerb.org/launch
+
+== DESCRIPTION:
+
+Launch allows agents and daemons launched by launchd to retrieve their list of
+sockets.  Launchd is an open source framework for launching and managing
+daemons, programs and scripts provided by Apple.
+
+== FEATURES/PROBLEMS:
+
+* Provides the Launch module for easy integration with existing programs
+* Allows on-demand execution of ruby programs through launchd
+
+== SYNOPSIS:
+
+  require 'launch'
+
+  class MyDaemon
+    def initialize
+      launch_checkin
+      launch_sockets('MyDaemonSocket', TCPServer).each do |server|
+        # handle requests, see sample/echo.rb
+      end
+    end
+  end
+
+  MyDaemon.new
+
+== REQUIREMENTS:
+
+* An installed launchd
+
+== INSTALL:
+
+  gem install launch
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Eric Hodel
+
+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/Rakefile

@@ -0,0 +1,37 @@
+# -*- ruby -*-
+
+task :default => :compile
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :minitest
+Hoe.plugin :git
+
+hoe = Hoe.spec 'launch' do
+  developer 'Eric Hodel', 'drbrain@segment7.net'
+
+  rdoc_locations << 'docs.seattlerb.org:/data/www/docs.seattlerb.org/launch/'
+
+  extra_dev_deps << ['rake-compiler', '~> 0.7']
+  self.spec_extras[:extensions] = %w[ext/launch/extconf.rb]
+
+  self.spec_extras[:required_ruby_version] = '>= 1.9.2'
+
+  self.clean_globs = %[
+    lib/launch/launch.bundle
+  ]
+end
+
+begin
+  gem 'rake-compiler', '~> 0.7'
+  require 'rake/extensiontask'
+
+  Rake::ExtensionTask.new hoe.name, hoe.spec do |ext|
+    ext.lib_dir = File.join 'lib', 'launch'
+  end
+rescue Gem::LoadError
+  warn 'You need to rake newb'
+end
+
+# vim: syntax=ruby

data/ext/launch/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+abort unless have_header 'launch.h'
+
+create_makefile 'launch/launch'
+

data/ext/launch/launch.c

@@ -0,0 +1,355 @@
+#include <ruby.h>
+#include <launch.h>
+#include <errno.h>
+#include <stdio.h>
+
+VALUE mLaunch;
+VALUE mLaunchKey;
+VALUE mLaunchJobKey;
+VALUE mLaunchSocket;
+VALUE mLaunchJobPolicy;
+VALUE mLaunchData;
+VALUE cLaunchError;
+
+static VALUE launch_data_to_ruby(launch_data_t);
+
+static void
+launch_dict_iterator(launch_data_t item, const char * key, void * hash) {
+  rb_hash_aset((VALUE)hash, rb_str_new2(key), launch_data_to_ruby(item));
+}
+
+static VALUE
+launch_data_to_ruby(launch_data_t item) {
+  VALUE out = Qnil;
+  launch_data_t temp = NULL;
+  launch_data_type_t item_type = launch_data_get_type(item);
+  int i = 0;
+  size_t length = 0;
+
+  switch(item_type) {
+    case LAUNCH_DATA_DICTIONARY:
+      out = rb_hash_new();
+
+      launch_data_dict_iterate(item, launch_dict_iterator, (void *)out);
+
+      break;
+	  case LAUNCH_DATA_ARRAY:
+      length = launch_data_array_get_count(item);
+      out = rb_ary_new2(length);
+
+      for (i = 0; i < length; i++) {
+        temp = launch_data_array_get_index(item, i);
+        rb_ary_store(out, i, launch_data_to_ruby(temp));
+      }
+
+      break;
+	  case LAUNCH_DATA_FD:
+      out = INT2NUM(launch_data_get_fd(item));
+      break;
+	  case LAUNCH_DATA_INTEGER:
+      out = LONG2NUM(launch_data_get_integer(item));
+      break;
+	  case LAUNCH_DATA_REAL:
+      out = DBL2NUM(launch_data_get_real(item));
+      break;
+	  case LAUNCH_DATA_BOOL:
+      out = launch_data_get_bool(item) == TRUE ? Qtrue : Qfalse;
+      break;
+	  case LAUNCH_DATA_STRING:
+      out = rb_str_new2(launch_data_get_string(item));
+      break;
+	  case LAUNCH_DATA_OPAQUE:
+      out = rb_str_new(launch_data_get_opaque(item),
+          launch_data_get_opaque_size(item));
+      break;
+	  case LAUNCH_DATA_ERRNO:
+      out = INT2NUM(launch_data_get_errno(item));
+      break;
+	  case LAUNCH_DATA_MACHPORT:
+      break;
+    default:
+      rb_raise(cLaunchError, "unknown item type %d", item_type);
+  }
+
+  return out;
+}
+
+/*
+ * call-seq:
+ *   launch_message(Launch::Key::CHECKIN) # => response
+ *
+ * launch_message wraps launch(3)'s launch_msg function.  The argument is a
+ * message to send launchd from Launch::Key.  Please use launch_checkin
+ * and launch_sockets instead of this method.
+ *
+ * The response from launchd is converted to a ruby structure and freed
+ * (usually a Hash).  Currently the following data types in the response are
+ * indistinguishable in the ruby structure:
+ *
+ * * STRING and OPAQUE
+ * * INTEGER, FD and ERRNO
+ *
+ * Additionally, MACHPORT is ignored.
+ *
+ * If there was a failure to retrieve checkin data an error will be raised.
+ */
+static VALUE
+message(VALUE self, VALUE message) {
+  VALUE out, tmp;
+  launch_data_t send, response;
+  launch_data_type_t response_type;
+
+  message = rb_str_to_str(message);
+
+  send = launch_data_new_string(StringValueCStr(message));
+
+  if (send == NULL) {
+    tmp = rb_inspect(message);
+    rb_raise(cLaunchError, "unable to create message %s",
+        StringValueCStr(tmp));
+  }
+
+  response = launch_msg(send);
+
+  if (response == NULL)
+    rb_sys_fail("launch_msg");
+
+  response_type = launch_data_get_type(response);
+
+  if (response_type == LAUNCH_DATA_ERRNO) {
+    errno = launch_data_get_errno(response);
+    rb_sys_fail("launch_msg");
+  }
+
+  out = launch_data_to_ruby(response);
+
+  launch_data_free(response);
+
+  return out;
+}
+
+void
+Init_launch() {
+  mLaunch = rb_define_module("Launch");
+  cLaunchError = rb_define_class_under(mLaunch, "Error", rb_eRuntimeError);
+
+  rb_define_method(mLaunch, "launch_message", message, 1);
+
+  rb_const_set(mLaunch, rb_intern("JOBINETDCOMPATIBILITY_WAIT"),
+      rb_str_new2(LAUNCH_JOBINETDCOMPATIBILITY_WAIT));
+
+  /*
+   * Launch::Key holds launch message types
+   */
+  mLaunchKey = rb_define_module_under(mLaunch, "Key");
+  rb_const_set(mLaunchKey, rb_intern("SUBMITJOB"),
+        rb_str_new2(LAUNCH_KEY_SUBMITJOB));
+  rb_const_set(mLaunchKey, rb_intern("REMOVEJOB"),
+      rb_str_new2(LAUNCH_KEY_REMOVEJOB));
+  rb_const_set(mLaunchKey, rb_intern("STARTJOB"),
+      rb_str_new2(LAUNCH_KEY_STARTJOB));
+  rb_const_set(mLaunchKey, rb_intern("STOPJOB"),
+      rb_str_new2(LAUNCH_KEY_STOPJOB));
+  rb_const_set(mLaunchKey, rb_intern("GETJOB"),
+      rb_str_new2(LAUNCH_KEY_GETJOB));
+  rb_const_set(mLaunchKey, rb_intern("GETJOBS"),
+      rb_str_new2(LAUNCH_KEY_GETJOBS));
+  rb_const_set(mLaunchKey, rb_intern("CHECKIN"),
+      rb_str_new2(LAUNCH_KEY_CHECKIN));
+
+  /*
+   * Launch::JobKey holds various keys returned in a message response
+   */
+  mLaunchJobKey = rb_define_module_under(mLaunch, "JobKey");
+  rb_const_set(mLaunchJobKey, rb_intern("LABEL"),
+      rb_str_new2(LAUNCH_JOBKEY_LABEL));
+  rb_const_set(mLaunchJobKey, rb_intern("DISABLED"),
+      rb_str_new2(LAUNCH_JOBKEY_DISABLED));
+  rb_const_set(mLaunchJobKey, rb_intern("USERNAME"),
+      rb_str_new2(LAUNCH_JOBKEY_USERNAME));
+  rb_const_set(mLaunchJobKey, rb_intern("GROUPNAME"),
+      rb_str_new2(LAUNCH_JOBKEY_GROUPNAME));
+  rb_const_set(mLaunchJobKey, rb_intern("TIMEOUT"),
+      rb_str_new2(LAUNCH_JOBKEY_TIMEOUT));
+  rb_const_set(mLaunchJobKey, rb_intern("EXITTIMEOUT"),
+      rb_str_new2(LAUNCH_JOBKEY_EXITTIMEOUT));
+  rb_const_set(mLaunchJobKey, rb_intern("INITGROUPS"),
+      rb_str_new2(LAUNCH_JOBKEY_INITGROUPS));
+  rb_const_set(mLaunchJobKey, rb_intern("SOCKETS"),
+      rb_str_new2(LAUNCH_JOBKEY_SOCKETS));
+  rb_const_set(mLaunchJobKey, rb_intern("MACHSERVICES"),
+      rb_str_new2(LAUNCH_JOBKEY_MACHSERVICES));
+  rb_const_set(mLaunchJobKey, rb_intern("MACHSERVICELOOKUPPOLICIES"),
+      rb_str_new2(LAUNCH_JOBKEY_MACHSERVICELOOKUPPOLICIES));
+  rb_const_set(mLaunchJobKey, rb_intern("INETDCOMPATIBILITY"),
+      rb_str_new2(LAUNCH_JOBKEY_INETDCOMPATIBILITY));
+  rb_const_set(mLaunchJobKey, rb_intern("ENABLEGLOBBING"),
+      rb_str_new2(LAUNCH_JOBKEY_ENABLEGLOBBING));
+  rb_const_set(mLaunchJobKey, rb_intern("PROGRAMARGUMENTS"),
+      rb_str_new2(LAUNCH_JOBKEY_PROGRAMARGUMENTS));
+  rb_const_set(mLaunchJobKey, rb_intern("PROGRAM"),
+      rb_str_new2(LAUNCH_JOBKEY_PROGRAM));
+  rb_const_set(mLaunchJobKey, rb_intern("ONDEMAND"),
+      rb_str_new2(LAUNCH_JOBKEY_ONDEMAND));
+  rb_const_set(mLaunchJobKey, rb_intern("KEEPALIVE"),
+      rb_str_new2(LAUNCH_JOBKEY_KEEPALIVE));
+  rb_const_set(mLaunchJobKey, rb_intern("LIMITLOADTOHOSTS"),
+      rb_str_new2(LAUNCH_JOBKEY_LIMITLOADTOHOSTS));
+  rb_const_set(mLaunchJobKey, rb_intern("LIMITLOADFROMHOSTS"),
+      rb_str_new2(LAUNCH_JOBKEY_LIMITLOADFROMHOSTS));
+  rb_const_set(mLaunchJobKey, rb_intern("LIMITLOADTOSESSIONTYPE"),
+      rb_str_new2(LAUNCH_JOBKEY_LIMITLOADTOSESSIONTYPE));
+  rb_const_set(mLaunchJobKey, rb_intern("RUNATLOAD"),
+      rb_str_new2(LAUNCH_JOBKEY_RUNATLOAD));
+  rb_const_set(mLaunchJobKey, rb_intern("ROOTDIRECTORY"),
+      rb_str_new2(LAUNCH_JOBKEY_ROOTDIRECTORY));
+  rb_const_set(mLaunchJobKey, rb_intern("WORKINGDIRECTORY"),
+      rb_str_new2(LAUNCH_JOBKEY_WORKINGDIRECTORY));
+  rb_const_set(mLaunchJobKey, rb_intern("ENVIRONMENTVARIABLES"),
+      rb_str_new2(LAUNCH_JOBKEY_ENVIRONMENTVARIABLES));
+  rb_const_set(mLaunchJobKey, rb_intern("USERENVIRONMENTVARIABLES"),
+      rb_str_new2(LAUNCH_JOBKEY_USERENVIRONMENTVARIABLES));
+  rb_const_set(mLaunchJobKey, rb_intern("UMASK"),
+      rb_str_new2(LAUNCH_JOBKEY_UMASK));
+  rb_const_set(mLaunchJobKey, rb_intern("NICE"),
+      rb_str_new2(LAUNCH_JOBKEY_NICE));
+  rb_const_set(mLaunchJobKey, rb_intern("HOPEFULLYEXITSFIRST"),
+      rb_str_new2(LAUNCH_JOBKEY_HOPEFULLYEXITSFIRST));
+  rb_const_set(mLaunchJobKey, rb_intern("HOPEFULLYEXITSLAST"),
+      rb_str_new2(LAUNCH_JOBKEY_HOPEFULLYEXITSLAST));
+  rb_const_set(mLaunchJobKey, rb_intern("LOWPRIORITYIO"),
+      rb_str_new2(LAUNCH_JOBKEY_LOWPRIORITYIO));
+  rb_const_set(mLaunchJobKey, rb_intern("SESSIONCREATE"),
+      rb_str_new2(LAUNCH_JOBKEY_SESSIONCREATE));
+  rb_const_set(mLaunchJobKey, rb_intern("STARTONMOUNT"),
+      rb_str_new2(LAUNCH_JOBKEY_STARTONMOUNT));
+  rb_const_set(mLaunchJobKey, rb_intern("SOFTRESOURCELIMITS"),
+      rb_str_new2(LAUNCH_JOBKEY_SOFTRESOURCELIMITS));
+  rb_const_set(mLaunchJobKey, rb_intern("HARDRESOURCELIMITS"),
+      rb_str_new2(LAUNCH_JOBKEY_HARDRESOURCELIMITS));
+  rb_const_set(mLaunchJobKey, rb_intern("STANDARDINPATH"),
+      rb_str_new2(LAUNCH_JOBKEY_STANDARDINPATH));
+  rb_const_set(mLaunchJobKey, rb_intern("STANDARDOUTPATH"),
+      rb_str_new2(LAUNCH_JOBKEY_STANDARDOUTPATH));
+  rb_const_set(mLaunchJobKey, rb_intern("STANDARDERRORPATH"),
+      rb_str_new2(LAUNCH_JOBKEY_STANDARDERRORPATH));
+  rb_const_set(mLaunchJobKey, rb_intern("DEBUG"),
+      rb_str_new2(LAUNCH_JOBKEY_DEBUG));
+  rb_const_set(mLaunchJobKey, rb_intern("WAITFORDEBUGGER"),
+      rb_str_new2(LAUNCH_JOBKEY_WAITFORDEBUGGER));
+  rb_const_set(mLaunchJobKey, rb_intern("QUEUEDIRECTORIES"),
+      rb_str_new2(LAUNCH_JOBKEY_QUEUEDIRECTORIES));
+  rb_const_set(mLaunchJobKey, rb_intern("WATCHPATHS"),
+      rb_str_new2(LAUNCH_JOBKEY_WATCHPATHS));
+  rb_const_set(mLaunchJobKey, rb_intern("STARTINTERVAL"),
+      rb_str_new2(LAUNCH_JOBKEY_STARTINTERVAL));
+  rb_const_set(mLaunchJobKey, rb_intern("STARTCALENDARINTERVAL"),
+      rb_str_new2(LAUNCH_JOBKEY_STARTCALENDARINTERVAL));
+  rb_const_set(mLaunchJobKey, rb_intern("BONJOURFDS"),
+      rb_str_new2(LAUNCH_JOBKEY_BONJOURFDS));
+  rb_const_set(mLaunchJobKey, rb_intern("LASTEXITSTATUS"),
+      rb_str_new2(LAUNCH_JOBKEY_LASTEXITSTATUS));
+  rb_const_set(mLaunchJobKey, rb_intern("PID"),
+      rb_str_new2(LAUNCH_JOBKEY_PID));
+  rb_const_set(mLaunchJobKey, rb_intern("THROTTLEINTERVAL"),
+      rb_str_new2(LAUNCH_JOBKEY_THROTTLEINTERVAL));
+  rb_const_set(mLaunchJobKey, rb_intern("LAUNCHONLYONCE"),
+      rb_str_new2(LAUNCH_JOBKEY_LAUNCHONLYONCE));
+  rb_const_set(mLaunchJobKey, rb_intern("ABANDONPROCESSGROUP"),
+      rb_str_new2(LAUNCH_JOBKEY_ABANDONPROCESSGROUP));
+  rb_const_set(mLaunchJobKey, rb_intern("IGNOREPROCESSGROUPATSHUTDOWN"),
+      rb_str_new2(LAUNCH_JOBKEY_IGNOREPROCESSGROUPATSHUTDOWN));
+  rb_const_set(mLaunchJobKey, rb_intern("POLICIES"),
+      rb_str_new2(LAUNCH_JOBKEY_POLICIES));
+  rb_const_set(mLaunchJobKey, rb_intern("ENABLETRANSACTIONS"),
+      rb_str_new2(LAUNCH_JOBKEY_ENABLETRANSACTIONS));
+
+  rb_const_set(mLaunchJobKey, rb_intern("MACH_RESETATCLOSE"),
+      rb_str_new2(LAUNCH_JOBKEY_MACH_RESETATCLOSE));
+  rb_const_set(mLaunchJobKey, rb_intern("MACH_HIDEUNTILCHECKIN"),
+      rb_str_new2(LAUNCH_JOBKEY_MACH_HIDEUNTILCHECKIN));
+  rb_const_set(mLaunchJobKey, rb_intern("MACH_DRAINMESSAGESONCRASH"),
+      rb_str_new2(LAUNCH_JOBKEY_MACH_DRAINMESSAGESONCRASH));
+
+  rb_const_set(mLaunchJobKey, rb_intern("KEEPALIVE_SUCCESSFULEXIT"),
+      rb_str_new2(LAUNCH_JOBKEY_KEEPALIVE_SUCCESSFULEXIT));
+  rb_const_set(mLaunchJobKey, rb_intern("KEEPALIVE_NETWORKSTATE"),
+      rb_str_new2(LAUNCH_JOBKEY_KEEPALIVE_NETWORKSTATE));
+  rb_const_set(mLaunchJobKey, rb_intern("KEEPALIVE_PATHSTATE"),
+      rb_str_new2(LAUNCH_JOBKEY_KEEPALIVE_PATHSTATE));
+  rb_const_set(mLaunchJobKey, rb_intern("KEEPALIVE_OTHERJOBACTIVE"),
+      rb_str_new2(LAUNCH_JOBKEY_KEEPALIVE_OTHERJOBACTIVE));
+  rb_const_set(mLaunchJobKey, rb_intern("KEEPALIVE_OTHERJOBENABLED"),
+      rb_str_new2(LAUNCH_JOBKEY_KEEPALIVE_OTHERJOBENABLED));
+  rb_const_set(mLaunchJobKey, rb_intern("KEEPALIVE_AFTERINITIALDEMAND"),
+      rb_str_new2(LAUNCH_JOBKEY_KEEPALIVE_AFTERINITIALDEMAND));
+
+  rb_const_set(mLaunchJobKey, rb_intern("CAL_MINUTE"),
+      rb_str_new2(LAUNCH_JOBKEY_CAL_MINUTE));
+  rb_const_set(mLaunchJobKey, rb_intern("CAL_HOUR"),
+      rb_str_new2(LAUNCH_JOBKEY_CAL_HOUR));
+  rb_const_set(mLaunchJobKey, rb_intern("CAL_DAY"),
+      rb_str_new2(LAUNCH_JOBKEY_CAL_DAY));
+  rb_const_set(mLaunchJobKey, rb_intern("CAL_WEEKDAY"),
+      rb_str_new2(LAUNCH_JOBKEY_CAL_WEEKDAY));
+  rb_const_set(mLaunchJobKey, rb_intern("CAL_MONTH"),
+      rb_str_new2(LAUNCH_JOBKEY_CAL_MONTH));
+
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_CORE"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_CORE));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_CPU"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_CPU));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_DATA"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_DATA));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_FSIZE"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_FSIZE));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_MEMLOCK"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_MEMLOCK));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_NOFILE"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_NOFILE));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_NPROC"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_NPROC));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_RSS"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_RSS));
+  rb_const_set(mLaunchJobKey, rb_intern("RESOURCELIMIT_STACK"),
+      rb_str_new2(LAUNCH_JOBKEY_RESOURCELIMIT_STACK));
+
+  rb_const_set(mLaunchJobKey, rb_intern("DISABLED_MACHINETYPE"),
+      rb_str_new2(LAUNCH_JOBKEY_DISABLED_MACHINETYPE));
+  rb_const_set(mLaunchJobKey, rb_intern("DISABLED_MODELNAME"),
+      rb_str_new2(LAUNCH_JOBKEY_DISABLED_MODELNAME));
+
+  /*
+   * Launch::Socket holds various socket keys
+   */
+  mLaunchSocket = rb_define_module_under(mLaunch, "Socket");
+  rb_const_set(mLaunchSocket, rb_intern("TYPE"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_TYPE));
+  rb_const_set(mLaunchSocket, rb_intern("PASSIVE"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_PASSIVE));
+  rb_const_set(mLaunchSocket, rb_intern("BONJOUR"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_BONJOUR));
+  rb_const_set(mLaunchSocket, rb_intern("SECUREWITHKEY"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_SECUREWITHKEY));
+  rb_const_set(mLaunchSocket, rb_intern("PATHNAME"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_PATHNAME));
+  rb_const_set(mLaunchSocket, rb_intern("PATHMODE"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_PATHMODE));
+  rb_const_set(mLaunchSocket, rb_intern("NODENAME"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_NODENAME));
+  rb_const_set(mLaunchSocket, rb_intern("SERVICENAME"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_SERVICENAME));
+  rb_const_set(mLaunchSocket, rb_intern("FAMILY"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_FAMILY));
+  rb_const_set(mLaunchSocket, rb_intern("PROTOCOL"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_PROTOCOL));
+  rb_const_set(mLaunchSocket, rb_intern("MULTICASTGROUP"),
+      rb_str_new2(LAUNCH_JOBSOCKETKEY_MULTICASTGROUP));
+
+  /*
+   * Launch::JobPolicy holds the job policy keys
+   */
+  mLaunchJobPolicy = rb_define_module_under(mLaunch, "JobPolicy");
+  rb_const_set(mLaunchJobPolicy, rb_intern("DENYCREATINGOTHERJOBS"),
+      rb_str_new2(LAUNCH_JOBPOLICY_DENYCREATINGOTHERJOBS));
+}

data/lib/launch.rb

@@ -0,0 +1,86 @@
+##
+# Launch is a wrapper for the launch(3) API for daemons and agents spawned by
+# launchd(8).
+#
+# Launch agents and daemons MUST NOT:
+#
+# * Call daemon(3)
+# * Do the equivalent of daemon(3) by calling fork and having the parent exit
+#
+# Launch agents and daemons SHOULD NOT do the following as part of their
+# starup initialization:
+#
+# * Set the user ID or group ID (Process::Sys.setuid, Process::Sys.setgid and
+#   friends)
+# * Setup the working directory (Dir.chdir)
+# * chroot(2)
+# * setsid(2) (Process.setsid)
+# * Close "stray" file descriptors
+# * Change stdio(3) to /dev/null (STDOUT.reopen and friends)
+# * Setup resource limits with setrusage (Process.setrlimit)
+# * Ignore the SIGTERM signal (trap 'TERM', 'IGNORE')
+#
+# The above is from launchd.plist(5).  Please read it for further details.
+#
+# To shut down cleanly <tt>trap 'TERM'</tt> and perform any shutdown steps
+# before exiting.
+
+module Launch
+
+  ##
+  # The version of launch you are using
+
+  VERSION = '1.0'
+
+  ##
+  # Checks in with launch and retrieves the agent's configuration.  The
+  # configuration can be retrieved later through <tt>@launch_checkin<tt>.
+
+  def launch_checkin
+    response = launch_message Launch::Key::CHECKIN
+
+    return if response.nil?
+
+    @launch_checkin = response
+  end
+
+  ##
+  # Creates ruby sockets from the sockets list in +name+.
+  # <tt>socket_class.for_fd</tt> is called for each socket in the named list.
+  #
+  # +name+ comes from the socket's name key in the launchd plist.
+  #
+  # Example plist Sockets dictionary:
+  #
+  #  <key>Sockets</key>
+  #  <dict>
+  #    <key>EchoSocket</key>
+  #    <dict>
+  #      <key>SockServiceName</key>
+  #      <string>12345</string>
+  #    </dict>
+  #  </dict>
+  #
+  # Example call:
+  #
+  #   servers = launch_sockets 'Echo', TCPServer
+  #
+  #   p servers.map { |server| server.addr }
+
+  def launch_sockets name, socket_class
+    require 'socket'
+
+    sockets = @launch_checkin[Launch::JobKey::SOCKETS][name]
+
+    raise Error, "no sockets found for #{name.inspect}" unless sockets
+
+    sockets.map do |fd|
+      socket_class.for_fd fd
+    end
+  end
+
+end
+
+require 'launch/launch'
+require 'socket'
+

data/lib/launch/webrick.rb

@@ -0,0 +1,78 @@
+require 'launch'
+require 'webrick'
+
+##
+# Launch::WEBrickHTTPServer adds launchd support to WEBrick.
+#
+# To use, replace WEBrick::HTTPServer with Launch::WEBrickHTTPServer.
+#
+# By default Launch::WEBrickHTTPServer expects to find the socket list under
+# <tt>'WEBrickSockets'</tt> but this may be overridden through the
+# +:LaunchdSockets+ option.
+#
+# The server will automatically shut down when a TERM signal is sent.  If you
+# wish to perform other shutdown actions override TERM but be sure to shut
+# down webrick.
+#
+# An example WEBrick server using Launch::WEBrickHTTPServer would be:
+#
+#   require 'launch/webrick'
+#
+#   Launch::WEBrickHTTPServer.new(:DocumentRoot => ARGV.shift).start
+#
+# Here is an example plist for this server which listens on port 8000:
+#
+#   <?xml version="1.0" encoding="UTF-8"?>
+#   <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+#   <plist version="1.0">
+#   <dict>
+#     <key>Label</key>
+#     <string>net.segment7.launch.webrick</string>
+#     <key>ProgramArguments</key>
+#     <array>
+#       <string>/path/to/ruby</string>
+#       <string>/path/to/webrick</string>
+#       <string>/Users/your_user/Sites</string>
+#     </array>
+#     <key>ServiceIPC</key>
+#     <true/>
+#     <key>Sockets</key>
+#     <dict>
+#       <key>WEBrickSockets</key>
+#       <dict>
+#         <key>SockServiceName</key>
+#         <string>8000</string>
+#       </dict>
+#     </dict>
+#   </dict>
+#   </plist>
+
+class Launch::WEBrickHTTPServer < WEBrick::HTTPServer
+  
+  include Launch
+
+  ##
+  # Initializes an HTTP server with +options+ and set the server's listeners
+  # using Launch.  A TERM handler to shut down the server is automatically
+  # set.
+  #
+  # +:LaunchdSockets+ may be set to change the socket key from the default of
+  # <tt>'WEBrickSockets'</tt>
+
+  def initialize options = {}
+    options[:DoNotListen] = true
+    sockets_key = options.delete(:LaunchdSockets) || 'WEBrickSockets'
+
+    super
+
+    launch_checkin
+
+    servers = launch_sockets sockets_key, TCPServer
+
+    listeners.replace servers
+
+    trap 'TERM' do shutdown end
+  end
+
+end
+

data/sample/echo.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'launch'
+
+##
+# This is an echo server that runs using launchd on port 12345.
+#
+# To start, run:
+#
+#   ruby echo.rb net.segment7.launch.echo.plist
+#   launchctl load net.segment7.launch.echo.plist
+#
+# To use the echo server run:
+#
+#   telnet localhost 12345
+#
+# To quit the echo server type ^] followed by ^D
+#
+# To stop run:
+#
+#   launchctl unload net.segment7.launch.echo.plist
+
+class Echo
+
+  include Launch
+
+  def self.plist name
+    file = File.expand_path __FILE__
+    root = File.expand_path '../..', __FILE__
+
+    plist = <<-PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>#{name}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>#{Gem.ruby}</string>
+    <string>-I#{root}/lib</string>
+    <string>-I#{root}/ext</string>
+    <string>#{file}</string>
+  </array>
+  <key>ServiceIPC</key>
+  <true/>
+  <key>Sockets</key>
+  <dict>
+    <key>EchoSocket</key>
+    <dict>
+      <key>SockServiceName</key>
+      <string>12345</string>
+    </dict>
+  </dict>
+</dict>
+</plist>
+    PLIST
+
+    open name, 'w' do |io|
+      io.write plist
+    end
+  end
+
+  def initialize
+    launch_checkin
+  end
+
+  ##
+  # echo lines sent from +socket+
+
+  def echo socket
+    Thread.start do
+      loop do
+        socket.puts socket.gets
+      end
+    end
+  end
+
+  ##
+  # Listens on +server+ for connections to echo on.
+
+  def listen server
+    Thread.start do
+      loop do
+        echo server.accept
+      end
+    end
+  end
+
+  ##
+  # Starts listening on the sockets given by launchd and waits forever
+
+  def run
+    launch_sockets('EchoSocket', TCPServer).each do |server|
+      listen server
+    end
+
+    sleep
+  end
+
+end
+
+if ARGV.empty? then
+  Echo.new.run
+else
+  Echo.plist ARGV.first
+end
+

data/test/test_launch.rb

@@ -0,0 +1,55 @@
+require 'minitest/autorun'
+require 'launch'
+
+class TestLaunch < MiniTest::Unit::TestCase
+
+  include Launch
+
+  def launch_message message
+    @message = message
+
+    return { 'response' => 'hash' }
+  end
+
+  def test_launch_checkin
+    response = launch_checkin
+
+    assert_equal Launch::Key::CHECKIN, @message
+
+    expected = { 'response' => 'hash' }
+
+    assert_equal expected, response
+    assert_equal expected, @launch_checkin
+  end
+
+  def test_launch_sockets
+    @launch_checkin = {
+      Launch::JobKey::SOCKETS => {
+        'MySockets' => [STDIN.to_i, STDOUT.to_i]
+      }
+    }
+
+    sockets = launch_sockets 'MySockets', IO
+
+    assert_equal 2, sockets.length
+
+    assert_instance_of IO, sockets.first
+    assert_instance_of IO, sockets.last
+
+    assert_equal [0, 1], sockets.map { |io| io.to_i }
+  end
+
+  def test_launch_sockets_none
+    @launch_checkin = {
+      Launch::JobKey::SOCKETS => {
+      }
+    }
+
+    e = assert_raises Launch::Error do
+      launch_sockets 'NoSockets', IO
+    end
+
+    assert_equal 'no sockets found for "NoSockets"', e.message
+  end
+
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification 
+name: launch
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- Eric Hodel
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMRAwDgYDVQQDDAdkcmJy
+  YWluMRgwFgYKCZImiZPyLGQBGRYIc2VnbWVudDcxEzARBgoJkiaJk/IsZAEZFgNu
+  ZXQwHhcNMDcxMjIxMDIwNDE0WhcNMDgxMjIwMDIwNDE0WjBBMRAwDgYDVQQDDAdk
+  cmJyYWluMRgwFgYKCZImiZPyLGQBGRYIc2VnbWVudDcxEzARBgoJkiaJk/IsZAEZ
+  FgNuZXQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCbbgLrGLGIDE76
+  LV/cvxdEzCuYuS3oG9PrSZnuDweySUfdp/so0cDq+j8bqy6OzZSw07gdjwFMSd6J
+  U5ddZCVywn5nnAQ+Ui7jMW54CYt5/H6f2US6U0hQOjJR6cpfiymgxGdfyTiVcvTm
+  Gj/okWrQl0NjYOYBpDi+9PPmaH2RmLJu0dB/NylsDnW5j6yN1BEI8MfJRR+HRKZY
+  mUtgzBwF1V4KIZQ8EuL6I/nHVu07i6IkrpAgxpXUfdJQJi0oZAqXurAV3yTxkFwd
+  g62YrrW26mDe+pZBzR6bpLE+PmXCzz7UxUq3AE0gPHbiMXie3EFE0oxnsU3lIduh
+  sCANiQ8BAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+  BBS5k4Z75VSpdM0AclG2UvzFA/VW5DANBgkqhkiG9w0BAQUFAAOCAQEAHagT4lfX
+  kP/hDaiwGct7XPuVGbrOsKRVD59FF5kETBxEc9UQ1clKWngf8JoVuEoKD774dW19
+  bU0GOVWO+J6FMmT/Cp7nuFJ79egMf/gy4gfUfQMuvfcr6DvZUPIs9P/TlK59iMYF
+  DIOQ3DxdF3rMzztNUCizN4taVscEsjCcgW6WkUJnGdqlu3OHWpQxZBJkBTjPCoc6
+  UW6on70SFPmAy/5Cq0OJNGEWBfgD9q7rrs/X8GGwUWqXb85RXnUVi/P8Up75E0ag
+  14jEc90kN+C7oI/AGCBN0j6JnEtYIEJZibjjDJTSMWlUKKkj30kq7hlUC2CepJ4v
+  x52qPcexcYZR7w==
+  -----END CERTIFICATE-----
+
+date: 2011-02-27 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 0
+        - 2
+        version: 2.0.2
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 7
+        version: "0.7"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 2
+        - 9
+        - 0
+        version: 2.9.0
+  type: :development
+  version_requirements: *id003
+description: |-
+  Launch allows agents and daemons launched by launchd to retrieve their list of
+  sockets.  Launchd is an open source framework for launching and managing
+  daemons, programs and scripts provided by Apple.
+email: 
+- drbrain@segment7.net
+executables: []
+
+extensions: 
+- ext/launch/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- ext/launch/extconf.rb
+- ext/launch/launch.c
+- lib/launch.rb
+- lib/launch/webrick.rb
+- sample/echo.rb
+- test/test_launch.rb
+- .gemtest
+has_rdoc: true
+homepage: https://github.com/drbrain/launch
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 55
+      segments: 
+      - 1
+      - 9
+      - 2
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: launch
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Launch allows agents and daemons launched by launchd to retrieve their list of sockets
+test_files: 
+- test/test_launch.rb

metadata.gz.sig

@@ -0,0 +1,2 @@
+}��K������g��1�OM��u+5��U#_�&���a�d�OO�f�A<yM��S��#�DE��~� �~&�wN$�H��[Ǽ�j?��E���5�s��ݍ�Ը3�q�+�����&��B"�j�������-{`��5�!���3�&~u��(���G�_8-����Yn��lF�>L�?';��*��
+�,F���:#@~�E�<�"�m8�a�b����q�vP�b/����v:�ZF��^E]��v�"#