armstrong 0.2.1

data/README.md

@@ -0,0 +1,70 @@
+# Armstrong #
+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
+
+#### ZMQ and other gems ####
+	gem install zmq
+	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 './lib/armstrong'
+	
+	get "/" do
+		output_string "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. 
+
+You can also call the `get_message` method which returns the request from the browser, and then reply to the request with `reply(request, message)`. `reply_string(message)` is a helper function that grabs the message and instantly replies to it with `message`.
+
+Now you should run `ruby armstrong_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/armstrong_test.rb` file. For instance, you can extract the id of a certain part of your path like so:
+
+	require 'armstrong'
+	
+	get "/:id" do
+		req = get_request
+		reply req, "id: #{req[:params]["id"]}"
+	end
+	
+The params are always going to be stored in the request, naturally.
+
+## benchmarking ##
+
+	$ time curl localhost:6767/
+	Hello World
+	real	0m0.014s
+	user	0m0.007s
+	sys		0m0.004s
+
+## License ##
+GPLv3

data/demo/armstrong_test.rb

@@ -0,0 +1,15 @@
+require '../lib/armstrong'
+
+get "/" do
+  reply_string "hello world"
+end
+
+get "/:id" do
+  req = get_request
+  reply req, "id: #{req[:params]["id"]}"
+end
+
+get "/:id/do" do
+  req = get_request
+  reply req, "do: #{req[:params]["id"]}"
+end

data/demo/mongrel2.conf

@@ -0,0 +1,32 @@
+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="f400bf85-4538-4f7a-8908-67e313d515c2",
+    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=6767,
+    hosts = [armstrong_host]
+)
+
+settings = {"zeromq.threads": 2, "limits.min_ping": 15, "limits.kill_limit": 2}
+
+servers = [armstrong_serv]

data/lib/armstrong/connection.rb

