ftw 0.0.8 → 0.0.9

data/README.md

@@ -2,9 +2,10 @@
 
 ## Getting Started
 
-For doing client stuff (http requests, etc), you'll want {FTW::Agent}.
-
-For doing server stuff (http serving, etc), you'll want {FTW::Server}. (not implemented yet)
+* For web agents: {FTW::Agent}
+* For dns: {FTW::DNS}
+* For tcp connections: {FTW::Connection}
+* For tcp servers: {FTW::Server}
 
 ## Overview
 
@@ -12,11 +13,12 @@ net/http is pretty much not good. Additionally, DNS behavior in ruby changes qui
 
 I primarily want two things in both client and server operations:
 
-* A consistent API with good documentation and tests
+* A consistent API with good documentation, readable code, and high quality tests.
 * Modern web features: websockets, spdy, etc.
 
 Desired features:
 
+* Awesome documentation
 * A HTTP client that acts as a full user agent, not just a single connections. (With connection reuse)
 * HTTP and SPDY support.
 * WebSockets support.
@@ -32,6 +34,8 @@ For reference:
 
 ## Agent API
 
+Reference: {FTW::Agent}
+
 ### Common case
 
     agent = FTW::Agent.new
@@ -46,6 +50,8 @@ For reference:
 
 ### SPDY
 
+* This is not implemented yet
+
 SPDY should automatically be attempted. The caller should be unaware.
 
 I do not plan on exposing any direct means for invoking SPDY.
@@ -60,7 +66,7 @@ I do not plan on exposing any direct means for invoking SPDY.
       puts :received => message
     end
 
-## Server API
+## Web Server API
 
 I have implemented a rack server, Rack::Handler::FTW. It does not comply fully
 with the Rack spec. See 'Rack Compliance Issues' below.
@@ -82,7 +88,7 @@ the beginning of the request.
 
 For high-data connections (like uploads, HTTP CONNECT, and HTTP Upgrade), it's
 not practical to hold the entire history of time in a buffer. We'll run out of
-memory, you crazy!
+memory, you crazy fools!
 
 Details here: https://github.com/rack/rack/issues/347
 
@@ -92,6 +98,11 @@ Here are some related projects that I have no affiliation with:
 
 * https://github.com/igrigorik/em-websocket - websocket server for eventmachine
 * https://github.com/faye/faye - pubsub for the web (includes a websockets implementation)
+* https://github.com/faye/faye-websocket-ruby - websocket client and server in ruby
 * https://github.com/lifo/cramp - real-time web framework (async, websockets)
 * https://github.com/igrigorik/em-http-request - HTTP client for EventMachine
 * https://github.com/geemus/excon - http client library
+
+Given some of the above (especially the server-side stuff), I'm likely try and integrate
+with those projects. For example, writing a Faye handler that uses the FTW server, if the
+FTW web server even stays around.

data/lib/ftw/agent.rb

@@ -6,7 +6,6 @@ require "ftw/pool"
 require "ftw/websocket"
 require "addressable/uri"
 require "cabin"
-require "logger"
 
 # This should act as a proper web agent.
 #
@@ -47,9 +46,7 @@ class FTW::Agent
 
   def initialize
     @pool = FTW::Pool.new
-    @logger = Cabin::Channel.get($0)
-    @logger.subscribe(Logger.new(STDOUT))
-    @logger.level = :warn
+    @logger = Cabin::Channel.get
 
     @redirect_max = 20
   end # def initialize
@@ -213,6 +210,17 @@ class FTW::Agent
     return response
   end # def execute
 
+  # shutdown this agent.
+  #
+  # This will shutdown all active connections.
+  def shutdown
+    @pool.each do |identifier, list|
+      list.each do |connection|
+        connection.disconnect("stopping agent")
+      end
+    end
+  end # def shutdown
+
   # Returns a FTW::Connection connected to this host:port.
   def connect(host, port)
     address = "#{host}:#{port}"
