caldecott 0.0.1 → 0.0.3

data/README.md

@@ -1,3 +1,2 @@
 # caldecott
-
-TBD
+TCP over HTTP tunnel.

data/lib/caldecott.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'rubygems'
+require 'bundler'
+
+require 'caldecott/client'
+require 'caldecott/server'
+
+require 'caldecott/session_logger'
+require 'caldecott/tcp_connection'
+require 'caldecott/version'

data/lib/caldecott/client.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'caldecott'
+require 'caldecott/client/client'
+require 'caldecott/client/tunnel'
+require 'caldecott/client/http_tunnel'
+require 'caldecott/client/websocket_tunnel'

data/lib/caldecott/client/client.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'eventmachine'
+
+module Caldecott
+  module Client
+    def self.sanitize_url(tun_url)
+      tun_url = tun_url =~ /(http|https|ws).*/i ? tun_url : "https://#{tun_url}"
+    end
+
+    def self.start(opts)
+      local_port = opts[:local_port]
+      tun_url    = opts[:tun_url]
+      dst_host   = opts[:dst_host]
+      dst_port   = opts[:dst_port]
+      log_file   = opts[:log_file]
+      log_level  = opts[:log_level]
+      auth_token = opts[:auth_token]
+
+      @quiet = opts[:quiet]
+
+      trap("TERM") { stop }
+      trap("INT") { stop }
+
+      tun_url = sanitize_url(tun_url)
+
+      EM.run do
+        unless @quiet
+          puts "Starting local server on port #{local_port} to #{tun_url}"
+        end
+
+        EM.start_server("localhost", local_port, TcpConnection) do |conn|
+          # avoid races between tunnel setup and incoming local data
+          conn.pause
+
+          log = SessionLogger.new("client", log_file)
+          log.level = SessionLogger.severity_from_string(log_level)
+
+          tun = nil
+
+          conn.onopen do
+            log.debug "local connected"
+            tun = Tunnel.start(log, tun_url, dst_host, dst_port, auth_token)
+          end
+
+          tun.onopen do
+            log.debug "tunnel connected"
+            conn.resume
+          end
+
+          conn.onreceive do |data|
+            log.debug "l -> t #{data.length}"
+            tun.send_data(data)
+          end
+
+          tun.onreceive do |data|
+            log.debug("l <- t #{data.length}")
+            conn.send_data(data)
+          end
+
+          conn.onclose do
+            log.debug "local closed"
+            tun.close
+          end
+
+          tun.onclose do
+            log.debug "tunnel closed"
+            conn.close_connection_after_writing
+          end
+        end
+      end
+    end
+
+    def self.stop
+      puts "Caldecott shutting down" unless @quiet
+      EM.stop
+    end
+  end
+end

data/lib/caldecott/client/http_tunnel.rb

