shooting_star 1.0.3

data/History.txt

@@ -0,0 +1,42 @@
+*** 1.0.3 / 2007-03-22
++ 2 major enhancements:
+  + Rails plugin is installed when shooting_star init.
+  + Implemented logging.
++ 1 major bug fix:
+  + Fixed execution queuing and flashing.
++ 3 minor enhancements:
+  + Suppressed warnings reported while installing gem.
+  + Added simple documentation.
+  + Independent from pthread.
++ 1 minor bug fix:
+  + encodeURIComponent() is used for escaping tag list instead of escape().
+
+*** 1.0.2 / 2007-03-16
++ 1 major enhancement:
+  + Separated notification by tag grouping.
+  
+*** 1.0.1 / 2007-03-12
++ 2 major enhancements:
+  + Corrected management of sessions.
+  + Added implementation using kqueue (Thank you Takanori Ishikawa!)
+
+*** 1.0.0 / 2007-03-09
++ 1 major enhancement:
+  + Supported tags in order to handle various events via single connection.
+
+*** 1.0.0 / 2007-02-27
++ 2 major enhancements:
+  + Added the ruby extension named Asteroid which is socket manager using epoll.
+  + Merged gem and rails app for testing.
+
+*** 0.0.3 / 2006-11-18
++ 2 major enhancements:
+  + Added function to initialize directory.
+  + Changed status code of execution response from 200 to 201.
++ 1 minor enhancements:
+  + Exploited better algorithm for reconnection.
+
+*** 0.0.2 / 2006-11-04
++ 2 major enhancements:
+  + Supported install_gem task.
+  + Converted Rakefile+gemspec to Hoe-based Rakefile.

data/Manifest.txt

@@ -0,0 +1,38 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/shooting_star
+lib/shooting_star.rb
+lib/shooting_star/server.rb
+lib/shooting_star/shooter.rb
+lib/shooting_star/channel.rb
+lib/shooting_star/config.rb
+lib/form_encoder.rb
+ext/asteroid.c
+ext/extconf.rb
+ext/asteroid.h
+test/test_helper.rb
+test/lib/shooting_star_test.rb
+test/lib/test_c10k_problem.c
+test/ext/asteroid_test.rb
+vendor
+vendor/plugins
+vendor/plugins/meteor_strike
+vendor/plugins/meteor_strike/README
+vendor/plugins/meteor_strike/Rakefile
+vendor/plugins/meteor_strike/init.rb
+vendor/plugins/meteor_strike/lib
+vendor/plugins/meteor_strike/lib/meteor_strike.rb
+vendor/plugins/meteor_strike/test
+vendor/plugins/meteor_strike/test/meteor_strike_test.rb
+vendor/plugins/meteor_strike/generators
+vendor/plugins/meteor_strike/generators/meteor
+vendor/plugins/meteor_strike/generators/meteor/meteor_generator.rb
+vendor/plugins/meteor_strike/generators/meteor/templates
+vendor/plugins/meteor_strike/generators/meteor/templates/controller.rb
+vendor/plugins/meteor_strike/generators/meteor/templates/model.rb
+vendor/plugins/meteor_strike/generators/meteor/templates/view.rhtml
+vendor/plugins/meteor_strike/generators/meteor/templates/migration.rb
+vendor/plugins/meteor_strike/generators/meteor/templates/unit_test.rb
+vendor/plugins/meteor_strike/generators/meteor/templates/functional_test.rb

data/README.txt