@@ -241,5 +249,5 @@ class FTW::Agent
     return connection, nil
   end # def connect
 
-  public(:initialize, :execute, :websocket!, :upgrade!)
+  public(:initialize, :execute, :websocket!, :upgrade!, :shutdown)
 end # class FTW::Agent

data/lib/ftw/connection.rb

@@ -56,8 +56,9 @@ class FTW::Connection
     setup
   end # def initialize
 
+  # Set up this connection.
   def setup
-    @logger = Cabin::Channel.get($0)
+    @logger = Cabin::Channel.get
     @connect_timeout = 2
 
     # Use a fixed-size string that we set to BINARY encoding.
@@ -78,7 +79,7 @@ class FTW::Connection
 
     # TODO(sissel): Validate @destinations
     # TODO(sissel): Barf if a destination is not of the form "host:port"
-  end # def initialize
+  end # def setup
 
   # Create a new connection from an existing IO instance (like a socket)
   # 
@@ -135,7 +136,8 @@ class FTW::Connection
     @socket = Socket.new(family, Socket::SOCK_STREAM, 0)
 
     # This api is terrible. pack_sockaddr_in? This isn't C, man...
-    sockaddr = Socket.pack_sockaddr_in(port, @remote_address)
+    @logger.info("packing", :data => [port.to_i, @remote_address])
+    sockaddr = Socket.pack_sockaddr_in(port.to_i, @remote_address)
     # TODO(sissel): Support local address binding
 
     # Connect with timeout
@@ -303,6 +305,14 @@ class FTW::Connection
     end
   end # def secure
 
+  # Secure this connection.
+  #
+  # The handshake method for OpenSSL::SSL::SSLSocket is different depending
+  # on the mode (client or server).
+  #
+  # @param [Symbol] handshake_method The method to call on the socket to
+  #   complete the ssl handshake. See OpenSSL::SSL::SSLSocket#connect_nonblock
+  #   of #accept_nonblock for more details
   def do_secure(handshake_method)
     # SSLSocket#connect_nonblock will do the SSL/TLS handshake.
     # TODO(sissel): refactor this into a method that both secure and connect
@@ -348,10 +358,12 @@ class FTW::Connection
     return @secure
   end # def secured?
 
+  # Is this a client connection?
   def client?
     return @mode == :client
   end # def client?
 
+  # Is this a server connection?
   def server?
     return @mode == :server
   end # def server?

data/lib/ftw/dns.rb

@@ -1,6 +1,7 @@
 require "ftw/namespace"
 require "socket" # for Socket.gethostbyname
 require "ftw/singleton"
+require "ftw/dns/dns"
 
 # I wrap whatever Ruby provides because it is historically very
 # inconsistent in implementation behavior across ruby platforms and versions.
@@ -11,28 +12,31 @@ require "ftw/singleton"
 # behavior is necessary for my continued sanity :)
 class FTW::DNS
   extend FTW::Singleton
-  # TODO(sissel): Switch to using Resolv::DNS since it lets you (the programmer)
-  # choose dns configuration (servers, etc)
 
+  # The ipv4-in-ipv6 address space prefix.
   V4_IN_V6_PREFIX = "0:" * 12
 
+  # An array of resolvers. By default this includes a FTW::DNS::DNS instance.
+  attr_reader :resolvers
+
   private
 
+  # A new resolver.
+  #
+  # The default set of resolvers is only {FTW::DNS::DNS} which does DNS
+  # resolution.
+  def initialize
+    @resolvers = [FTW::DNS::DNS.new]
+  end # def initialize
+
   # Resolve a hostname.
   #
-  # It will return an array of all known addresses for the host.
+  # Returns an array of all addresses for this host. Empty array resolution
+  # failure.
   def resolve(hostname)
