forward 0.1.6 → 0.2.0

data/lib/forward/api.rb

@@ -9,12 +9,15 @@ module Forward
     class BadResponse < StandardError; end
     class ResourceNotFound < StandardError; end
     class ResourceError < StandardError
-      attr_reader :action, :errors
+      attr_reader :code, :type, :action, :api_message, :errors
 
-      def initialize(action, json)
-        @action = action
-        @json   = json
-        @errors = json[:errors]
+      def initialize(code, action, json = {})
+        @code        = code
+        @action      = action
+        @json        = json
+        @type        = json[:type]
+        @api_message = json[:message]
+        @errors      = json[:errors] || {}
       end
     end
 
@@ -35,11 +38,11 @@ module Forward
     end
 
     def self.token=(token)
-      @@api_token = token
+      @api_token = token
     end
 
     def self.token
-      defined?(@@api_token) ? @@api_token : nil
+      defined?(@api_token) ? @api_token : nil
     end
   end
 end

data/lib/forward/api/client_log.rb

@@ -4,7 +4,7 @@ module Forward
 
       def self.create(log)
         resource     = ClientLog.new(:create)
-        resource.uri = '/api/client_logs'
+        resource.uri = '/api/v2/client_logs'
         params       = {
           :client => Forward.client_string,
           :log    => log

data/lib/forward/api/resource.rb

@@ -28,8 +28,6 @@ module Forward
         response = @http.request(@request)
 
         parse_response(response)
-      rescue ResourceError => e
-        self.class.dispatch_error(e)
       end
 
       def build_request(method, params = {})
@@ -77,10 +75,11 @@ module Forward
 
       def parse_response(response)
         log(:debug, "Response: [#{response.code}] `#{response.body}'")
+        code = response.code.to_i
 
-        if response.code.to_i == 404
+        if code == 404
           raise ResourceNotFound
-        elsif response.code.to_i != 200
+        elsif ![ 200, 422, 401 ].include? code
           raise BadResponse, "response code was: #{response.code}"
         elsif response['content-type'] !~ /^application\/json/
           raise BadResponse, "response was not JSON, unable to parse"
@@ -90,22 +89,22 @@ module Forward
 
         if json.is_a? Hash
           json.symbolize_keys!
-          raise ResourceError.new(@action, json) if json.has_key?(:errors)
+          raise ResourceError.new(code, @action, json) if code != 200 
         end
 
         json
       end
 
-      def self.dispatch_error(error)
-        Forward.log(:debug, "Dispatching ResourceError:   action: #{error.action}   errors: #{error.errors.inspect}")
-        method = :"#{error.action}_error"
-
-        if respond_to? method
-          send(method, error.errors)
-        else
-          Forward::Client.cleanup_and_exit!('An error occured, please contact support@forwardhq.com')
-        end
-      end
+      # def self.dispatch_error(error)
+      #   Forward.log(:debug, "Dispatching ResourceError:   action: #{error.action}   errors: #{error.errors.inspect}")
+      #   method = :"#{error.action}_error"
+      # 
+      #   if respond_to? method
+      #     send(method, error.errors)
+      #   else
+      #     Forward::Client.cleanup_and_exit!('An error occured, please contact support@forwardhq.com')
+      #   end
+      # end
 
       private
 

data/lib/forward/api/tunnel.rb

@@ -4,7 +4,7 @@ module Forward
 
       def self.create(options = {})
         resource     = Tunnel.new(:create)
-        resource.uri = '/api/tunnels'
+        resource.uri = '/api/v2/tunnels'
         params       = {
           :hostport => options[:port],
           :vhost    => options[:host],
@@ -15,35 +15,39 @@ module Forward
           params[param] = options[param] unless options[param].nil?
         end
 
-        resource.post(params)
+        resource.post(params)[:tunnel].symbolize_keys
+      rescue ResourceError => e
+        error_on_create(e, options)
       end
 
       def self.index
         resource     = Tunnel.new(:index)
-        resource.uri = "/api/tunnels"
+        resource.uri = "/api/v2/tunnels"
 
-        resource.get
+        resource.get[:tunnels]
       end
 
       def self.destroy(id)
         resource     = Tunnel.new(:destroy)
-        resource.uri = "/api/tunnels/#{id}"
+        resource.uri = "/api/v2/tunnels/#{id}"
 
         resource.delete
+      rescue ResourceError => e
+        nil
       end
 
       def self.show(id)
         resource     = Tunnel.new(:show)
-        resource.uri = "/api/tunnels/#{id}"
+        resource.uri = "/api/v2/tunnels/#{id}"
 
-        resource.get
+        resource.get[:tunnel].symbolize_keys
       rescue Forward::Api::ResourceNotFound
         nil
       end
 
       private
 
-      def self.ask_to_destroy(message)
+      def self.ask_to_destroy(message, options)
         tunnels = index
 
         puts message
@@ -51,49 +55,42 @@ module Forward
           menu.prompt = "Choose a tunnel from the list to close or `q' to exit forward "
 
           tunnels.each do |tunnel|
-            text = "tunnel forwarding port #{tunnel['hostport']}"
-            menu.choice(text) { destroy_and_create(tunnel['_id']) }
+            text = "Forwarding port #{tunnel['hostport']}"
+            menu.choice(text) { destroy_and_create(tunnel['_id'], options) }
           end
           menu.hidden('quit') { Forward::Client.cleanup_and_exit! }
           menu.hidden('exit') { Forward::Client.cleanup_and_exit! }
         end
       end
 
-      def self.destroy_and_create(id)
+      def self.destroy_and_create(id, options)
         Forward.log(:debug, "Destroying tunnel: #{id}")
         destroy(id)
         puts "tunnel removed, now we're creating a new one"
-        create(Forward.client.options)
+        create(options)
       end
 
-      def self.create_error(errors)
-        Forward.log(:debug, "An error occured creating tunnel:\n#{errors.inspect}")
-        base_errors = errors['base']
+      def self.error_on_create(error, options)
+        Forward.log(:debug, "An error occured creating tunnel:\n#{error.inspect}")
 
-        if base_errors && base_errors.any? { |e| e.include? 'limit' }
-          message = base_errors.select { |e| e.include? 'limit' }.first
+        if error.type == 'tunnel_limit_reached'
           Forward.log(:debug, 'Tunnel limit reached')
-          ask_to_destroy(message)
+          ask_to_destroy(error.api_message, options)
+        elsif error.type =~ /(?:account_suspended|trial_expired)/i
+          Forward::Client.cleanup_and_exit!(error.api_message)
         else
           message = "We were unable to create your tunnel for the following reasons: \n"
-          errors.each do |key, value|
-            if key != 'base'
-              message << " #{key} #{value.join(', ')}\n"
-            elsif key == 'base'
-              base_errors.each do |error|
-                message << " #{error}\n"
-              end
+          error.errors.each do |key, value|
+            if key == 'base'
+              message << " #{value.join(', ')}\n"
+            else
+              value.each { |m| message << " #{key} #{m}\n"}
             end
           end
           Forward::Client.cleanup_and_exit!(message)
         end
       end
 
-      def self.destroy_error(errors)
-        # TODO: this is where we will tie into the logger
-        nil
-      end
-
     end
   end
 end

data/lib/forward/api/tunnel_key.rb

@@ -4,11 +4,13 @@ module Forward
 
       def self.create
         resource     = TunnelKey.new(:create)
-        resource.uri = '/api/tunnel_keys'
+        resource.uri = '/api/v2/tunnel_keys'
 
         response = resource.post
 
         response[:private_key]
+      rescue
+        Forward::Client.cleanup_and_exit!
       end
 
     end

data/lib/forward/api/user.rb

@@ -4,13 +4,14 @@ module Forward
 
       def self.api_token(email, password)
         resource     = User.new(:api_token)
-        resource.uri = '/api/users/api_token'
+        resource.uri = '/api/v2/users/api_token'
         params       = { :email => email, :password => password }
 
-        resource.post(params)
-      end
+        user      = resource.post(params)[:user].symbolize_keys
+        user[:id] = user.delete(:_id)
 
-      def self.api_token_error(errors)
+        user
+      rescue ResourceError => e
         Forward::Client.cleanup_and_exit!('Unable to authenticate with email and password')
       end
 

data/lib/forward/client.rb

@@ -20,8 +20,9 @@ module Forward
       if @tunnel.id
         @tunnel.poll_status
       else
-        cleanup_and_exit!('Unable to create a tunnel. If this continues contact support@forwardhq.com')
+        Forward::Client.cleanup_and_exit!('Unable to create a tunnel. If this continues contact support@forwardhq.com')
       end
+      Forward.log(:debug, "Tunnel setup: #{@tunnel.inspect}")
 
       @tunnel
     end
@@ -48,6 +49,23 @@ module Forward
       true
     end
 
+    def self.forwarding_message(tunnel)
+      remote = "\033[04mhttps://#{@tunnel.subdomain}.fwd.wf\033[0m"
+
+      unless tunnel.cname.nil? || tunnel.cname.empty?
+        remote << " and \033[04mhttp://#{@tunnel.cname}\033[0m"
+      end
+
+      if !tunnel.vhost.nil? && tunnel.vhost !~ /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+        local = tunnel.vhost
+        local << " port #{tunnel.hostport}" unless tunnel.hostport.to_i == 80
+      else
+        local = "port #{tunnel.hostport}"
+      end
+
+      "Forwarding #{local} to #{remote}\nCtrl-C to stop forwarding"
+    end
+
     def self.start(options = {})
       Forward.log(:debug, 'Starting client')
       trap(:INT) { cleanup_and_exit!('closing tunnel and exiting...') }
@@ -56,8 +74,9 @@ module Forward
       @tunnel        = @client.setup_tunnel
       @session       = Net::SSH.start(@tunnel.tunneler, Forward.ssh_user, @client.ssh_options)
 
-      Forward.log(:debug, "Starting remote forward at #{@tunnel.subdomain}.fwd.wf on port #{@tunnel.port}")
-      puts "Forwarding port #{@tunnel.hostport} at \033[04mhttps://#{@tunnel.subdomain}.fwd.wf\033[0m\nCtrl-C to stop forwarding"
+      Forward.log(:debug, "Starting remote forward at #{@tunnel.subdomain}.fwd.wf")
+      # puts "Forwarding port #{@tunnel.hostport} at \033[04mhttps://#{@tunnel.subdomain}.fwd.wf\033[0m\nCtrl-C to stop forwarding"
+      puts forwarding_message(@tunnel)
 
       @session.forward.remote(@tunnel.hostport, @tunnel.host, @tunnel.port)
       @session.loop { watch_session(@session) }

data/lib/forward/tunnel.rb

@@ -2,20 +2,24 @@ module Forward
   class Tunnel
     CHECK_INTERVAL = 7
 
-    # The Tunnel resource ID.
+    # The Tunnel resource ID
     attr_reader :id
-    # The domain for the Tunnel.
+    # The domain for the Tunnel
     attr_reader :subdomain
+    # The CNAME for the Tunnel
+    attr_reader :cname
     # The host
     attr_reader :host
     # The vhost
     attr_reader :vhost
     # The hostport (local port)
     attr_reader :hostport
-    # The remote port.
+    # The remote port
     attr_reader :port
-    # The tunneler host.
+    # The tunneler host
     attr_reader :tunneler
+    # The timeout
+    attr_reader :timeout
     # The amount of time in seconds the Tunnel has be inactive for
     attr_accessor :inactive_for
 
@@ -28,6 +32,7 @@ module Forward
       @response     = Forward::Api::Tunnel.create(options)
       @id           = @response[:_id]
       @subdomain    = @response[:subdomain]
+      @cname        = @response[:cname]
       @vhost        = @response[:vhost]
       @hostport     = @response[:hostport]
       @port         = @response[:port]

data/lib/forward/version.rb

@@ -1,3 +1,3 @@
 module Forward
-  VERSION = '0.1.6'
+  VERSION = '0.2.0'
 end

data/test/api/tunnel_key_test.rb

@@ -6,19 +6,19 @@ describe Forward::Api::TunnelKey do
     FakeWeb.allow_net_connect = false
   end
 
-  it 'retrieves the public_key and returns it' do
+  it "retrieves the public_key and returns it" do
     fake_body = { :private_key => 'ssh-key 1234567890' }
 
-    stub_api_request(:post, '/api/tunnel_keys', :body => fake_body.to_json)
+    stub_api_request(:post, '/api/v2/tunnel_keys', :body => fake_body.to_json)
 
     response = Api::TunnelKey.create
     response.must_equal fake_body[:private_key]
   end
 
-  it 'exits with message if response has errors' do
-    fake_body = { :errors => { :base => 'Unable to retrieve a private key' } }
+  it "exits with message if response has errors" do
+    fake_body = { :type => 'api_error' }
 
-    stub_api_request(:post, '/api/tunnel_keys', :body => fake_body.to_json)
+    stub_api_request(:post, '/api/v2/tunnel_keys', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
 
     lambda { 
       dev_null { Api::TunnelKey.create }

data/test/api/tunnel_test.rb

@@ -7,66 +7,104 @@ describe Forward::Api::Tunnel do
     Forward::Api.token      = 'abc123'
   end
 
-  it 'creates a tunnel and returns the attributes' do
-    Forward.client = mock
-    fake_body      = { :_id => '1', :subdomain => 'foo', :port => 56789 }
+  it "creates a tunnel and returns the attributes" do
+    fake_body = { :tunnel => { :_id => '1', :subdomain => 'foo', :port => 56789 }}
 
-    stub_api_request(:post, '/api/tunnels', :body => fake_body.to_json)
+    stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json)
 
     response = Forward::Api::Tunnel.create(:port => 3000)
 
-    fake_body.each do |key, value|
-      response[key].must_equal fake_body[key]
-    end
+    response[:_id].must_equal fake_body[:tunnel][:_id]
+    response[:subdomain].must_equal fake_body[:tunnel][:subdomain]
+    response[:port].must_equal fake_body[:tunnel][:port]
   end
 
-  it 'exits with message if create response has errors' do
-    Forward.client = mock
-    fake_body      = { :errors => { :base => [ 'unable to create tunnel' ] } }
-
-    stub_api_request(:post, '/api/tunnels', :body => fake_body.to_json)
-
-    lambda { 
-      dev_null { Forward::Api::Tunnel.create(:port => 3000) }
-    }.must_raise SystemExit
+  it "exits with message if create response is a resource_error" do
+    fake_body = {
+      :type => 'resource_error',
+      :errors => {
+        :base => [ 'did not work '],
+        :subdomain => [ 'is invalid', 'is too short' ]
+      }
+    }
+
+    stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
+
+    out, err = capture_io do
+      begin
+        Forward::Api::Tunnel.create(:port => 3000)
+      rescue SystemExit; end
+    end
+    out.must_match /did not work/i
+    out.must_match /subdomain is invalid/i
+    out.must_match /subdomain is too short/i
   end
 
-  it 'gives a choice and closes a tunnel if limit is reached' do
-    Forward.client = mock
-    post_options   = [
-      { :body => { :errors => { :base => [ 'you have reached your limit' ] } }.to_json },
-      { :body => { :_id => '1', :subdomain => 'foo', :port => 56789 }.to_json }
-    ]
-    index_body     = [ { :_id => 'abc123' }, { :_id => 'def456' } ]
+  it "exits with message if trial has expired" do
+     fake_body = {
+       :type => 'trial_expired',
+       :message => 'your trial has expired'
+     }
+
+     stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
+
+     out, err = capture_io do
+       begin
+         Forward::Api::Tunnel.create(:port => 3000)
+       rescue SystemExit; end
+     end
+     out.must_match /trial has expired/i
+   end
+
+   it "exits with message if account has been suspended" do
+      fake_body = {
+        :type => 'account_suspended',
+        :message => 'your account has been suspended due for failed payment'
+      }
+
+      stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
+
+      out, err = capture_io do
+        begin
+          Forward::Api::Tunnel.create(:port => 3000)
+        rescue SystemExit; end
+      end
+      out.must_match /account has been suspended/i
+    end
+
+  it "gives a choice and closes a tunnel if limit is reached" do
+     post_options = [
+       { :body => { :type => 'tunnel_limit_reached', :message => 'you have reached your limit' }.to_json, :status => [ 422, 'Unprocessable Entity' ] },
+       { :body => { :tunnel => { :_id => '1', :subdomain => 'foo', :port => 56789 } }.to_json }
+     ]
+     index_body = { :tunnels => [ { :_id => 'abc123', :hostport => 1234 }, { :_id => 'def456', :hostport => 1235 } ] }
 
-    stub_api_request(:post, '/api/tunnels', post_options)
-    stub_api_request(:get, '/api/tunnels', :body => index_body.to_json)
-    STDIN.expects(:gets).returns('1')
-    Forward::Api::Tunnel.expects(:destroy).with(index_body.first[:_id])
+     stub_api_request(:post, '/api/v2/tunnels', post_options)
+     stub_api_request(:get, '/api/v2/tunnels', :body => index_body.to_json)
+     STDIN.expects(:gets).returns('1')
+     Forward::Api::Tunnel.expects(:destroy).with(index_body[:tunnels].first[:_id])
 
-    dev_null { Forward::Api::Tunnel.create(:port => 3000) }
-  end
+     dev_null { Forward::Api::Tunnel.create(:port => 3000) }
+   end
 
-  it 'destroys a tunnel and returns the attributes' do
-    Forward.client = mock
-    fake_body      = { :_id => '1', :subdomain => 'foo', :port => 56789 }
+   it 'destroys a tunnel and returns the attributes' do
+     fake_body = { :_id => '1', :subdomain => 'foo', :port => 56789 }
 
-    stub_api_request(:delete, '/api/tunnels/1', :body => fake_body.to_json)
+     stub_api_request(:delete, '/api/v2/tunnels/1', :body => fake_body.to_json)
 
-    response = Forward::Api::Tunnel.destroy(1)
+     response = Forward::Api::Tunnel.destroy(1)
 
-    fake_body.each do |key, value|
-      response[key].must_equal fake_body[key]
-    end
-  end
+     fake_body.each do |key, value|
+       response[key].must_equal fake_body[key]
+     end
+   end
 
-  it 'gracefully handles the error if destroy has errors' do
-    Forward.client = mock
-    fake_body      = { :errors => { :base => 'unable to create tunnel' } }
+   it 'gracefully handles the error if destroy has errors' do
+     fake_body = { :type => 'api_error' }
 
-    stub_api_request(:delete, '/api/tunnels/1', :body => fake_body.to_json)
+     stub_api_request(:delete, '/api/v2/tunnels/1', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
 
-    Forward::Api::Tunnel.destroy(1).must_be_nil
-  end
+     Forward::Api::Tunnel.destroy(1).must_be_nil
+   end
 
 end

data/test/api/user_test.rb

@@ -6,19 +6,32 @@ describe Forward::Api::User do
     FakeWeb.allow_net_connect = false
   end
 
-  it 'retrieves the users api token and returns it' do
-    fake_body      = { :api_token => '123abc' }
+  it "retrieves the users api token and returns it" do
+    fake_body = { :user => { :api_token => '123abc' } }
 
-    stub_api_request(:post, '/api/users/api_token', :body => fake_body.to_json)
+    stub_api_request(:post, '/api/v2/users/api_token', :body => fake_body.to_json)
 
     response = Api::User.api_token('guy@example.com', 'secret')
     response[:api_token].must_equal '123abc'
   end
 
-  it 'exits with message if response has errors' do
-    fake_body      = { :errors => { :base => 'Unable to authenticate user' } }
+  it "exits with message if authentication fails" do
+    fake_body = { :type => 'api_error' }
 
-    stub_api_request(:post, '/api/users/api_token', :body => fake_body.to_json)
+    stub_api_request(:post, '/api/v2/users/api_token', :body => fake_body.to_json, :status => [ 401, 'Authentication Failed' ])
+
+    out, err = capture_io do
+      begin
+        Api::User.api_token('guy@example.com', 'secret')
+      rescue SystemExit; end
+    end
+    out.must_match /unable to authenticate/i
+  end
+
+  it "exits with message if response has errors" do
+    fake_body = { :type => 'api_error' }
+
+    stub_api_request(:post, '/api/v2/users/api_token', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
 
     lambda { 
       dev_null { Api::User.api_token('guy@example.com', 'secret') }

data/test/tunnel_test.rb

@@ -2,7 +2,28 @@ require 'test_helper'
 
 describe Forward::Tunnel do
 
-  it 'should have access to api resources via the api method ' do
+  it "create a tunnel instance" do
+    tunnel_response = {
+      :_id => '1234',
+      :subdomain => 'foo',
+      :cname => 'foo.bar.com',
+      :vhost => '127.0.0.1',
+      :hostport => '3000',
+      :port => 20000,
+      :tunneler_public => 'test.forwardhq.com',
+      :timeout => 0
+    }
 
+    Forward::Api::Tunnel.expects(:create).returns(tunnel_response)
+    tunnel = Forward::Tunnel.new
+
+    tunnel.id.must_equal tunnel_response[:_id]
+    tunnel.subdomain.must_equal tunnel_response[:subdomain]
+    tunnel.cname.must_equal tunnel_response[:cname]
+    tunnel.vhost.must_equal tunnel_response[:vhost]
+    tunnel.hostport.must_equal tunnel_response[:hostport]
+    tunnel.port.must_equal tunnel_response[:port]
+    tunnel.tunneler.must_equal tunnel_response[:tunneler_public]
+    tunnel.timeout.must_equal tunnel_response[:timeout]
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forward
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-18 00:00:00.000000000 Z
+date: 2012-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json