caldecott-client 0.0.1

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2010-2011 VMware Inc, All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+This software downloads additional open source software components upon install
+that are distributed under separate terms and conditions.  Please see the license
+information provided in the individual software components for more information.

data/README.md

@@ -0,0 +1,6 @@
+# caldecott-client
+TCP over HTTP tunnel.
+
+## File a Bug
+
+To file a bug against Cloud Foundry Open Source and its components, sign up and use our bug tracking system: [http://cloudfoundry.atlassian.net](http://cloudfoundry.atlassian.net)

data/lib/caldecott-client/client.rb

@@ -0,0 +1,195 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require "socket"
+require "logger"
+
+$:.unshift(File.join(File.dirname(__FILE__), "tunnel"))
+
+require "tunnel"
+require "http_tunnel"
+
+module Caldecott
+
+  class NotImplemented < StandardError; end
+  class InvalidTunnelUrl < StandardError; end
+  class ServerError < StandardError; end
+  class ClientError < StandardError; end
+
+  class << self
+    attr_accessor :logger
+
+    def init
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  init
+
+  module Client
+
+    BUFFER_SIZE = 1024 * 1024 # 1Mb
+    SOCKET_TIMEOUT = 30000 # 30s
+
+    # This is how it's currently used by VMC:
+    # Caldecott::Client.start(
+    #   :local_port => local_port,
+    #   :tun_url => tunnel_url,
+    #   :dst_host => conn_info['hostname'],
+    #   :dst_port => conn_info['port'],
+    #   :log_file => STDOUT,
+    #   :log_level => ENV["VMC_TUNNEL_DEBUG"] || "ERROR",
+    #   :auth_token => auth,
+    #   :quiet => true
+    # )
+    def self.start(options)
+      @client = CaldecottClient.new(options)
+      @client.start
+    end
+
+    def self.stop
+      @client.close if @client
+    end
+
+    class CaldecottClient
+
+      def initialize(options)
+        raise InvalidTunnelUrl, "Tunnel URL is required" unless options[:tun_url]
+
+        if options[:log_file]
+          Caldecott.logger = Logger.new(options[:log_file])
+        end
+
+        Caldecott.logger.level = logger_severity_from_string(options[:log_level])
+
+        @logger = Caldecott.logger
+
+        @local_port = options[:local_port] || 20000
+
+        @tunnel_url = sanitize_url(options[:tun_url])
+
+        @tunnel_options = {
+            :dst_host => options[:dst_host],
+            :dst_port => options[:dst_port],
+            :token => options[:auth_token]
+        }
+
+        @closed = false
+      end
+
+      def close
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+
+      def start
+        @logger.info("Starting the tunnel on port #{@local_port}...")
+        server = TCPServer.new("127.0.0.1", @local_port)
+        @logger.info("Tunnel started")
+
+        loop do
+          # server.accept is blocking until request is received
+          Thread.new(server.accept) do |conn|
+            @logger.info("Connection accepted on #{@local_port}...")
+
+            tunnel = create_tunnel
+            tunnel.start
+
+            w = Thread.new do
+              write_to_tunnel(tunnel, conn)
+            end
+
+            r = Thread.new do
+              read_from_tunnel(tunnel, conn)
+            end
+
+            c = Thread.new do
+              control_threads(tunnel, conn, [w, r])
+            end
+
+            r.join
+            w.join
+            c.join
+
+            @logger.info("Closing tunnel")
+            conn.close
+            tunnel.stop
+
+            break if closed?
+          end
+        end
+
+        server.close
+      end
+
+      def create_tunnel
+        Tunnel.for_url(@tunnel_url, @tunnel_options)
+      end
+
+      def control_threads(tunnel, conn, threads)
+        loop do
+          if tunnel.closed? || conn.closed? || closed?
+            threads.each { |t| t.exit }
+            break
+          end
+
+          sleep(0.01)
+        end
+      end
+
+      def read_from_tunnel(tunnel, conn)
+        in_buf = ""
+        loop do
+          in_buf << tunnel.read unless tunnel.closed?
+
+          break if in_buf.size < 1
+
+          if in_buf.size > 0
+            n_sent = conn.sendmsg(in_buf.slice!(0, BUFFER_SIZE))
+            @logger.debug("l <- t: #{n_sent}, buf: #{in_buf.size}")
+          end
+        end
+      end
+
+      def write_to_tunnel(tunnel, conn)
+        loop do
+          out_data = conn.recv(BUFFER_SIZE)
+
+          break if out_data.size < 1 # connection closed
+
+          @logger.debug("l -> t: #{out_data.size}")
+          tunnel.write(out_data)
+        end
+      end
+
+      private
+
+      def sanitize_url(tun_url)
+        tun_url = tun_url.strip.downcase
+        tun_url =~ /(http|https|ws).*/i ? tun_url : "https://#{tun_url}"
+      end
+
+      def logger_severity_from_string(str)
+        case str.to_s.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
+end

data/lib/caldecott-client/tunnel/http_tunnel.rb

@@ -0,0 +1,132 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require "uri"
+require "net/http"
+require "json"
+
+module Caldecott
+  module Client
+    class HttpTunnel < Tunnel
+      MAX_RETRIES = 10
+
+      attr_reader :path_in, :path_out, :write_seq, :read_seq
+
+      def initialize(url, options)
+        super
+
+        begin
+          @tun_url = URI.parse(url)
+        rescue URI::Error
+          raise ClientError, "Parsing tunnel URL failed"
+        end
+
+        @path_in = nil
+        @path_out = nil
+        @write_seq = nil
+        @read_seq = nil
+      end
+
+      def start
+        req = Net::HTTP::Post.new("/tunnels")
+        req.body = JSON.generate(:host => dst_host, :port => dst_port)
+        req["Content-Type"] = "application/json"
+
+        resp = request(req, "creating tunnel remotely", [200, 201, 204])
+
+        begin
+          payload = JSON.parse(resp.body)
+        rescue
+          raise ClientError, "Parsing response data failed"
+        end
+
+        @tunnel_path = payload["path"]
+        @path_in = payload["path_in"]
+        @path_out = payload["path_out"]
+
+        logger.info("Init success: tunnel_path=#{@tunnel_path}, " +
+                        "path_in=#{@path_in}, path_out=#{@path_out}")
+        @read_seq = 1
+        @write_seq = 1
+      end
+
+      def write(data)
+        if @path_in.nil? || @write_seq.nil?
+          raise ClientError, "Cannot write, tunnel isn't ready"
+        end
+
+        req = Net::HTTP::Put.new(@path_in + "/#{@write_seq}")
+        req.body = data
+        logger.debug("Sending #{data.bytesize} bytes")
+
+        resp = request(req, "sending data", [200, 202, 204, 404, 410])
+
+        if [404, 410].include?(resp.code.to_i)
+          close
+          return
+        end
+
+        @write_seq += 1
+      end
+
+      def read
+        if @path_out.nil? || @read_seq.nil?
+          raise ClientError, "Cannot read, tunnel isn't ready"
+        end
+
+        req = Net::HTTP::Get.new(@path_out + "/#{@read_seq}")
+        resp = request(req, "reading data", [200, 404, 410])
+
+        @read_seq += 1
+
+        if [404, 410].include?(resp.code.to_i)
+          close
+          return ""
+        end
+
+        resp.body
+      end
+
+      def stop
+        return unless @tunnel_path # failed to start
+        req = Net::HTTP::Delete.new(@tunnel_path)
+        request(req, "closing remote tunnel", [200, 202, 204, 404])
+        close
+      end
+
+      def request(req, msg, success_codes)
+        req["Auth-Token"] = token
+        retries = 0
+        resp = nil
+
+        loop do
+          retries += 1
+          logger.info("#{msg.capitalize} (retries=#{retries})")
+
+          begin
+            http = Net::HTTP.new(@tun_url.host, @tun_url.port)
+            http.use_ssl = @tun_url.scheme == "https"
+
+            resp = http.request(req)
+
+            break if success_codes.include?(resp.code.to_i)
+
+            logger.debug("Failed #{msg}: HTTP #{resp.code.to_i}")
+          rescue Timeout::Error
+            logger.error("Failed #{msg}: Timeout error")
+          rescue EOFError # HTTP quirk?
+            logger.debug("Failed #{msg}: #{e.message}")
+          rescue StandardError => e # To satisfy current specs, do we need this really?
+            logger.error("Failed #{msg}: #{e.message}")
+          end
+
+          if retries >= MAX_RETRIES
+            raise ServerError, "Failed #{msg}"
+          end
+        end
+
+        resp
+      end
+
+    end
+  end
+end

data/lib/caldecott-client/tunnel/tunnel.rb

@@ -0,0 +1,56 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+module Caldecott
+  module Client
+    class Tunnel
+
+      def self.for_url(url, options)
+        case url
+          when /^https?/
+            HttpTunnel.new(url, options)
+          when /^ws/
+            # TODO: implement
+            raise NotImplemented, "Web Sockets support coming soon"
+          else
+            raise InvalidTunnelUrl,
+                  "Invalid tunnel url: #{url}, only HTTP and WS schemas supported"
+        end
+      end
+
+      attr_reader :url, :dst_host, :dst_port, :token, :logger
+
+      def initialize(url, options)
+        @url = url
+        @dst_host = options[:dst_host]
+        @dst_port = options[:dst_port]
+        @token = options[:token]
+        @logger = Caldecott.logger
+        @closed = false
+      end
+
+      def close
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+
+      def start
+        raise NotImplemented, "#start not implemented for #{self.class.name}"
+      end
+
+      def write(data)
+        raise NotImplemented, "#write not implemented for #{self.class.name}"
+      end
+
+      def read
+        raise NotImplemented, "#read not implemented for #{self.class.name}"
+      end
+
+      def stop
+        raise NotImplemented, "#stop not implemented for #{self.class.name}"
+      end
+    end
+  end
+end

data/lib/caldecott-client/version.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+module Caldecott
+  module Client
+    VERSION = "0.0.1"
+  end
+end

data/lib/caldecott-client.rb

@@ -0,0 +1,4 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require "caldecott-client/client"
+require "caldecott-client/version"

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification 
+name: caldecott-client
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- VMware
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-01-10 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 6
+        - 1
+        version: 1.6.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 9
+        - 2
+        version: 0.9.2
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 0
+        - 9
+        - 10
+        version: 0.9.10
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 11
+        - 0
+        version: 2.11.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 7
+        - 6
+        version: 1.7.6
+  type: :development
+  version_requirements: *id006
+description: Caldecott Client HTTP/Websocket Tunneling Library
+email: support@vmware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE
+files: 
+- LICENSE
+- README.md
+- lib/caldecott-client/client.rb
+- lib/caldecott-client/tunnel/http_tunnel.rb
+- lib/caldecott-client/tunnel/tunnel.rb
+- lib/caldecott-client/version.rb
+- lib/caldecott-client.rb
+homepage: http://vmware.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Caldecott Client HTTP/Websocket Tunneling Library
+test_files: []
+