-    official, aliases, family, *addresses = Socket.gethostbyname(hostname)
-    # We ignore family, here. Ruby will return v6 *and* v4 addresses in
-    # the same gethostbyname() call. It is confusing. 
-    #
-    # Let's just rely entirely on the length of the address string.
-    return addresses.collect do |address|
-      if address.length == 16
-        unpack_v6(address)
-      else
-        unpack_v4(address)
-      end
+    return @resolvers.reduce([]) do |memo, resolver|
+      result = resolver.resolve(hostname)
+      memo += result unless result.nil?
     end
   end # def resolve
 
@@ -45,25 +49,5 @@ class FTW::DNS
     return addresses[rand(addresses.size)]
   end # def resolve_random
 
-  # Unserialize a 4-byte ipv4 address into a human-readable a.b.c.d string
-  def unpack_v4(address)
-    return address.unpack("C4").join(".")
-  end # def unpack_v4
-
-  # Unserialize a 16-byte ipv6 address into a human-readable a:b:c:...:d string
-  def unpack_v6(address)
-    if address.length == 16
-      # Unpack 16 bit chunks, convert to hex, join with ":"
-      address.unpack("n8").collect { |p| p.to_s(16) } \
-        .join(":").sub(/(?:0:(?:0:)+)/, "::")
-    else 
-      # assume ipv4
-      # Per the following sites, "::127.0.0.1" is valid and correct
-      # http://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses
-      # http://www.tcpipguide.com/free/t_IPv6IPv4AddressEmbedding.htm
-      "::" + unpack_v4(address)
-    end
-  end # def unpack_v6
-
   public(:resolve, :resolve_random)
 end # class FTW::DNS

data/lib/ftw/dns/dns.rb

@@ -0,0 +1,48 @@
+require "ftw/namespace"
+
+# A FTW::DNS resolver that uses Socket.gethostbyname() to resolve addresses.
+class FTW::DNS::DNS
+  # TODO(sissel): Switch to using Resolv::DNS since it lets you (the programmer)
+  # choose dns configuration (servers, etc)
+  private
+
+  # Resolve a hostname.
+  #
+  # It will return an array of all known addresses for the host.
+  def resolve(hostname)
+    official, aliases, family, *addresses = Socket.gethostbyname(hostname)
+    # We ignore family, here. Ruby will return v6 *and* v4 addresses in
+    # the same gethostbyname() call. It is confusing. 
+    #
+    # Let's just rely entirely on the length of the address string.
+    return addresses.collect do |address|
+      if address.length == 16
+        unpack_v6(address)
+      else
+        unpack_v4(address)
+      end
+    end
+  end # def resolve
+
+  # Unserialize a 4-byte ipv4 address into a human-readable a.b.c.d string
+  def unpack_v4(address)
+    return address.unpack("C4").join(".")
+  end # def unpack_v4
+
+  # Unserialize a 16-byte ipv6 address into a human-readable a:b:c:...:d string
+  def unpack_v6(address)
+    if address.length == 16
+      # Unpack 16 bit chunks, convert to hex, join with ":"
+      address.unpack("n8").collect { |p| p.to_s(16) } \
+        .join(":").sub(/(?:0:(?:0:)+)/, "::")
+    else 
+      # assume ipv4
+      # Per the following sites, "::127.0.0.1" is valid and correct
+      # http://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses
+      # http://www.tcpipguide.com/free/t_IPv6IPv4AddressEmbedding.htm
+      "::" + unpack_v4(address)
+    end
+  end # def unpack_v6
+
+  public(:resolve)
+end # class FTW::DNS::DNS

data/lib/ftw/dns/hash.rb

@@ -0,0 +1,25 @@
+require "ftw/namespace"
+
+# Provide resolution name -> address mappings through hash lookups
+class FTW::DNS::Hash
+  private
+
+  # A new hash dns resolver.
+  #
+  # @param [#[]] data Must be a hash-like thing responding to #[]
+  def initialize(data={})
+    @data = data
+  end # def initialize
+
+  # Resolve a hostname.
+  #
+  # It will return an array of all known addresses for the host.
+  def resolve(hostname)
+    result = @data[hostname]
+    return nil if result.nil?
+    return result if result.is_a?(Array)
+    return [result]
+  end # def resolve
+
+  public(:resolve)
+end

