shooting_star 1.0.3

data/lib/shooting_star/server.rb

@@ -0,0 +1,219 @@
+require 'json'
+require 'cgi'
+require 'md5'
+require 'set'
+require 'form_encoder'
+
+module ShootingStar
+  # The module which will be included by servant who was born in the Asteroid.
+  # This idea is from EventMachine.
+  module Server
+    attr_reader :signature
+    @@servers = {}
+    @@uids = {}
+    @@tags = {}
+    @@executings = {}
+
+    # initialize servant waked up.
+    def post_init
+      @execution = ''
+      @data = ''
+    end
+
+    # receive the data sent from client.
+    def receive_data(data)
+      @data += data
+      response if @data[-4..-1] == "\r\n\r\n"
+    end
+
+    # detect disconnection from the client and clean it up.
+    def unbind
+      @unbound = true
+      if channel = Channel[@channel]
+        channel.leave(self)
+        notify(:event => :leave, :uid => @uid, :tag => @tag)
+        Channel.cleanup(@channel)
+      end
+      @@servers.delete(@signature)
+      @@uids.delete(@signature)
+      @@tags.delete(@signature)
+      @@executings.delete(@signature)
+      log "Disconnected: #{@uid}"
+    end
+
+    # respond to an execution command. it'll be buffered.
+    def respond(id, params)
+      @executing = @@executings[@signature] ||= Hash.new
+      if params[:tag] && !params[:tag].empty? && !@tag.empty?
+        return false if (params[:tag] & @tag).empty?
+      end
+      @executing[id] = params
+      @waiting
+    end
+
+    # perform buffered executions.
+    def commit
+      return false if @unbound
+      @executing.each{|id, params| execute(id, params)}
+      return false if @execution.empty?
+      send_data "HTTP/1.1 200 OK\nContent-Type: text/javascript\n\n"
+      send_data @execution
+      @waiting = nil
+      @execution = ''
+      @executing = Hash.new
+      @@executings.delete(@signature)
+      write_and_close
+      true
+    end
+
+    # noticed execution and remove the command from execution buffer.
+    def executed(id) 
+      @executing = @@executings[@signature] ||= Hash.new
+      @executing.delete(id)
+    end
+    
+    # update current status of servant.
+    def update(uid, tag)
+      if @uid != uid || @tag != tag
+        notify(:event => :leave, :uid => @uid, :tag => @tag)
+        @@uids[@signature] = @uid = uid
+        @@tags[@signature] = @tag = tag
+        notify(:event => :enter, :uid => @uid, :tag => @tag)
+      end
+      log "Update: #{@uid}:#{@tag.join(',')}"
+    end
+
+    def uid; @@uids[@signature] end
+    def tag; @@tags[@signature] end
+
+    # an accessor which maps signatures to servers.
+    def self.[](signature)
+      @@servers[signature]
+    end
+
+  private
+    def log(*arg, &block) ShootingStar::log(*arg, &block) end
+
+    # broadcast an event to clients.
+    def notify(params = {})
+      return unless Channel[@channel]
+      event_id = ShootingStar::timestamp
+      log "Event(#{event_id}): #{@channel}:#{params.inspect}"
+      Channel[@channel].transmit("event-#{event_id}", params)
+    end
+
+    # wait for commands or events until they occur. if they're already in
+    # the execution buffer, they'll be flushed and return on the spot.
+    def wait_for
+      log "Wait for: #{@channel}:#{@uid}:#{@tag.join(',')}"
+      if Channel[@channel].join(self)
+        log "Flushed: #{@channel}:#{@uid}:#{@tag.join(',')}"
+      end
+      @waiting = true
+    end
+
+    # clean up channel and it'll be closed if no one's listening.
+    def cleanup(channel)
+      if Channel.cleanup(channel)
+        log "Channel closed: #{@channel}"
+      end
+    end
+
+    # give a response to the request or keep them waiting.
+    def response
+      headers = @data.split("\n")
+      head = headers.shift
+      method, path, protocol = head.split(/\s+/)
+      # recognize header
+      hdr = headers.inject({}) do |hash, line|
+        key, value = line.chop.split(/ *?: */, 2)
+        hash[key.downcase] = value if key
+        hash
+      end
+      # recognize parameter
+      @params = Hash.new
+      if @query = path.split('?', 2)[1]
+        if @query = @query.split('#', 2)[0]
+          @query.split('&').each do |item|
+            key, value = item.split('=', 2)
+            @params[key] = CGI.unescape(value) if value && value.length > 0
+          end
+        end
+      end
+      # load or create session informations
+      @signature ||= @params['sig']
+      @channel ||= path[1..-1].split('?', 2)[0]
+      @uid = @@uids[@signature] ||= @params['uid']
+      @tag = @@tags[@signature] ||=
+        (@params['tag'] || '').split(',').map{|i| CGI.unescape(i)}
+      @executing = @@executings[@signature] ||= Hash.new
+      @@servers[@signature] = self
+      # make uncacheable path
+      @timestamp = ShootingStar::timestamp
+      path += (path.index('?') ? '&' : '?') + "timestamp=#{@timestamp}"
+      @query = "channel=#{@channel}&sig=#{@signature}"
+      # prepare channel
+      unless Channel[@channel]
+        Channel.new(@channel)
+        log "Channel opened: #{@channel}"
+      end
+      # process verb
+      if method == 'GET'
+        make_connection(path)
+        notify(:event => :enter, :uid => @uid, :tag => @tag)
+        log "Connected: #{@uid}"
+      else
+        wait_for
+      end
+    rescue
+      log "ERROR: #{$!.message}\n#{@data}"
+      raise
+    ensure
+      @data = ''
+    end
+
+    # add execution line to the buffer.
+    def execute(id, params)
+      @executing[id] = params
+      @query += "&" +FormEncoder.encode(params) if params
+      @execution += <<-"EOH"
+      (function(){
+        var iframe = document.createElement('iframe');
+        var remove = function(){document.body.removeChild(iframe)};
+        iframe.onload = function(){setTimeout(remove, 0)};
+        iframe.src = '#{@params['execute']}/#{id}?#{@query}';
+        document.body.appendChild(iframe);
+      })();
+      EOH
+    end
+
+    # make client connect us.
+    def make_connection(path)
+      send_data "HTTP/1.1 200 OK\nContent-Type: text/html\n\n" +
+      <<-"EOH"
+      <html><head><script type='text/javascript'
+       src='http://alphastars.drecom.jp/javascripts/prototype.js'
+      ></script>
+      <script type='text/javascript'>
+      //<![CDATA[
+      var connect = function()
+      { var request = new Ajax.Request(
+          #{path.to_json}, {method: 'post', evalScript: true,
+          onComplete: function(xhr){
+            setTimeout(connect,
+              xhr.getResponseHeader('Content-Type') ? 0 : 1000);
+          }});
+        var disconnect = function()
+        { request.options.onComplete = function(){};
+          request.transport.abort();
+        };
+        Event.observe(window, 'unload', disconnect);
+      };
+      setTimeout(connect, 0);
+      //]]>
+      </script></head><body></body></html>
+      EOH
+      write_and_close
+    end
+  end
+end

