forward 0.0.1 → 0.0.11

data/lib/forward/api/tunnel.rb

@@ -0,0 +1,91 @@
+module Forward
+  module Api
+    class Tunnel < Resource
+
+      def self.create(options = {})
+        resource     = Tunnel.new(:create)
+        resource.uri = '/api/tunnels'
+        params       = {
+          :hostport => options[:port],
+          :client   => Forward.client_string,
+        }
+
+        [ :subdomain, :cname, :username, :password ].each do |param|
+          params[param] = options[param] unless options[param].nil?
+        end
+
+        resource.post(params)
+      end
+
+      def self.index
+        resource     = Tunnel.new(:index)
+        resource.uri = "/api/tunnels"
+
+        resource.get
+      end
+
+      def self.destroy(id)
+        resource     = Tunnel.new(:destroy)
+        resource.uri = "/api/tunnels/#{id}"
+
+        resource.delete
+      end
+
+      def self.show(id)
+        resource     = Tunnel.new(:show)
+        resource.uri = "/api/tunnels/#{id}"
+
+        resource.get
+      rescue Forward::Api::ResourceNotFound
+        nil
+      end
+
+      private
+
+      def self.ask_to_destroy(message)
+        tunnels = index
+
+        puts message
+        choose do |menu|
+          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']) }
+          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)
+        Forward.log(:debug, "Destroying tunnel: #{id}")
+        destroy(id)
+        puts "tunnel removed, creating your new forward"
+        create
+      end
+
+      def self.create_error(errors)
+        base_errors = errors['base']
+
+        if base_errors && base_errors.any? { |e| e.include? 'limit' }
+          message = base_errors.select { |e| e.include? 'limit' }.first
+          Forward.log(:debug, 'Tunnel limit reached')
+          ask_to_destroy(message)
+        else
+          message = "An error occured creating your tunnel: \n"
+          errors.each do |key, value|
+            message << " #{key} #{value.join(', ')}" if key != 'base'
+          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/user.rb

@@ -0,0 +1,19 @@
+module Forward
+  module Api
+    class User < Resource
+
+      def self.api_token(email, password)
+        resource     = User.new(:api_token)
+        resource.uri = '/api/users/api_token'
+        params       = { :email => email, :password => password }
+
+        resource.post(params)
+      end
+
+      def self.api_token_error(errors)
+        Forward::Client.cleanup_and_exit!('Unable to authenticate with email and password')
+      end
+
+    end
+  end
+end

data/lib/forward/cli.rb

