pipe2me-client 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45f85801ad57c6402d4c6aecbe01cd335e6363e5
+  data.tar.gz: c72fa32c04e45830226f4f5a103e112ef0448cc6
+SHA512:
+  metadata.gz: 65c12c51649a8b1b01cdaf274012a9d3ac2accba70dff89064cc260c3c4423288fa40b2042a16f9c859eda270d5df0d789082db93d526aeb5386fc1c0ac6bb3c
+  data.tar.gz: f934aeef86119c2feb2c5fba0c824c59366f9d79d29d77173750397ac16b11077147f8e64e5e4d6b1df10e6480020b8ede0ce166969d34d9c5f5f56b8fd23689

data/README.mdown

@@ -0,0 +1,96 @@
+# pipe2me client
+
+This is the ruby client for the pipe2me server package. 
+The pipe2me client lets you publish local services to the public internet
+with the help and orchestration of a pipe2me server. For more details
+see [pipe2me](https://github.com/kinko/pipe2me)
+
+## Installation
+
+    gem install pipe2me-client
+    # optional: install man page
+    sudo rake install
+
+## Usage
+
+Mini-example: This registers two tunnels with a single hostname for 
+two services on localhost (http on port 9090, https on port 9091). 
+
+    # Setup tunnels. This responds with the domain name
+    > ./bin/pipe2me setup -p http,https --server http://pipe2.me --auth 123 --ports 9090,9091
+    pretty-ivory-horse.test.pipe2.me
+
+    # Review the assigned URLs:
+    > cat pipe2me.info.inc | grep URL
+    PIPE2ME_URLS_0=http://pretty-ivory-horse.test.pipe2.me:10003
+    PIPE2ME_URLS_1=https://pretty-ivory-horse.test.pipe2.me:10004
+
+    # Start the tunnels via foreman (but please review on using foreman)
+    > /bin/pipe2me start
+
+See also the [example session](http://test.pipe2.me/example_session.html) 
+and the [man page](http://test.pipe2.me/pipe2me.1.html).
+
+## Testing
+
+Tests are implemented using 
+[roundup](https://github.com/bmizerany/roundup/blob/master/INSTALLING#files).
+To install roundup on OSX, run `brew install roundup`. Other systems are 
+supported as well, compare roundup's documentation for details.
+
+The implemented tests are *integration tests* in the sense, that they test the 
+behaviour of the *pipe2me-client* package in connection to an external pipe2me 
+server. That means you should run a pipe2me server on your local machine. Note 
+that the server must be configured to support test mode. (In test mode a pipe2me
+server accepts test auth tokens, that create short lived tunnels 
+with self-signed certificates.) 
+
+To run the tests against a locally installed test server run `rake`. Note that
+the local test server is expected at "pipe2.dev:8080". You might have to adjust
+the `/etc/hosts` file to add an entry 
+
+    127.0.0.1    pipe2.dev
+
+Before submitting a pull request you should also run a test against the 
+test.pipe2.me instance, which is available most of the time for that purpose. 
+To do that, run `rake test:release`.
+
+## Auth tokens
+
+As ports and domain names are sparse resources the pipe2me server API
+requires the use of authorization tokens when requesting a tunnel. A
+token is similar to a currency in that it describes which tunnels are
+supported. This could limit the number of tunneled ports, the traffic
+for those ports, whether or not a certificate is self-signed or signed
+by a regular CA, etc. 
+
+The features of a token are not defined within this protocol. However,
+there has to be one. Contact the administrator of the pipe2me server
+to know more.
+
+### Auth tokens on test.pipe2.me
+
+The test.pipe2.me server is configured to use some public tokens. 
+
+- a test token: this builds tunnels that are available for 5 minutes.
+  The test token is intended for use with automated test scenarios.
+  The current test token is `test@test.kinko.me`.
+- a review token: this builds tunnels that are available for up to 
+  one day. A review token is intended for get a feel for the pipe2me
+  package. The current review token is `review@test.kinko.me`.
+
+If you need a longer lived token for development, review and/or test 
+feel free to contact us at contact@kinko.me. 
+
+If you want to use pipe2me for any practical purpose consider 
+signing up at https://pipe2.me, which should be online end of January. 
+
+## Licensing
+
+**The pipe2me client software** is (c) The Kinko Team, 2014 and released to you 
+under the terms of the MIT License (MIT), see COPYING.MIT for details.
+
+The subdirectory lib/vendor contains third-party code, which is subject to its own copyrights.
+Please see the respective source files for copyright information.
+ 
+(c) The kinko team, 2014

data/bin/pipe2me

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require "pipe2me"
+require "pipe2me/cli"
+require "pipe2me/cli-foreman"
+require "pipe2me/cli-monit"
+
+begin
+  Pipe2me::CLI.start ARGV
+rescue
+  if UI.verbosity >= 2
+    UI.error $!
+    raise
+  elsif UI.verbosity >= 0
+    UI.error $!
+  else
+    STDERR.puts $!
+  end
+  exit 1
+end

data/lib/pipe2me.rb

@@ -0,0 +1,9 @@
+module Pipe2me
+end
+
+require "simple/ui"
+
+require_relative "pipe2me/version"
+require_relative "pipe2me/config"
+require_relative "pipe2me/tunnel"
+

data/lib/pipe2me/cli-foreman.rb

@@ -0,0 +1,21 @@
+class Pipe2me::CLI < Thor
+  desc "start", "Start tunnels"
+  option :echo, :type => :boolean, :banner => "Also run echo servers"
+  def start
+    procfile = options[:echo] ? "pipe2me.procfile.echo" : "pipe2me.procfile"
+
+    File.open procfile, "w" do |io|
+      Pipe2me::Tunnel.tunnel_commands.each do |name, cmd|
+        io.write "#{name}: #{cmd}\n"
+      end
+      
+      next unless options[:echo]
+        
+      Pipe2me::Tunnel.echo_commands.each do |name, cmd|
+        io.write "#{name}: #{cmd}\n"
+      end
+    end
+
+    Kernel.exec "foreman start -f #{procfile}"
+  end
+end

data/lib/pipe2me/cli-monit.rb

@@ -0,0 +1,62 @@
+class Pipe2me::CLI < Thor
+  desc "monit", "Create monitrc file and run monit"
+  option :port, :default => 5555, :banner => "control port"
+  option :echo, :type => :boolean, :banner => "Also run echo servers"
+  def monit(*args)
+    monitrc_file = create_monitrc
+    
+    UI.warn "Running: monit -c #{monitrc_file} #{args.join(" ")}"
+    Kernel.exec "monit", "-c", monitrc_file, *args
+  end
+  
+  desc "monitrc", "Create monitrc file"
+  option :port, :default => 5555, :banner => "control port"
+  option :echo, :type => :boolean, :banner => "Also run echo servers"
+  def monitrc
+    monitrc_file = create_monitrc
+    Kernel.exec "monit", "-c", monitrc_file, "-t"
+  end
+
+  private
+  
+  def create_monitrc
+    path = options[:echo] ? "pipe2me.monitrc.echo" : "pipe2me.monitrc"
+
+    # The daemon binary
+    daemon_bin = `which daemon`.chomp 
+    daemon = "#{daemon_bin} -D #{File.expand_path(Dir.getwd)}"
+    
+    port = options[:port]
+
+    logfile = File.expand_path "pipe2me.monit.log"
+    piddir = File.expand_path "pipe2me.monit.pids"
+    FileUtils.mkdir_p piddir
+
+    commands = Pipe2me::Tunnel.tunnel_commands
+    commands += Pipe2me::Tunnel.echo_commands if options[:echo]
+    
+    File.open path, "w", 0600 do |io|
+      require "erb"
+
+      erb = ERB.new MONITRC_ERB
+      io.write erb.result(self.send(:binding))
+    end
+    
+    UI.success "Created #{path}"
+    
+    path
+  end
+
+MONITRC_ERB =  %q{
+set daemon 10 
+set httpd port <%= port %> and use address localhost allow localhost
+
+<% commands.each do |name, cmd| %>
+check process <%= name %> with pidfile <%= piddir %>/<%= name %>.pid
+  <% daemon = "#{daemon} -N --name #{name} --pidfiles #{piddir} --output #{logfile}" %>
+  start program = "<%= daemon %> -- <%= cmd %>" with timeout 60 seconds
+  stop program = "<%= daemon %> --stop"
+<% end %>
+}
+
+end

data/lib/pipe2me/cli.rb

@@ -0,0 +1,29 @@
+require "thor"
+
+class Pipe2me::CLI < Thor
+  def self.exit_on_failure?; true; end
+  
+  desc "setup", "fetch a new tunnel setup"
+  option :server, :default => "http://test.pipe2.me:8080"
+  option :auth, :required => true                     # "auth token"
+  option :protocols, :default => "https"              # "protocol names, e.g. 'http,https,imap'"
+  option :ports                                       # "local ports, one per protocol"
+  def setup
+    Pipe2me::Config.server = options[:server]
+    server_info = Pipe2me::Tunnel.setup options
+
+    update
+    puts server_info[:fqdn]
+  end
+
+  desc "env", "show tunnel configuration"
+  def env(*args)
+    puts File.read("pipe2me.local.inc")
+    puts File.read("pipe2me.info.inc")
+  end
+
+  desc "update", "Updates configuration"
+  def update
+    Pipe2me::Tunnel.update
+  end
+end

data/lib/pipe2me/config.rb

@@ -0,0 +1,7 @@
+require "tmpdir"
+
+module Pipe2me::Config
+  extend self
+  
+  attr :server, true
+end

data/lib/pipe2me/ext/file_ext.rb

@@ -0,0 +1,16 @@
+require "tempfile"
+
+class File
+  def self.atomic_write(path, data=nil, &block)
+    tmpfile = Tempfile.new(File.basename(path))
+    tmpfile.write data if data
+    yield(tmpfile) if block
+    tmpfile.write data if data
+    tmpfile.close
+    FileUtils.mv tmpfile.path, path           # atomic replace
+    tmpfile.unlink                            # deletes the temp file
+  rescue
+    tmpfile.close! rescue nil                 # close and deletes the temp file
+    raise
+  end
+end

data/lib/pipe2me/ext/http.rb

@@ -0,0 +1,213 @@
+require "net/http"
+require "ostruct"
+
+# The HTTP module implements a simple wrapper around Net::HTTP, intended to
+# ease the pain of dealing with HTTP requests.
+module Pipe2me::HTTP
+  extend self
+
+  # Error to be raised when maximum number of redirections is reached.
+  class RedirectionLimit < RuntimeError; end
+
+  # Base class for HTTP related errors.
+  class Error < RuntimeError
+
+    # The response object (of class HTTP::Response).
+    attr_reader :response
+
+    def initialize(response) #:nodoc:
+      @response = response
+    end
+
+    def code
+      response.code
+    end
+
+    def message #:nodoc:
+      "#{@response.response.class}: #{@response[0..120]}"
+    end
+  end
+
+  # Raised when a server responded with an error 5xx.
+  class ServerError < Error; end
+
+  # Raised when a server responded with an error 4xx.
+  class ResourceNotFound < Error; end
+
+  # -- configuration
+
+  @@config = OpenStruct.new
+
+  # The configuration object. It supports the following entries:
+  # - <tt>config.headers</tt>: default headers to use when doing HTTP requests. Default: "Ruby HTTP client/1.0"
+  # - <tt>config.max_redirections</tt>: the number of maximum redirections to follow. Default: 10
+  #
+  # To adjust the configuration change these objects, like so:
+  #
+  #   HTTP.config.headers =  { "User-Agent" => "My awesome thingy/1.0" }
+  def config
+    @@config
+  end
+
+  # A default set of headers
+  config.headers = {
+    "User-Agent" => "Ruby HTTP client/1.0"
+  }
+
+  # The default number of max redirections.
+  config.max_redirections = 10
+
+  # -- return types
+
+  # The HTTP::Response class works like a string, but contains extra "attributes"
+  # status and headers, which return the response status and response headers.
+  class Response < String
+
+    # The URL of the final request.
+    attr_reader :url
+
+    # The URL of the original request.
+    attr_reader :original_url
+
+    # The response object.
+    attr_reader :response
+
+    def initialize(response, url, original_url) #:nodoc:
+      @response, @url, @original_url = response, url, original_url
+      super(response.body || "")
+    end
+
+    # returns true if the status is in the 2xx range.
+    def valid?
+      (200..299).include? status
+    end
+
+    # returns the response object itself, if it is valid (i.e. has a ), or raise
+    def validate!
+      return self if valid?
+
+      case status
+      when 400..499 then raise ResourceNotFound, self
+      when 500..599 then raise ServerError, self
+      else raise Error, self
+      end
+    end
+
+    # returns the HTTP status code, as an Integer.
+    def code
+      @response.code.to_i
+    end
+
+    alias :status :code
+
+    # returns all headers.
+    def headers
+      @headers ||= {}.tap do |h|
+        @response.each_header do |key, value|
+          h[key] = value
+        end
+      end
+    end
+
+    def content_type
+      headers["content-type"]
+    end
+
+    def parse
+      case content_type
+      when /application\/json/
+        require "json" unless defined?(JSON)
+        JSON.parse(self)
+      else
+        UI.warn "#{url}: Cannot parse #{content_type.inspect} response"
+        self
+      end
+    end
+  end
+
+  # -- do requests ----------------------------------------------------
+
+  # runs a get request and return a HTTP::Response object.
+  def get(url, headers = {})
+    do_request Net::HTTP::Get, url, headers
+  end
+
+  # runs a post request and return a HTTP::Response object.
+  def post(url, body, headers = {})
+    do_request Net::HTTP::Post, url, headers, body
+  end
+
+  private
+
+  def method_missing(sym, *args, &block)
+    case sym.to_s
+    when /^(.*)\!$/
+      response = send $1, *args, &block
+      response.validate!
+    when /^(.*)\?$/
+      response = send $1, *args, &block
+      response if response.valid?
+    else
+      super
+    end
+  end
+
+  #:nodoc:
+  def do_request(verb, uri, headers, body = nil)
+    UI.benchmark :info, "[#{verb.name.gsub(/.*::/, "").upcase}] #{uri}" do
+      do_raw_request verb, uri, headers, body, config.max_redirections, uri, Net::HTTP::Get
+    end
+
+  rescue
+    raise "#{uri}: #{$!}"
+  end
+
+  def do_raw_request(verb, uri, headers, body, max_redirections, original_url, redirection_verb = Net::HTTP::Get)
+    # merge default headers
+    headers = config.headers.merge(headers)
+
+    # create connection
+
+    uri = URI.parse(uri) if uri.is_a?(String)
+
+    default_port = uri.scheme == "https" ? 443 : 80
+    http = Net::HTTP.new(uri.host, uri.port || default_port)
+    if uri.scheme == "https"
+      http.use_ssl = true
+    end
+
+    # create request and get response
+
+    request = verb.new(uri.request_uri)
+    request.initialize_http_header headers
+
+    if verb.const_get "REQUEST_HAS_BODY"
+      case body
+      when String
+        request.body = body
+      when Hash
+        request.form_data = body
+      when nil
+      else
+        raise ArgumentError, "Unsupported body of class #{body.class.name}"
+      end
+    end
+
+
+    request.basic_auth(r.user, r.password) if uri.user && uri.password
+    response = http.request(request)
+
+    # follow redirection, if needed
+
+    case response
+    when Net::HTTPRedirection
+      # Note: we always follow the redirect using a GET. This seems to violate parts of
+      # RFC 2616, but sadly seems the best default behaviour, as is implemented that way
+      # in many clients..
+      raise RedirectionLimit.new(original_url) if max_redirections <= 0
+      return do_raw_request redirection_verb, response["Location"], headers, max_redirections-1, original_url, redirection_verb
+    else
+      Response.new(response, uri.to_s, original_url)
+    end
+  end
+end