forward 0.0.14 → 0.1.0

data/lib/forward.rb

@@ -39,6 +39,14 @@ module Forward
     ENV['FORWARD_SSH_PORT'] || DEFAULT_SSH_PORT
   end
 
+  def self.config=(config)
+    @config = config
+  end
+
+  def self.config
+    @config
+  end
+
   def self.client=(client)
     @client = client
   end

data/lib/forward/api.rb

@@ -1,6 +1,6 @@
 require 'forward/api/resource'
 require 'forward/api/client_log'
-require 'forward/api/public_key'
+require 'forward/api/tunnel_key'
 require 'forward/api/tunnel'
 require 'forward/api/user'
 

data/lib/forward/api/client_log.rb

@@ -7,22 +7,14 @@ module Forward
         resource.uri = '/api/client_logs'
         params       = {
           :client => Forward.client_string,
-          :log    => log,
+          :log    => log
         }
 
-        params[:user_id] = user_id unless user_id.nil?
+        params[:api_token] = Forward.config.api_token unless Forward.config.nil?
 
         resource.post(params)
       end
 
-      private
-
-      def self.user_id
-        if !Forward.client.nil? && !Forward.client.config.nil?
-          Forward.client.config.id
-        end
-      end
-
     end
   end
 end

data/lib/forward/api/tunnel.rb

@@ -62,8 +62,8 @@ module Forward
       def self.destroy_and_create(id)
         Forward.log(:debug, "Destroying tunnel: #{id}")
         destroy(id)
-        puts "tunnel removed, creating your new forward"
-        create
+        puts "tunnel removed, now we're creating a new one"
+        create(Forward.client.options)
       end
 
       def self.create_error(errors)

data/lib/forward/api/{public_key.rb → tunnel_key.rb}

@@ -1,10 +1,10 @@
 module Forward
   module Api
-    class PublicKey < Resource
+    class TunnelKey < Resource
 
       def self.create
-        resource     = PublicKey.new(:create)
-        resource.uri = '/api/public_keys'
+        resource     = TunnelKey.new(:create)
+        resource.uri = '/api/tunnel_keys'
 
         response = resource.post
 

data/lib/forward/cli.rb

@@ -193,16 +193,12 @@ module Forward
     #
     # 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
+      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
 
     # Parses various options and arguments, validates everything to ensure 

data/lib/forward/client.rb

@@ -53,17 +53,18 @@ module Forward
       trap(:INT) { cleanup_and_exit!('closing tunnel and exiting...') }
 
       Forward.client = @client = Client.new(options)
-      @tunnel = @client.setup_tunnel
+      @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[m\nCtrl-C to stop forwarding"
-      @session = Net::SSH.start(@tunnel.tunneler, Forward.ssh_user, @client.ssh_options)
+
       @session.forward.remote(@tunnel.hostport, @tunnel.host, @tunnel.port)
       @session.loop { watch_session(@session) }
 
     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")
+      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...")

data/lib/forward/config.rb

@@ -1,9 +1,10 @@
+require 'fileutils'
+require 'rbconfig'
+require 'yaml'
+
 module Forward
   class Config
-    CONFIG_PATH   = File.join(ENV['HOME'], '.forward')
-    CIPHER_LENGTH = 128
-    CIPHER_MODE   = :CBC
-    DELIMETER     = '-------M-------'
+    CONFIG_FILE_VALUES = [ :api_token ]
 
     attr_accessor :id
     attr_accessor :api_token
@@ -39,12 +40,11 @@ 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 = [:id, :api_token, :private_key]
+      attributes = [:api_token, :private_key]
       errors = []
 
       attributes.each do |attribute|
@@ -58,62 +58,76 @@ module Forward
       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')
-      self.validate
-
-      data = JSON.dump(self.to_hash)
-      cipher = OpenSSL::Cipher::AES.new(CIPHER_LENGTH, CIPHER_MODE)
-      cipher.encrypt
+      key_folder  = File.dirname(Config.key_path)
+      config_data = to_hash.delete_if { |k,v| !CONFIG_FILE_VALUES.include?(k) }
 
-      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}")
+      self.validate
 
-      File.open(CONFIG_PATH, 'w') { |f| f.write(config_data) }
+      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) }
 
       self
+    rescue
+      raise ConfigError, 'Unable to write config file'
     end
 
+    # Shortcut for checking if host os is windows.
     #
-    #
-    #
-    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
+    # Returns true or false if windows or not.
+    def self.windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+    end
 
-      unencrypted = decipher.update(encrypted_data) + decipher.final
+    # Returns the location of the forward ssh private key
+    # based on the host os.
+    #
+    # Returns the String path.
+    def self.key_path
+      if windows?
+        File.join(ENV['HOME'], 'forward', 'key')
+      else
+        File.join(ENV['HOME'], '.ssh', 'forwardhq.com')
+      end
+    end
 
