control_tower 1.0

data/ext/CTParser/http11_parser.h

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#ifndef http11_parser_h
+#define http11_parser_h
+
+#include <sys/types.h>
+
+#if defined(_WIN32)
+#include <stddef.h>
+#endif
+
+typedef void (*element_cb)(void *data, const char *at, size_t length);
+typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
+
+typedef struct http_parser { 
+  int cs;
+  size_t body_start;
+  int content_len;
+  size_t nread;
+  size_t mark;
+  size_t field_start;
+  size_t field_len;
+  size_t query_start;
+
+  void *data;
+
+  field_cb http_field;
+  element_cb request_method;
+  element_cb request_uri;
+  element_cb fragment;
+  element_cb request_path;
+  element_cb query_string;
+  element_cb http_version;
+  element_cb header_done;
+  
+} http_parser;
+
+int http_parser_init(http_parser *parser);
+int http_parser_finish(http_parser *parser);
+size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off);
+int http_parser_has_error(http_parser *parser);
+int http_parser_is_finished(http_parser *parser);
+
+#define http_parser_nread(parser) (parser)->nread 
+
+#endif

data/lib/control_tower.rb

@@ -0,0 +1,9 @@
+# This file is covered by the Ruby license. See COPYING for more details.
+# Copyright (C) 2009-2010, Apple Inc. All rights reserved.
+
+require 'socket'
+require 'tempfile'
+$: << File.join(File.dirname(__FILE__), 'control_tower', 'vendor')
+require 'rack'
+require File.join(File.dirname(__FILE__), 'control_tower', 'rack_socket')
+require File.join(File.dirname(__FILE__), 'control_tower', 'server')

data/lib/control_tower/rack_socket.rb

@@ -0,0 +1,181 @@
+# This file is covered by the Ruby license. See COPYING for more details.
+# Copyright (C) 2009-2010, Apple Inc. All rights reserved.
+
+framework 'Foundation'
+require 'CTParser'
+require 'stringio'
+
+CTParser # Making sure the Objective-C class is pre-loaded
+
+module ControlTower
+  class RackSocket
+    VERSION = [1,0].freeze
+
+    def initialize(host, port, server, concurrent)
+      @app = server.app
+      @socket = TCPServer.new(host, port)
+      @socket.listen(50)
+      @status = :closed # Start closed and give the server time to start
+
+      if concurrent
+        @multithread = true
+        @request_queue = Dispatch::Queue.concurrent
+        puts "Caution! Wake turbulance from heavy aircraft landing on parallel runway.\n(Parallel Request Action ENABLED!)"
+      else
+        @multithread = false
+        @request_queue = Dispatch::Queue.new('com.apple.ControlTower.rack_socket_queue')
+      end
+      @request_group = Dispatch::Group.new
+    end
+
+    def open
+      @status = :open
+      while (@status == :open)
+        connection = @socket.accept
+
+        @request_queue.async(@request_group) do
+          env = { 'rack.errors' => $stderr,
+                  'rack.multiprocess' => false,
+                  'rack.multithread' => @multithread,
+                  'rack.run_once' => false,
+                  'rack.version' => VERSION }
+          resp = nil
+          x_sendfile_header = 'X-Sendfile'
+          x_sendfile = nil
+          begin
+            request_data = parse!(connection, env)
+            if request_data
+              request_data['REMOTE_ADDR'] = connection.addr[3]
+              status, headers, body = @app.call(request_data)
+
+              # If there's an X-Sendfile header, we'll use sendfile(2)
+              if headers.has_key?(x_sendfile_header)
+                x_sendfile = headers[x_sendfile_header]
+                x_sendfile = ::File.open(x_sendfile, 'r') unless x_sendfile.kind_of? IO
+                x_sendfile_size = x_sendfile.stat.size
+                headers.delete(x_sendfile_header)
+                headers['Content-Length'] = x_sendfile_size
+              end
+
+              # Unless somebody's already set it for us (or we don't need it), set the Content-Length
+              unless (status == -1 ||
+                      (status >= 100 and status <= 199) ||
+                      status == 204 ||
+                      status == 304 ||
+                      headers.has_key?('Content-Length'))
+                headers['Content-Length'] = if body.respond_to?(:each)
+                                              size = 0
+                                              body.each { |x| size += x.bytesize }
+                                              size
+                                            else
+                                              body.bytesize
+                                            end
+              end
+
+              # TODO -- We don't handle keep-alive connections yet
+              headers['Connection'] = 'close'
+
+              resp = "HTTP/1.1 #{status}\r\n"
+              headers.each do |header, value|
+                resp << "#{header}: #{value}\r\n"
+              end
+              resp << "\r\n"
+
+              # Start writing the response
+              connection.write resp
+
+              # Write the body
+              if x_sendfile
+                connection.sendfile(x_sendfile, 0, x_sendfile_size)
+              elsif body.respond_to?(:each)
+                body.each do |chunk|
+                  connection.write chunk
+                end
+              else
+                connection.write body
+              end
+
+            else
+              $stderr.puts "Error: No request data received!"
+            end
+          rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::EINVAL
+            $stderr.puts "Error: Connection terminated!"
+          rescue Object => e
+            if resp.nil? && !connection.closed?
+              connection.write "HTTP/1.1 400\r\n\r\n"
+            else
+              # We have a response, but there was trouble sending it:
+              $stderr.puts "Error: Problem transmitting data -- #{e.inspect}"
+              $stderr.puts e.backtrace.join("\n")
+            end
+          ensure
+            # We should clean up after our tempfile, if we used one.
+            input = env['rack.input']
+            input.unlink if input.class == Tempfile
+            connection.close rescue nil
+          end
+        end
+      end
+    end
+
+    def close
+      @status = :close
+
+      # You get 30 seconds to empty the request queue and get outa here!
+      Dispatch::Source.timer(30, 0, 1, Dispatch::Queue.concurrent) do
+        $stderr.puts "Timed out waiting for connections to close"
+        exit 1
+      end
+      @request_group.wait
+      @socket.close
+    end
+
+
+    private
+
+    def parse!(connection, env)
+      parser = Thread.current[:http_parser] ||= CTParser.new
+      parser.reset
+      data = NSMutableData.alloc.init
+      data.increaseLengthBy(1) # add sentinel
+      parsing_headers = true # Parse headers first
+      nread = 0
+      content_length = 0
+      content_uploaded = 0
+      connection_handle = NSFileHandle.alloc.initWithFileDescriptor(connection.fileno)
+
+      while (parsing_headers || content_uploaded < content_length) do
+        # Read the availableData on the socket and give up if there's nothing
+        incoming_bytes = connection_handle.availableData
+        return nil if incoming_bytes.length == 0
+
+        # Until the headers are done being parsed, we'll parse them
+        if parsing_headers
+          data.setLength(data.length - 1) # Remove sentinel
+          data.appendData(incoming_bytes)
+          data.increaseLengthBy(1) # Add sentinel
+          nread = parser.parseData(data, forEnvironment: env, startingAt: nread)
+          if parser.finished == 1
+            parsing_headers = false # We're done, now on to receiving the body
+            content_length = env['CONTENT_LENGTH'].to_i
+            content_uploaded = env['rack.input'].length
+          end
+        else # Done parsing headers, now just collect request body:
+          content_uploaded += incoming_bytes.length
+          env['rack.input'].appendData(incoming_bytes)
+        end
+      end
+
+      if content_length > 1024 * 1024
+        body_file = Tempfile.new('control-tower-request-body-')
+        NSFileHandle.alloc.initWithFileDescriptor(body_file.fileno).writeData(env['rack.input'])
+        body_file.rewind
+        env['rack.input'] = body_file
+      else
+        env['rack.input'] = StringIO.new(NSString.alloc.initWithData(env['rack.input'], encoding: NSASCIIStringEncoding))
+      end
+      # Returning what we've got...
+      return env
+    end
+  end
+end

