forward 0.3.3 → 1.0.0

data/lib/forward/command/tunnel.rb

@@ -0,0 +1,178 @@
+module Forward
+  module Command
+    class Tunnel < Base
+      BASIC_AUTH_REGEX       = /\A[^\s:]+:[^\s:]+\z/i.freeze
+      CNAME_REGEX            = /\A[a-z0-9]+(?:[\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}\z/i.freeze
+      SUBDOMAIN_PREFIX_REGEX = /\A[a-z0-9]{1}[a-z0-9\-]+\z/i.freeze
+      STATIC_HOST            = '127.0.0.1'.freeze
+      STATIC_PORT            = 32645.freeze
+      DEFAULT_OPTIONS        = {
+        host: '127.0.0.1',
+        port: 80
+      }
+
+      def start
+        print_help_and_exit! if !forwardfile? && @args.empty?
+
+        config.create_or_load
+        @options.merge!(DEFAULT_OPTIONS)
+        parse_forwardfile
+        parse_forwarded
+
+        @options[:subdomain_prefix] = @args[1] if @args.length > 1
+        @options[:no_auth]          = @options.fetch(:'no-auth', nil)
+
+        validate :port, :auth, :cname, :subdomain_prefix
+
+        client do
+          authenticate_user do
+            start_static_server if @options[:static_path]
+            open_tunnel
+          end
+        end
+      end
+
+      private
+
+      def authenticate_user(&block)
+        return block.call if logged_in?
+
+        email, password = ask_for_credentials(email)
+
+        logger.debug("[API] authenticating user: `#{email}:#{password.gsub(/./, 'x')}'")
+
+        API::User.authenticate(email, password) do |subdomain, token|
+          config.add_account(subdomain, token)
+          block.call
+        end
+      end
+
+      def open_tunnel
+        API::Tunnel.create(@options) do |attributes|
+          Forward.tunnel = Forward::Tunnel.new(@options.merge(attributes))
+        end
+      end
+
+      def start_static_server
+        require 'thin'
+        require 'forward/static/app'
+        static_path          = @options[:static_path]
+        Thin::Logging.silent = true
+        logger.debug "[static] starting server on port: #{STATIC_PORT}"
+        Thin::Server.start(STATIC_HOST, STATIC_PORT) { run Static::App.new(static_path) }
+      end
+
+      def forwardfile?
+        @has_forwardfile ||= File.exist?(forwardfile_path)
+      end
+
+      # Returns a String file path for PWD/Forwardfile
+      def forwardfile_path
+        @forwardfile_path ||= File.join(Dir.pwd, 'Forwardfile')
+      end
+
+      def parse_forwardfile
+        return unless forwardfile?
+
+        options = YAML.load_file(forwardfile_path)
+
+        raise CLIError unless options.kind_of?(Hash)
+
+        logger.debug "[CLI] read Forwardfile `#{forwardfile_path}' as: `#{options.inspect}'"
+
+        @options.merge!(options.symbolize_keys)
+      rescue ArgumentError, SyntaxError, CLIError
+        exit_with_error "Unable to parse Forwardfile at `#{forwardfile_path}'"
+      end
+
+      # Parses the arguments to determine if we're forwarding a port or host
+      # and validates the port or host and updates @options if valid.
+      #
+      # arg - A String representing the port or host.
+      #
+      # Returns a Hash containing the forwarded host or port
+      def parse_forwarded
+        return if @args.empty?
+
+        forwarded = @args[0]
+        logger.debug "[CLI] forwarded: `#{forwarded}'"
+
+        if Dir.exist?(forwarded)
+          @options[:static_path] = forwarded
+          @options[:host]        = STATIC_HOST
+          @options[:port]        = STATIC_PORT
+          return
+        end
+
+        case forwarded
+        when /\A\d{1,5}\z/
+          @options[:port] = forwarded.to_i
+        when /\A[-a-z0-9\.\-]+\z/i
+          @options[:host] = forwarded
+        when /\A[-a-z0-9\.\-]+:\d{1,5}\z/i
+          host, port = forwarded.split(':')
+          port       = port.to_i
+
+          @options[:host] = host
+          @options[:port] = port
+        end
+      end
+
+      # Checks to make sure the port being set is a number between 1 and 65535
+      # and exits with an error message if it's not.
+      #
+      # port - port number Integer
+      def validate_port
+        port = @options[:port]
+
+        logger.debug "[CLI] validating port: `#{port}'"
+        unless port.between?(1, 65535)
+          raise CLIError, "Invalid Port: #{port} is an invalid port number"
+        end
+      end
+
+      def validate_auth
+        auth = @options[:auth]
+
+        return if auth.nil?
+
+        logger.debug "[CLI] validating auth: `#{auth}'"
+        if auth =~ BASIC_AUTH_REGEX
+          @options[:username], @options[:password] = @options[:auth].split(':')
+        else
+          raise CLIError, "`#{auth}' isn't a valid username:password pair"
+        end
+      end
+
+      # Checks to make sure the cname is in the correct format and exits with an
+      # error message if it isn't.
+      #
+      # cname - cname String
+      def validate_cname
+        cname = @options[:cname]
+
+        return if cname.nil?
+
+        logger.debug "[CLI] validating CNAME: `#{cname}'"
+        unless cname =~ CNAME_REGEX
+          raise CLIError, "`#{cname}' is an invalid domain format"
+        end
+      end
+
+      # Checks to make sure the subdomain prefix is in the correct format
+      # and exits with an error message if it isn't.
+      #
+      # prefix - subdomain prefix String
+      def validate_subdomain_prefix
+        prefix = @options[:subdomain_prefix]
+
+        return if prefix.nil?
+
+        logger.debug "[CLI] validating subdomain prefix: `#{prefix}'"
+        unless prefix =~ SUBDOMAIN_PREFIX_REGEX
+          raise CLIError, "`#{prefix}' is an invalid subdomain prefix format"
+        end
+      end
+    end
+  end
+end

data/lib/forward/common.rb

@@ -0,0 +1,44 @@
+module Forward
+  module Common
+    EMAIL_REGEX   = /\A[^@]+@[^@]+\.[^@]+\z/.freeze
+
+    def logger
+      Forward.logger
+    end
+    alias_method :log, :logger
+
+    def config
+      Forward::Config
+    end
+
+    def logged_in?
+      !Config.default_account.nil?
+    end
+
+    def os
+      Forward.os
+    end
+
+    def windows?
+      Forward.windows?
+    end
+
+    def exit_with_message(message = nil)
+      puts message if message
+      stop_reactor_and_exit
+    end
+
+    def stop_reactor_and_exit(code = 0)
+      EM.stop if EM.reactor_running?
+      exit(code)
+    end
+
+    def exit_with_error(message = nil)
+      if message
+        puts HighLine.color(message, :red)
+      end
+      stop_reactor_and_exit(1)
+    end
+
+  end
+end

data/lib/forward/config.rb

@@ -1,30 +1,71 @@
-require 'fileutils'
-require 'yaml'
-
 module Forward
-  class Config
-    CONFIG_FILE_VALUES = [ :api_token ]
+  module Config
+    extend self
+    DEFAULTS = {
+      accounts: {},
+      default_account: nil,
+      auto_copy: true,
+      auto_open: false
+    }.freeze
+
+    attr_accessor :accounts
+    attr_accessor :default_account
+    attr_accessor :auto_copy
+    attr_accessor :auto_open
+
+    def set_defaults!
+      DEFAULTS.keys.each { |setting| set_default!(setting) }
+    end
 
-    attr_accessor :id
-    attr_accessor :api_token
-    attr_accessor :private_key
+    def set_default!(setting)
+      value = DEFAULTS[setting.to_sym]
+      value = value.dup if value.is_a?(Hash) || value.is_a?(Array)
+      self.send("#{setting}=", value)
 
-    # Initializes a Config object with the given attributes.
-    #
-    # attributes - A Hash of attributes
-    #
-    # Returns the new Config object.
-    def initialize(attributes = {})
-      attributes.each do |key, value|
-        self.send(:"#{key}=", value)
-      end
+      value
+    end
+
+    def set_default_account(subdomain)
+      self.default_account = subdomain
+
+      write
+    end
+
+    def add_account(subdomain, api_token)
+      accounts[subdomain.to_sym] = api_token
+      self.default_account       = subdomain
+
+      write
+    end
+
+    def remove_account(subdomain)
+      accounts.delete(subdomain.to_sym)
+      self.default_account = accounts.empty? ? nil : accounts.keys.first
+
+      write
+    end
+
+    %w[set_default_account add_account remove_account].each do |name|
+      module_eval "def #{name}!(*args); #{name}(*args); write; end"
+    end
+
+    def api_key
+      accounts[default_account.to_sym]
+    end
+
+    def auto_open?
+      auto_open == true
+    end
+
+    def auto_copy?
+      auto_copy == true
     end
 
     # Updates an existing Config object.
     #
     # Returns the updated Config object.
     def update(attributes)
-      Forward.log.debug('Updating Config')
+      Forward.logger.debug('[config] updating')
       attributes.each do |key, value|
         self.send(:"#{key}=", value)
       end
@@ -39,113 +80,49 @@ module Forward
       Hash[instance_variables.map { |var| [var[1..-1].to_sym, instance_variable_get(var)] }]
     end
 
-    # Validate that the required values are in the Config.
-    # Raises a config error if values are missing.
-    def validate
-      Forward.log.debug('Validating Config')
-      attributes = [:api_token, :private_key]
-      errors = []
-
-      attributes.each do |attribute|
-        value = instance_variable_get("@#{attribute}")
-
-        errors << attribute if value.nil? || value.to_s.empty?
-      end
-
-      if errors.length == 1
-        raise ConfigError, "#{errors.first} is a required field"
-      elsif errors.length >= 2
-        raise ConfigError, "#{errors.join(', ')} are required fields"
-      end
-    end
-
     # Write the current config data to `config_path', and the current
     # private_key to `key_path'.
     #
     # Returns the Config object.
     def write
-      Forward.log.debug('Writing Config')
-      key_folder  = File.dirname(Config.key_path)
-      config_data = to_hash.delete_if { |k,v| !CONFIG_FILE_VALUES.include?(k) }
-
-      self.validate
+      Forward.logger.debug('[config] writing')
 
-      FileUtils.mkdir(key_folder) unless File.exist?(key_folder)
-      File.open(Config.config_path, 'w') { |f| f.write(YAML.dump(config_data)) }
-      File.open(Config.key_path, 'w') { |f| f.write(private_key) }
+      File.open(config_path, 'w') { |f| f.write(YAML.dump(to_hash)) }
 
       self
-    rescue
+    rescue Exception => e
+      Forward.logger.fatal "#{e.message}"
       raise ConfigError, 'Unable to write config file'
     end
 
-    # Returns the location of the forward ssh private key
-    # based on the host os.
-    #
-    # Returns the String path.
-    def self.key_path
-      if Forward.windows?
-        File.join(ENV['HOME'], 'forward', 'key')
-      else
-        File.join(ENV['HOME'], '.ssh', 'forwardhq.com')
-      end
-    end
-
     # Returns the location of the forward config file
     # based on the host os.
     #
     # Returns the String path.
-    def self.config_path
+    def config_path
       if Forward.windows?
         File.join(ENV['HOME'], 'forward', 'config')
       else
-        File.join(ENV['HOME'], '.forward')
+        File.join(ENV['HOME'], '.forwardrc')
       end
     end
 
     # Checks to see if a .forward config file exists.
     #
     # Returns true or false based on the existence of the config file.
-    def self.present?
+    def present?
       File.exist? config_path
     end
 
-    # Checks to see if a `private_key' exist.
-    #
-    # Returns true or false based on the existence of the key file.
-    def self.key_file_present?
-      File.exist? key_path
-    end
-
     # Create a config file if it doesn't exist, load one if it does.
     #
     # Returns the resulting Config object.
-    def self.create_or_load
-      if Config.present?
-        Config.load
+    def create_or_load
+      if present?
+        load
       else
-        Config.create
-      end
-    end
-
-    # Create a config by authenticating the user via the api,
-    # and saving the users api_token/id/private_key.
-    #
-    # Returns the new Config object.
-    def self.create
-      Forward.log.debug('Creating Config')
-      if @updating_config || ask('Already have an account with Forward? ').chomp =~ /\Ay/i
-        config             = Config.new
-        email, password    = CLI.authenticate.values_at(:email, :password)
-        config.update(Forward::Api::User.api_token(email, password))
-        Forward::Api.token = config.api_token
-        config.private_key = Forward::Api::TunnelKey.create
-
-        config.write
-      else
-        message = "You'll need a Forward account first. You can create one at "
-        message << HighLine.color('https://forwardhq.com', :underline)
-        Client.cleanup_and_exit!(message)
+        set_defaults!
+        write
       end
     end
 
@@ -154,31 +131,11 @@ module Forward
     # the config options aren't valid.
     #
     # Returns the Config object.
-    def self.load
-      Forward.log.debug('Loading Config')
-      config = Config.new
-
-      raise ConfigError, "Unable to find a forward config file at `#{config_path}'" unless Config.present?
-
-      if File.read(config_path).include? '-----M-----'
-        puts "Forward needs to update your config file, please re-authenticate"
-        File.delete(config_path)
-        @updating_config = true
-        create_or_load
-      end
-
-      raise ConfigError, "Unable to find a forward key file at `#{key_path}'" unless Config.key_file_present?
-
-
-      config.update(YAML.load_file(config_path).symbolize_keys)
-      config.private_key = File.read(key_path)
-      Forward::Api.token = config.api_token
-
-      config.validate
-
-      Forward.config = config
+    def load
+      Forward.logger.debug('[config] loading')
+      raise ConfigError, "Unable to find a forward config file at `#{config_path}'" unless present?
 
-      config
+      update(YAML.load_file(config_path).symbolize_keys)
     end
 
   end

data/lib/forward/request.rb

@@ -0,0 +1,72 @@
+module Forward
+  class Request
+    include Common
+
+    attr_accessor :tunnel
+    attr_accessor :id
+    attr_accessor :method
+    attr_accessor :path
+    attr_accessor :body
+    attr_accessor :headers
+
+    def initialize(tunnel, attributes)
+      @tunnel      = tunnel
+      @id          = attributes[:id]
+      @method      = attributes[:method]
+      @path        = attributes[:url]
+      @headers     = attributes[:headers]
+      @body        = ''
+    end
+
+    def url
+      @url ||= "http://#{@tunnel.host}:#{@tunnel.port}"
+    end
+
+    def <<(data)
+      @body << data
+
+      @body
+    end
+
+    def destroy
+      @tunnel.requests.delete(@id)
+    end
+
+    def process
+      options = {
+        path: path,
+        body: (body.empty? ? nil : body),
+        head: headers
+      }
+
+      puts "[#{Time.now.strftime('%H:%M:%S')}] [#{method}] #{path}" unless Forward.quiet?
+
+      http = EM::HttpRequest.new(url).send(method.downcase, options)
+
+      http.headers { |header|
+        tunnel.socket.send(type: 'response:start', data: { id: id, headers: header.raw, status: header.status })
+      }
+
+      http.stream { |chunk|
+        tunnel.socket.send({type: 'response:data', data: { id: id }}, chunk)
+      }
+
+      http.callback {
+        tunnel.socket.send(type: 'response:end', data: { id: id })
+        destroy
+      }
+
+      http.errback {
+        handle_error(http.error)
+        destroy
+      }
+    end
+
+    def handle_error(error)
+      puts "\e[31mhttp://#{tunnel.authority} isn't responding, make sure your server is running on localhost.\e[0m"
+      tunnel.socket.send(type: 'response:error', data: { id: id, error_type: 'localhost_unavailable' })
+
+      destroy
+    end
+  end
+end

data/lib/forward/socket.rb

@@ -0,0 +1,125 @@
+module Forward
+  class Socket
+    include Common
+    HEART_BEAT_INTERVAL = 10.freeze
+    WATCH_INTERVAL      = 60.freeze
+    ACTIVITY_TIMEOUT    = 60.freeze
+
+    def initialize(tunnel)
+      @tunnel = tunnel
+      @socket = Faye::WebSocket::Client.new(@tunnel.tunneler)
+      @socket.on :open do |event|
+        logger.debug '[socket] open'
+        send(type: 'tunnel:identify', tunnelId: @tunnel.id)
+      end
+
+      @socket.on :message do |event|
+        receive(event.data)
+      end
+
+      @socket.on :close do |event|
+        logger.debug "[socket] close - code: #{event.code} reason: #{event.reason}"
+        if @tunnel.open?
+          exit_with_message "Your tunnel has been disconnected"
+        else
+          @tunnel.destroy { exit_with_error "Unable to open tunnel, please contact us at #{SUPPORT_EMAIL}" }
+        end
+      end
+
+      @socket.on :error do |event|
+        logger.debug "[socket] error #{event.inspect}"
+      end
+    end
+
+    def send(message, data = nil)
+      @socket.send(pack(message, data))
+    end
+
+    private
+
+    def receive(data)
+      message, data = unpack(data)
+      logger.debug "[socket] #{message[:type]}"
+
+      @tunnel.track_activity!
+
+      if message[:type] == 'tunnel:ready'
+        @tunnel.ready!
+        beat
+        watch
+
+        return
+      end
+
+      if message[:type] == 'tunnel:notfound'
+        logger.debug "[socket] tunnel not found"
+        exit_with_message "Unable to open tunnel, please contact us at #{SUPPORT_EMAIL}"
+      end
+
+      if message[:type] == 'notification'
+        puts message[:message]
+
+        return
+      end
+
+      if message[:type] == 'request:start'
+        logger.debug "[request] start #{message[:url]}"
+        request = Request.new(@tunnel, message)
+        @tunnel.requests[request.id] = request
+        return
+      end
+
+      request = @tunnel.requests[message[:id]]
+      return if request.nil?
+
+      if message[:type] == 'request:data'
+        logger.debug '[request] data'
+        request << data
+      end
+
+      if message[:type] == 'request:end'
+        logger.debug '[request] end'
+        request.process
+      end
+    end
+
+    def beat
+      EM.add_periodic_timer(HEART_BEAT_INTERVAL) do
+        logger.debug "[heartbeat] lub"
+        send(type: 'heartbeat:lub')
+      end
+    end
+
+    def watch
+      EM.add_periodic_timer(WATCH_INTERVAL) do
+        logger.debug "[socket] checking activity"
+        inactive_for = Time.now.to_i - @tunnel.last_active_at
+
+        if inactive_for > ACTIVITY_TIMEOUT
+          logger.debug "[socket] closing due to inactivity (heartbeats and requests)"
+          @socket.close
+        end
+      end
+    end
+
+    def pack(message, data = nil)
+      message = message.is_a?(String) ? message : message.to_json
+      message.encode!('utf-16le')
+
+      bytes = Array(message.bytesize).pack('v').bytes.to_a
+      bytes += message.bytes.to_a
+      bytes += data.bytes.to_a unless data.nil?
+
+      bytes
+    end
+
+    def unpack(bytes)
+      bytes         = bytes.pack('C*')
+      message_size  = bytes.unpack('v')[0]
+      message       = bytes.byteslice(2, message_size)
+      binary_offset = 2 + message_size
+
+      [JSON.parse(message, symbolize_names: true), bytes.byteslice(binary_offset..-1)]
+    end
+  end
+end