giga-smart-mod 0.0.1

data/thin-2.0.1/example/async_app.ru

@@ -0,0 +1,126 @@
+#!/usr/bin/env rackup -s thin
+# 
+#  async_app.ru
+#  raggi/thin
+#   
+#   A second demo app for async rack + thin app processing!
+#   Now using http status code 100 instead.
+# 
+#  Created by James Tucker on 2008-06-17.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+#
+#--
+# Benchmark Results:
+#
+# raggi@mbk:~$ ab -c 100 -n 500 http://127.0.0.1:3000/
+# This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0
+# Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+# Copyright 2006 The Apache Software Foundation, http://www.apache.org/
+# 
+# Benchmarking 127.0.0.1 (be patient)
+# Completed 100 requests
+# Completed 200 requests
+# Completed 300 requests
+# Completed 400 requests
+# Finished 500 requests
+# 
+# 
+# Server Software:        thin
+# Server Hostname:        127.0.0.1
+# Server Port:            3000
+# 
+# Document Path:          /
+# Document Length:        12 bytes
+# 
+# Concurrency Level:      100
+# Time taken for tests:   5.263089 seconds
+# Complete requests:      500
+# Failed requests:        0
+# Write errors:           0
+# Total transferred:      47000 bytes
+# HTML transferred:       6000 bytes
+# Requests per second:    95.00 [#/sec] (mean)
+# Time per request:       1052.618 [ms] (mean)
+# Time per request:       10.526 [ms] (mean, across all concurrent requests)
+# Transfer rate:          8.55 [Kbytes/sec] received
+# 
+# Connection Times (ms)
+#               min  mean[+/-sd] median   max
+# Connect:        0    3   2.2      3       8
+# Processing:  1042 1046   3.1   1046    1053
+# Waiting:     1037 1042   3.6   1041    1050
+# Total:       1045 1049   3.1   1049    1057
+# 
+# Percentage of the requests served within a certain time (ms)
+#   50%   1049
+#   66%   1051
+#   75%   1053
+#   80%   1053
+#   90%   1054
+#   95%   1054
+#   98%   1056
+#   99%   1057
+#  100%   1057 (longest request)
+
+class DeferrableBody
+  include EventMachine::Deferrable
+
+  def call(body)
+    body.each do |chunk|
+      @body_callback.call(chunk)
+    end
+  end
+
+  def each &blk
+    @body_callback = blk
+  end
+
+end
+
+class AsyncApp
+  
+  # This is a template async response. N.B. Can't use string for body on 1.9
+  AsyncResponse = [-1, {}, []].freeze
+    
+  def call(env)
+    
+    body = DeferrableBody.new
+    
+    # Get the headers out there asap, let the client know we're alive...
+    EventMachine::next_tick { env['async.callback'].call [200, {'content-type' => 'text/plain'}, body] }
+    
+    # Semi-emulate a long db request, instead of a timer, in reality we'd be 
+    # waiting for the response data. Whilst this happens, other connections 
+    # can be serviced.
+    # This could be any callback based thing though, a deferrable waiting on 
+    # IO data, a db request, an http request, an smtp send, whatever.
+    EventMachine::add_timer(1) {
+      body.call ["Woah, async!\n"]
+      
+      EventMachine::next_tick {
+        # This could actually happen any time, you could spawn off to new 
+        # threads, pause as a good looking lady walks by, whatever.
+        # Just shows off how we can defer chunks of data in the body, you can
+        # even call this many times.
+        body.call ["Cheers then!"]
+        body.succeed
+      }
+    }
+    
+    # throw :async # Still works for supporting non-async frameworks...
+    
+    AsyncResponse # May end up in Rack :-)
+  end
+  
+end
+
+# The additions to env for async.connection and async.callback absolutely 
+# destroy the speed of the request if Lint is doing it's checks on env.
+# It is also important to note that an async response will not pass through 
+# any further middleware, as the async response notification has been passed 
+# right up to the webserver, and the callback goes directly there too.
+# Middleware could possibly catch :async, and also provide a different 
+# async.connection and async.callback.
+
+# use Rack::Lint
+run AsyncApp.new

data/thin-2.0.1/example/async_chat.ru