@@ -0,0 +1,236 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'em-http'
+require 'json'
+
+module Caldecott
+  module Client
+    class HttpTunnel
+      MAX_RETRIES = 10
+
+      def initialize(logger, url, dst_host, dst_port, auth_token)
+        @log, @auth_token = logger, auth_token
+        @closing = false
+        @retries = 0
+        init_msg = ""
+
+        # FIXME: why is this optional?
+        if dst_host
+          init_msg = { :host => dst_host, :port => dst_port }.to_json
+        end
+
+        start(url, init_msg)
+      end
+
+      def onopen(&blk)
+        @onopen = blk
+        @onopen.call if @opened
+      end
+
+      def onclose(&blk)
+        @onclose = blk
+        @onclose.call if @closed
+      end
+
+      def onreceive(&blk)
+        @onreceive = blk
+      end
+
+      def send_data(data)
+        @writer.send_data(data)
+      end
+
+      def close
+        return if @closing or @closed
+        @closing = true
+        @writer.close if @writer
+        @reader.close if @reader
+        stop
+      end
+
+      def trigger_on_open
+        @opened = true
+        @onopen.call if @onopen
+      end
+
+      def trigger_on_close
+        close
+        @closed = true
+        @onclose.call if @onclose
+        @onclose = nil
+      end
+
+      def trigger_on_receive(data)
+        @onreceive.call(data)
+      end
+
+      def start(base_uri, init_msg)
+        if (@retries += 1) > MAX_RETRIES
+          trigger_on_close
+          return
+        end
+
+        begin
+          parsed_uri = Addressable::URI.parse(base_uri)
+          parsed_uri.path = '/tunnels'
+
+          @log.debug "post #{parsed_uri.to_s}"
+          req = EM::HttpRequest.new(parsed_uri.to_s).post :body => init_msg, :head => { "Auth-Token" => @auth_token }
+
+          req.callback do
+            @log.debug "post #{parsed_uri.to_s} #{req.response_header.status}"
+            unless [200, 201, 204].include?(req.response_header.status)
+              start(base_uri, init_msg)
+            else
+              @retries = 0
+              resp = JSON.parse(req.response)
+
+              parsed_uri.path = resp["path"]
+              @tun_uri = parsed_uri.to_s
+
+              parsed_uri.path = resp["path_out"]
+              @reader = Reader.new(@log, parsed_uri.to_s, self, @auth_token)
+
+              parsed_uri.path = resp["path_in"]
+              @writer = Writer.new(@log, parsed_uri.to_s, self, @auth_token)
+              trigger_on_open
+            end
+          end
+
+          req.errback do
+            @log.debug "post #{parsed_uri.to_s} error"
+            start(base_uri, init_msg)
+          end
+
+        rescue Exception => e
+          @log.error e
+          trigger_on_close
+          raise e
+        end
+      end
+
+      def stop
+        if (@retries += 1) > MAX_RETRIES
+          trigger_on_close
+          return
+        end
+
+        return if @tun_uri.nil?
+
+        @log.debug "delete #{@tun_uri}"
+        req = EM::HttpRequest.new("#{@tun_uri}").delete :head => { "Auth-Token" => @auth_token }
+
+        req.errback do
+          @log.debug "delete #{@tun_uri} error"
+          stop
+        end
+
+        req.callback do
+          @log.debug "delete #{@tun_uri} #{req.response_header.status}"
+          if [200, 202, 204, 404].include?(req.response_header.status)
+            trigger_on_close
+          else
+            stop
+          end
+        end
+      end
+
+      class Reader
+        def initialize(log, uri, conn, auth_token)
+          @log, @base_uri, @conn, @auth_token = log, uri, conn, auth_token
+          @retries = 0
+          @closing = false
+          start
+        end
+
+        def close
+          @closing = true
+        end
+
+        def start(seq = 1)
+          if (@retries += 1) > MAX_RETRIES
+            @conn.trigger_on_close
+            return
+          end
+
+          return if @closing
+          uri = "#{@base_uri}/#{seq}"
+          @log.debug "get #{uri}"
+          req = EM::HttpRequest.new(uri).get :timeout => 0, :head => { "Auth-Token" => @auth_token }
+
+          req.errback do
+            @log.debug "get #{uri} error"
+            start(seq)
+          end
+
+          req.callback do
+            @log.debug "get #{uri} #{req.response_header.status}"
+            case req.response_header.status
+            when 200
+              @conn.trigger_on_receive(req.response)
+              @retries = 0
+              start(seq + 1)
+            when 404
+              @conn.trigger_on_close
+            else
+              start(seq)
+            end
+          end
+        end
+      end
+
+      class Writer
+        def initialize(log, uri, conn, auth_token)
+          @log, @uri, @conn, @auth_token = log, uri, conn, auth_token
+          @retries = 0
+          @seq, @write_buffer = 1, ""
+          @closing = @writing = false
+        end
+
+        def send_data(data)
+          @write_buffer << data
+          send_data_buffered
+        end
+
+        def close
+          @closing = true
+        end
+
+        def send_data_buffered
+          if (@retries += 1) > MAX_RETRIES
+            @conn.trigger_on_close
+            return
+          end
+
+          return if @closing
+          data, @write_buffer = @write_buffer, "" unless @writing
+
+          @writing = true
+          uri = "#{@uri}/#{@seq}"
+          @log.debug "put #{uri}"
+          req = EM::HttpRequest.new(uri).put :body => data, :head => { "Auth-Token" => @auth_token }
+
+          req.errback do
+            @log.debug "put #{uri} error"
+            send_data_buffered
+          end
+
+          req.callback do
+            @log.debug "put #{uri} #{req.response_header.status}"
+            case req.response_header.status
+            when 200, 202, 204
+              @writing = false
+              @seq += 1
+              @retries = 0
+              send_data_buffered unless @write_buffer.empty?
+            when 404
+              @conn.trigger_on_close
+            else
+              send_data_buffered
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caldecott/client/tunnel.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'addressable/uri'
+
+module Caldecott
+  module Client
+    module Tunnel
+      # Note: I wanted to do this with self#new but had issues
+      # with getting send :initialize to figure out the right
+      # number of arguments
+      def self.start(logger, tun_url, dst_host, dst_port, auth_token)
+        case Addressable::URI.parse(tun_url).normalized_scheme
+        when "http", "https"
+          HttpTunnel.new(logger, tun_url, dst_host, dst_port, auth_token)
+        when "ws"
+          WebSocketTunnel.new(logger, tun_url, dst_host, dst_port, auth_token)
+        else
+          raise "invalid url"
+        end
+      end
+    end
+  end
+end