data/lib/shooting_star/shooter.rb

@@ -0,0 +1,62 @@
+require 'shooting_star/channel'
+
+# DRbObject
+module ShootingStar
+  class Shooter
+    def shoot(channel, id, tag)
+      return unless Channel[channel]
+      log "Shot: #{channel}:#{id}:#{tag.join(',')}"
+      Channel[channel].transmit(id, :tag => tag)
+    end
+
+    def update(sig, uid, tag)
+      ::ShootingStar::Server[sig].update(uid, tag || [])
+    end
+
+    def signature; ShootingStar::timestamp end
+    def channels; Channel.list end
+    def sweep; Channel.sweep end
+
+    def count(channel, tag = nil)
+      servers(channel, tag).size
+    end
+
+    def count_with(sig, channel, tag = nil)
+      (signatures(channel, tag) | [sig]).size
+    end
+
+    def listeners(channel, tag = nil)
+      servers(channel, tag).map{|s| s.uid}
+    end
+
+    def listeners_with(uid, sig, channel, tag = nil)
+      servers(channel, tag).inject([uid]) do |result, server|
+        result << server.uid unless server.signature == sig
+        result
+      end
+    end
+
+    def signatures(channel, tag = nil)
+      servers(channel, tag).map{|s| s.signature}
+    end
+
+    def executed(sig, id)
+      ::ShootingStar::Server[sig].executed(id)
+    rescue
+    end
+
+  private
+    def log(*arg, &block) ShootingStar::log(*arg, &block) end
+
+    def servers(channel, tag = nil)
+      return [] unless Channel[channel]
+      result = Channel[channel].waiters.values
+      if tag && !tag.empty?
+        result = result.select do |server|
+          server.tag.empty? || !(server.tag & tag).empty?
+        end 
+      end
+      result
+    end
+  end
+end