data/lib/ftw/namespace.rb

@@ -3,4 +3,6 @@ module FTW
   module HTTP; end
   # :nodoc:
   class WebSocket; end
+  # :nodoc:
+  class DNS; end
 end

data/lib/ftw/pool.rb

@@ -52,4 +52,16 @@ class FTW::Pool
       return add(identifier, obj)
     end
   end # def fetch
+
+  # Iterate over all pool members.
+  #
+  # This holds the pool lock during this method, so you should not call 'fetch'
+  # or 'add'.
+  def each(&block)
+    @lock.synchronize do
+      @pool.each do |identifier, object|
+        block.call(identifier, object)
+      end
+    end
+  end # def each
 end # class FTW::Pool

data/lib/ftw/server.rb

@@ -70,7 +70,7 @@ class FTW::Server
         end
 
         # Break when successfully listened
-        p :accept? => socket.respond_to?(:accept)
+        #p :accept? => socket.respond_to?(:accept)
         @sockets["#{host}(#{ip}):#{port}"] = socket
         local_failures.clear
         break
@@ -82,12 +82,12 @@ class FTW::Server
     raise ServerSetupFailure.new(failures) if failures.any?
   end # def initialize
 
-  # Close the server sockets
-  def close
+  # Stop serving.
+  def stop
     @sockets.each do |name, socket|
       socket.close
     end
-  end # def close
+  end # def stop
 
   # Yield FTW::Connection instances to the block as clients connect.
   def each_connection(&block)
@@ -97,7 +97,7 @@ class FTW::Server
       sockets = @sockets.values
       read, write, error = IO.select(sockets, nil, nil, nil)
       read.each do |serversocket|
-        p serversocket.methods.sort
+        #p serversocket.methods.sort
         socket, addrinfo = serversocket.accept
         connection = FTW::Connection.from_io(socket)
         yield connection
@@ -105,6 +105,6 @@ class FTW::Server
     end
   end # def each_connection
 
-  public(:initialize, :close, :each_connection)
+  public(:initialize, :stop, :each_connection)
 end # class FTW::Server
 

data/lib/ftw/singleton.rb

@@ -12,11 +12,24 @@ require "ftw/namespace"
 #
 # foo = Foo.singleton
 module FTW::Singleton
+  # This is invoked when you include this module. It raises an exception because you should be
+  # using 'extend' not 'include' for this module..
   def self.included(klass)
     raise ArgumentError.new("In #{klass.name}, you want to use 'extend #{self.name}', not 'include ...'")
   end # def included
 
-  # Create a singleton instance of this class.
+  # Create a singleton instance of whatever class this module is extended into.
+  #
+  # Example:
+  #
+  #     class Foo
+  #       extend FTW::Singleton
+  #       def bar
+  #         "Hello!"
+  #       end
+  #     end
+  #
+  #     p Foo.singleton.bar   # == "Hello!"
   def singleton
     @instance ||= self.new
     return @instance

data/lib/ftw/version.rb

@@ -3,5 +3,5 @@ require "ftw/namespace"
 # :nodoc:
 module FTW
   # The version of this library
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/lib/ftw/websocket.rb

@@ -38,6 +38,7 @@ class FTW::WebSocket
     @request = request
     prepare(@request)
     @parser = FTW::WebSocket::Parser.new
+    @messages = []
   end # def initialize
 
   # Set the connection for this websocket. This is usually invoked by FTW::Agent
@@ -118,13 +119,26 @@ class FTW::WebSocket
   #
   # The text payload of each message will be yielded to the block.
   def each(&block)
-    loop do
-      @parser.feed(@connection.read(16384)) do |payload|
-        yield payload
-      end
+    while true
+      block.call(receive)
     end
   end # def each
 