data/lib/caldecott/client/websocket_tunnel.rb

@@ -0,0 +1,36 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'em-http'
+
+module Caldecott
+  module Client
+    class WebSocketTunnel
+      def initialize(logger, url, dst_host, dst_port, auth_token)
+        @ws = EM::HttpRequest.new("#{url}/websocket/#{dst_host}/#{dst_port}").get :timeout => 0
+      end
+
+      def onopen(&blk)
+        @ws.callback { blk.call }
+      end
+
+      def onclose(&blk)
+        @ws.errback { blk.call }
+        @ws.disconnect { blk.call }
+      end
+
+      def onreceive(&blk)
+        @ws.stream { |data| blk.call(Base64.decode64(data)) }
+      end
+
+      def send_data(data)
+        # Um.. as soon as the em websocket object adds a better named
+        # method for this, start using it.
+        @ws.send(Base64.encode64(data))
+      end
+
+      def close
+        @ws.close_connection_after_writing
+      end
+    end
+  end
+end

data/lib/caldecott/server.rb

@@ -0,0 +1,4 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'caldecott/server/http_tunnel'
+require 'caldecott/server/websocket_tunnel'

data/lib/caldecott/server/http_tunnel.rb

@@ -0,0 +1,212 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'rubygems'
+require 'logger'
+require 'sinatra'
+require 'sinatra/async'
+require 'json'
+require 'uuidtools'
+require 'eventmachine'
+require 'caldecott/tcp_connection.rb'
+require 'caldecott/session_logger.rb'
+
+module Caldecott
+  module Server
+    class Tunnel
+      attr_reader :tun_id, :log, :last_active_at
+      DEFAULT_MAX_DATA_TO_BUFFER = 1 * 1024 * 1024 # 1MB
+
+      def initialize(log, tunnels, host, port, max_data_to_buffer = DEFAULT_MAX_DATA_TO_BUFFER)
+        @log, @tunnels, @host, @port = log, tunnels, host, port
+        @tun_id = UUIDTools::UUID.random_create.to_s
+        @data = @data_next = ""
+        @seq_out = @seq_in = 0
+        @max_data_to_buffer = max_data_to_buffer
+        @last_active_at = Time.now
+      end
+
+      def open(resp)
+        EM::connect(@host, @port, TcpConnection) do |dst_conn|
+          @dst_conn = dst_conn
+
+          @dst_conn.onopen do
+            @log.debug "dst connected"
+            @tunnels[@tun_id] = self
+            resp.content_type :json
+            resp.status 201
+            resp.body safe_hash.to_json
+          end
+
+          @dst_conn.onreceive do |data|
+            @log.debug "t <- d #{data.length}"
+            @data_next << data
+            trigger_reader
+            @dst_conn.pause if @data_next.length > @max_data_to_buffer
+          end
+
+          @dst_conn.onclose do
+            @log.debug "target disconnected"
+            @dst_conn = nil
+            trigger_reader
+            @tunnels.delete(@tun_id) if @data_next.empty?
+          end
+        end
+        @tunnel_created_at = Time.now
+      end
+
+      def delete
+        @log.debug "target disconnected"
+        if @dst_conn
+          @dst_conn.close_connection_after_writing
+        else
+          @tunnels.delete(@tun_id)
+        end
+      end
+
+      def get(resp, seq)
+        @last_active_at = Time.now
+        resp.halt(400, "invalid sequence #{seq} for server seq #{@seq_out}") unless (seq == @seq_out or seq == @seq_out + 1)
+        if seq == @seq_out + 1
+          @data, @data_next = @data_next, ""
+          @seq_out = seq
+        end
+
+        if @data.empty?
+          resp.halt(410, "destination socket closed\n") if @dst_conn.nil?
+          @log.debug "get: waiting for data"
+          @reader = EM.Callback do
+            @data, @data_next = @data_next, ""
+            resp.ahalt(410, "destination socket closed\n") if @data.empty?
+            @log.debug "get: returning data (async)"
+            resp.body @data
+          end
+        else
+          @log.debug "get: returning data (immediate)"
+          resp.body @data
+          @dst_conn.resume
+        end
+      end
+
+      def put(resp, seq)
+        @last_active_at = Time.now
+        resp.halt(400, "invalid sequence #{seq} for server seq #{@seq_in}") unless (seq == @seq_in or seq == @seq_in + 1)
+        if seq == @seq_in
+          resp.status 201
+        else
+          @seq_in = seq
+          @log.debug "t -> d #{resp.request.body.length}"
+          @dst_conn.send_data(resp.request.body.read)
+          resp.status 202
+        end
+      end
+
+      def trigger_reader
+        return unless @reader
+        reader = @reader
+        @reader = nil
+        reader.call
+      end
+
+      def safe_hash
+        {
+          :path => "/tunnels/#{@tun_id}",
+          :path_in => "/tunnels/#{@tun_id}/in",
+          :path_out => "/tunnels/#{@tun_id}/out",
+          :dst_host => @host,
+          :dst_port => @port,
+          :dst_connected => @dst_conn.nil? == false,
+          :seq_out => @seq_out,
+          :seq_in => @seq_in
+        }
+      end
+
+    end
+
+    class HttpTunnel < Sinatra::Base
+      register Sinatra::Async
+
+      @@tunnels = {}
+
+      def self.tunnels
+        @@tunnels
+      end
+
+      # defaults are 1 hour of inactivity with sweeps every 5 minutes
+      def self.start_timer(inactive_timeout = 3600, sweep_interval = 300)
+        EventMachine::add_periodic_timer sweep_interval do
+          # This is needed because there seems to have a bug on the
+          # Connection#set_comm_inactivity_timeout (int overflow )
+          # Look at eventmachine/ext/em.cpp 2289
+          # It reaps the inactive connections
+          #
+          # We also can not seem to add our own timer per tunnel instance.
+          # When we do, the ruby interpreter freaks out and starts throwing
+          #
+          # errors like:
+          #    undefined method `cancel' for 57:Fixnum
+          #
+          # for code like the following during shutdown:
+          #    @inactivity_timer.cancel if @inactivity_timer
+          #    @inactivity_timer.cancel
+          #    @inactivity_timer = nil
+          @@tunnels.each do |id, t|
+            t.delete if (Time.now - t.last_active_at) > inactive_timeout
+          end
+        end
+      end
+
+      def tunnel_from_id(tun_id)
+        tun = @@tunnels[tun_id]
+        not_found("tunnel #{tun_id} does not exist\n") unless tun
+        tun.log.debug "#{request.request_method} #{request.url}"
+        tun
+      end
+
+      before do
+        @log = SessionLogger.new("server", STDOUT)
+        @log.debug "#{request.request_method} #{request.url}"
+        if env['HTTP_AUTH_TOKEN'] != settings.auth_token
+          @log.debug "AUTH FAILURE #{env.inspect}"
+          not_found
+        end
+      end
+
+      get '/' do
+        return "Caldecott Tunnel (HTTP Transport) #{VERSION}\n"
+      end
+
+      get '/tunnels' do
+        content_type :json
+        resp = @@tunnels.values.collect { |t| t.safe_hash }
+        resp.to_json
+      end
+
+      apost '/tunnels' do
+        req = JSON.parse(request.body.read, :symbolize_names => true)
+        Tunnel.new(@log, @@tunnels, req[:host], req[:port]).open(self)
+      end
+
+      get '/tunnels/:tun' do |tun_id|
+        tun = tunnel_from_id(tun_id)
+        tun.safe_hash.to_json
+      end
+
+      delete '/tunnels/:tun' do |tun_id|
+        tun = tunnel_from_id(tun_id)
+        tun.delete
+      end
+
+      aget '/tunnels/:tun_id/out/:seq' do |tun_id, seq|
+        tun = tunnel_from_id(tun_id)
+        seq = seq.to_i
+        tun.get(self, seq)
+      end
+
+      put '/tunnels/:tun_id/in/:seq' do |tun_id, seq|
+        tun = tunnel_from_id(tun_id)
+        seq = seq.to_i
+        tun.put(self, seq)
+      end
+    end
+  end
+end