@@ -0,0 +1,238 @@
+module Forward
+  class CLI
+    CNAME_REGEX     = /\A[a-z0-9]+(?:[\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}\z/i
+    SUBDOMAIN_REGEX = /\A[a-z0-9]{1}[a-z0-9\-]+\z/i
+    BANNER = <<-BANNER
+    Usage: forward <port> [options]
+           forward <host> [options]
+           forward <host:port> [options]
+
+    Description:
+
+       Share a server running on localhost:port over the web by tunneling
+       through Forward. A URL is created for each tunnel.
+
+    Simple example:
+
+      # You are developing a Rails site.
+
+      > rails server &
+      > forward 3000
+        Forward created at https://4ad3f-mycompany.fwd.wf
+
+    Assigning a subdomain:
+
+      > rails server &
+      > forward 3000 myapp
+        Forward created at https://myapp-mycompany.fwd.wf
+
+    Virtual Host example:
+
+      # You are already running something on port 80 that uses
+      # virtual host names.
+
+      > forward mysite.dev
+        Forward created at https://dh43a-mycompany.fwd.wf
+
+    BANNER
+
+    # Parse non-published options and remove them from ARGV, then
+    # parse published options and update the @options Hash with provided
+    # options and removes switches from ARGV.
+    def self.parse_options
+      Forward.log(:debug, "Parsing options")
+      @options = {
+        :host   => '0.0.0.0',
+        :port   => 80,
+        :random => true
+      }
+
+      if ARGV.include?('--debug')
+        Forward.debug!
+        ARGV.delete('--debug')
+      elsif ARGV.include?('--debug-remotely')
+        Forward.debug_remotely!
+        ARGV.delete('--debug-remotely')
+      end
+
+      @opts = OptionParser.new do |opts|
+        opts.banner = BANNER.gsub(/^ {6}/, '')
+
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on('-a', '--auth [USER:PASS]', 'Protect this tunnel with HTTP Basic Auth.') do |credentials|
+          username, password  = parse_basic_auth(credentials)
+          @options[:username] = username
+          @options[:password] = password
+        end
+
+        opts.on('-c', '--cname [CNAME]', 'Allow access to this tunnel as NAME.') do |cname|
+          validate_cname(cname)
+          @options[:cname] = cname
+        end
+
+        opts.on( '-h', '--help', 'Display this help.' ) do
+          puts opts
+          exit
+        end
+
+        opts.on('-v', '--version', 'Display version number.') do
+          puts "forward #{VERSION}"
+          exit
+        end
+      end
+
+      @opts.parse!
+    end
+
+    # Attempts to validate the basic auth credentials, if successful updates
+    # the @options Hash with given credentials.
+    #
+    # credentials - A String containing a username and password separated
+    #               by a colon.
+    #
+    # Returns an Array containing the username and password
+    def self.parse_basic_auth(credentials)
+      validate_basic_auth(credentials)
+      username, password  = credentials.split(':')
+
+      [ username, password ]
+    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 self.parse_forwarded(arg)
+      Forward.log(:debug, "Forwarded: `#{arg}'")
+      forwarded = {}
+
+      if arg =~ /\A\d{1,5}\z/
+        port = arg.to_i
+        validate_port(port)
+
+        forwarded[:port] = port
+      elsif arg =~ /\A[-a-z0-9\.\-]+\z/i
+        forwarded[:host] = arg
+      elsif arg =~ /\A[-a-z0-9\.\-]+:\d{1,5}\z/i
+        host, port = arg.split(':')
+        port       = port.to_i
+        validate_port(port)
+
+        forwarded[:host] = host
+        forwarded[:port] = port
+      end
+
+      forwarded
+    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 - A String containing the port number.
+    def self.validate_port(port)
+      Forward.log(:debug, "Validating Port: `#{port}'")
+      unless port.between?(1, 65535)
+        exit_with_error "Invalid Port: #{port} is an invalid port number"
+      end
+    end
+
+    # Checks to make sure the basic auth credentials are in the correct format
+    # and exits with an error message if they're not.
+    #
+    # credentials - A String with the username and password for basic auth.
+    def self.validate_basic_auth(credentials)
+      Forward.log(:debug, "Validating Basic Auth: `#{credentials}'")
+      if credentials !~ /\A[^\s:]+:[^\s:]+\z/
+        exit_with_error "Basic Auth: bad format, expecting USER:PASS"
+      end
+    end
+
+    # Checks to make sure the cname is in the correct format and exits with an
+    # error message if it isn't.
+    #
+    # cname - A String containing the cname.
+    def self.validate_cname(cname)
+      Forward.log(:debug, "Validating CNAME: `#{cname}'")
+      exit_with_error("`#{cname}' is an invalid domain format") unless cname =~ CNAME_REGEX
+    end
+
+    # Validates the subdomain and returns a Hash containing it and also
+    # sets random to false, if validation passes.
+    #
+    # subdomain - A String containing the subdomain.
+    #
+    # Returns a Hash containing the subdomain
+    def self.parse_subdomain(subdomain)
+      validate_subdomain(subdomain)
+      { :subdomain => subdomain, :random => false }
+    end
+
+    # Checks to make sure the subdomain is in the correct format and exits with an
+    # error message if it isn't.
+    #
+    # cname - A String containing the subdomain.
+    def self.validate_subdomain(subdomain)
+      Forward.log(:debug, "Validating Subdomain: `#{subdomain}'")
+      exit_with_error("`#{subdomain}' is an invalid subdomain format") unless subdomain =~ SUBDOMAIN_REGEX
+    end
+
+    # Checks to see if the cname and random options are both set at the same.
+    # time and exits with an error message if they are.
+    def self.validate_options
+      Forward.log(:debug, "Validating options: `#{@options.inspect}'")
+      if !@options[:cname].nil? && @options[:random]
+        exit_with_error "You can't use a cname and a random url"
+      end
+    end
+
+    # Asks for the user's email and password and puts them in a Hash.
+    #
+    # Returns a Hash with the email and password.
+    def self.authenticate
+      if ask('Already have an account with Forward? ').chomp =~ /\An/i
+        Client.cleanup_and_exit!("You'll need a Forward account first. You can create one at \033[04mhttps://forwardhq.com\033[04m")
+      else
+        puts 'Enter your email and password'
+        email    = ask('email: ').chomp
+        password = ask('password: ') { |q| q.echo = false }.chomp
+        Forward.log(:debug, "Authenticating User: `#{email}:#{password.gsub(/./, 'x')}'")
+
+        { :email => email, :password => password }
+      end
+    end
+
+    # Parses various options and arguments, validates everything to ensure 
+    # we're safe to proceed, and finally passes @options to the Client.
+    def self.run(args)
+      Forward.log(:debug, "Starting forward v#{Forward::VERSION}")
+      parse_options
+      @options.merge!(parse_forwarded(args[0]))
+      @options.merge!(parse_subdomain(args[1])) if args.length > 1
+      validate_options
+
+      print_usage_and_exit if args.empty?
+
+      Client.start(@options)
+    end
+
+    # Colors an error message red and displays it.
+    #
+    # message - A String containing an error message.
+    def self.exit_with_error(message)
+      Forward.log(:fatal, message)
+      puts "\033[31m#{message}\033[0m"
+      exit 1
+    end
+
+    # Print the usage banner and Exit Code 0.
+    def self.print_usage_and_exit
+      puts @opts
+      exit
+    end
+
+  end
+end

data/lib/forward/client.rb

@@ -0,0 +1,92 @@
+module Forward
+  class Client
+    attr_reader :config
+    attr_reader :options
+    attr_accessor :tunnel
+
+    def initialize(options = {})
+      @options = options
+      @config  = Config.create_or_load
+    end
+
+    def basic_auth?
+      @options[:username] && @options[:password]
+    end
+
+   # Sets up a Tunnel instance and adds it to the Client.
+    def setup_tunnel
+      Forward.log(:debug, 'Setting up tunnel')
+      @tunnel = Forward::Tunnel.new(self.options)
+      if @tunnel.id
+        @tunnel.poll_status
+      else
+        cleanup_and_exit!('Unable to create a tunnel. If this continues contact support@forwardhq.com')
+      end
+    end
+
+    # The options Hash used by Net::SSH.
+    #
+    # Returns a Hash of options.
+    def ssh_options
+      {
+        :port       => Forward.ssh_port,
+        :keys_only  => true,
+        :keys       => [],
+        :key_data   => [ @config.private_key ],
+        :encryption => 'blowfish-cbc'
+      }
+    end
+
+    def self.current
+      @client
+    end
+
+    def self.watch_session(session)
+      @client.tunnel.inactive_for = 0 if session.busy?(true)
+      true
+    end
+
+    def self.start(options = {})
+      Forward.log(:debug, 'Starting client')
+      trap(:INT) { cleanup_and_exit!('closing tunnel and exiting...') }
+
+      @client = Client.new(options)
+
+      @client.setup_tunnel
+
+      Forward.log(:debug, "Starting remote forward on https://#{@client.tunnel.subdomain}.fwd.wf on port #{@client.tunnel.port}")
+      puts "Forwarding port #{@client.options[:port]} at \033[04mhttps://#{@client.tunnel.subdomain}.fwd.wf\033[m\nCtrl-C to stop forwarding"
+      Net::SSH.start(@client.tunnel.tunneler, Forward.ssh_user, @client.ssh_options) do |session|
+        session.forward.remote(@client.options[:port], @client.options[:host], @client.tunnel.port)
+        session.loop { watch_session(session) }
+      end
+
+      # cleanup_and_exit!
+    rescue Net::SSH::AuthenticationFailed => e
+      Forward.log(:fatal, "SSH Auth failed `#{e}'")
+      cleanup_and_exit!("Authentication failed, try deleting `#{Forward::Config::CONFIG_PATH}' and giving it another go. If the problem continues, contact support@forwardhq.com")
+    rescue => e
+      Forward.log(:fatal, "#{e.message}\n#{e.backtrace.join("\n")}")
+      cleanup_and_exit!("You've been disconnected...")
+    end
+
+    def self.cleanup_and_exit!(message = 'exiting...')
+      puts message
+      if @client && @client.tunnel && @client.tunnel.id
+        Forward.log(:debug, "Cleaning up tunnel: `#{@client.tunnel.id}'")
+        @client.tunnel.cleanup
+        @client.tunnel = nil
+      end
+
+      Forward.log(:debug, 'Exiting')
+      send_debug_log if Forward.debug_remotely?
+    ensure
+      Thread.main.exit
+    end
+
+    def self.send_debug_log
+      log = Forward.stringio_log.string
+      Forward::Api::ClientLog.create(log)
+    end
+  end
+end

data/lib/forward/config.rb

@@ -0,0 +1,163 @@
+module Forward
+  class Config
+    CONFIG_PATH   = File.join(ENV['HOME'], '.forward')
+    CIPHER_LENGTH = 128
+    CIPHER_MODE   = :CBC
+    DELIMETER     = '-------M-------'
+
+    attr_accessor :id
+    attr_accessor :api_token
+    attr_accessor :private_key
+
+    # 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
+    end
+
+    # Updates an existing Config object.
+    #
+    # Returns the updated Config object.
+    def update(attributes)
+      Forward.log(:debug, 'Updating Config')
+      attributes.each do |key, value|
+        self.send(:"#{key}=", value)
+      end
+
+      self
+    end
+
+    # Converts a Config object to a Hash.
+    #
+    # Returns a Hash representation of the object
+    def to_hash
+      Hash[instance_variables.map { |var| [var[1..-1].to_sym, instance_variable_get(var)] }]
+    end
+
+    #
+    #
+    #
+    def validate
+      Forward.log(:debug, 'Validating Config')
+      attributes = [:id, :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
+
+    #
+    #
+    #
+    def write
+      Forward.log(:debug, 'Writing Config')
+      self.validate
+
+      data = JSON.dump(self.to_hash)
+      cipher = OpenSSL::Cipher::AES.new(CIPHER_LENGTH, CIPHER_MODE)
+      cipher.encrypt
+
+      key = cipher.random_key
+      iv  = cipher.random_iv
+
+      encrypted_data = cipher.update(data) + cipher.final
+      config_data = Base64.encode64(encrypted_data)
+      config_data << DELIMETER
+      config_data << Base64.encode64("#{key}::#{iv}")
+
+      File.open(CONFIG_PATH, 'w') { |f| f.write(config_data) }
+
+      self
+    end
+
+    #
+    #
+    #
+    def self.read
+      Forward.log(:debug, 'Reading Config')
+      config_data = File.read(CONFIG_PATH)
+      encrypted_data, keys = config_data.split(DELIMETER).map { |d| Base64.decode64(d) }
+      key, iv  = keys.split('::')
+      decipher = OpenSSL::Cipher::AES.new(CIPHER_LENGTH, CIPHER_MODE)
+
+      decipher.decrypt
+
+      decipher.key = key
+      decipher.iv  = iv
+
+      unencrypted = decipher.update(encrypted_data) + decipher.final
+
+      JSON.parse(unencrypted).symbolize_keys
+    rescue
+      raise ConfigError, 'Unable to read config file'
+    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?
+      File.exist? CONFIG_PATH
+    end
+
+    def self.create_or_load
+      if Config.present?
+        Config.load
+      else
+        Config.create
+      end
+    end
+
+    def self.create
+      Forward.log(:debug, 'Creating Config')
+      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::PublicKey.create
+
+      config.write
+    end
+
+    # It initializes a new Config instance, updates it with the config values
+    # from the config file, and raises an error if there's not a config or if
+    # the config options aren't valid.
+    #
+    # Returns the Config instance.
+    def self.load
+      Forward.log(:debug, 'Loading Config')
+      config = Config.new
+
+      if Config.present?
+        config.update(Config.read)
+      end
+
+      config.validate
+
+      Forward::Api.token = config.api_token;
+
+      config
+    end
+
+    # Deletes the .forward config file if it exists.
+    def self.clear
+      Forward.log(:debug, 'Clearning Config')
+      File.delete(CONFIG_PATH) if Config.present?
+    end
+
+  end
+end