@@ -0,0 +1,247 @@
+#!/usr/bin/env rackup -s thin
+# 
+#  async_chat.ru
+#  raggi/thin
+#  
+#  Created by James Tucker on 2008-06-19.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+
+# Uncomment if appropriate for you..
+EM.epoll
+# EM.kqueue # bug on OS X in 0.12?
+
+class DeferrableBody
+  include EventMachine::Deferrable
+  
+  def initialize
+    @queue = []
+  end
+  
+  def schedule_dequeue
+    return unless @body_callback
+    EventMachine::next_tick do
+      next unless body = @queue.shift
+      body.each do |chunk|
+        @body_callback.call(chunk)
+      end
+      schedule_dequeue unless @queue.empty?
+    end
+  end 
+
+  def call(body)
+    @queue << body
+    schedule_dequeue
+  end
+
+  def each &blk
+    @body_callback = blk
+    schedule_dequeue
+  end
+
+end
+
+class Chat
+  
+  module UserBody
+    attr_accessor :username
+  end
+  
+  def initialize
+    @users = {}
+  end
+  
+  def render_page
+    [] << <<-EOPAGE
+  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+  <html>
+    <head>
+      <style>
+        body {
+          font-family: sans-serif;
+          margin: 0; 
+          padding: 0;
+          margin-top: 4em;
+          margin-bottom: 1em;
+        }
+        #header {
+          background: silver;
+          height: 4em;
+          width: 100%;
+          position: fixed;
+          top: 0px;
+          border-bottom: 1px solid black;
+          padding-left: 0.5em;
+        }
+        #messages {
+          width: 100%;
+          height: 100%;
+        }
+        .message {
+          margin-left: 1em;
+        }
+        #send_form {
+          position: fixed;
+          bottom: 0px;
+          height: 1em;
+          width: 100%;
+        }
+        #message_box {
+          background: silver;
+          width: 100%;
+          border: 0px;
+          border-top: 1px solid black;
+        }
+        .gray {
+          color: gray;
+        }
+      </style>
+      <script type="text/javascript" src="http://ra66i.org/tmp/jquery-1.2.6.min.js"></script>
+      <script type="text/javascript">
+        XHR = function() {
+          var request = false;
+          try { request = new ActiveXObject('Msxml2.XMLHTTP');    } catch(e) {
+            try { request = new ActiveXObject('Microsoft.XMLHTTP'); } catch(e1) {
+      		    try {	request = new XMLHttpRequest();                 	}	catch(e2) { 
+      		      return false; 
+    		      }
+  		      }
+  	      }
+          return request;
+        }
+        scroll = function() {
+        	window.scrollBy(0,50);
+        	setTimeout('scroll()',100);
+        }
+        focus = function() {
+          $('#message_box').focus();
+        }
+        send_message = function(message_box) {
+          xhr = XHR();
+          xhr.open("POST", "/", true); 
+      		xhr.setRequestHeader("content-type", "application/x-www-form-urlencoded");
+      		xhr.setRequestHeader("X_REQUESTED_WITH", "XMLHttpRequest");
+      		xhr.send("message="+escape(message_box.value));
+          scroll();
+          message_box.value = '';
+          focus();
+          return false;
+        }
+        new_message = function(username, message) {
+          // TODO html escape message
+          formatted_message = "<div class='message'>" + username + ": " + message + "</div>";
+          messages_div = $('#messages');
+          $(formatted_message).appendTo(messages_div);
+          scroll();
+          return true;
+        }
+      </script>
+      <title>Async Chat</title>
+    </head>
+    <body>
+      <div id="header">
+        <h1>Async Chat</h1>
+      </div>
+      <div id="messages" onclick="focus();">
+        <span class="gray">Your first message will become your nickname!</span>
+        <span>Users: #{@users.map{|k,u|u.username}.join(', ')}</span>
+      </div>
+      <form id="send_form" onSubmit="return send_message(this.message)">
+        <input type="text" id="message_box" name="message"></input>
+      </form>
+      <script type="text/javascript">focus();</script>
+    </body>
+  </html>
+  EOPAGE
+  end
+  
+  def register_user(user_id, renderer)
+    body = create_user(user_id)
+    body.call render_page
+    body.errback { delete_user user_id }
+    body.callback { delete_user user_id }
+    
+    EventMachine::next_tick do
+      renderer.call [200, {'content-type' => 'text/html'}, body]
+    end
+  end
+  
+  def new_message(user_id, message)
+    return unless @users[user_id]
+    if @users[user_id].username == :anonymous
+      username = unique_username(message)
+      log "User: #{user_id} is #{username}"
+      @users[user_id].username = message
+      message = "<span class='gray'>-> #{username} signed on.</span>"
+    end
+    username ||= @users[user_id].username
+    log "User: #{username} sent: #{message}"
+    @users.each do |id, body|
+      EventMachine::next_tick { body.call [js_message(username, message)] }
+    end
+  end
+  
+  private
+  def unique_username(name)
+    name.concat('_') while @users.any? { |id,u| name == u.username }
+    name
+  end
+  
+  def log(str)
+    print str, "\n"
+  end
+  
+  def add_user(id, body)
+    @users[id] = body
+  end
+  
+  def delete_user(id)
+    message = "User: #{id} - #{@users[id].username if @users[id]} disconnected."
+    log message
+    new_message(id, message)
+    @users.delete id
+  end
+  
+  def js_message(username, message)
+    %(<script type="text/javascript">new_message("#{username}","#{message}");</script>)
+  end
+  
+  def create_user(id)
+    message = "User: #{id} connected."
+    log message
+    new_message(id, message)
+    body = DeferrableBody.new
+    body.extend UserBody
+    body.username = :anonymous
+    add_user(id, body)
+    body
+  end
+  
+end
+
+class AsyncChat
+  
+  AsyncResponse = [-1, {}, []].freeze
+  AjaxResponse = [200, {}, []].freeze
+  
+  def initialize
+    @chat = Chat.new
+  end
+  
+  def call(env)  
+    request = Rack::Request.new(env)
+    # TODO - cookie me, baby
+    user_id = request.env['REMOTE_ADDR']
+    if request.xhr?
+      message = request['message']
+      @chat.new_message(user_id, Rack::Utils.escape_html(message))
+      AjaxResponse
+    else
+      renderer = request.env['async.callback']
+      @chat.register_user(user_id, renderer)
+      AsyncResponse
+    end
+  end
+  
+end
+
+run AsyncChat.new