@@ -0,0 +1,80 @@
+shooting_star
+    by Genki Takiuchi <takiuchi@drecom.co.jp>
+    http://rails.office.drecom.jp/takiuchi/
+    http://labs.drecom.jp/
+
+== DESCRIPTION:
+
+Our goal is development of practical comet server which will be achieving
+over 100,000 simultaneous connections per host. On this purpose, we abandon
+portability and use system calls depending on particular OS such as epoll
+and kqueue.
+
+== FEATURES/PROBLEMS:
+
+* Comet server
+* Comet client implementation (Rails plugin)
+
+== SYNOPSYS:
+
+    shooting_star {init|restart|start|stat|stop} [options]
+
+      -f <config file>
+      -g                               debug mode.
+      -s                               silent mode.
+      -v, --version                    Show version.
+      -h, --help                       Show this message.
+
+    Options for subcommand `init':
+      -d <base dir>                    ShootingStarize directory.
+
+    Options for subcommand `start':
+      -d                               daemon mode.
+
+    Options for subcommand `stat':
+      -u                               with uid.
+      -s                               with signature.
+
+== REQUIREMENTS:
+
+* Linux or xBSD OS having epoll or kqueue.
+* Increase ulimit of nofile up to over 100,000.
+  (edit /etc/security/limits.conf file.)
+* prototype.js 1.5.0+
+* Ruby 1.8.5+
+* Ruby on Rails 1.2.0+
+
+== INSTALL:
+
+    $ sudo gem install shooting_star
+    $ cd /path/to/rails/root
+    $ shooting_star init
+    $ ./script/generate meteor
+
+And then, you need to configure config/shooting_star.yml and database.yml.
+See also vendor/plugins/meteor_strike/README.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Genki Takiuchi
+
+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,54 @@
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'tasks/rails'
+
+namespace :gem do
+  require 'hoe'
+
+  $: << './lib'
+  $: << './ext'
+  require 'shooting_star'
+
+  Hoe.new('shooting_star', ShootingStar::VERSION) do |hoe|
+    hoe.author = 'Genki Takiuchi'
+    hoe.email = 'takiuchi@drecom.co.jp'
+    hoe.description = 'Comet server.'
+    hoe.rubyforge_name = 'shooting-star'
+    hoe.summary = hoe.paragraphs_of('README.txt', 2)[0]
+    hoe.description = hoe.paragraphs_of('README.txt', 2..5).join("\n\n")
+    hoe.url = hoe.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+    hoe.changes = hoe.paragraphs_of('History.txt', 0..1).join("\n\n")
+    hoe.spec_extras = {
+      :extensions => 'ext/extconf.rb',
+      :rdoc_options => ['-S',
+        '--template', 'kilmer',
+        '--main', 'README.txt',
+        '--exclude', 'ext/asteroid',
+        'README.txt']
+    }
+  end
+end
+
+desc 'default gem task.'
+task :gem => 'gem:default'
+
+desc 'update generator template files.'
+task 'update_generator_template_files' do
+  templates = 'vendor/plugins/meteor_strike/generators/meteor/templates'
+  cp 'app/controllers/meteor_controller.rb',
+    templates + '/controller.rb'
+  cp 'app/models/meteor.rb',
+    templates + '/model.rb'
+  cp 'app/views/meteor/strike.rhtml',
+    templates + '/view.rhtml'
+  cp 'test/unit/meteor_test.rb',
+    templates + '/unit_test.rb'
+  cp 'test/functional/meteor_controller_test.rb',
+    templates + '/functional_test.rb'
+end
+
+desc 'test all tests'
+task 'test:all' => [:test, 'test:plugins', 'test:exts', 'test:libs']

data/bin/shooting_star

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+$:.unshift File.join(File.dirname(__FILE__), '../ext')
+require 'shooting_star'
+
+# define options
+$command_line = "#{$0} #{ARGV.join(' ')}"
+OPT = {}
+opt = OptionParser.new
+opt.on('-f <config file>'){|v| OPT[:config] = v}
+opt.on('-g', 'debug mode.'){$debug = true}
+opt.on('-s', 'silent mode.'){OPT[:silent] = true}
+subopt = Hash.new{|h,k| $stderr.puts "no such subcommand: #{k}."; exit 1}
+subopt['init'] = OptionParser.new do |cmd|
+  cmd.banner = ['Usage:', cmd.program_name, 'init [options]'].join(' ')
+  cmd.on('-d <base dir>', 'ShootingStarize directory.'){|v| OPT[:directory] = v}
+end
+subopt['start'] = OptionParser.new do |cmd|
+  cmd.banner = ['Usage:', cmd.program_name, 'start [options]'].join(' ')
+  cmd.on('-d', 'daemon mode.'){OPT[:daemon] = true}
+end
+subopt['stop'] = OptionParser.new do |cmd| end
+subopt['restart'] = OptionParser.new do |cmd| end
+subopt['stat'] = OptionParser.new do |cmd|
+  cmd.banner = ['Usage:', cmd.program_name, 'stat [options]'].join(' ')
+  cmd.on('-u', 'with uid.'){OPT[:with_uid] = true}
+  cmd.on('-s', 'with signature.'){OPT[:with_sig] = true}
+end
+opt.on_tail('-v', '--version', 'Show version.'){puts opt.ver; exit}
+opt.on_tail('-h', '--help', 'Show this message.') do
+  opt.banner = "  " + ['Usage:', opt.program_name,
+    "{#{subopt.keys.sort.join('|')}}", '[options]'].join(' ') + "\n\n"
+  puts "#{'-'*opt.ver.length}\n#{opt.ver}\n#{'-'*opt.ver.length}"
+  puts opt.help
+  subopt.keys.sort.each do |key| cmd = subopt[key]
+    next if cmd.to_a.size <= 1
+    cmd.banner = "\n  Options for subcommand `#{key}':\n"
+    puts cmd.help
+  end; exit
+end
+
+# parse options
+Version = ShootingStar::VERSION
+opt.order!(ARGV)
+CMD = ARGV.shift
+begin
+  subopt[CMD].parse!(ARGV) unless ARGV.empty?
+rescue OptionParser::InvalidOption => e
+  puts e.message; exit
+end
+ShootingStar.configure(OPT)
+OPT[:daemon] = true if CMD == 'restart'
+
+# execute
+case CMD
+when "init"
+  ShootingStar.init
+when "start"
+  ShootingStar.start
+when "stop"
+  ShootingStar.stop
+when "restart"
+  ShootingStar.restart
+when "stat"
+  ShootingStar.report
+else
+  puts `#{$0} --help`
+end