-      JSON.parse(unencrypted).symbolize_keys
-    rescue
-      raise ConfigError, 'Unable to read config file'
+    # Returns the location of the forward config file
+    # based on the host os.
+    #
+    # Returns the String path.
+    def self.config_path
+      if windows?
+        File.join(ENV['HOME'], 'forward', 'config')
+      else
+        File.join(ENV['HOME'], '.forward')
+      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?
-      File.exist? CONFIG_PATH
+      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
@@ -122,42 +136,56 @@ module Forward
       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')
-      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
+      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
+        Client.cleanup_and_exit!("You'll need a Forward account first. You can create one at \033[04mhttps://forwardhq.com\033[04m")
+      end
     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.
+    # Returns the Config object.
     def self.load
       Forward.log(:debug, 'Loading Config')
       config = Config.new
 
-      if Config.present?
-        config.update(Config.read)
+      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::Api.token = config.api_token;
+      Forward.config = config
 
       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

data/lib/forward/version.rb

@@ -1,3 +1,3 @@
 module Forward
-  VERSION = '0.0.14'
+  VERSION = '0.1.0'
 end

data/test/api/{public_key_test.rb → tunnel_key_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-describe Forward::Api::PublicKey do
+describe Forward::Api::TunnelKey do
 
   before :each do
     FakeWeb.allow_net_connect = false
@@ -9,19 +9,19 @@ describe Forward::Api::PublicKey do
   it 'retrieves the public_key and returns it' do
     fake_body = { :private_key => 'ssh-key 1234567890' }
 
-    stub_api_request(:post, '/api/public_keys', :body => fake_body.to_json)
+    stub_api_request(:post, '/api/tunnel_keys', :body => fake_body.to_json)
 
-    response = Api::PublicKey.create
+    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' } }
 
-    stub_api_request(:post, '/api/public_keys', :body => fake_body.to_json)
+    stub_api_request(:post, '/api/tunnel_keys', :body => fake_body.to_json)
 
     lambda { 
-      dev_null { Api::PublicKey.create }
+      dev_null { Api::TunnelKey.create }
     }.must_raise SystemExit
   end
 

data/test/api/tunnel_test.rb

@@ -11,10 +11,9 @@ describe Forward::Api::Tunnel do
     Forward.client = mock
     fake_body      = { :_id => '1', :subdomain => 'foo', :port => 56789 }
 
-    Forward.client.expects(:options).returns(:port => 3000)
     stub_api_request(:post, '/api/tunnels', :body => fake_body.to_json)
 
-    response = Forward::Api::Tunnel.create
+    response = Forward::Api::Tunnel.create(:port => 3000)
 
     fake_body.each do |key, value|
       response[key].must_equal fake_body[key]
@@ -25,11 +24,10 @@ describe Forward::Api::Tunnel do
     Forward.client = mock
     fake_body      = { :errors => { :base => [ 'unable to create tunnel' ] } }
 
-    Forward.client.expects(:options).returns(:port => 3000)
     stub_api_request(:post, '/api/tunnels', :body => fake_body.to_json)
 
     lambda { 
-      dev_null { Forward::Api::Tunnel.create }
+      dev_null { Forward::Api::Tunnel.create(:port => 3000) }
     }.must_raise SystemExit
   end
 
@@ -41,13 +39,12 @@ describe Forward::Api::Tunnel do
     ]
     index_body     = [ { :_id => 'abc123' }, { :_id => 'def456' } ]
 
-    Forward.client.expects(:options).returns(:port => 3000).twice
     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])
 
-    dev_null { Forward::Api::Tunnel.create }
+    dev_null { Forward::Api::Tunnel.create(:port => 3000) }
   end
 
   it 'destroys a tunnel and returns the attributes' do

data/test/config_test.rb

@@ -3,8 +3,7 @@ require 'test_helper'
 describe Forward::Config do
 
   before :each do