+  # Receive a single payload
+  def receive
+    @messages += network_consume if @messages.empty?
+    @messages.shift
+  end # def receive
+
+  # Consume payloads from the network.
+  def network_consume
+    payloads = []
+    @parser.feed(@connection.read(16384)) do |payload|
+      payloads << payload
+    end
+    return payloads
+  end # def network_consume
+
   # Publish a message text.
   #
   # This will send a websocket text frame over the connection.
@@ -133,6 +147,5 @@ class FTW::WebSocket
     writer.write_text(@connection, message)
   end # def publish
 
-  public(:initialize, :connection=, :handshake_ok?, :each, :publish)
+  public(:initialize, :connection=, :handshake_ok?, :each, :publish, :receive)
 end # class FTW::WebSocket
-

data/lib/ftw/websocket/parser.rb

@@ -47,7 +47,7 @@ class FTW::WebSocket::Parser
 
   # A new WebSocket protocol parser.
   def initialize
-    @logger = Cabin::Channel.get($0)
+    @logger = Cabin::Channel.get
     @opcode = 0
     @masking_key = ""
     @flag_final_payload = 0
@@ -171,9 +171,9 @@ class FTW::WebSocket::Parser
     data = get
     case @need
       when 2
-        @payload_length = data.unpack("S")
+        @payload_length = data.unpack("S").first
       when 8
-        @payload_length = data.unpack("Q")
+        @payload_length = data.unpack("Q").first
       else
         raise "Unknown payload_length byte length '#{@need}'"
     end
@@ -190,6 +190,8 @@ class FTW::WebSocket::Parser
     return nil
   end # def extended_payload_length
 
+  # State: mask
+  # Read the mask key
   def mask
     #    + - - - - - - - - - - - - - - - +-------------------------------+
     #    |                               |Masking-key, if MASK set to 1  |
@@ -203,7 +205,6 @@ class FTW::WebSocket::Parser
   # State: payload
   # Read the full payload and return it.
   # See: http://tools.ietf.org/html/rfc6455#section-5.3
-  #
   def payload
     # TODO(sissel): Handle massive payload lengths without exceeding memory.
     # Perhaps if the payload is large (say, larger than 500KB by default),
@@ -219,6 +220,10 @@ class FTW::WebSocket::Parser
     end
   end # def payload
 
+  # Unmask the message using the key.
+  #
+  # For implementation specification, see
+  # http://tools.ietf.org/html/rfc6455#section-5.3
   def unmask(message, key)
     masked = []
     mask_bytes = key.unpack("C4")
@@ -229,7 +234,7 @@ class FTW::WebSocket::Parser
     end
     p :unmasked => masked.pack("C*"), :original => message
     return  masked.pack("C*")
-  end # def mask
+  end # def unmask
 
   public(:feed)
 end # class FTW::WebSocket::Parser

data/lib/ftw/websocket/rack.rb

@@ -1,5 +1,6 @@
 require "ftw/namespace"
 require "ftw/websocket/parser"
+require "ftw/crlf"
 require "base64" # stdlib 
 require "digest/sha1" # stdlib
 
@@ -20,6 +21,7 @@ require "digest/sha1" # stdlib
 #     end
 class FTW::WebSocket::Rack
   include FTW::WebSocket::Constants
+  include FTW::CRLF
 
   private
 
@@ -34,7 +36,11 @@ class FTW::WebSocket::Rack
     expect_equal("websocket", @env["HTTP_UPGRADE"],
                  "The 'Upgrade' header must be set to 'websocket'")
     # RFC6455 section 4.2.1 bullet 4
