packet 0.1.0 → 0.1.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2004-2007 Hemant Kumar
+
+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

@@ -242,6 +242,10 @@ end
   reasonably well. Mongrel, running on top of Packet is a tad
   slower than Mongrel running on top of EventMachine. More benchmarks coming soon.
 
+== SVN repo:
+   Code for packet is on google code, svn repo is:
+   http://packet.googlecode.com/svn/trunk/
+
 == Credits
   Francis for awesome EventMachine lib, which has constantly acted as an inspiration.
   Ezra, for being a early user and porting mongrel to run on top of packet      

data/Rakefile

@@ -6,6 +6,7 @@ require 'rake/rdoctask'
 require 'rake/testtask'
 require 'spec/rake/spectask'
 require 'fileutils'
+
 def __DIR__
   File.dirname(__FILE__)
 end
@@ -31,7 +32,7 @@ task :doc => [:rdoc]
 
 
 Rake::RDocTask.new do |rdoc|
-      files = ['README', 'LICENSE', 'CHANGELOG',
+      files = ['README', 'MIT-LICENSE', 'CHANGELOG',
                'lib/**/*.rb']
       rdoc.rdoc_files.add(files)
       rdoc.main = 'README'
@@ -45,20 +46,19 @@ spec = Gem::Specification.new do |s|
   s.version = Packet::VERSION
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.extra_rdoc_files = ["README", "MIT-LICENSE", 'TODO']
   #s.rdoc_options += RDOC_OPTS +
   #  ['--exclude', '^(app|uploads)']
-  s.summary = "Packet, Events... we got em."
+  s.summary = "Packet, A Pure Ruby library for Event Driven Network Programming."
   s.description = s.summary
-  s.author = "Hemant"
-  s.email = 'foo@bar.com'
+  s.author = "Hemant Kumar"
+  s.email = 'mail@gnufied.org'
   s.homepage = 'http://code.google.com/p/packet/'
-  s.required_ruby_version = '>= 1.8.4'
+  s.required_ruby_version = '>= 1.8.5'
 
-  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{bin,spec,lib,examples,script}/**/*")
+  s.files = %w(MIT-LICENSE README Rakefile TODO) + Dir.glob("{spec,lib,examples}/**/*")
 
   s.require_path = "lib"
-  s.bindir = "bin"
 end
 
 Rake::GemPackageTask.new(spec) do |p|
@@ -85,3 +85,11 @@ task :svn_add do
 end
 
 
+desc "Converts a YAML file into a test/spec skeleton"
+task :yaml_to_spec do
+  require 'yaml'
+
+  puts YAML.load_file(ENV['FILE']||!puts("Pass in FILE argument.")&&exit).inject(''){|t,(c,s)|
+    t+(s ?%.context "#{c}" do.+s.map{|d|%.\n  xspecify "#{d}" do\n  end\n.}*''+"end\n\n":'')
+  }.strip
+end

data/TODO

@@ -0,0 +1,8 @@
+* Overview *
+** TODO Implement ability to have a pool of workers.
+** TODO Remove class and class instance attributes from core classes.
+** TODO Cleanup callback mechanism
+** TODO Implement a sample worker, which provides capabilities to execute mysql statements async.
+
+
+

data/examples/asteroid.c

@@ -0,0 +1,296 @@
+/* --------------------------------------------------------------------------
+ * Asteroid ruby extension.
+ *   by Genki Takiuchi <takiuchi@drecom.co.jp>
+ * -------------------------------------------------------------------------- */
+#include <ruby.h>
+#include <rubysig.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include "extconf.h"
+#include "asteroid.h"
+
+/* -------------------------------------------------------------------------- 
+ * epoll / kqueue
+ * - 2007/03/09 *BSD kqueue port, Mac OS X MSG_NOSIGNAL missing.
+ *   (Takanori Ishikawa)
+ * -------------------------------------------------------------------------- */
+#ifdef HAVE_SYS_EVENT_H
+#include <sys/event.h>
+typedef int asteroid_pollfd_t;
+typedef struct kevent asteroid_poll_event_t;
+#endif
+
+#ifdef HAVE_SYS_EPOLL_H
+#include <sys/epoll.h>
+typedef int asteroid_pollfd_t;
+typedef struct epoll_event asteroid_poll_event_t;
+#endif
+
+static asteroid_pollfd_t asteroid_poll_create(int sizeHint) {
+#ifdef HAVE_SYS_EVENT_H
+  return kqueue();
+#endif
+#ifdef HAVE_SYS_EPOLL_H
+  return epoll_create(sizeHint);
+#endif
+}
+
+static int asteroid_poll_add(
+  asteroid_pollfd_t pollfd,
+  asteroid_poll_event_t *event,
+  int fd) {
+#ifdef HAVE_SYS_EVENT_H
+  EV_SET(event, fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
+  return kevent(pollfd, event, 1, NULL, 0, NULL);
+#endif
+#ifdef HAVE_SYS_EPOLL_H
+  event->events = (EPOLLIN | EPOLLPRI);
+  event->data.fd = fd;
+  return epoll_ctl(pollfd, EPOLL_CTL_ADD, fd, event);
+#endif
+}
+
+static int asteroid_poll_remove(
+  asteroid_pollfd_t pollfd,
+  asteroid_poll_event_t *event,
+  int fd) {
+#ifdef HAVE_SYS_EVENT_H
+  EV_SET(event, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
+  return kevent(pollfd, event, 1, NULL, 0, NULL);
+#endif
+#ifdef HAVE_SYS_EPOLL_H
+  return epoll_ctl(pollfd, EPOLL_CTL_DEL, fd, event);
+#endif
+}
+
+static int asteroid_poll_wait(
+  asteroid_pollfd_t pollfd,
+  asteroid_poll_event_t *events,
+  int maxevents,
+  int timeout) {
+#ifdef HAVE_SYS_EVENT_H
+  struct timespec tv, *tvptr;
+  if (timeout < 0) {
+    tvptr = NULL;
+  }
+  else {
+    tv.tv_sec = (long) (timeout/1000);
+    tv.tv_nsec = (long) (timeout%1000)*1000;
+    tvptr = &tv;
+  }
+  return kevent(pollfd, NULL, 0, events, maxevents, tvptr);
+#endif
+#ifdef HAVE_SYS_EPOLL_H
+  return epoll_wait(pollfd, events, maxevents, timeout);
+#endif
+}
+
+#ifdef HAVE_SYS_EVENT_H
+  #define AST_POLL_EVENT_SOCK(event) ((event)->ident)
+  #define AST_POLL_EVENT_CAN_READ(event) ((event)->filter == EVFILT_READ)
+#endif
+#ifdef HAVE_SYS_EPOLL_H
+  #define AST_POLL_EVENT_SOCK(event) ((event)->data.fd)
+  #define AST_POLL_EVENT_CAN_READ(event) ((event)->events & (EPOLLIN|EPOLLPRI))
+#endif
+
+#ifdef SO_NOSIGPIPE
+#ifndef MSG_NOSIGNAL
+#define MSG_NOSIGNAL 0
+#endif
+
+/*
+ * The preferred method on Mac OS X (10.2 and later) to prevent SIGPIPEs when
+ * sending data to a dead peer (instead of relying on the 4th argument to send
+ * being MSG_NOSIGNAL). Possibly also existing and in use on other BSD
+ * systems? 
+ *
+ * curl-7.15.5/lib/connect.c 
+ */
+
+static void nosigpipe(int sockfd) {
+  int one = 1;
+  setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&one, sizeof(one));
+}
+#else
+#define nosigpipe(x)
+#endif
+
+#define MAX_CONNECTION  (102400)
+#define EVENT_BUF_SIZE  (1024)
+
+static VALUE Asteroid;
+static VALUE clients;
+static volatile int running = 0;
+static asteroid_pollfd_t epoll_fd = 0;
+static asteroid_poll_event_t events[EVENT_BUF_SIZE];
+
+int dispatch();
+void runtime_error();
+
+void Init_asteroid(){
+  Asteroid = rb_define_module("Asteroid");
+  rb_define_singleton_method(Asteroid, "run", asteroid_s_run, 3);
+  rb_define_singleton_method(Asteroid, "stop", asteroid_s_stop, 0);
+  rb_define_singleton_method(Asteroid, "now", asteroid_s_now, 0);
+  rb_define_class_variable(Asteroid, "@@clients", clients = rb_hash_new());
+}
+
+static VALUE close_socket_proc(VALUE Pair, VALUE Arg, VALUE Self) {
+  close(FIX2INT(RARRAY(Pair)->ptr[0]));
+  return Qnil;
+}
+
+static VALUE asteroid_s_run(VALUE Self, VALUE Host, VALUE Port, VALUE Module){
+  char *host = StringValuePtr(Host);
+  int port = FIX2INT(Port);
+  
+  epoll_fd = asteroid_poll_create(1024);
+  if(epoll_fd == -1) runtime_error();
+
+  struct sockaddr_in addr;
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(port);
+  addr.sin_addr.s_addr = inet_addr(host);
+  int s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP), c, one = 1;
+  if(s == -1) runtime_error();
+  fcntl(s, F_SETFL, fcntl(s, F_GETFL, 0) | O_NONBLOCK);
+  setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+  nosigpipe(s);
+  if(bind(s, (struct sockaddr*)&addr, sizeof(addr)) != 0) runtime_error();
+  if(listen(s, MAX_CONNECTION) != 0) runtime_error();
+  if(rb_block_given_p()) rb_yield(Qnil);
+  
+  VALUE Class = rb_define_class_under(Asteroid, "Server", rb_cObject);
+  rb_define_method(Class, "send_data",
+    asteroid_server_send_data, 1);
+  rb_define_method(Class, "write_and_close",
+    asteroid_server_write_and_close, 0);
+  rb_include_module(Class, Module);
+  // Mac OS X, Fedora needs explicit rb_thread_schedule call.
+  for(running = 1; running; rb_thread_schedule()){
+    socklen_t len = sizeof(addr);
+    while((c = accept(s, (struct sockaddr*)&addr, &len)) != -1){
+      printf("A New client connected here\n");
+      fcntl(c, F_SETFL, fcntl(c, F_GETFL, 0) | O_NONBLOCK);
+      asteroid_poll_event_t event;
+      memset(&event, 0, sizeof(event));
+      if(asteroid_poll_add(epoll_fd, &event, c) == -1) runtime_error();
+      // instantiate server class which responds to client.
+      VALUE Server = rb_class_new_instance(0, NULL, Class);
+      rb_iv_set(Server, "@fd", rb_fix_new(c));
+      rb_hash_aset(clients, rb_fix_new(c), Server);
+      if(rb_respond_to(Server, rb_intern("post_init"))){
+        rb_funcall(Server, rb_intern("post_init"), 0);
+      }
+    }
+    if(dispatch() != 0) asteroid_s_stop(Asteroid);
+    // You must call them to give a chance for ruby to handle system events.
+    // CHECK_INTS;
+  }
+
+  rb_iterate(rb_each, clients, close_socket_proc, Qnil);
+  rb_funcall(clients, rb_intern("clear"), 0);
+  close(s);
+  close(epoll_fd);
+  return Qnil;
+}
+
+static VALUE asteroid_s_stop(VALUE Self){
+  running = 0;
+  return Qnil;
+}
+
+static VALUE asteroid_s_now(VALUE Self){
+  struct timeval now;
+  gettimeofday(&now, NULL);
+  return rb_float_new(now.tv_sec + now.tv_usec/1000000.0);
+}
+
+static VALUE asteroid_server_send_data(VALUE Self, VALUE Data){
+  VALUE Fd = rb_iv_get(Self, "@fd");
+  int fd = FIX2INT(Fd), remain = RSTRING(Data)->as.heap.len, len, trial = 100;
+  char *data = StringValuePtr(Data);
+  while(remain){
+    len = send(fd, data, remain, MSG_DONTWAIT|MSG_NOSIGNAL);
+    if(len == -1){
+      if(errno == EAGAIN && --trial){
+        rb_thread_schedule();
+        // CHECK_INTS;
+      }else{
+        if(rb_respond_to(Self, rb_intern("unbind"))){
+          rb_funcall(Self, rb_intern("unbind"), 0);
+        }
+        return Qnil;
+      }
+    }else{
+      remain -= len;
+      data += len;
+    }
+  }
+  return Qtrue;
+}
+
+static VALUE asteroid_server_write_and_close(VALUE Self){
+  VALUE Fd = rb_iv_get(Self, "@fd");
+  int fd = FIX2INT(Fd);
+  char buf[1];
+  if(read(fd, buf, 1) == -1 && errno != EAGAIN){
+    if(rb_respond_to(Self, rb_intern("unbind"))){
+      rb_funcall(Self, rb_intern("unbind"), 0);
+    }
+  }
+  asteroid_poll_event_t event;
+  memset(&event, 0, sizeof(event));
+  asteroid_poll_remove(epoll_fd, &event, fd);
+  close(fd);
+  rb_hash_delete(clients, Fd);
+  return Qnil;
+}
+
+int dispatch(){
+  int i, s, len;
+  while(1){
+    TRAP_BEG;
+    s = asteroid_poll_wait(epoll_fd, events, EVENT_BUF_SIZE, 1);
+    TRAP_END;
+    if(s <= 0) break;
+    for(i = 0; i < s; ++i){
+      asteroid_poll_event_t event = events[i];
+      int fd = AST_POLL_EVENT_SOCK(&event);
+      VALUE Fd = rb_fix_new(fd);
+      VALUE Server = rb_hash_aref(clients, Fd);
+      if(AST_POLL_EVENT_CAN_READ(&event)){
+        VALUE Buf = rb_str_new("", 0);
+        char buf[1024];
+        while((len = read(fd, buf, 1023)) > 0){
+          buf[len] = '\0';
+          rb_str_concat(Buf, rb_str_new2(buf));
+        }
+        if(len == -1 && errno == EAGAIN){
+          if(rb_respond_to(Server, rb_intern("receive_data"))){
+            rb_funcall(Server, rb_intern("receive_data"), 1, Buf);
+          }
+        }else{
+          if(rb_respond_to(Server, rb_intern("unbind"))){
+            rb_funcall(Server, rb_intern("unbind"), 0);
+          }
+          asteroid_poll_remove(epoll_fd, &event, fd);
+          rb_hash_delete(clients, Fd);
+          close(fd);
+        }
+      }
+    }
+  }
+  return 0;
+}
+
+void runtime_error(){
+  rb_raise(rb_eRuntimeError, strerror(errno));
+}

data/examples/asteroid.h

@@ -0,0 +1,5 @@
+static VALUE asteroid_s_run(VALUE Self, VALUE Host, VALUE Port, VALUE Module);
+static VALUE asteroid_s_stop(VALUE Self);
+static VALUE asteroid_s_now(VALUE Self);
+static VALUE asteroid_server_send_data(VALUE Self, VALUE Data);
+static VALUE asteroid_server_write_and_close(VALUE Self);

data/examples/concurrent_thread.c

@@ -0,0 +1,53 @@
+#include <ruby.h>
+#include <rubysig.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+static VALUE ConcurrentThread;
+static VALUE ConcurrentThreadPool;
+
+static void count_to_10000(void* data){
+  int i = 0;
+  for( i = 0; i < 10000; i++ ) {
+    if ((*(VALUE *)data) == Qtrue) break;
+    printf("Currently Counting from thr 1: %d\n",i);
+  }
+}
+
+static void count_to_20000(void* data){
+  int i = 0;
+  for( i = 0; i < 10000; i++ ) {
+    if ((*(VALUE *)data) == Qtrue) break;
+    printf("Currently Counting from thr 2: %d\n",i);
+  }
+}
+
+static void stop_thr1(void* data) {
+  printf("Calling thread1 break method\n");
+  *((VALUE *)data) = Qtrue;
+}
+
+static void stop_thr2(void* data) {
+  printf("Calling thread2 break method\n");
+  *((VALUE *)data) = Qtrue;
+}
+
+static VALUE rb_concurrent_thread_method(VALUE self)
+{
+  VALUE interrupt_flag;
+  VALUE interrupt_flag2;
+  rb_thread_blocking_region(count_to_10000,&interrupt_flag,stop_thr1,&interrupt_flag);
+  rb_thread_blocking_region(count_to_20000,&interrupt_flag2,stop_thr2,&interrupt_flag2);
+}
+
+
+void Init_concurrent_thread(){
+  ConcurrentThread = rb_define_class("ConcurrentThread",rb_cObject);
+  rb_define_method(ConcurrentThread,"defer",rb_concurrent_thread_method,0);
+}