data/ext/asteroid.c

@@ -0,0 +1,262 @@
+/* --------------------------------------------------------------------------
+ * 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 <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>
+#include <sys/time.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_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){
+      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_server_send_data(VALUE Self, VALUE Data){
+  VALUE Fd = rb_iv_get(Self, "@fd");
+  int fd = FIX2INT(Fd);
+  char *data = StringValuePtr(Data);
+  send(fd, data, RSTRING(Data)->len, MSG_NOSIGNAL);
+  return Qnil;
+}
+
+static VALUE asteroid_server_write_and_close(VALUE Self){
+  VALUE Fd = rb_iv_get(Self, "@fd");
+  int fd = FIX2INT(Fd);
+  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;
+  // We need to wait at least 1 millisecond to avoid busy loop.
+  while((s = asteroid_poll_wait(epoll_fd, events, EVENT_BUF_SIZE, 1)) > 0){
+    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){
+          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/ext/asteroid.h

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

data/ext/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+unless have_header("sys/epoll.h") || have_header("sys/event.h")
+  message "epoll or kqueue required.\n"
+  exit 1
+end
+
+create_header
+create_makefile 'asteroid'

data/lib/form_encoder.rb

@@ -0,0 +1,23 @@
+module FormEncoder
+  def self.encode(parameters, prefix = "")
+    case parameters
+    when Hash; encode_hash(parameters, prefix)
+    when Array; encode_array(parameters, prefix)
+    else "#{prefix}=#{CGI.escape(parameters.to_s)}"
+    end
+  end
+
+private
+  def self.encode_hash(hash, prefix)
+    hash.inject([]) do |result, (key, value)|
+      key = CGI.escape(key.to_s)
+      result << encode(value, prefix.empty? ? key : "#{prefix}[#{key}]")
+    end.join('&')
+  end
+
+  def self.encode_array(array, prefix)
+    array.inject([]) do |result, value|
+      result << encode(value, "#{prefix}[]")
+    end.join('&')
+  end
+end

data/lib/shooting_star/channel.rb

@@ -0,0 +1,41 @@
+require 'set'
+
+module ShootingStar
+  class Channel
+    class InvalidIdError < StandardError; end
+    attr_reader :path, :waiters
+    @@channels = {}
+
+    def initialize(path)
+      @path = path
+      @waiters = Hash.new
+      @event_id = 0
+      @@channels[path] = self
+    end
+
+    def transmit(id, params)
+      @waiters.each do |signature, server|
+        server.commit if server.respond(id, params)
+      end
+    end
+
+    def join(server)
+      @waiters[server.signature] = server
+      server.commit
+    end
+
+    def leave(server)
+      @waiters.delete(server.signature)
+    end
+
+    def self.[](channel); @@channels[channel] end
+    def self.list; @@channels.keys end
+    def self.sweep; @@channels.delete_if{|k,v| v.waiters.empty?} end
+
+    def self.cleanup(channel)
+      result = @@channels[channel] && @@channels[channel].waiters.empty?
+      @@channels.delete(channel) if result
+      result
+    end
+  end
+end

data/lib/shooting_star/config.rb

@@ -0,0 +1,19 @@
+module ShootingStar
+  class Config
+    def initialize(hash)
+      @hash = hash.keys.inject({}) do |new_hash, key|
+        new_hash[key.to_s] = hash[key]
+        new_hash
+      end
+    end
+
+    def merge!(hash)
+      hash.keys.each{|key| @hash[key.to_s] = hash[key]}; self
+    end
+
+    def method_missing(method, *arg, &block)
+      value = @hash[method.to_s]
+      value.is_a?(Hash) ? Config.new(value) : value
+    end
+  end
+end