-    expect_equal("Upgrade", @env["HTTP_CONNECTION"],
+    # Firefox uses a multivalued 'Connection' header, that appears like this:
+    #   Connection: keep-alive, Upgrade
+    # So we have to split this multivalue field. 
+    expect_equal(true,
+                 @env["HTTP_CONNECTION"].split(/, +/).include?("Upgrade"),
                  "The 'Connection' header must be set to 'Upgrade'")
     # RFC6455 section 4.2.1 bullet 6
     expect_equal("13", @env["HTTP_SEC_WEBSOCKET_VERSION"],
@@ -100,7 +106,13 @@ class FTW::WebSocket::Rack
   def each
     connection = @env["ftw.connection"]
     while true
-      data = connection.read(16384)
+      begin
+        data = connection.read(16384)
+      rescue EOFError
+        # connection shutdown, close up.
+        break
+      end
+
       @parser.feed(data) do |payload|
         yield payload if !payload.nil?
       end

data/lib/ftw/websocket/writer.rb

@@ -57,12 +57,16 @@ class FTW::WebSocket::Writer
     connection.write(data.pack(pack.join("")))
   end # def write_text
 
+  # Pack the opcode and flags
+  #
+  # Currently assumes 'fin' flag is set.
   def pack_opcode(data, pack, opcode)
     # Pack the first byte (fin + opcode)
     data << ((1 << 7) | opcode)
     pack << "C"
   end # def pack_opcode
 
+  # Pack the payload.
   def pack_payload(data, pack, text, mode)
     pack_maskbit_and_length(data, pack, text.length, mode)
     pack_extended_length(data, pack, text.length) if text.length > 126
@@ -97,6 +101,7 @@ class FTW::WebSocket::Writer
     return masked.pack("C*")
   end # def mask
 
+  # Pack the first part of the length (mask and 7-bit length)
   def pack_maskbit_and_length(data, pack, length, mode)
     # Pack mask + payload length
     maskbit = (mode == :client) ? (1 << 7) : 0
@@ -113,5 +118,16 @@ class FTW::WebSocket::Writer
     pack << "C"
   end
 
+  def pack_extended_length(data, pack, length)
+    data << length
+    if length >= (1 << 16)
+      # For lengths >= 16 bits, pack 8 byte length
+      pack << "Q"
+    else
+      # For lengths < 16 bits, pack 2 byte length
+      pack << "S"
+    end
+  end # def pack_extended_length
+
   public(:initialize, :write_text)
 end # module FTW::WebSocket::Writer

data/lib/rack/handler/ftw.rb

@@ -3,6 +3,7 @@ require "ftw"
 require "ftw/protocol"
 require "ftw/crlf"
 require "socket"
+require "cabin"
 
 # FTW cannot fully respect the Rack 1.1 specification due to technical
 # limitations in the Rack design, specifically:
@@ -54,10 +55,13 @@ class Rack::Handler::FTW
   # A string constant value (used to avoid typos).
   RACK_DOT_RUN_ONCE = "rack.run_once".freeze
   # A string constant value (used to avoid typos).
+  RACK_DOT_LOGGER = "rack.logger".freeze
+  # A string constant value (used to avoid typos).
   FTW_DOT_CONNECTION = "ftw.connection".freeze
 
   # This method is invoked when rack starts this as the server.
   def self.run(app, config)
+    #@logger.subscribe(STDOUT)
     server = self.new(app, config)
     server.run
   end # def self.run
@@ -68,6 +72,7 @@ class Rack::Handler::FTW
   def initialize(app, config)
     @app = app
     @config = config
+    @threads = []
   end # def initialize
 
   # Run the server.
@@ -85,14 +90,20 @@ class Rack::Handler::FTW
     # call.  It takes exactly one argument, the environment and returns an
     # Array of exactly three values: The status, the headers, and the body."""
     #
-    server = FTW::Server.new([@config[:Host], @config[:Port]].join(":"))
-    server.each_connection do |connection|
-      Thread.new do
+    logger.info("Starting server", :config => @config)
+    @server = FTW::Server.new([@config[:Host], @config[:Port]].join(":"))
+    @server.each_connection do |connection|
+      @threads << Thread.new do
         handle_connection(connection)
       end
     end
   end # def run
 
+  def stop
+    @server.stop unless @server.nil?
+    @threads.each(&:join)
+  end # def stop
+
   # Handle a new connection.
   #
   # This method parses http requests and passes them on to #handle_request
@@ -102,6 +113,13 @@ class Rack::Handler::FTW
     while true
       begin
         request = read_http_message(connection)
+      rescue EOFError, Errno::EPIPE, Errno::ECONNRESET, HTTP::Parser::Error
+        # Connection EOF'd or errored before we finished reading a full HTTP
+        # message, shut it down.
+        break
+      end
+
+      begin
         handle_request(request, connection)
       rescue => e
         puts e.inspect
@@ -133,6 +151,7 @@ class Rack::Handler::FTW
       RACK_DOT_MULTITHREAD => true,
       RACK_DOT_MULTIPROCESS => false,
       RACK_DOT_RUN_ONCE => false,
+      RACK_DOT_LOGGER => logger,
 
       # Extensions, not in Rack v1.1. 
 
@@ -140,7 +159,7 @@ class Rack::Handler::FTW
       # It should be used when you need to hijack the connection for use
       # in proxying, HTTP CONNECT, websockets, SPDY(maybe?), etc.
       FTW_DOT_CONNECTION => connection
-    }
+    } # env
 
     request.headers.each do |name, value|
       # The Rack spec says: 
