forward 0.3.3 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b188425121deedc6db3120b631fe576a3e4bbf67
+  data.tar.gz: 1371bf60526e65fd941b9e17398d5f004bd7f7b3
+SHA512:
+  metadata.gz: cce5f2e20c6788d420b1faa01e6eb778175cb7486271a58e531a0a1a35c75e49a5c943dbf183deedbf146aed8c7e2f16bd7ed6e8d2a09e9dc30ba2b3740d0429
+  data.tar.gz: 014d3a99305e8e755fd5544239442fb62e342a804e87d2eb918dd9abcfbc08c7f66f94aa7fc8e955bac76b6bf38c59d6a62c262083f2d033f1d5cdab3a549f8c

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
+.ruby-version
 InstalledFiles
 _yardoc
 coverage
@@ -14,4 +15,5 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
+vendor/
 tmp

data/Gemfile

@@ -1,4 +1,2 @@
 source 'https://rubygems.org'
-
-# Specify your gem's dependencies in showoff.gemspec
 gemspec

data/README.md

@@ -4,9 +4,33 @@ The ruby client for [https://forwardhq.com/](https://forwardhq.com/). Forward gi
 
 ## Usage
 
+
+    # login/logout/switch accounts
+    forward login
+    forward accounts
+    forward logout 50east*
+    forward default 50east*
+
+    forward account:login
+    forward account:logout
+    forward account:default
+
+    # use default account
+    forward .
+    forward ~/Dev/static/blah
+    forward 3000
+    forward foo.dev
+    forward blah.local
+
+    # use specific account/subdomain
+    forward . -s tarface
+    forward 3000 -s 50east
+
+
     > forward <port> [options]
     > forward <host> [options]
     > forward <host:port> [options]
+    > forward <path> [options]
 
     Description:
 

data/Rakefile

@@ -5,4 +5,6 @@ require 'bundler/gem_tasks'
 Rake::TestTask.new do |t|
     t.libs << 'test'
     t.test_files = FileList['test/**/*_test.rb']
-end
+end
+
+task default: :test

data/bin/forward

@@ -3,4 +3,4 @@ $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'forward'
 
-Forward::CLI.run(ARGV)
+Forward::CLI.start

data/forward.gemspec

@@ -2,10 +2,11 @@
 require File.expand_path('../lib/forward/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ['blahed']
-  gem.email         = ['travis@50east.co']
-  gem.summary       = 'Forward Lets You Share localhost over the Web. Demo a Website Without Hosting.'
+  gem.authors       = ['Travis Dunn', 'Noah Burney']
+  gem.email         = ['travis@50east.co', 'noah@50east.co']
+  gem.summary       = 'Forward lets you get a link to localhost and share it with anyone over the web.'
   gem.homepage      = 'https://forwardhq.com'
+  gem.license       = 'MIT'
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -14,13 +15,18 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
   gem.version       = Forward::VERSION
 
-  gem.add_dependency 'json_pure', '~> 1.8.1'
-  gem.add_dependency 'highline', '~> 1.6.21'
-  gem.add_dependency 'net-ssh', '~> 2.8.0'
+  gem.add_dependency 'slop', '~> 3.6'
+  gem.add_dependency 'json_pure', '~> 1.8'
+  gem.add_dependency 'highline', '~> 1.6'
+  gem.add_dependency 'eventmachine', '~> 1.0.3'
+  gem.add_dependency 'thin', '~> 1.6'
+  gem.add_dependency 'em-http-request', '~> 1.1'
+  gem.add_dependency 'faye-websocket', '~> 0.8'
+  gem.add_dependency 'clipboard', '~> 1.0'
 
-  gem.add_development_dependency 'rake', '~> 10.1.1'
-  gem.add_development_dependency 'minitest', '~> 5.3.0'
-  gem.add_development_dependency 'mocha', '~> 0.14.0'
-  gem.add_development_dependency 'fakeweb', '~> 1.3.0'
-  gem.add_development_dependency 'fakefs', '~> 0.4.3'
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'minitest', '~> 5.3'
+  gem.add_development_dependency 'mocha', '~> 1.0'
+  gem.add_development_dependency 'webmock', '~> 1.20'
+  gem.add_development_dependency 'fakefs', '~> 0.5'
 end

data/lib/forward/api/resource.rb

@@ -5,113 +5,81 @@ require 'net/https'
 require 'uri'
 
 module Forward
-  module Api
+  module API
     class Resource
+      include Common
+      extend Common
+
+      DEFAULT_ERROR_MESSAGE = "Unable to connect to API, please contact support@forwardhq.com".freeze
 
       attr_accessor :http
       attr_accessor :uri
 
-      def initialize(action = nil)
-        @action           = action
-        @http             = Net::HTTP.new(Forward::Api.uri.host, Forward::Api.uri.port)
-        @http.use_ssl     = Forward::Api.ssl?
-        @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        @http.ca_file     = File.expand_path('../../../../forwardhq.crt', __FILE__)
+      class JSONify
+        def response(resp)
+            resp.response = JSON.parse(resp.response, symbolize_names: true)
+          rescue JSON::ParserError
+            Forward.logger.debug 'Unable to parse API response'
+        end
       end
 
-      def request(method = :get, params = {})
-        log(:debug, "Request: [#{method.to_s.upcase}] for `#{http.address}:#{http.port}#{uri}'")
-        log(:debug, "Request: params `#{params.reject { |k,v| k == :password }.inspect }'")
-        build_request(method, params)
-        add_headers!
+      def initialize
+        @http = EM::HttpRequest.new(Forward::API.host)
 
-        response = @http.request(@request)
-
-        parse_response(response)
+        @http.use JSONify
       end
 
-      def build_request(method, params = {})
-        @method = method
-
-        case @method
-        when :get
-          @request = Net::HTTP::Get.new(uri)
-        when :post
-          @request = Net::HTTP::Post.new(uri)
-          @request.body = params.to_json unless params.empty?
-        when :put
-          @request = Net::HTTP::Put.new(uri)
-          @request.body = params.to_json unless params.empty?
-        when :delete
-          @request = Net::HTTP::Delete.new(uri)
-          @request.body = params.to_json unless params.empty?
-        end
-      end
+      def request(method = :get, options = {}, &block)
+        logger.debug "[API] request: #{method.to_s.upcase} #{@http.uri}#{options[:path]}"
+        @options = options || {}
 
-      def add_headers!
-        if Forward::Api.token
-          @request['Authorization'] = "Token token=#{Forward::Api.token}"
-        end
+        add_head!
+        add_body!
 
-        @request['Content-Type'] = 'application/json'
-        @request['Accept']       = 'application/json'
-      end
+        @_request = @http.send(method, @options)
 
-      def get(params = {})
-        @response = request(:get, params)
-      end
+        @_request.callback {
+          status = @_request.response_header.status
 
-      def post(params = {})
-        @response = request(:post, params)
-      end
+          logger.debug "[API] response: #{status} #{@_request.response}"
+          if @_request.response.is_a?(String) && !@_request.response.empty?
+            # no JSON response
+            exit_with_error DEFAULT_ERROR_MESSAGE
+          else
+            block.call(@_request.response, status)
+          end
+        }
 
-      def put(params = {})
-        @response = request(:put, params)
+        @_request.errback {
+          exit_with_error DEFAULT_ERROR_MESSAGE
+        }
       end
 
-      def delete(params = {})
-        @response = request(:delete, params)
+      def get(options = {}, &block)
+        request(:get, options, &block)
       end
 
-      def parse_response(response)
-        log(:debug, "Response: [#{response.code}] `#{response.body}'")
-        code = response.code.to_i
-
-        if code == 404
-          raise ResourceNotFound
-        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"
-        end
+      def post(options = {}, &block)
+        request(:post, options, &block)
+      end
 
-        json = JSON.parse(response.body)
+      def delete(options = {}, &block)
+        request(:delete, options, &block)
+      end
 
-        if json.is_a? Hash
-          json.symbolize_keys!
-          raise ResourceError.new(code, @action, json) if code != 200
-        end
+      def add_body!
+        return unless @options.has_key?(:params)
 
-        json
+        logger.debug "[API] request params: #{@options[:params].inspect}"
+        @options[:body] = @options.delete(:params).to_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
-
-      private
-
-      def log(level, message)
-        unless self.class.to_s == 'Forward::Api::ClientLog'
-          Forward.log.send(level.to_sym, message)
-        end
+      def add_head!
+        @options[:head] ||= {
+          'content-type' => 'application/json',
+          'accept'       => 'application/json'
+        }
+        @options[:head]['authorization'] = "Token token=#{config.api_key}" if @options[:authenticated]
       end
 
     end

data/lib/forward/api/tunnel.rb

@@ -1,85 +1,58 @@
 module Forward
-  module Api
+  module API
     class Tunnel < Resource
 
-      def self.create(options = {})
-        resource     = Tunnel.new(:create)
-        resource.uri = '/api/v2/tunnels'
-        params       = {
-          :hostport => options[:port],
-          :vhost    => options[:host],
-          :client   => Forward.client_string,
+      def self.create(options, &block)
+        resource = new
+        options  = {
+          path:          "#{API.base_path}/tunnels/",
+          authenticated: true,
+          params: {
+             hostport:  options[:port],
+             vhost:     options[:host],
+             subdomain: options[:subdomain_prefix],
+             cname:     options[:cname],
+             username:  options[:username],
+             password:  options[:password],
+             no_auth:   options[:no_auth],
+             client:    Forward.client_string,
+          }
         }
-        
-        params[:subdomain] = options[:subdomain_prefix] if options.has_key?(:subdomain_prefix)
-        [ :cname, :username, :password, :no_auth ].each do |param|
-          params[param] = options[param] if options.has_key?(param)
-        end
-
-        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/v2/tunnels"
-
-        resource.get[:tunnels]
-      end
-
-      def self.show(id)
-        resource     = Tunnel.new(:show)
-        resource.uri = "/api/v2/tunnels/#{id}"
-
-        resource.get[:tunnel].symbolize_keys
-      rescue Forward::Api::ResourceNotFound
-        nil
+        resource.post(options) do |response, status|
+          if status == 200
+            block.call(response)
+          else
+            handle_error(response, status)
+          end
+        end
       end
 
-      private
-
-      def self.ask_to_destroy(message, options)
-        tunnels = index
-
-        puts message
-        choose do |menu|
-          menu.prompt = "Choose a tunnel from the list to close or `q' to exit forward "
+      def self.destroy(id, &block)
+        resource = new
+        options  = {
+          path:          "#{API.base_path}/tunnels/#{id}",
+          authenticated: true,
+        }
 
-          tunnels.each do |tunnel|
-            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! }
+        resource.delete(options) do |response, status|
+          block.call(response)
         end
       end
 
-      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(options)
-      end
+      private
 
-      def self.error_on_create(error, options)
-        Forward.log.debug("An error occured creating tunnel:\n#{error.inspect}")
+      def self.handle_error(response, status)
+        exit_with_error "Unable to authenticate your account. Try logging out with `forward account logout' or contact #{SUPPORT_EMAIL}" if status == 401
+        exit_with_error DEFAULT_ERROR_MESSAGE if response.is_a?(String) || !response.has_key?(:type)
 
-        if error.type == 'tunnel_limit_reached'
-          Forward.log.debug('Tunnel limit reached')
-          ask_to_destroy(error.api_message, options)
-        elsif error.type =~ /(?:account_suspended|trial_expired)/i
-          Forward::Client.cleanup_and_exit!(error.api_message)
+        case response[:type]
+        when 'invalid_request_error'
+          exit_with_error "Invalid tunnel parameters, try `forward --help' or contact us at #{SUPPORT_EMAIL}"
+        when 'account_error'
+          exit_with_error response[:errors][:account].first
         else
-          message = "We were unable to create your tunnel for the following reasons: \n"
-          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)
+          exit_with_error DEFAULT_ERROR_MESSAGE
         end
       end
 

data/lib/forward/api/user.rb

@@ -1,18 +1,21 @@
 module Forward
-  module Api
+  module API
     class User < Resource
 
-      def self.api_token(email, password)
-        resource     = User.new(:api_token)
-        resource.uri = '/api/v2/users/api_token'
-        params       = { :email => email, :password => password }
+      def self.authenticate(email, password, &block)
+        resource = new
+        options  = {
+          path: "#{API.base_path}/user/token",
+          params: { email: email, password: password }
+        }
 
-        user      = resource.post(params)[:user].symbolize_keys
-        user[:id] = user.delete(:_id)
-
-        user
-      rescue ResourceError => e
-        Forward::Client.cleanup_and_exit!('Unable to authenticate with email and password')
+        resource.post(options) do |response, status|
+          if status != 200
+            exit_with_error "Unable to authenticate `#{email}' on forwardhq.com"
+          else
+            block.call(response[:subdomain], response[:token])
+          end
+        end
       end
 
     end

data/lib/forward/api.rb

@@ -1,40 +1,21 @@
 require 'forward/api/resource'
-require 'forward/api/client_log'
-require 'forward/api/tunnel_key'
 require 'forward/api/tunnel'
 require 'forward/api/user'
 
 module Forward
-  module Api
-    class BadResponse < StandardError; end
-    class ResourceNotFound < StandardError; end
-    class ResourceError < StandardError
-      attr_reader :code, :type, :action, :api_message, :errors
-
-      def initialize(code, action, json = {})
-        @code        = code
-        @action      = action
-        @json        = json
-        @type        = json[:type]
-        @api_message = json[:message]
-        @errors      = json[:errors] || {}
-      end
-    end
-
-    DEFAULT_API_HOST = 'https://forwardhq.com'
+  module API
+    VERSION          = 'v3'.freeze
+    DEFAULT_API_HOST = 'https://forwardhq.com'.freeze
 
     # Returns either an api host set in the environment or a set default.
     #
     # Returns a String containing the api host.
-    def self.uri
-      URI.parse(ENV['FORWARD_API_HOST'] || DEFAULT_API_HOST)
+    def self.host
+      @host ||= ENV['FORWARD_API_HOST'] || DEFAULT_API_HOST
     end
 
-    # Returns True or False if we should be using ssl
-    #
-    # Returns a Boolean.
-    def self.ssl?
-      uri.scheme == 'https'
+    def self.base_path
+      @base_path ||= "/api/#{VERSION}"
     end
 
     def self.token=(token)