data/thin-2.0.1/example/async_tailer.ru

@@ -0,0 +1,100 @@
+#!/usr/bin/env rackup -s thin
+# 
+#  async_tailer.ru
+#  raggi/thin
+#
+#  Tested with 150 spawned tails on OS X
+#  
+#  Created by James Tucker on 2008-06-18.
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+
+# Uncomment if appropriate for you..
+# EM.epoll
+# EM.kqueue
+
+class DeferrableBody
+  include EventMachine::Deferrable
+  
+  def initialize
+    @queue = []
+    # make sure to flush out the queue before closing the connection
+    callback{
+      until @queue.empty?
+        @queue.shift.each{|chunk| @body_callback.call(chunk) }
+      end
+    }
+  end
+  
+  def schedule_dequeue
+    return unless @body_callback
+    EventMachine::next_tick do
+      next unless body = @queue.shift
+      body.each do |chunk|
+        @body_callback.call(chunk)
+      end
+      schedule_dequeue unless @queue.empty?
+    end
+  end 
+
+  def call(body)
+    @queue << body
+    schedule_dequeue
+  end
+
+  def each &blk
+    @body_callback = blk
+    schedule_dequeue
+  end
+
+end
+
+module TailRenderer
+  attr_accessor :callback
+
+  def receive_data(data)
+    @callback.call([data])
+  end
+
+  def unbind
+    @callback.succeed
+  end
+end
+
+class AsyncTailer
+  
+  AsyncResponse = [-1, {}, []].freeze
+    
+  def call(env)
+    
+    body = DeferrableBody.new
+    
+    EventMachine::next_tick do
+      
+      env['async.callback'].call [200, {'content-type' => 'text/html'}, body]
+      
+      body.call ["<h1>Async Tailer</h1><pre>"]
+      
+    end
+    
+    EventMachine::popen('tail -f /var/log/system.log', TailRenderer) do |t|
+      
+      t.callback = body
+      
+      # If for some reason we 'complete' body, close the tail.
+      body.callback do
+        t.close_connection
+      end
+      
+      # If for some reason the client disconnects, close the tail.
+      body.errback do
+        t.close_connection
+      end
+      
+    end
+    
+    AsyncResponse
+  end
+  
+end
+
+run AsyncTailer.new