@@ -161,8 +180,10 @@ class Rack::Handler::FTW
       env["HTTP_#{name.upcase.gsub("-", "_")}"] = value
     end # request.headers.each
 
+    # Invoke the application in this rack app
     status, headers, body = @app.call(env)
 
+    # The application is done handling this request, respond to the client.
     response = FTW::Response.new
     response.status = status.to_i
     response.version = request.version
@@ -177,5 +198,13 @@ class Rack::Handler::FTW
     end
   end # def handle_request
 
-  public(:run, :initialize)
+  # Get the logger.
+  def logger
+    if @logger.nil?
+      @logger = Cabin::Channel.get
+    end
+    return @logger
+  end # def logger
+
+  public(:run, :initialize, :stop)
 end

data/test/ftw/singleton.rb

@@ -0,0 +1,19 @@
+require File.join(File.expand_path(__FILE__).sub(/\/ftw\/.*/, "/testing"))
+require "ftw/singleton"
+
+describe FTW::Singleton do
+  test "extending with FTW::Singleton gives a singleton method" do
+    class Foo
+      extend FTW::Singleton
+    end
+    assert_respond_to(Foo, :singleton)
+  end
+
+  test "FTW::Singleton gives a singleton instance" do
+    class Foo
+      extend FTW::Singleton
+    end
+    assert_instance_of(Foo, Foo.singleton)
+    assert_equal(Foo.singleton.object_id, Foo.singleton.object_id)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ftw
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-05 00:00:00.000000000 Z
+date: 2012-03-23 00:00:00.000000000 Z
 dependencies: []
 description: For The Web. Trying to build a solid and sane API for client and server
   web stuff. Client and Server operations for HTTP, WebSockets, SPDY, etc.
@@ -39,6 +39,8 @@ files:
 - lib/ftw/protocol.rb
 - lib/ftw/response.rb
 - lib/ftw/namespace.rb
+- lib/ftw/dns/dns.rb
+- lib/ftw/dns/hash.rb
 - lib/ftw/cookies.rb
 - lib/ftw/singleton.rb
 - lib/ftw/crlf.rb
@@ -46,6 +48,7 @@ files:
 - test/docs.rb
 - test/ftw/http/dns.rb
 - test/ftw/http/headers.rb
+- test/ftw/singleton.rb
 - test/ftw/crlf.rb
 - test/all.rb
 - README.md
@@ -71,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.16
+rubygems_version: 1.8.18
 signing_key: 
 specification_version: 3
 summary: For The Web. Trying to build a solid and sane API for client and server web