data/lib/shooting_star.rb

@@ -0,0 +1,142 @@
+require 'rubygems'
+require 'asteroid'
+require 'drb/drb'
+require 'yaml'
+require 'ftools'
+require 'shooting_star/config'
+require 'shooting_star/shooter'
+
+module ShootingStar
+  VERSION = '1.0.3'
+  CONFIG = Config.new(
+    :config => 'config/shooting_star.yml',
+    :pid_file => 'log/shooting_star.pid',
+    :log_file => 'log/shooting_star.log',
+    :daemon => false,
+    :slient => false)
+
+  def self.configure(options = {})
+    if @log_file
+      @log_file.close
+      @log_file = nil
+    end
+    config_file = options[:config] || CONFIG.config
+    CONFIG.merge!(YAML.load_file(config_file)) if File.exist?(config_file)
+    CONFIG.merge!(options)
+  end
+
+  def self.shooter
+    @@shooter ||= DRbObject.new_with_uri(CONFIG.shooter.uri)
+  end
+
+  # install config file and plugin
+  def self.init
+    base_dir = CONFIG.directory || `pwd`.chop
+    config_dir = File.join(base_dir, 'config')
+    `mkdir -p #{config_dir}` unless File.exist? config_dir
+    config_file = File.join(config_dir, 'shooting_star.yml')
+    unless File.exist? config_file
+      open(config_file, 'w') do |file|
+        open(__FILE__) do |data|
+          data.gets("__END__\n")
+          file.write data.read
+        end
+      end
+    end
+    log_dir = File.join(base_dir, 'log')
+    `mkdir -p #{log_dir}` unless File.exist? log_dir
+    plugin_dir = File.join(base_dir, 'vendor/plugins')
+    `mkdir -p #{plugin_dir}` unless File.exist? plugin_dir
+    meteor_strike_dir = File.join(plugin_dir, 'meteor_strike')
+    unless File.exist?(meteor_strike_dir)
+      src_dir = File.join(File.dirname(__FILE__),
+        '../vendor/plugins/meteor_strike')
+      `cp -R #{src_dir} #{meteor_strike_dir}`
+    end
+  end
+
+  def self.start(&block)
+    if File.exist?(CONFIG.pid_file)
+      log 'shooting_star is already running.'
+      return
+    end
+    if CONFIG.daemon
+      Signal.trap(:ALRM){exit} and sleep if fork
+      Process.setsid
+    end
+    require 'shooting_star/shooter'
+    @@druby = DRb.start_service(CONFIG.shooter.uri, Shooter.new)
+    require 'shooting_star/server'
+    Asteroid::run(CONFIG.server.host, CONFIG.server.port, Server) do
+      File.open(CONFIG.pid_file, "w") do |file|
+        file.puts Process.pid
+        file.puts $command_line
+      end
+      Signal.trap(:INT) do
+        Asteroid::stop
+        @@druby.stop_service
+        log "shooting_star service stopped."
+        File.rm_f(CONFIG.pid_file)
+      end
+      Signal.trap(:EXIT) do
+        File.rm_f(CONFIG.pid_file)
+        @log_file.close if @log_file
+      end
+      log "shooting_star service started."
+      Process.kill(:ALRM, Process.ppid) if CONFIG.daemon
+      block.call if block
+    end
+  end
+
+  def self.stop
+    command = ''
+    File.open(CONFIG.pid_file) do |file|
+      Process.kill(:INT, pid = file.gets.to_i)
+      command = file.gets
+    end
+    Thread.pass while File.exist?(CONFIG.pid_file)
+  rescue Errno::ENOENT
+    log "shooting_star service is not running."
+  rescue Errno::ESRCH
+    File.unlink(CONFIG.pid_file)
+  ensure
+    return command
+  end
+
+  def self.restart
+    command = stop
+    Thread.pass while File.exist?(CONFIG.pid_file)
+    system(command)
+  end
+
+  def self.report
+    puts "#{'-' * 79}\nconnections channel name\n#{'-' * 79}"
+    total_connections = 0
+    shooter.channels.each do |channel|
+      count = shooter.count(channel)
+      puts "%11d %s" % [count, channel]
+      puts shooter.listeners(channel).join(',') if CONFIG.with_uid
+      puts shooter.signatures(channel).join(',') if CONFIG.with_sig
+      total_connections +=  count
+    end
+    puts "#{'-' * 79}\n%11d %s\n#{'-' * 79}" % [total_connections, 'TOTAL']
+  end
+
+  def self.timestamp
+    now = Time.now
+    "%d%06d" % [now.tv_sec, now.tv_usec]
+  end
+
+private
+  def self.log(*arg, &block)
+    puts(*arg, &block) unless CONFIG.silent
+    @log_file ||= open(CONFIG.log_file, 'a')
+    @log_file.puts(*arg, &block) if @log_file
+  end
+end
+__END__
+server:
+  host: 0.0.0.0
+  port: 8080
+shooter:
+  uri: druby://0.0.0.0:7123