data/thin-2.0.1/example/config.ru

@@ -0,0 +1,22 @@
+# Run with: rackup -s thin
+# then browse to http://localhost:9292
+# Or with: thin start -R config.ru
+# then browse to http://localhost:3000
+# 
+# Check Rack::Builder doc for more details on this file format:
+#  http://rack.rubyforge.org/doc/classes/Rack/Builder.html
+require 'thin'
+
+app = proc do |env|
+  # Response body has to respond to each and yield strings
+  # See Rack specs for more info: http://rack.rubyforge.org/doc/files/SPEC.html
+  body = ['hi!']
+  
+  [
+    200,                                        # Status code
+    { 'content-type' => 'text/html' },          # Reponse headers
+    body                                        # Body of the response
+  ]
+end
+
+run app

data/thin-2.0.1/example/monit_sockets

@@ -0,0 +1,20 @@
+check process blog1
+    with pidfile /u/apps/blog/shared/pids/thin.14000.pid
+    start program = "ruby thin start -d -e production -u nobody -g nobody -p 14000 -a 127.0.0.1 -P tmp/pids/thin.14000.pid -c /u/apps/blog/current"
+    stop program  = "ruby thin stop -P /u/apps/blog/shared/pids/thin.14000.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+    if failed port 14000 then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+
+check process blog2
+    with pidfile /u/apps/blog/shared/pids/thin.14001.pid
+    start program = "ruby thin start -d -e production -u nobody -g nobody -p 14001 -a 127.0.0.1 -P tmp/pids/thin.14001.pid -c /u/apps/blog/current"
+    stop program  = "ruby thin stop -P /u/apps/blog/shared/pids/thin.14001.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+    if failed port 14001 then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+

data/thin-2.0.1/example/monit_unixsock

@@ -0,0 +1,20 @@
+check process blog1
+    with pidfile /u/apps/blog/shared/pids/thin.1.pid
+    start program = "ruby thin start -d -e production -S /u/apps/blog/shared/pids/thin.1.sock -P tmp/pids/thin.1.pid -c /u/apps/blog/current"
+    stop program  = "ruby thin stop -P /u/apps/blog/shared/pids/thin.1.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+		if failed unixsocket /u/apps/blog/shared/pids/thin.1.sock then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+
+check process blog2
+    with pidfile /u/apps/blog/shared/pids/thin.2.pid
+    start program = "ruby thin start -d -e production -S /u/apps/blog/shared/pids/thin.2.sock -P tmp/pids/thin.2.pid -c /u/apps/blog/current"
+    stop program  = "ruby thin stop -P /u/apps/blog/shared/pids/thin.2.pid"
+    if totalmem > 90.0 MB for 5 cycles then restart
+		if failed unixsocket /u/apps/blog/shared/pids/thin.2.sock then restart
+    if cpu usage > 95% for 3 cycles then restart
+    if 5 restarts within 5 cycles then timeout
+		group blog
+

data/thin-2.0.1/example/myapp.rb

@@ -0,0 +1 @@
+Myapp = lambda { |env| [200, {}, 'this is my app!'] }

data/thin-2.0.1/example/ramaze.ru

@@ -0,0 +1,12 @@
+# Ramaze Rackup config file.
+# by tmm1
+# Use with --rackup option:
+# 
+#   thin start -r ramaze.ru
+# 
+require 'start'
+
+Ramaze.trait[:essentials].delete Ramaze::Adapter
+Ramaze.start :force => true
+
+run Ramaze::Adapter::Base

data/thin-2.0.1/example/thin.god