data/lib/caldecott/server/websocket_tunnel.rb

@@ -0,0 +1,57 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'em-websocket'
+require 'base64'
+
+module Caldecott
+  module Server
+    class WebSocketTunnel
+
+      # quack like sinatra
+      def self.run!(opts)
+        WebSocketTunnel.new.start(opts[:port])
+      end
+
+      def start(port)
+        EM::WebSocket.start(:host => "0.0.0.0", :port => port) do |ws|
+          log = SessionLogger::new("server", STDOUT)
+          dst_conn = nil
+
+          ws.onopen do
+            log.debug "tunnel connected"
+            slash, tunnel, host, port = ws.request['Path'].split('/')
+
+            EM::connect(host, port, TcpConnection) do |d|
+              dst_conn = d
+
+              dst_conn.onopen do
+                log.debug "target connected"
+              end
+
+              dst_conn.onreceive do |data|
+                log.debug("t <- d #{data.length}")
+                ws.send(Base64.encode64(data))
+              end
+
+              dst_conn.onclose do
+                log.debug "target disconnected"
+                ws.close_connection
+              end
+            end
+          end
+
+          ws.onmessage do |msg|
+            decoded = Base64.decode64(msg)
+            log.debug("t -> d #{decoded.length}")
+            dst_conn.send_data(decoded)
+          end
+
+          ws.onclose do
+            log.debug "tunnel disconnected"
+            dst_conn.close_connection_after_writing if dst_conn
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caldecott/session_logger.rb