data/test/ext/asteroid_test.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+require 'thread'
+require 'ext/asteroid'
+require 'socket'
+
+module Server
+  def receive_data(data)
+    send_data data
+    write_and_close
+  end
+
+  def post_init
+    $post_init_test = true
+  end
+
+  def unbind
+    $unbind_test = true
+  end
+end
+
+class ShootingStarTest < Test::Unit::TestCase
+  def setup
+    mutex = Mutex.new
+    mutex.lock
+    @thread = Thread.new do
+      Asteroid::run('127.0.0.1', 7124, Server) do
+        mutex.unlock
+      end
+    end
+    mutex.lock
+  end
+
+  def teardown
+    Asteroid::stop
+    @thread.join
+  end
+
+  def test_communication
+    c = TCPSocket.open('127.0.0.1', 7124)
+    c.write "test"
+    assert_equal "test", c.read
+    assert $post_init_test
+  end
+
+  def test_unbind
+    c = TCPSocket.open('127.0.0.1', 7124)
+    c.close
+    Thread.pass
+    assert $unbind_test
+  end
+
+  def test_broad_cast
+    c1 = TCPSocket.open('127.0.0.1', 7124)
+    c2 = TCPSocket.open('127.0.0.1', 7124)
+    c1.write "test1"
+    c2.write "test2"
+    assert_equal "test1", c1.read
+    assert_equal "test2", c2.read
+  end
+end

data/test/lib/shooting_star_test.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+require 'shooting_star'
+require 'socket'
+require 'thread'
+
+$command_line = 'echo "testing"'
+
+class ShootingStarTest < Test::Unit::TestCase
+  def setup
+    @config = ShootingStar.configure :silent => true,
+      :pid_file => 'log/shooting_star.test.pid',
+      :log_file => 'log/shooting_star.test.log',
+      :server => {:host => '127.0.0.1', :port => 8081},
+      :shooter => {:uri => 'druby://127.0.0.1:7124'}
+    mutex = Mutex.new
+    mutex.lock
+    @thread = Thread.new{ShootingStar.start{mutex.unlock}}
+    mutex.lock
+  end
+
+  def teardown
+    ShootingStar.stop
+    File.rm_f(@config.pid_file)
+    File.rm_f @config.log_file
+    @thread.join
+  end
+
+  def test_connection
+    client = TCPSocket.open('127.0.0.1', 8081)
+    assert_not_nil client
+    send client, "GET", "test/channel"
+  end
+
+  def test_shooter_exists
+    shooter = ShootingStar.shooter
+    assert_not_nil shooter
+  end
+
+  def test_c10k_problem
+    bin = File.join(RAILS_ROOT, 'bin/test_c10k_problem')
+    src = File.join(File.dirname(__FILE__), 'test_c10k_problem.c')
+    if !File.exist?(bin) || File.mtime(src) > File.mtime(bin)
+      system "gcc #{src} -o #{bin}"
+    end
+    system bin 
+  end
+
+private
+  def send(client, method, path)
+    client.write "#{method} #{path} HTTP/1.1\n\r" +
+      "Host: #{@config.server.host}:#{@config.server.port}\n\r" +
+      "Keep-Alive: 300\n\r" +
+      "Connection: keep-alive\n\r\n\r"
+  end
+end