@@ -0,0 +1,80 @@
+# == God config file
+# http://god.rubyforge.org/
+# Authors: Gump and michael@glauche.de
+#
+# Config file for god that configures watches for each instance of a thin server for
+# each thin configuration file found in /etc/thin.
+# In order to get it working on Ubuntu, I had to make a change to god as noted at
+# the following blog:
+# http://blog.alexgirard.com/ruby-one-line-to-save-god/
+#
+require 'yaml'
+
+config_path = "/etc/thin"
+
+Dir[config_path + "/*.yml"].each do |file|
+  config = YAML.load_file(file)
+  num_servers = config["servers"] ||= 1
+
+  (0...num_servers).each do |i|
+    # UNIX socket cluster use number 0 to 2 (for 3 servers)
+    # and tcp cluster use port number 3000 to 3002.
+    number = config['socket'] ? i : (config['port'] + i)
+    
+    God.watch do |w|
+      w.group = "thin-" + File.basename(file, ".yml")
+      w.name = w.group + "-#{number}"
+      
+      w.interval = 30.seconds
+      
+      w.uid = config["user"]
+      w.gid = config["group"]
+      
+      w.start = "thin start -C #{file} -o #{number}"
+      w.start_grace = 10.seconds
+      
+      w.stop = "thin stop -C #{file} -o #{number}"
+      w.stop_grace = 10.seconds
+      
+      w.restart = "thin restart -C #{file} -o #{number}"
+
+      pid_path = config["chdir"] + "/" + config["pid"]
+      ext = File.extname(pid_path)
+
+      w.pid_file = pid_path.gsub(/#{ext}$/, ".#{number}#{ext}")
+      
+      w.behavior(:clean_pid_file)
+
+      w.start_if do |start|
+        start.condition(:process_running) do |c|
+          c.interval = 5.seconds
+          c.running = false
+        end
+      end
+
+      w.restart_if do |restart|
+        restart.condition(:memory_usage) do |c|
+          c.above = 150.megabytes
+          c.times = [3,5] # 3 out of 5 intervals
+        end
+
+        restart.condition(:cpu_usage) do |c|
+          c.above = 50.percent
+          c.times = 5
+        end
+      end
+
+      w.lifecycle do |on|
+        on.condition(:flapping) do |c|
+          c.to_state = [:start, :restart]
+          c.times = 5
+          c.within = 5.minutes
+          c.transition = :unmonitored
+          c.retry_in = 10.minutes
+          c.retry_times = 5
+          c.retry_within = 2.hours
+        end
+      end
+    end
+  end
+end

data/thin-2.0.1/example/thin_solaris_smf.erb

@@ -0,0 +1,36 @@
+<?xml version='1.0'?>
+<!DOCTYPE service_bundle SYSTEM '/usr/share/lib/xml/dtd/service_bundle.dtd.1'>
+<service_bundle type='manifest' name='thin/<%= service_name %>-production'>
+  <service name='network/thin/<%= service_name %>-production' type='service' version='0'>
+    <!-- Dependancies for all Thin servers. -->
+    <dependency name='fs' grouping='require_all' restart_on='none' type='service'>
+      <service_fmri value='svc:/system/filesystem/local'/>
+    </dependency>
+    <dependency name='net' grouping='require_all' restart_on='none' type='service'>
+      <service_fmri value='svc:/network/loopback'/>
+      <!-- uncomment the following line if you are on an L+ Accelerator since /home is mounted through nfs -->
+      <!--<service_fmri value='svc:/network/nfs/client'/>-->
+    </dependency>
+    <% 0.upto(thin_max_instances - 1) do |instance| %>
+    <!-- instance names can't start with digits. Bummer. -->
+    <instance name='i_<%= instance.to_s %>' enabled='false'>
+      <!-- Cause the multi-user milestone to bring these services up -->
+      <dependent name='<%= service_name %>_<%= instance.to_s %>_multi-user' restart_on='none' grouping='optional_all'>
+        <service_fmri value='svc:/milestone/multi-user'/>
+      </dependent>
+      <exec_method name='start' type='method'
+            exec='/opt/csw/bin/thin -C config/thin.yml --only <%= instance.to_s %> start'
+            timeout_seconds='10'>
+        <method_context working_directory='<%= working_directory %>'>
+          <method_credential user='<%= user %>' group='<%= group %>' />
+          <method_environment>
+            <envvar name='PATH' value='/usr/bin:/bin:/opt/csw/bin' />
+          </method_environment>
+        </method_context>
+      </exec_method>
+      <exec_method name='stop' type='method' exec=':kill' timeout_seconds='10' />
+    </instance>
+    <% end %>
+  </service>
+</service_bundle>
+