@@ -0,0 +1,115 @@
+require 'ffi-rzmq'
+
+class Connection
+  attr_reader :app_id, :sub_addr, :pub_addr, :request_sock, :response_sock
+  
+  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
+  def recv
+    msg = ""
+    @request_sock.recv_string msg
+    return msg
+  end
+  
+  #parse the request, this is the best way to get stuff back, as a Hash
+  def receive
+    data = parse(self.recv)
+    return data
+  end
+  
+  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.inspect
+    @response_sock.send_string string, ZMQ::NOBLOCK
+    puts "send string"
+  end
+  
+  def reply(request, message)
+    self.send(request[:uuid], [request[:id]], message)
+  end
+
+  def reply_http(req, body, code=200, headers={"Content-type" => "text/html"})
+    self.reply(req, 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(msg)
+    if(msg.empty?)
+      puts "msg is nil: [#{msg}]"
+      return nil
+    end
+    
+    uuid, id, path, header_size, headers, body_size, body = msg.match(/^(.{36}) (\d+) (.*?) (\d+):(.*?),(\d+):(.*?),$/).to_a[1..-1]
+  
+    return {:uuid => uuid, :id => id, :path => path, :header_size => header_size, :headers => headers, :body_size => body_size, :body => body}
+  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/armstrong/data_structures.rb

@@ -0,0 +1,6 @@
+AddRoute = Struct.new :route, :method
+AddRoutes = Struct.new :routes
+ShowRoutes = Struct.new :this
+Request = Struct.new :data
+ConnectionInformation = Struct.new :connection
+Reply = Struct.new :data, :body, :code, :headers

data/lib/armstrong/main_actors.rb

@@ -0,0 +1,108 @@
+module Aleph
+  class Base
+    class << self
+      attr_accessor :replier, :request_handler, :supervisor
+    end
+  end
+end
+
+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
+  return params
+end
+
+Aleph::Base.replier = Proc.new do   
+  @name = "replier"
+  puts "started (#{@name})"
+  Actor.register(:replier, Actor.current)
+  conn = nil
+  
+  loop do
+    Actor.receive do |msg|
+      msg.when(ConnectionInformation) do |c|
+        #puts "replier: got connection information #{c.inspect}"
+        conn = c.connection
+      end
+      msg.when(Reply) do |m|
+        begin
+          conn.reply_http(m.data, m.body, m.code, m.headers)
+        rescue Exception => e
+          puts "Actor[:replier]: I messed up with exception: #{e.message}"
+        end
+      end
+    end
+  end
+end
+
+Aleph::Base.request_handler = Proc.new do
+  @name = "request_handler"
+  puts "started (#{@name})"
+  Actor.register(:request_handler, Actor.current)
+  Actor.trap_exit = true
+  
+  routes = []
+  loop do
+    Actor.receive do |f|
+      f.when(AddRoute) do |r|
+        routes << [r.route, r.method]
+      end
+      
+      f.when(AddRoutes) do |r|
+        r.routes.each do |k|
+          routes << [k.route, k.method]
+        end
+      end
+
+      f.when(ShowRoutes) do |r|
+        routes.each {|s| puts s}
+      end
+
+      f.when(Request) do |r|
+        failure = true
+        routes.each do |route|
+          if route[0][0].match(r.data[:path])
+            r.data[:params] = process_route(r.data[:path], route[0][0], route[0][1])
+            #puts r.data.inspect
+            Actor.spawn_link(&route[1]) << r.data
+            failure = false
+          end
+        end
+        Actor[:replier] << Reply.new(r.data, "404") if failure
+      end
+
+      f.when(Actor::DeadActorError) do |exit|
+        puts "#{exit.actor} died with reason: [#{exit.reason}]"
+      end
+    end
+  end
+end
+
+#if this dies, all hell will break loose
+Aleph::Base.supervisor = Proc.new do
+  puts "started (supervisor)"
+  Actor.register(:supervisor, Actor.current)
+  Actor.trap_exit = true
+  
+  Actor.link(Actor[:replier])
+  Actor.link(Actor[:request_handler])
+
+  loop do
+    Actor.receive do |f|
+      f.when(Actor::DeadActorError) do |exit|
+        "#{exit.actor.name} died with reason: #{exit.reason}"
+        case exit.actor.name
+        when "request_handler"
+          Actor.spawn_link(&@request_handler)
+        when "replier"
+          Actor.spawn_link(&@replier)          
+        end
+      end
+    end
+  end
+end

data/lib/armstrong.rb

@@ -0,0 +1,148 @@
+require 'actor'
+require 'rubygems'
+require 'lazy'
+require 'open-uri'
+
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require "armstrong/connection"
+require 'armstrong/data_structures'
+require 'armstrong/main_actors'
+
+def get_request
+  return Actor.receive
+end
+
+def reply(request, body, code=200, headers={"Content-type" => "text/html"})
+  Actor[:replier] << Reply.new(request, body, code, headers)
+end
+
+def reply_string(body, code=200, headers={"Content-type" => "text/html"})
+  Actor[:replier] << Reply.new(Actor.receive, body, code, headers)
+end
+  
+module Aleph
+  class Base
+    class << self
+      attr_accessor :conn, :routes, :pairs
+      
+      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
+      
+      def get(path, &block)
+        (@pairs ||= []) << 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 Armstrong < Base  
+    def self.run!
+      uuid = new_uuid
+      puts "starting Armstrong as mongrel2 service #{uuid}"
+      @conn = Connection.new uuid
+      @conn.connect
+      
+      #ensure that all actors are launched. Yea.
+      done = Lazy::demand(Lazy::promise do |done|
+        Actor.spawn(&Aleph::Base.replier)
+        done = Lazy::demand(Lazy::promise do |done|
+          Actor.spawn(&Aleph::Base.request_handler)
+          done = Lazy::demand(Lazy::promise do |done|
+            Actor.spawn(&Aleph::Base.supervisor)
+            done = true
+          end)
+        end)
+      end)
+      
+      Actor[:replier] << ConnectionInformation.new(@conn) if done
+      
+      done = Lazy::demand(Lazy::Promise.new do |done|
+        Actor[:request_handler] << AddRoutes.new(@pairs)
+        done = true
+      end)
+
+      puts "","="*56,"Armstrong has launched on #{Time.now}","="*56, "" if done
+      
+      puts "s:#{Actor[:supervisor]} h:#{Actor[:request_handler]} r: #{Actor[:replier]}"
+      # main loop
+      loop do
+        req = @conn.receive
+        puts "s:#{Actor[:supervisor]} h:#{Actor[:request_handler]} r: #{Actor[:replier]}"
+        Actor[:request_handler] << Request.new(req) if !req.nil?
+      end
+    end
+  end
+  
+  # thank you sinatra!
+  # Sinatra delegation mixin. Mixing this module into an object causes all
+  # methods to be delegated to the Aleph::Armstrong 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
+
+    class << self
+      attr_accessor :target
+    end
+
+    self.target = Armstrong
+  end
+  
+  at_exit { Armstrong.run! }
+end
+
+include Aleph::Delegator
+

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: armstrong
+version: !ruby/object:Gem::Version 
+  hash: 2998277272998775549
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 1
+  version: 0.2.1
+platform: ruby
+authors: 
+- Artem Titoulenko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-06 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: Armstrong is an Mongrel2 fronted, actor-based web development framework similar in style to sinatra. With natively-threaded interpreters (Rubinius2), Armstrong provides true concurrency and high stability, by design.
+email: artem.titoulenko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- demo/armstrong_test.rb
+- demo/mongrel2.conf
+- lib/armstrong.rb
+- lib/armstrong/connection.rb
+- lib/armstrong/data_structures.rb
+- lib/armstrong/main_actors.rb
+homepage: https://www.github.com/artemtitoulenko/armstrong
+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: []
+