data/test/lib/test_c10k_problem.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/epoll.h>
+#include <netinet/in.h>
+
+#define NUM_CLIENT      (10000)
+
+int main(int argc, char **argv){
+  int status = EXIT_SUCCESS;
+
+  /* fill sockattr */
+  struct sockaddr_in addr;
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(8081);
+  addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+  
+  int i, j, s[NUM_CLIENT];
+  for(i = 0; i < NUM_CLIENT; ++i){
+    /* create socket */
+    s[i] = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+    int result = connect(s[i], (struct sockaddr*)&addr, sizeof(addr));
+    if(result != 0){
+      printf("failed to connect.");
+      for(j = 0; j < i; ++j){
+        close(s[j]);
+      }
+      return EXIT_FAILURE;
+    }
+
+    char hdr[] = "POST /chat/test HTTP/1.1\r\n";
+    char host[] = "Host: 127.0.0.1\r\n\r\n";
+    write(s[i], hdr, strlen(hdr));
+    write(s[i], host, strlen(host));
+
+    int n = i + 1;
+    if(n % 10 == 0) printf(".");
+    if(n % 100 == 0) printf(" %d connections\n", n);
+  }
+
+  /* close fd and exit */
+  for(i = 0; i < NUM_CLIENT; ++i){
+    close(s[i]);
+  }
+  return status;
+}

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+begin
+  require 'redgreen'
+rescue Exception
+end
+$: << File.join(RAILS_ROOT, 'ext')
+
+class Test::Unit::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+end

data/test/test_shooting_star.rb

@@ -0,0 +1,64 @@
+$: << File.join(File.dirname(__FILE__), '../lib')
+require 'test/unit'
+require 'shooting_star'
+require 'socket'
+require 'thread'
+require 'redgreen' rescue nil
+
+COMMAND_LINE = 'echo "testing"'
+
+class ShootingStarTest < Test::Unit::TestCase
+  def setup
+    @config = ShootingStar.configure(
+      :silent => true,
+      :server => {:host => '127.0.0.1', :port => 8080},
+      :shooter => {:uri => 'druby://127.0.0.1:7123'})
+    @thread = Thread.new do
+      ShootingStar.start
+    end
+    Thread.pass while !File.exist?(@config.pid_file)
+    @client = TCPSocket.open('127.0.0.1', 8080)
+    @shooter = ShootingStar.shooter
+  end
+
+  def teardown
+    ShootingStar.stop
+    @thread.join
+    File.rm_f(@config.pid_file)
+  end
+
+  def test_activation
+    assert_not_nil @thread
+  end
+
+  def test_shooter
+    assert_not_nil @shooter
+  end
+
+  def test_client
+    assert_not_nil @client
+  end
+
+  def test_disconnection
+    @client.close
+  end
+
+  def test_communication
+    mutex = Mutex.new
+    mutex.lock
+    thread = Thread.new do
+      #send 'GET', 'test_application/test_channel_name'
+      mutex.unlock
+    end
+    mutex.lock
+    thread.join
+  end
+
+private
+  def send(method, path)
+    @client.write "#{method} #{path} HTTP/1.1\n" +
+      "Host: #{ShootingStar.host}:#{ShootingStar.port}\n" +
+      "Keep-Alive: 300\n" +
+      "Connection: keep-alive\n\n"
+  end
+end