armstrong 0.3.0 → 0.4.0

data/armstrong.gemspec

@@ -1,4 +1,4 @@
-Gem::Specification.new 'armstrong', '0.3.0' do |s|
+Gem::Specification.new 'armstrong', '0.4.0' do |s|
   s.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."
   s.summary           = "Highly concurrent, sinatra-like framework"
   s.author            = "Artem Titoulenko"

data/demo/armstrong_test.rb

@@ -1,4 +1,4 @@
-require '../lib/armstrong'
+require File.join(File.dirname(__FILE__), "..", "lib/armstrong")
 
 get "/" do
   "hello world"

data/lib/armstrong/connection.rb

@@ -1,7 +1,9 @@
+require 'ffi'
 require 'ffi-rzmq'
+require 'json'
 
 class Connection
-  attr_reader :app_id, :sub_addr, :pub_addr, :request_sock, :response_sock
+  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
@@ -12,27 +14,29 @@ class Connection
   end
   
   def connect
-    context = ZMQ::Context.new 1
-    @request_sock = context.socket ZMQ::PULL
+    @context = ZMQ::Context.new 1
+    @request_sock = @context.socket ZMQ::PULL
     @request_sock.connect @sub_addr
     
-    @response_sock = context.socket ZMQ::PUB
+    @response_sock = @context.socket ZMQ::PUB
     @response_sock.setsockopt ZMQ::IDENTITY, @app_id
     @response_sock.connect @pub_addr
   end
   
-  #raw recv
+  #raw recv, unparsed message
   def recv
     msg = ""
-    @request_sock.recv_string 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(self.recv)
+    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 
@@ -40,12 +44,14 @@ class Connection
     @response_sock.send_string string, ZMQ::NOBLOCK
   end
   
-  def reply(request, message)
-    self.send(request[:uuid], [request[:id]], message)
+  # reply to an env with `message` string
+  def reply(env, message)
+    self.send(env[:sender], [env[:conn_id]], message)
   end
 
-  def reply_http(req, code=200, headers={"Content-type" => "text/html"}, body="")
-    self.reply(req, http_response(body, code, headers))
+  # 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
@@ -56,14 +62,25 @@ class Connection
     "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.empty?)
+    if msg.nil? || msg.empty?
       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}
+    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])
+    return env
   end
   
   # From WEBrick: thanks dawg.

data/lib/armstrong/main_actors.rb

@@ -7,6 +7,16 @@ module Aleph
   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 }
@@ -32,7 +42,7 @@ Aleph::Base.replier_proc = Proc.new do
       end
       msg.when(Reply) do |m|
         begin
-          conn.reply_http(m.env, m.code, m.headers, m.body)
+          conn.reply_http(m.env, m.body, m.code, m.headers)
         rescue Exception => e
           puts "Actor[:replier]: I messed up with exception: #{e.message}"
         end
@@ -44,7 +54,6 @@ 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
@@ -53,7 +62,7 @@ Aleph::Base.container_proc = Proc.new do
     #just like Rack: env, code, headers, body. HINT HINT
     Aleph::Base.replier << Reply.new(env, response[0], response[1], response[2])
   else
-    Aleph::Base.replier << Reply.new(env, 200, {"Content-Type" => "text/html"}, response)
+    Aleph::Base.replier << Reply.new(env, 200, {"Content-Type", "text/html;charset=utf-8", "Connection", "keep-alive", "Server", "Armstrong", "X-Frame-Options", "sameorigin", "X-XSS_Protection", "1; mode=block"}, response)
   end
 end
 
@@ -73,7 +82,6 @@ Aleph::Base.request_handler_proc = Proc.new do
 
       f.when(Request) do |r|
         failure = true
-        r.env[:headers] = JSON.parse(r.env[:headers])
         verb = r.env[:headers]["METHOD"]
         routes[verb].each do |route|
           if route.route[0].match(r.env[:path])

data/lib/armstrong.rb

@@ -1,8 +1,6 @@
 require 'actor'
 require 'rubygems'
 require 'lazy'
-require 'open-uri'
-require 'json'
 
 libdir = File.dirname(__FILE__)
 $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
@@ -16,6 +14,7 @@ module Aleph
     class << self
       attr_accessor :conn, :routes
       
+      # uuid generator. There's a pretty low chance of collision.
       def new_uuid
         values = [
           rand(0x0010000),
@@ -76,7 +75,16 @@ module Aleph
     end
   end
   
-  class Armstrong < Base  
+  class Armstrong < 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!
       uuid = new_uuid
       puts "starting Armstrong as mongrel2 service #{uuid}"
@@ -138,6 +146,7 @@ module Aleph
     self.target = Armstrong
   end
   
+  # Sinatras secret sauce.
   at_exit { Armstrong.run! }
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: armstrong
 version: !ruby/object:Gem::Version 
-  hash: 3600368719662819624
+  hash: 62288469761365696
   prerelease: 
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Artem Titoulenko
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-17 00:00:00 Z
+date: 2011-11-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ffi