angstrom 0.5.0

data/Gemfile

@@ -0,0 +1,5 @@
+gem 'lazy'
+gem 'open-uri'
+gem 'ffi'
+gem 'ffi-rzmq'
+gem 'cgi'

data/README.md

@@ -0,0 +1,109 @@
+# Angstrom #
+An evented, fiber-based server for Ruby. This project is heavily based on [Brubeck](http://brubeck.io). The goal was to make it really easy to make an evented server that acted quick and scaled infinitely. This is accomplished by using [Mongrel2](http://mongrel2.org), [ZeroMQ](http://zeromq.org) and [Rubinius](rubini.us). Rubinius has the actor gem included already so it makes it really convenient to just use rubinius. Also, the 2.0.0dev branch has super nice thread handling, allowing for true Ruby concurrency that MRI just can't offer with its GIL.
+
+## Mongrel2 and ZeroMQ ##
+Although it seems like a strange direction to start writing servers in, eventually most companies end up in the realm of evented servers. This is because it offers nearly infinite scalability for free.
+
+This is possible because of Mongrel2 and ZeroMQ. Mongrel2 acts as your server and parses requests. It then sends out ZeroMQ messages to your handlers and proxies and then returns their responses. Because it uses ZeroMQ messages, Mongrel2 can send messages anywhere and to any language. Conversely, it sends messages in a round-robin style, so scalability is achieved by just starting up another instance of your server.
+
+## setup ##
+#### Rubinius ####
+
+	rvm install rbx
+	rvm use rbx
+
+#### ZeroMQ ####
+Go grab the zip from [zeromq/zeromq2-1](https://github.com/zeromq/zeromq2-1), unzip it, and in the directory run:
+	
+	./autogen.sh; ./configure; make; sudo make install
+	
+#### Angstrom as a gem ####
+
+	gem install angstrom
+
+#### ZMQ and other gems ####
+	gem install ffi-rzmq
+	gem install lazy
+
+it should also install `ffi` and `ffi-rzmq` which are to dynamically load libs and call functions from them. Interesting stuff, but out of the scope of this measly README.
+
+#### Mongrel2 ####
+Finally, go grab a copy of mongrel2 (1.7.5 tested) from the [Mongrel2](http://mongrel2.org) website.
+
+There's a sample `mongrel2.conf` and `config.sqlite` in the `demo` folder, feel free to use those. Otherwise, load the `mongrel2.conf` into `m2sh` and then start the server.
+
+	m2sh load -config mongrel2.conf -db config.sqlite
+	m2sh start -host localhost
+
+## minimal example ##
+
+	require 'angstrom'
+
+	get "/" do
+		"hello world"
+	end
+
+Just like in Sinatra, we state the verb we want to use, the path, and give it a block with the relevant code to execute. So far only 'GET' requests are supported but more will come out in later builds. 
+
+Now you should run `ruby angstrom_test.rb` and then visit [localhost:6767](http://localhost:6767/) and relish in the 'Hello World'.
+
+## more functionality ##
+
+commit e86c74aed added functionality for parameters in your path. These are simply demonstrated in the `demo/angstrom_test.rb` file. For instance, you can extract the id of a certain part of your path like so:
+
+	require 'angstrom'
+	
+	get "/:id" do |env|
+		"id: #{env[:params]["id"]}"
+	end
+	
+The params are always going to be stored in `env`, naturally.
+
+You can also return other codes and custom headers by returning an array with the signature:
+	[code, headers, response]
+
+## benchmarking ##
+
+#### Armstrong ####
+	$ siege -d 1 -c 150 -t 10s localhost:6767/
+	** SIEGE 2.70
+	** Preparing 150 concurrent users for battle.
+	The server is now under siege...
+	Lifting the server siege...      done.
+	Transactions:		        	5029 hits
+	Availability:		      		100.00 %
+	Elapsed time:		        	9.06 secs
+	Data transferred:	        	0.05 MB
+	Response time:		        	0.26 secs
+	Transaction rate:	      		555.08 trans/sec
+	Throughput:		        		0.01 MB/sec
+	Concurrency:		      		146.56
+	Successful transactions:        5029
+	Failed transactions:	           0
+	Longest transaction:	        0.67
+	Shortest transaction:	        0.02
+	
+#### Sinatra ####
+
+_These benchmarks were done using Rubinius as the Ruby interpreter. You will get much better results for sinatra with MRI 1.9.2 but the concurrency will still plateau at about 110. I could not start up more than 110 concurrent users without sinatra closing all connections and blowing up._
+
+	$ siege -d1 -c 110 -t 10s localhost:4567/
+	** SIEGE 2.70
+	** Preparing 20 concurrent users for battle.
+	The server is now under siege...
+	Lifting the server siege...      done.
+	Transactions:		        	1192 hits
+	Availability:		       		97.23 %
+	Elapsed time:		        	9.39 secs
+	Data transferred:	        	0.01 MB
+	Response time:		        	0.70 secs
+	Transaction rate:	      		126.94 trans/sec
+	Throughput:		        		0.00 MB/sec
+	Concurrency:		       		88.98
+	Successful transactions:        1192
+	Failed transactions:	          34
+	Longest transaction:	        1.39
+	Shortest transaction:	        0.20
+
+## License ##
+GPLv3

data/Rakefile

@@ -0,0 +1,22 @@
+desc "Push actors to github, switch to master, merge actors, push master to github"
+namespace :super do
+  task :push do
+    `go master`
+    `git merge actors`
+    `git push github`
+    `go actors`
+  end
+end
+
+desc "Build gem"
+task :gb do
+  `gem build angstrom.gemspec`
+end
+
+desc "Push gem"
+task :gp do
+  Rake::Task[:gb].invoke
+  gem_file = `ls *.gem`.to_a.last.chomp
+  puts "pushing #{gem_file}"
+  puts `gem push #{gem_file}`
+end

data/angstrom.gemspec

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'angstrom/version'
+
+Gem::Specification.new 'angstrom', Aleph::VERSION do |s|
+  s.description       = "Angstrom is an Mongrel2 fronted, actor-based web development framework similar in style to sinatra. With natively-threaded interpreters (Rubinius2), Angstrom provides true concurrency and high stability, by design."
+  s.summary           = "Highly concurrent, sinatra-like framework"
+  s.author            = "Artem Titoulenko"
+  s.email             = "artem.titoulenko@gmail.com"
+  s.homepage          = "https://www.github.com/artemtitoulenko/angstrom"
+  s.files             = `git ls-files`.split("\n") - %w[.gitignore .travis.yml response_benchmark.rb demo/config.sqlite]
+  s.executables       = %w[ angstrom ]
+
+  s.add_dependency 'ffi',            '~> 1.0', '>= 1.0.10'
+  s.add_dependency 'ffi-rzmq', '~> 0.9', '>= 0.9.0'
+  s.add_dependency 'lazy', '>= 0.9.6'
+end

data/bin/angstrom

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+include FileUtils
+
+# this is a cli tool to make getting running with angstrom easier.
+def inform
+  puts """
+    Angstrom is an asynchronous ruby web framework that's fronted by mongrel2
+    and makes use of Actors in order to handle requests. It is preferred to use
+    rubinius2.0.0dev in order to take advantage of true concurrency in Ruby.
+    
+    usage: angstrom <command>
+    
+    commands:
+      create <name> [port]      Creates an angstrom app with a sample 
+                                mongrel2.conf and config.sqlite running on
+                                [port] or the default 6767.
+                                
+      start [host] [db.sqlite]  Starts a mongrel2 server in this directory
+                                and then runs the app called by the current 
+                                directorys name. This is equivalent to:
+                                  $m2sh start -host localhost -db config.sqlite >> /dev/null &
+                                  $ruby app.rb
+                                  
+      stop [host]               Kills the default running mongrel2 
+                                server or [host]. This is like:
+                                  $m2sh stop -host localhost
+                                  
+    short commands:
+      c = create
+      s = start
+      t = stop
+  """
+end
+
+mongrel2_conf = """
+angstrom_handler = Handler(
+    send_spec='tcp://127.0.0.1:9999',
+    send_ident='34f9ceee-cd52-4b7f-b197-88bf2f0ec378',
+    recv_spec='tcp://127.0.0.1:9998', 
+    recv_ident='')
+
+media_dir = Dir(
+    base='media/',
+    index_file='index.html',
+    default_ctype='text/plain')
+
+angstrom_host = Host(
+    name=\"localhost\", 
+    routes={
+        '/media/': media_dir,
+        '/': angstrom_handler})
+
+angstrom_serv = Server(
+    uuid=\"%s\",
+    access_log=\"/log/mongrel2.access.log\",
+    error_log=\"/log/mongrel2.error.log\",
+    chroot=\"./\",
+    default_host=\"localhost\",
+    name=\"angstrom test\",
+    pid_file=\"/run/mongrel2.pid\",
+    port=%i,
+    hosts = [angstrom_host]
+)
+
+settings = {\"zeromq.threads\": 2, \"limits.min_ping\": 15, \"limits.kill_limit\": 2}
+
+servers = [angstrom_serv]
+"""
+
+inform if ARGV.empty?
+
+case ARGV[0]
+when 'create', 'c'
+  inform if ARGV[1].nil?
+  port = (ARGV[2].nil? ? 6767 : ARGV[2])
+  mkdir ARGV[1]
+  cd ARGV[1]
+  %w[log run tmp].map(&method(:mkdir))
+  File.open("mongrel2.conf", 'w') {|file| file.puts(mongrel2_conf % [`m2sh uuid`.chomp, port]) }
+  puts "loading in the mongrel2.conf config"
+  puts `m2sh load -config mongrel2.conf -db config.sqlite`
+  File.open("#{ARGV[1]}.rb", 'w') {|file| file.puts "require 'rubygems'\nrequire 'angstrom'\n\n"}
+  puts "Created app #{ARGV[1]} that will run on port #{port}"
+  
+when 'start', 's'
+  host = (ARGV[1].nil? ? 'localhost' : ARGV[1])
+  db = (ARGV[2].nil? ? 'config.sqlite' : ARGV[2])
+  
+  output = `m2sh start -host #{host} -config #{db} > /dev/null &`
+  if output.match /Aborting/
+    puts "Error starting up mongrel2.\n\nTrace:\n#{output}"
+    break
+  end
+  puts "Started #{host} using the #{db} db" 
+  
+  file = Dir.pwd.split('/').last
+  puts "now running #{file}.rb"
+  puts `ruby #{file}.rb`
+  
+when 'stop', 't'
+  host = (ARGV[1].nil? ? 'localhost' : ARGV[1])
+  puts `m2sh stop -host #{host}`
+  puts "Stopped #{host}, I think"
+else
+  inform
+end

data/bin/armstrong

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+include FileUtils
+
+# this is a cli tool to make getting running with armstrong easier.
+def inform
+  puts """
+    Armstrong is an asynchronous ruby web framework that's fronted by mongrel2
+    and makes use of Actors in order to handle requests. It is preferred to use
+    rubinius2.0.0dev in order to take advantage of true concurrency in Ruby.
+    
+    usage: armstrong <command>
+    
+    commands:
+      create <name> [port]      Creates an armstrong app with a sample 
+                                mongrel2.conf and config.sqlite running on
+                                [port] or the default 6767.
+                                
+      start [host] [db.sqlite]  Starts a mongrel2 server in this directory
+                                and then runs the app called by the current 
+                                directorys name. This is equivalent to:
+                                  $m2sh start -host localhost -db config.sqlite >> /dev/null &
+                                  $ruby app.rb
+                                  
+      stop [host]               Kills the default running mongrel2 
+                                server or [host]. This is like:
+                                  $m2sh stop -host localhost
+                                  
+    short commands:
+      c = create
+      s = start
+      t = stop
+  """
+end
+
+mongrel2_conf = """
+armstrong_handler = Handler(
+    send_spec='tcp://127.0.0.1:9999',
+    send_ident='34f9ceee-cd52-4b7f-b197-88bf2f0ec378',
+    recv_spec='tcp://127.0.0.1:9998', 
+    recv_ident='')
+
+media_dir = Dir(
+    base='media/',
+    index_file='index.html',
+    default_ctype='text/plain')
+
+armstrong_host = Host(
+    name=\"localhost\", 
+    routes={
+        '/media/': media_dir,
+        '/': armstrong_handler})
+
+armstrong_serv = Server(
+    uuid=\"%s\",
+    access_log=\"/log/mongrel2.access.log\",
+    error_log=\"/log/mongrel2.error.log\",
+    chroot=\"./\",
+    default_host=\"localhost\",
+    name=\"armstrong test\",
+    pid_file=\"/run/mongrel2.pid\",
+    port=%i,
+    hosts = [armstrong_host]
+)
+
+settings = {\"zeromq.threads\": 2, \"limits.min_ping\": 15, \"limits.kill_limit\": 2}
+
+servers = [armstrong_serv]
+"""
+
+inform if ARGV.empty?
+
+case ARGV[0]
+when 'create', 'c'
+  inform if ARGV[1].nil?
+  port = (ARGV[2].nil? ? 6767 : ARGV[2])
+  mkdir ARGV[1]
+  cd ARGV[1]
+  %w[log run tmp].map(&method(:mkdir))
+  File.open("mongrel2.conf", 'w') {|file| file.puts(mongrel2_conf % [`m2sh uuid`.chomp, port]) }
+  puts "loading in the mongrel2.conf config"
+  puts `m2sh load -config mongrel2.conf -db config.sqlite`
+  File.open("#{ARGV[1]}.rb", 'w') {|file| file.puts "require 'rubygems'\nrequire 'armstrong'\n\n"}
+  puts "Created app #{ARGV[1]} that will run on port #{port}"
+  
+when 'start', 's'
+  host = (ARGV[1].nil? ? 'localhost' : ARGV[1])
+  db = (ARGV[2].nil? ? 'config.sqlite' : ARGV[2])
+  
+  output = `m2sh start -host #{host} -config #{db} > /dev/null &`
+  if output.match /Aborting/
+    puts "Error starting up mongrel2.\n\nTrace:\n#{output}"
+    break
+  end
+  puts "Started #{host} using the #{db} db" 
+  
+  file = Dir.pwd.split('/').last
+  puts "now running #{file}.rb"
+  puts `ruby #{file}.rb`
+  
+when 'stop', 't'
+  host = (ARGV[1].nil? ? 'localhost' : ARGV[1])
+  puts `m2sh stop -host #{host}`
+  puts "Stopped #{host}, I think"
+else
+  inform
+end

data/demo/mongrel2.conf

@@ -0,0 +1,32 @@
+angstrom_handler = Handler(
+    send_spec='tcp://127.0.0.1:9999',
+    send_ident='34f9ceee-cd52-4b7f-b197-88bf2f0ec378',
+    recv_spec='tcp://127.0.0.1:9998', 
+    recv_ident='')
+
+media_dir = Dir(
+    base='media/',
+    index_file='index.html',
+    default_ctype='text/plain')
+
+angstrom_host = Host(
+    name="localhost", 
+    routes={
+        '/media/': media_dir,
+        '/': angstrom_handler})
+
+angstrom_serv = Server(
+    uuid="f400bf85-4538-4f7a-8908-67e313d515c2",
+    access_log="/log/mongrel2.access.log",
+    error_log="/log/mongrel2.error.log",
+    chroot="./",
+    default_host="localhost",
+    name="angstrom test",
+    pid_file="/run/mongrel2.pid",
+    port=6767,
+    hosts = [angstrom_host]
+)
+
+settings = {"zeromq.threads": 2, "limits.min_ping": 15, "limits.kill_limit": 2}
+
+servers = [angstrom_serv]

data/lib/angstrom.rb

@@ -0,0 +1,130 @@
+require 'actor'
+require 'rubygems'
+require 'lazy'
+
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require "angstrom/connection"
+require 'angstrom/data_structures'
+require 'angstrom/main_actors'
+  
+module Aleph
+  class Base
+    class << self
+      attr_accessor :conn, :routes
+      
+      def get(path, &block) route "GET", path, &block end
+      def put(path, &block)  route "PUT",  path, &block end
+      def post(path, &block) route "POST", path, &block end
+      def head(path, &block) route "HEAD", path, &block end
+      def delete(path, &block) route "DELETE", path, &block end
+      def patch(path, &block) route "PATCH", path, &block end
+      
+      def route(verb, path, &block)
+        @routes ||= {}
+        (@routes[verb] ||= []) << AddRoute.new(compile(path), block)
+      end
+      
+      private
+        def compile(path)
+          keys = []
+          if path.respond_to? :to_str
+            pattern = path.to_str.gsub(/[^\?\%\\\/\:\*\w]/) { |c| encoded(c) }
+            pattern.gsub!(/((:\w+)|\*)/) do |match|
+              if match == "*"
+                keys << 'splat'
+                "(.*?)"
+              else
+                keys << $2[1..-1]
+                "([^/?#]+)"
+              end
+            end
+            [/^#{pattern}$/, keys]
+          elsif path.respond_to?(:keys) && path.respond_to?(:match)
+            [path, path.keys]
+          elsif path.respond_to?(:names) && path.respond_to?(:match)
+            [path, path.names]
+          elsif path.respond_to? :match
+            [path, keys]
+          else
+            raise TypeError, path
+          end
+        end
+
+        def encoded(char)
+          enc = URI.encode(char)
+          enc = "(?:#{Regexp.escape enc}|#{URI.encode char, /./})" if enc == char
+          enc = "(?:#{enc}|#{encoded('+')})" if char == " "
+          enc
+        end
+    end
+  end
+  
+  class Angstrom < Base
+    
+    # the kicker. It all gets launched from here.
+    # this function makes a new connection object to handle the communication,
+    # promises to start the replier, request handler, and their supervisor,
+    # gives the replier the connection information, tells the request_handler
+    # what routes it should be able to match, then checks that all of the services
+    # are running correctly, gives us a launch time, then jumps into our main loop
+    # that waits for an incoming message, parses it, and sends it off to be
+    # operated on by the request handler. Boom.
+    def self.run!
+      #ensure that all actors are launched. Yea.
+      done = Lazy::demand(Lazy::promise do |done|
+        Actor.spawn(&Aleph::Base.supervisor_proc)
+        done = true
+      end)
+
+      if done
+        done2 = Lazy::demand(Lazy::Promise.new do |done2|
+          Actor[:supervisor] << SpawnRequestHandlers.new(4)
+          Actor[:supervisor] << SpawnReceivers.new(1)
+          Actor[:supervisor] << AddRoutes.new(@routes)
+          done2 = true
+        end)
+      end
+
+      if Aleph::Base.supervisor && Aleph::Base.replier && done2
+        puts "","="*56,"Angstrom has launched on #{Time.now}","="*56, ""
+      end
+      
+      # main loop
+      loop do
+        gets
+      end
+    end
+  end
+  
+  # thank you sinatra!
+  # Sinatra delegation mixin. Mixing this module into an object causes all
+  # methods to be delegated to the Aleph::Angstrom class. Used primarily
+  # at the top-level.
+  module Delegator
+    def self.delegate(*methods)
+      methods.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          return super(*args, &block) if respond_to? method_name
+          Delegator.target.send(method_name, *args, &block)
+        end
+        private method_name
+      end
+    end
+
+    delegate :get, :post, :put, :patch, :delete, :head
+
+    class << self
+      attr_accessor :target
+    end
+
+    self.target = Angstrom
+  end
+  
+  # Sinatras secret sauce.
+  at_exit { Angstrom.run! }
+end
+
+include Aleph::Delegator
+

data/lib/angstrom/connection.rb

@@ -0,0 +1,142 @@
+require 'ffi'
+require 'ffi-rzmq'
+require 'json'
+require 'cgi'
+
+class Connection
+  attr_reader :app_id, :sub_addr, :pub_addr, :request_sock, :response_sock, :context
+  
+  def initialize(app_id, zmq_sub_pub_addr=["tcp://127.0.0.1", 9999, "tcp://127.0.0.1", 9998])
+    @app_id = app_id
+    @sub_addr = zmq_sub_pub_addr[0..1].join(":")
+    @pub_addr = zmq_sub_pub_addr[2..3].join(":")
+    
+    @request_sock = @response_sock = nil
+  end
+  
+  def connect
+    @context = ZMQ::Context.new 1
+    @request_sock = @context.socket ZMQ::PULL
+    @request_sock.connect @sub_addr
+    
+    @response_sock = @context.socket ZMQ::PUB
+    @response_sock.setsockopt ZMQ::IDENTITY, @app_id
+    @response_sock.connect @pub_addr
+  end
+  
+  #raw recv, unparsed message
+  def recv
+    msg = ""
+    rc = @request_sock.recv_string(msg)
+    puts "errno [#{ZMQ::Util.errno}] with description [#{ZMQ::Util.error_string}]" unless ZMQ::Util.resultcode_ok?(rc)
+    msg
+  end
+  
+  #parse the request, this is the best way to get stuff back, as a Hash
+  def receive
+    parse(recv)
+  end
+  
+  # sends the message off, formatted for Mongrel2 to understand
+  def send(uuid, conn_id, msg)
+    header = "%s %d:%s" % [uuid, conn_id.join(' ').length, conn_id.join(' ')]
+    string =  header + ', ' + msg 
+    #puts "\t\treplying to #{conn_id} with: ", string
+    rc = @response_sock.send_string string, ZMQ::NOBLOCK
+    puts "errno [#{ZMQ::Util.errno}] with description [#{ZMQ::Util.error_string}]" unless ZMQ::Util.resultcode_ok?(rc)
+  end
+  
+  # reply to an env with `message` string
+  def reply(env, message)
+    self.send(env[:sender], [env[:conn_id]], message)
+  end
+
+  # reply to a req with a valid http header
+  def reply_http(env, body, code=200, headers={"Content-type" => "text/html"})
+    self.reply(env, http_response(body, code, headers))
+  end
+  
+  private
+  def http_response(body, code, headers)
+    headers['Content-Length'] = body.size
+    headers_s = headers.map{|k, v| "%s: %s" % [k,v]}.join("\r\n")
+    
+    "HTTP/1.1 #{code} #{StatusMessage[code.to_i]}\r\n#{headers_s}\r\n\r\n#{body}"
+  end
+  
+  def parse_netstring(ns)
+    len, rest = ns.split(':', 2)
+    len = len.to_i
+    raise "Netstring did not end in ','" unless rest[len].chr == ','
+    [ rest[0...len], rest[(len+1)..-1] ]
+  end
+  
+  def parse(msg)
+    if msg.nil? || msg.empty?
+      return nil
+    end
+    
+    env = {}
+    env[:sender], env[:conn_id], env[:path], rest = msg.split(' ', 4)
+    env[:headers], head_rest = parse_netstring(rest)
+    env[:body], _ = parse_netstring(head_rest)
+
+    env[:headers] = JSON.parse(env[:headers])
+    if(env[:headers]["METHOD"] == "POST")
+      env[:post] = parse_params(env)
+    end
+    
+    return env
+  end
+  
+  def parse_params(env)
+    r = {}
+    env[:body].split('&').map{|x| x.scan(/(.*?)=(.*?)$/)}.each_slice(2) { |k| r[CGI::unescape(k[0].to_s)] = CGI::unescape(k[1]) }
+    return r
+  end
+  
+  # From WEBrick: thanks dawg.
+  StatusMessage = {
+    100 => 'Continue',
+    101 => 'Switching Protocols',
+    200 => 'OK',
+    201 => 'Created',
+    202 => 'Accepted',
+    203 => 'Non-Authoritative Information',
+    204 => 'No Content',
+    205 => 'Reset Content',
+    206 => 'Partial Content',
+    300 => 'Multiple Choices',
+    301 => 'Moved Permanently',
+    302 => 'Found',
+    303 => 'See Other',
+    304 => 'Not Modified',
+    305 => 'Use Proxy',
+    307 => 'Temporary Redirect',
+    400 => 'Bad Request',
+    401 => 'Unauthorized',
+    402 => 'Payment Required',
+    403 => 'Forbidden',
+    404 => 'Not Found',
+    405 => 'Method Not Allowed',
+    406 => 'Not Acceptable',
+    407 => 'Proxy Authentication Required',
+    408 => 'Request Timeout',
+    409 => 'Conflict',
+    410 => 'Gone',
+    411 => 'Length Required',
+    412 => 'Precondition Failed',
+    413 => 'Request Entity Too Large',
+    414 => 'Request-URI Too Large',
+    415 => 'Unsupported Media Type',
+    416 => 'Request Range Not Satisfiable',
+    417 => 'Expectation Failed',
+    500 => 'Internal Server Error',
+    501 => 'Not Implemented',
+    502 => 'Bad Gateway',
+    503 => 'Service Unavailable',
+    504 => 'Gateway Timeout',
+    505 => 'HTTP Version Not Supported'
+  }
+end
+

data/lib/angstrom/data_structures.rb

@@ -0,0 +1,10 @@
+AddRoute = Struct.new :route, :method
+AddRoutes = Struct.new :routes
+Request = Struct.new :env
+ConnectionInformation = Struct.new :connection
+Reply = Struct.new :env, :code, :headers, :body
+MessageAndProc = Struct.new :env, :proccess
+
+SpawnRequestHandlers = Struct.new :num
+SpawnReceivers = Struct.new :num
+Num = Struct.new :index

data/lib/angstrom/main_actors.rb

@@ -0,0 +1,183 @@
+module Aleph
+  class Base
+    class << self
+      attr_accessor :replier, :supervisor
+      attr_accessor :message_receiver_proc, :request_handler_proc, :supervisor_proc, :container_proc
+    end
+  end
+end
+
+# take the route and pattern and keys and this function will match the keyworded params in
+# the url with the pattern. Example:
+# 
+#   url: /user/2/view/345
+#   pattern: /user/:id/view/:comment
+#
+# returns:
+#
+#   params = {id: 2, comment: 345}
+#
+def process_route(route, pattern, keys, values = [])
+  return unless match = pattern.match(route)
+  values += match.captures.map { |v| URI.decode(v) if v }
+  params = {}
+  
+  if values.any?
+    keys.zip(values) { |k,v| (params[k] ||= '') << v if v }
+  end
+  params
+end
+
+# uuid generator. There's a pretty low chance of collision.
+def new_uuid
+  values = [
+    rand(0x0010000),
+    rand(0x0010000),
+    rand(0x0010000),
+    rand(0x0010000),
+    rand(0x0010000),  
+    rand(0x1000000),
+    rand(0x1000000),
+  ]
+  "%04x%04x-%04x-%04x-%04x%06x%06x" % values
+end
+
+
+
+
+
+
+
+# this nifty mess helps us just to use the output of the Procs that handle
+# the request instead of making the user manually catch messages and send 
+# them out to the replier. 
+Aleph::Base.container_proc = Proc.new do
+  data = Actor.receive
+  env, proccess = data.env, data.proccess
+  response = proccess.call(env)
+  puts "[container] using response: ", response
+  if response.is_a? Array
+    #just like Rack: env, code, headers, body. HINT HINT ( can't work because it's all async )
+    env[:conn].reply_http(env, response[1], response[2], response[0])
+  else
+    puts "[container] sending http_reply"
+    env[:conn].reply_http(env, response, 200, {"Content-Type", "text/html;charset=utf-8", "Connection", "keep-alive", "Server", "Angstrom", "X-Frame-Options", "sameorigin", "X-XSS_Protection", "1; mode=block"})
+  end
+end
+
+Aleph::Base.message_receiver_proc = Proc.new do
+  @name = "message_receiver"
+  puts "started (#{@name})"
+
+  uuid = new_uuid
+  conn = Connection.new uuid
+  conn.connect
+  puts "replying as mongrel2 service #{uuid}"
+  
+  loop do
+    puts "waiting..."
+    env = conn.receive
+    env[:conn] = conn
+    puts "[message_receiver] got request, req = #{!req.nil?}"
+    Actor[:supervisor] << Request.new(env) if !req.nil?
+  end
+end
+
+
+
+Aleph::Base.request_handler_proc = Proc.new do
+  @name = "request_handler"
+  @num = 0
+  puts "started (#{@name})"
+  Actor.trap_exit = true
+  
+  routes = {}
+  loop do
+    Actor.receive do |f|
+      f.when(Num) do |n|
+        @num = n.index
+      end
+      
+      f.when(AddRoutes) do |r|
+        routes = r.routes
+      end
+
+      f.when(Request) do |r|
+        failure = true
+        verb = r.env[:headers]["METHOD"]
+        routes[verb].each do |route|
+          if route.route[0].match(r.env[:path])
+            puts "[request_handler:#{@num}] route matched! Making container..."
+            r.env[:params] = process_route(r.env[:path], route.route[0], route.route[1])
+            Actor.spawn(&Aleph::Base.container_proc) << MessageAndProc.new(r.env, route.method)
+            failure = false
+            break
+          end
+        end
+        env[:conn].reply_http(r.env, "<h1>404</h1>", 404, {'Content-type'=>'text/html'} ) if failure
+      end
+
+      f.when(Actor::DeadActorError) do |exit|
+        puts "[request_handler] #{exit.actor} died with reason: [#{exit.reason}]"
+      end
+    end
+  end
+end
+
+#if this dies, all hell will break loose
+Aleph::Base.supervisor_proc = Proc.new do
+  Actor.register(:supervisor, Actor.current)
+  Aleph::Base.supervisor = Actor.current
+  Actor.trap_exit = true
+  puts "started (supervisor)"
+  
+  handlers = []
+  receivers = []
+  handler_turn = 0
+  receiver_turn = 0
+      
+  loop do
+    Actor.receive do |f|
+      
+      f.when(AddRoutes) do |r|
+        puts "Adding routes"
+        handlers.each { |h| h << r }
+      end
+      
+      f.when(SpawnRequestHandlers) do |r|
+        r.num.times do
+          puts "spawning a request_handler in handlers[#{handlers.size}]"
+          handlers << (Actor.spawn_link(&Aleph::Base.request_handler_proc) << Num.new(handlers.size))
+        end
+      end
+      
+      f.when(Request) do |req|
+        puts "[supervisor] routing request"
+        handlers[handler_turn] << req
+        if(handler_turn == handlers.size)
+          handler_turn = 0
+        else
+          handler_turn += 1
+        end
+      end
+      
+      f.when(SpawnReceivers) do |r|
+        r.num.times do
+          puts "spawning a receiver in receivers[#{receivers.size}]"
+          receivers << Actor.spawn_link(&Aleph::Base.message_receiver_proc)
+        end
+      end
+      
+      f.when(Actor::DeadActorError) do |exit|
+        "[supervisor] #{exit.actor} died with reason: [#{exit.reason}]"
+        # case exit.actor.name
+        # when "request_handler"
+        #   # lets replace that failed request_handler with a new one. NO DOWN TIME
+        #   handlers[exit.actor.num] = (Actor.spawn_link(&Aleph::Base.request_handler_proc) << Num.new(exit.actor.num))
+        # when "message_receiver"
+        #   repliers[exit.actor.num] = (Actor.spawn_link(&Aleph::Base.message_receiver_proc) << Num.new(exit.actor.num))     
+        # end
+      end
+    end
+  end
+end

data/lib/angstrom/version.rb

@@ -0,0 +1,3 @@
+module Aleph
+  VERSION = "0.5.0"
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: angstrom
+version: !ruby/object:Gem::Version 
+  hash: 1694540110752149318
+  prerelease: 
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Artem Titoulenko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 4428665182548103036
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 4428537186080172355
+        segments: 
+        - 1
+        - 0
+        - 10
+        version: 1.0.10
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ffi-rzmq
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 2854635824043747355
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 1509009585894205680
+        segments: 
+        - 0
+        - 9
+        - 0
+        version: 0.9.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: lazy
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 2770302470405238287
+        segments: 
+        - 0
+        - 9
+        - 6
+        version: 0.9.6
+  type: :runtime
+  version_requirements: *id003
+description: Angstrom is an Mongrel2 fronted, actor-based web development framework similar in style to sinatra. With natively-threaded interpreters (Rubinius2), Angstrom provides true concurrency and high stability, by design.
+email: artem.titoulenko@gmail.com
+executables: 
+- angstrom
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- README.md
+- Rakefile
+- angstrom.gemspec
+- bin/angstrom
+- bin/armstrong
+- demo/mongrel2.conf
+- lib/angstrom.rb
+- lib/angstrom/connection.rb
+- lib/angstrom/data_structures.rb
+- lib/angstrom/main_actors.rb
+- lib/angstrom/version.rb
+homepage: https://www.github.com/artemtitoulenko/angstrom
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 2002549777813010636
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 2002549777813010636
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Highly concurrent, sinatra-like framework
+test_files: []
+