data/lib/control_tower/server.rb

@@ -0,0 +1,32 @@
+# This file is covered by the Ruby license. See COPYING for more details.
+# Copyright (C) 2009-2010, Apple Inc. All rights reserved.
+
+module ControlTower
+  class Server
+    attr_reader :app
+
+    def initialize(app, options)
+      @app = app
+      parse_options(options)
+      @socket = RackSocket.new(@host, @port, self, @concurrent)
+    end
+
+    def start
+      trap 'INT' do
+        @socket.close
+        exit
+      end
+
+      # Ok, let the server do it's thing
+      @socket.open
+    end
+
+    private
+
+    def parse_options(opt)
+      @port = (opt[:port] || 8080).to_i
+      @host = opt[:host] || `hostname`.chomp
+      @concurrent = opt[:concurrent]
+    end
+  end
+end

data/lib/rack/handler/control_tower.rb

@@ -0,0 +1,17 @@
+# This file is covered by the Ruby license. See COPYING for more details.
+# Copyright (C) 2009-2010, Apple Inc. All rights reserved.
+
+require "control_tower"
+
+module Rack
+  module Handler
+    class ControlTower
+      def self.run(app, options={})
+        app = Rack::Chunked.new(Rack::ContentLength.new(app))
+        server = ::ControlTower::Server.new(app, options)
+        yield server if block_given?
+        server.start
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: control_tower
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- MacRuby Team
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 1
+        version: 1.2.1
+  type: :runtime
+  version_requirements: *id001
+description: "  Control Tower is a Rack-based HTTP server designed to work with MacRuby. It can\n  be used by calling to its Rack::Handler class, or by running the control_tower\n  executable with a Rackup configuration file (see the control tower help for more\n  details).\n"
+email: macruby-devel@lists.macosforge.org
+executables: 
+- control_tower
+extensions: 
+- ext/CTParser/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- lib/control_tower.rb
+- lib/control_tower/rack_socket.rb
+- lib/control_tower/server.rb
+- lib/rack/handler/control_tower.rb
+- bin/control_tower
+- ext/CTParser/http11_parser.h
+- ext/CTParser/http11_parser.c
+- ext/CTParser/CTParser.h
+- ext/CTParser/CTParser.m
+- ext/CTParser/extconf.rb
+has_rdoc: true
+homepage: http://www.macruby.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Rack-based HTTP server for MacRuby
+test_files: []
+