-    @user_attributes = {
-      :id => '12345',
+    @config_attributes = {
       :api_token => 'abcdefg',
       :private_key => 'secret'
     }
@@ -12,56 +11,58 @@ describe Forward::Config do
   end
 
   after :each do
-    if Forward::Config.present?
-      FileUtils.rm(Forward::Config::CONFIG_PATH)
-    end
+    FileUtils.rm(Forward::Config.config_path) if Forward::Config.present?
+    FileUtils.rm(Forward::Config.key_path) if Forward::Config.key_file_present?
   end
 
   it "initializes a config with a hash" do
-    config = Forward::Config.new(@user_attributes)
+    config = Forward::Config.new(@config_attributes)
 
-    @user_attributes.each do |key, value|
+    @config_attributes.each do |key, value|
       config.send(key).must_equal value
     end
   end
 
   it "updates a config with a hash" do
     config = Forward::Config.new
-    config.update(@user_attributes)
+    config.update(@config_attributes)
 
-    @user_attributes.each do |key, value|
+    @config_attributes.each do |key, value|
       config.send(key).must_equal value
     end
   end
 
   it "writes and reads a config from disk" do
-    config = Forward::Config.new(@user_attributes)
+    config = Forward::Config.new(@config_attributes)
     config.write
 
     saved_config = Forward::Config.load
 
-    @user_attributes.each do |key, value|
+    File.exist?(Forward::Config.config_path).must_equal true
+    File.exist?(Forward::Config.key_path).must_equal true
+
+    @config_attributes.each do |key, value|
       saved_config.send(key).must_equal value
     end
   end
 
+  it "only writes config values to the config file" do
+    config = Forward::Config.new(@config_attributes)
+    config.write
+
+    config_file = File.read(Forward::Config.config_path)
+    config_file.include?('private_key').must_equal false
+  end
+
   it "converts a config to a hash" do
-    config = Forward::Config.new(@user_attributes)
+    config = Forward::Config.new(@config_attributes)
     config_hash = config.to_hash
 
-    @user_attributes.each do |key, value|
+    @config_attributes.each do |key, value|
       config_hash[key].must_equal value
     end
   end
 
-  it "deletes config file" do
-    config = Forward::Config.new(@user_attributes)
-    config.write
-    Forward::Config.clear
-
-    Forward::Config.wont_be :present?
-  end
-
   it "raises exception with an empty config" do
     config = Forward::Config.new
 
@@ -69,34 +70,26 @@ describe Forward::Config do
   end
 
   it "raises exception with an invalid config" do
-    @user_attributes.delete(:api_token)
-    config = Forward::Config.new(@user_attributes)
+    @config_attributes.delete(:api_token)
+    config = Forward::Config.new(@config_attributes)
 
     lambda { config.validate }.must_raise Forward::ConfigError
   end
 
-  it "raises exception with bad config on write" do
-    @user_attributes.delete(:private_key)
-    config = Forward::Config.new(@user_attributes)
-
-    lambda { config.write }.must_raise Forward::ConfigError
-  end
+  # it "raises exception with bad config on write" do
+  #   @config_attributes.delete(:private_key)
+  #   config = Forward::Config.new(@config_attributes)
+  # 
+  #   lambda { config.write }.must_raise Forward::ConfigError
+  # end
 
   it "raises exception when a config file is not found" do
     lambda { Forward::Config.load }.must_raise Forward::ConfigError
   end
 
-  it "raises exception when reading bad config file" do
-    config_path = Forward::Config::CONFIG_PATH
-    config_data = 'the trash alone'
-
-    File.open(config_path, 'w') { |f| f.write(config_data) }
-
-    lambda { Forward::Config.read }.must_raise Forward::ConfigError
-  end
-
-  it "raises exception when an invalid config file is loaded" do
-    skip
+  it "raises exception when a key file is not found" do
+    File.open(Forward::Config.config_path, 'w') { |f| f.write YAML.dump(@config_attributes) }
+    lambda { Forward::Config.load }.must_raise Forward::ConfigError
   end
 
 end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
 $LOAD_PATH.unshift(File.expand_path('../../spec', __FILE__))
 
 require 'rubygems'
+require 'yaml'
 require 'bundler'
 Bundler.setup
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forward
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-04 00:00:00.000000000 Z
+date: 2012-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -142,9 +142,9 @@ files:
 - lib/forward.rb
 - lib/forward/api.rb
 - lib/forward/api/client_log.rb
-- lib/forward/api/public_key.rb
 - lib/forward/api/resource.rb
 - lib/forward/api/tunnel.rb
+- lib/forward/api/tunnel_key.rb
 - lib/forward/api/user.rb
 - lib/forward/cli.rb
 - lib/forward/client.rb
@@ -153,8 +153,8 @@ files:
 - lib/forward/error.rb
 - lib/forward/tunnel.rb
 - lib/forward/version.rb
-- test/api/public_key_test.rb
 - test/api/resource_test.rb
+- test/api/tunnel_key_test.rb
 - test/api/tunnel_test.rb
 - test/api/user_test.rb
 - test/api_test.rb
@@ -188,8 +188,8 @@ signing_key:
 specification_version: 3
 summary: Forward Lets You Share localhost over the Web. Demo a Website Without Hosting.
 test_files:
-- test/api/public_key_test.rb
 - test/api/resource_test.rb
+- test/api/tunnel_key_test.rb
 - test/api/tunnel_test.rb
 - test/api/user_test.rb
 - test/api_test.rb