@@ -0,0 +1,39 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'logger'
+
+module Caldecott
+  class SessionLogger < Logger
+    attr_reader :component, :session
+    @@session = 0
+
+    def initialize(component, *args)
+      super(*args)
+      @component = component
+      @session = @@session += 1
+    end
+
+    def format_message(severity, timestamp, progname, msg)
+      "#{@component} [#{@session}] #{msg}\n"
+    end
+
+    def self.severity_from_string(str)
+      case str.upcase
+      when 'DEBUG'
+        Logger::DEBUG
+      when 'INFO'
+        Logger::INFO
+      when 'WARN'
+        Logger::WARN
+      when 'ERROR'
+        Logger::ERROR
+      when 'FATAL'
+        Logger::FATAL
+      when 'UNKNOWN'
+        Logger::UNKNOWN
+      else
+        Logger::ERROR
+      end
+    end
+  end
+end

data/lib/caldecott/tcp_connection.rb

@@ -0,0 +1,38 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'eventmachine'
+
+module Caldecott
+  # wrapper to avoid callback and state passing spaghetti
+  class TcpConnection < EventMachine::Connection
+    @initialzied = false
+
+    # callbacks
+    def onopen(&blk)
+      @initialized ? blk.call : @onopen = blk
+    end
+
+    def onreceive(&blk)
+      @onreceive = blk
+    end
+
+    def onclose(&blk)
+      @onclose = blk
+    end
+
+    # handle EventMachine::Connection methods
+    def post_init
+      @initialized = true
+      @onopen.call if @onopen
+    end
+
+    def receive_data(data)
+      @onreceive.call(data) if @onreceive
+    end
+
+    def unbind
+      @onclose.call if @onclose
+    end
+
+  end
+end

data/lib/caldecott/version.rb

@@ -1,5 +1,5 @@
 # Copyright (c) 2009-2011 VMware, Inc.
 
 module Caldecott
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

metadata

@@ -2,7 +2,7 @@
 name: caldecott
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors: 
 - VMware
@@ -10,11 +10,131 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-20 00:00:00 -07:00
+date: 2011-11-08 00:00:00 -08:00
 default_executable: 
-dependencies: []
-
-description: TBD
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: em-websocket
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.3.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: async_sinatra
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.2.6
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.6.1
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.2
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.10
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.6.1
+  type: :development
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.7.6
+  type: :development
+  version_requirements: *id011
+description: Caldecott HTTP/Websocket Tunneling Library
 email: support@vmware.com
 executables: []
 
@@ -26,7 +146,18 @@ extra_rdoc_files:
 files: 
 - LICENSE
 - README.md
+- lib/caldecott/client/client.rb
+- lib/caldecott/client/http_tunnel.rb
+- lib/caldecott/client/tunnel.rb
+- lib/caldecott/client/websocket_tunnel.rb
+- lib/caldecott/client.rb
+- lib/caldecott/server/http_tunnel.rb
+- lib/caldecott/server/websocket_tunnel.rb
+- lib/caldecott/server.rb
+- lib/caldecott/session_logger.rb
+- lib/caldecott/tcp_connection.rb
 - lib/caldecott/version.rb
+- lib/caldecott.rb
 has_rdoc: true
 homepage: http://vmware.com
 licenses: []
@@ -54,6 +185,6 @@ rubyforge_project:
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: TBD
+summary: Caldecott HTTP/Websocket Tunneling Library
 test_files: []