forward 0.3.3 → 1.0.0

data/lib/forward/cli.rb

@@ -1,280 +1,82 @@
+require 'forward/command/base'
+require 'forward/command/account'
+require 'forward/command/tunnel'
+require 'forward/command/config'
+
 module Forward
   class CLI
-    BASIC_AUTH_REGEX       = /\A[^\s:]+:[^\s:]+\z/i
-    CNAME_REGEX            = /\A[a-z0-9]+(?:[\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}\z/i
-    SUBDOMAIN_PREFIX_REGEX = /\A[a-z0-9]{1}[a-z0-9\-]+\z/i
-    USERNAME_REGEX         = PASSWORD_REGEX = /\A[^\s]+\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:
+    class ValidationError < StandardError; end
 
-      # You are developing a Rails site.
+    extend Forward::Common
+    BANNER = <<-BANNER.gsub /^ {4}/, ''
+    Usage: forward <port|host|host:port|path> [options]
 
-      > rails server &
-      > forward 3000
-        Forward created at https://mycompany.fwd.wf
+    Examples:
+       > forward 3000                            # forward server running on port 3000
+       > forward mysite.dev                      # forward virtual host mysite.dev
+       > forward ~/Dev/mysite                    # forward a path or directory
 
-    Assigning a static subdomain prefix:
-
-      > 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://mycompany.fwd.wf
+    Common Options:
+       > forward 3000 -a foo:bar                 # password protect a tunnel
+       > forward 3000 myapp                      # assign a static subdomain prefix
+       > forward 3000 myapp -c my.domain.com     # use a custom CNAME
 
+    Options:
     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_cli_options(args)
-      Forward.log.debug("Parsing options")
-      options = {}
-
-      @opts = OptionParser.new do |opts|
-        opts.banner = BANNER.gsub(/^ {6}/, '')
+    # Parses various options and arguments, validates everything to ensure
+    # we're safe to proceed, and finally passes options to the Client.
+    def self.start
+      HighLine.use_color = false if windows?
+      if ARGV.include?('--debug')
+        Forward.debug!
+        ARGV.delete('--debug')
+      end
+      Forward.logger.debug("Starting forward v#{Forward::VERSION}")
 
-        opts.separator ''
-        opts.separator 'Options:'
+      Slop.parse(banner: BANNER, help: true) do
+        on '-a=', '--auth=',   "Protect this tunnel with HTTP Basic Auth."
+        on '-A',  '--no-auth', "Disable authentication on this tunnel (if a default is set in your preferences)"
+        on '-c=', '--cname=',  "Allow access to this tunnel as CNAME (requires CNAME setup on your DNS server)"
 
-        opts.on('-a', '--auth [USER:PASS]', 'Protect this tunnel with HTTP Basic Auth.') do |credentials|
-          exit_with_error("Basic Auth: bad format, expecting USER:PASS") if credentials !~ BASIC_AUTH_REGEX
-          username, password  = credentials.split(':')
-          options[:username] = username
-          options[:password] = password
+        on '-q',  '--quiet',   "Don't display requests" do
+          Forward.quiet!
         end
 
-        opts.on('-A', '--no-auth', 'Disable authentication on this tunnel (if a default is set in your preferences)') do |credentials|
-          options[:no_auth] = true
+        on '-v', '--version', 'Display version number' do
+          puts "forward #{VERSION}"
+          exit
         end
 
-        opts.on('-c', '--cname [CNAME]', 'Allow access to this tunnel as CNAME (you will need to setup a CNAME entry on your DNS server).') do |cname|
-          options[:cname] = cname.downcase
+        # Start / Open a Tunnel
+        run do |opts, args|
+          Command::Tunnel.run(:start, opts, args)
         end
 
-        opts.on('--logout', 'Remove credentials to allow logging in as another user.' ) do
-          logout
+        # Account Commands
+        command 'account:login', banner: "Usage: forward account:login", help: true do
+          description "Logs into a new account and makes it the default"
+          run { |opts, args| Command::Account.run(:login, opts, args) }
         end
 
-        opts.on( '-h', '--help', 'Display this help.' ) do
-          puts opts
-          exit
+        command 'account:default', banner: "Usage: forward account:default SUBDOMAIN", help: true do
+          description "Sets an account to the default account"
+          run { |opts, args| Command::Account.run(:default, opts, args) }
         end
 
-        opts.on('-v', '--version', 'Display version number.') do
-          puts "forward #{VERSION}"
-          exit
+        command 'account:logout', banner: "Usage: forward account:logout SUBDOMAIN", help: true do
+          description "Logs out of an account"
+          run { |opts, args| Command::Account.run(:logout, opts, args) }
         end
-      end
-
-      @opts.parse!(args)
-
-      options
-    end
-
-    # Returns a String file path for PWD/Forwardfile
-    def self.forwardfile_path
-      File.join(Dir.pwd, 'Forwardfile')
-    end
-
-    # Parse arguments from CLI and options from Forwardfile
-    #
-    # args - An Array of command line arguments
-    #
-    # Returns a Hash of options.
-    def self.parse_args_and_options(args)
-      options = {
-        :host   => '127.0.0.1',
-        :port   => 80
-      }
-
-      Forward.log.debug("Default options: `#{options.inspect}'")
-
-      if File.exist? forwardfile_path
-        options.merge!(parse_forwardfile)
-        Forward.log.debug("Forwardfile options: `#{options.inspect}'")
-      end
-
-      options.merge!(parse_cli_options(args))
-
-      forwarded, prefix = args[0..1]
-      options[:subdomain_prefix] = prefix unless prefix.nil?
-      options.merge!(parse_forwarded(forwarded))
-      Forward.log.debug("CLI options: `#{options.inspect}'")
-
-      options
-    end
-
-    # Parse a local Forwardfile (in the PWD) and return it as a Hash.
-    # Raise an error and exit if unable to parse or result isn't a Hash.
-    #
-    # Returns a Hash of the options found in the Forwardfile
-    def self.parse_forwardfile
-      options = YAML.load_file(forwardfile_path)
-      raise CLIError unless options.kind_of?(Hash)
-
-      options.symbolize_keys
-    rescue ArgumentError, SyntaxError, CLIError
-      exit_with_error("Unable to parse #{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 self.parse_forwarded(arg)
-      Forward.log.debug("Forwarded: `#{arg}'")
-      forwarded = {}
 
-      if arg =~ /\A\d{1,5}\z/
-        port = arg.to_i
-
-        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
-
-        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 - port number Integer
-    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 username is a valid format
-    # and exits with an error message if not.
-    #
-    # username - username String
-    def self.validate_username(username)
-      Forward.log.debug("Validating Username: `#{username}'")
-      exit_with_error("`#{username}' is an invalid username format") unless username =~ USERNAME_REGEX
-    end
-
-    # Checks to make sure the password is a valid format
-    # and exits with an error message if not.
-    #
-    # password - password String
-    def self.validate_password(password)
-      Forward.log.debug("Validating Password: `#{password}'")
-      exit_with_error("`#{password}' is an invalid password format") unless password =~ PASSWORD_REGEX
-    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 self.validate_cname(cname)
-      Forward.log.debug("Validating CNAME: `#{cname}'")
-      exit_with_error("`#{cname}' is an invalid domain format") unless cname =~ CNAME_REGEX
-    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 self.validate_subdomain_prefix(prefix)
-      Forward.log.debug("Validating Subdomain Prefix: `#{prefix}'")
-      exit_with_error("`#{prefix}' is an invalid subdomain prefix format") unless prefix =~ SUBDOMAIN_PREFIX_REGEX
-    end
-
-    # Validate all options in options Hash.
-    #
-    # options - the options Hash
-    def self.validate_options(options)
-      Forward.log.debug("Validating options: `#{options.inspect}'")
-      options.each do |key, value|
-        next if value.nil?
-        validate_method = :"validate_#{key}"
-        send(validate_method, value) if respond_to?(validate_method)
-      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
-      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
-
-    # Remove .forward file and SSH key (log a user out)
-    def self.logout
-      FileUtils.rm_f(Config.config_path)
-      FileUtils.rm_f(Config.key_path)
-
-      puts "You've been logged out. You'll be asked to log back in when you create a new tunnel."
-      exit
-    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)
-      ::HighLine.use_color = false if Forward.windows?
-      if ARGV.include?('--debug')
-        Forward.debug!
-        ARGV.delete('--debug')
-      elsif ARGV.include?('--rdebug')
-        Forward.debug_remotely!
-        ARGV.delete('--rdebug')
+        command 'account:list', banner: "Usage: forward account:list", help: true do
+          description "Lists active accounts"
+          run { |opts, args| Command::Account.run(:list, opts, args) }
+        end
       end
 
-      Forward.log.debug("Starting forward v#{Forward::VERSION}")
-
-      options = parse_args_and_options(args)
-
-      validate_options(options)
-      print_usage_and_exit if args.empty? && !File.exist?(forwardfile_path)
-
-      Client.start(options)
-    end
-
-    # Colors an error message red and displays it.
-    #
-    # message - error message String
-    def self.exit_with_error(message)
-      Forward.log.fatal(message)
-      puts HighLine.color(message, :red)
-      exit 1
-    end
-
-    # Print the usage banner and Exit Code 0.
-    def self.print_usage_and_exit
-      puts @opts
-      exit
+    rescue CLIError => e
+      exit_with_error(e.message)
     end
 
   end

data/lib/forward/command/account.rb

@@ -0,0 +1,69 @@
+module Forward
+  module Command
+    class Account < Base
+      def login
+        config.create_or_load
+        email = @args.first
+
+        email, password = ask_for_credentials(email)
+        logger.debug("[API] logging in user: `#{email}:#{password.gsub(/./, 'x')}'")
+
+        client do
+          API::User.authenticate(email, password) do |subdomain, token|
+            config.add_account(subdomain, token)
+            exit_with_message "`#{subdomain}' is now logged in and set to the default account"
+          end
+        end
+      end
+
+      def logout
+        config.create_or_load
+        subdomain = @args.first
+
+        if config.accounts.empty?
+          exit_with_message "You aren't logged into any accounts"
+        elsif subdomain
+          config.remove_account!(subdomain)
+          exit_with_message "You are now logged out of the '#{subdomain}' account"
+        else
+          message = "You must provide a subdomain to logout of an account, you're currently logged into:\n"
+          message << config.accounts.map { |s, _| " - #{s}" }.join("\n")
+
+          exit_with_message message
+        end
+      end
+
+      def list
+        config.create_or_load
+
+        if config.accounts.empty?
+          exit_with_message("You're not logged into any accounts. You can login with: `forward account:login'")
+        else
+          puts "Currently logged into:"
+          config.accounts.keys.sort.each do |subdomain|
+            default = config.default_account.to_sym == subdomain.to_sym
+            puts default ? HighLine.color(" - #{subdomain} (default)", :green) : " - #{subdomain}"
+          end
+          exit_with_message
+        end
+      end
+
+      def default
+        config.create_or_load
+        subdomain = @args.first
+
+        if config.accounts.empty?
+          exit_with_message "You aren't logged into any accounts"
+        elsif subdomain && config.accounts.has_key?(subdomain.to_sym)
+          config.create_or_load
+          config.set_default_account!(subdomain.to_sym)
+          exit_with_message "#{subdomain} is now your default account"
+        else
+          exit_with_message "You're not logged into that account. You can login with: `forward account:login'"
+        end
+      rescue ConfigError => e
+        exit_with_error(e.message)
+      end
+    end
+  end
+end

data/lib/forward/command/base.rb

@@ -0,0 +1,62 @@
+module Forward
+  module Command
+    class Base
+      include Forward::Common
+
+      attr_accessor :options
+      attr_accessor :args
+
+      def self.run(command, options = {}, args = [])
+        Forward.logger.debug "[CLI] running `#{command}'"
+        new(options, args).send(command)
+      end
+
+      def initialize(options = {}, args = [])
+        @opts    = options
+        @options = options.to_hash
+        @args    = args
+        logger.debug "[CLI] options: #{@options.inspect}"
+        logger.debug "[CLI] args: #{@args.inspect}"
+      end
+
+      private
+
+      def client(&block)
+        EM.run {
+          yield
+          Signal.trap('INT')  { EM.stop; exit }
+          Signal.trap('TERM') { EM.stop; exit }
+        }
+      end
+
+      def ask_for_credentials(email = nil)
+        if email.nil? || email !~ EMAIL_REGEX
+          puts "Forward requires an account on #{HighLine.color('forwardhq.com', :underline)}"
+          puts "Enter your email and password"
+          email = ask('email: ').chomp
+        end
+
+        password = ask('password: ') { |q| q.echo = false }.chomp
+
+        [email, password]
+      end
+
+      def print_help_and_exit!
+        puts @opts
+        exit
+      end
+
+      def validate(*validators)
+        validators.each do |validator|
+          validator = "validate_#{validator}"
+
+          if respond_to?(validator, true)
+            send(validator)
+          else
+            raise UnknownValidator, "Unable to find validator `#{validator}' in #{self.class.name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forward/command/config.rb

@@ -0,0 +1,64 @@
+module Forward
+  module Command
+    class Config < Base
+      CONFIGURABLE_SETTINGS = %w[auto_copy auto_open].freeze
+      TRUTHY_REGEX          = /\A(?:true|t|yes|y|1)\z/i.freeze
+      FALESY_REGEX          = /\A(?:false|f|no|n|0)\z/i.freeze
+
+      def set(*args)
+        @setting = args[0]
+        @value   = args[1]
+
+        validate :setting, :value
+        config.load
+        config.send("#{@setting}=", @value)
+        config.write
+        exit_with_message "#{@setting} is now #{config.send(@setting)}"
+      end
+
+      def unset(*args)
+        @setting = args.first
+
+        validate :setting
+        config.load
+        default_value = config.set_default!(@setting)
+        config.write
+        exit_with_message "#{@setting} is now set to the default `#{default_value}'"
+      end
+
+      def get(*args)
+        @setting = args.first
+
+        validate :setting
+        config.load
+        exit_with_message "#{@setting} is currently #{config.send(@setting)}"
+      end
+
+      private
+
+      def validate_value
+        @value = @value.dup.strip
+
+        case @setting
+        when 'auto_copy'
+          booleanize_value
+        when 'auto_open'
+          booleanize_value
+        end
+      end
+
+      def booleanize_value
+        return @value = true if @value =~ TRUTHY_REGEX
+        return @value = false if @value =~ FALESY_REGEX
+
+        raise ValidationError, "#{@setting} cannot be set to `#{@value}'"
+      end
+
+      def validate_setting
+        unless CONFIGURABLE_SETTINGS.include?(@setting)
+          raise ValidationError, "`#{@setting}' is an unknown setting"
+        end
+      end
+    end
+  end
+end