straight-server 0.1.2 → 0.2.0

data/lib/straight-server/gateway.rb

@@ -4,19 +4,89 @@ module StraightServer
   # in one of the classes below.
   module GatewayModule
 
+    # Temporary fix for straight server benchmarking
+    @@redis = StraightServer::Config.redis[:connection] if StraightServer::Config.redis
+    @@websockets = {}
+    
+    def fetch_transactions_for(address)
+      try_adapters(@blockchain_adapters) { |b| b.fetch_transactions_for(address) }
+    end
+
     class InvalidSignature           < Exception; end
     class InvalidOrderId             < Exception; end
     class CallbackUrlBadResponse     < Exception; end
     class WebsocketExists            < Exception; end
     class WebsocketForCompletedOrder < Exception; end
+    class GatewayInactive            < Exception; end
+    class NoBlockchainAdapters       < Exception
+      def message
+        "No blockchain adapters were found! StraightServer cannot query the blockchain.\n" +
+        "Check your ~/.straight/config.yml file and make sure valid blockchain adapters\n" +
+        "are present."
+      end
+    end
+    class NoWebsocketsForNewGateway  < Exception
+      def message
+        "You're trying to get access to websockets on a Gateway that hasn't been saved yet"
+      end
+    end
+    class OrderCountersDisabled      < Exception
+      def message
+        "Please enable order counting in config file! You can do is using the following option:\n\n" +
+        "  count_orders: true\n\n" +
+        "and don't forget to provide Redis connection info by adding this to the config file as well:\n\n" +
+        "  redis:\n" +
+        "    host: localhost\n" +
+        "    port: 6379\n" +
+        "    db:   null\n"
+      end
+    end
 
     CALLBACK_URL_ATTEMPT_TIMEFRAME = 3600 # seconds
 
-    def initialize(*attrs)
-      
+
+    ############# Initializers methods ########################################################
+    # We have separate methods, because with GatewayOnDB they are called from #after_initialize
+    # but in GatewayOnConfig they are called from #initialize intself.
+    # #########################################################################################
+    #
+    def initialize_exchange_rate_adapters
+      @exchange_rate_adapters ||= []
+      if self.exchange_rate_adapter_names
+        self.exchange_rate_adapter_names.each do |adapter|
+          begin
+            @exchange_rate_adapters << Straight::ExchangeRate.const_get("#{adapter}Adapter").instance
+          rescue NameError => e 
+            puts "WARNING: No exchange rate adapter with the name #{a} was found!"
+          end
+        end
+      end
+    end
+
+    def initialize_blockchain_adapters
+      @blockchain_adapters = []
+      StraightServer::Config.blockchain_adapters.each do |a|
+
+        adapter = begin
+          Straight::Blockchain.const_get("#{a}Adapter")
+        rescue NameError
+          begin
+            Kernel.const_get(a)
+          rescue NameError
+            puts "WARNING: No blockchain adapter with the name #{a} was found!"
+            nil
+          end
+        end
+
+        @blockchain_adapters << adapter.mainnet_adapter if adapter
+      end
+      raise NoBlockchainAdapters if @blockchain_adapters.empty?
+    end
+
+    def initialize_callbacks
       # When the status of an order changes, we send an http request to the callback_url
       # and also notify a websocket client (if present, of course).
-      @order_callbacks     = [
+      @order_callbacks = [
         lambda do |order|
           StraightServer::Thread.new do
             send_callback_http_request     order
@@ -24,27 +94,25 @@ module StraightServer
           end
         end
       ]
+    end
 
-      @blockchain_adapters = [
-        Straight::Blockchain::BlockchainInfoAdapter.mainnet_adapter,
-        Straight::Blockchain::HelloblockIoAdapter.mainnet_adapter
-      ]
-
-      @exchange_rate_adapters = []
+    def initialize_status_check_schedule
       @status_check_schedule = Straight::GatewayModule::DEFAULT_STATUS_CHECK_SCHEDULE
-      @websockets            = {}
-
-      super
-      initialize_exchange_rate_adapters # should always go after super
     end
+    #
+    ############# END OF Initializers methods ##################################################
+ 
     
     # Creates a new order and saves into the DB. Checks if the MD5 hash
     # is correct first.
     def create_order(attrs={})
+
+      raise GatewayInactive unless self.active
+
       StraightServer.logger.info "Creating new order with attrs: #{attrs}"
       signature = attrs.delete(:signature)
-      raise InvalidOrderId if check_signature && (attrs[:id].nil? || attrs[:id].to_i <= 0)
       if !check_signature || sign_with_secret(attrs[:id]) == signature
+        raise InvalidOrderId if check_signature && (attrs[:id].nil? || attrs[:id].to_i <= 0)
         order = order_for_keychain_id(
           amount:           attrs[:amount],
           keychain_id:      increment_last_keychain_id!,
@@ -75,47 +143,69 @@ module StraightServer
     end
 
     def add_websocket_for_order(ws, order)
-      raise WebsocketExists            unless @websockets[order.id].nil?
+      raise WebsocketExists            unless websockets[order.id].nil?
       raise WebsocketForCompletedOrder unless order.status < 2
       StraightServer.logger.info "Opening ws connection for #{order.id}"
       ws.on(:close) do |event|
-        @websockets.delete(order.id)
+        websockets.delete(order.id)
         StraightServer.logger.info "Closing ws connection for #{order.id}"
       end
-      @websockets[order.id] = ws
+      websockets[order.id] = ws
       ws
     end
 
+    def websockets
+      raise NoWebsocketsForNewGateway unless self.id
+      @@websockets[self.id]
+    end
+
     def send_order_to_websocket_client(order)
-      if ws = @websockets[order.id]
+      if ws = websockets[order.id]
         ws.send(order.to_json)
         ws.close
       end
     end
 
-    def initialize_exchange_rate_adapters
-      if self.exchange_rate_adapter_names
-        self.exchange_rate_adapter_names.each do |adapter|
-          begin
-            @exchange_rate_adapters << Kernel.const_get("Straight::ExchangeRate::#{adapter}Adapter").new
-          rescue NameError 
-            raise NameError, "No such adapter exists: Straight::ExchangeRate::#{adapter}Adapter"
-          end
-        end
+    def sign_with_secret(content, level: 1)
+      result = content.to_s
+      level.times do
+        result = OpenSSL::HMAC.digest('sha256', secret, result).unpack("H*").first
       end
+      result
     end
 
-    private
-
-      def sign_with_secret(content, level: 1)
-        result = content.to_s
-        level.times do
-          h = HMAC::SHA1.new(secret)
-          h << result
-          result = h.hexdigest
-        end
-        result
+    def order_status_changed(order)
+      statuses = Order::STATUSES.invert
+      if StraightServer::Config.count_orders
+        increment_order_counter!(statuses[order.old_status], -1) if order.old_status
+        increment_order_counter!(statuses[order.status])
       end
+      super
+    end
+
+    def order_counters(reload: false)
+      return @order_counters if @order_counters && !reload
+      @order_counters = {
+        new:         get_order_counter(:new),
+        unconfirmed: get_order_counter(:unconfirmed),
+        paid:        get_order_counter(:paid),
+        underpaid:   get_order_counter(:underpaid),
+        overpaid:    get_order_counter(:overpaid),
+        expired:     get_order_counter(:expired)
+      }
+    end
+
+    def get_order_counter(counter_name)
+      raise OrderCountersDisabled unless StraightServer::Config.count_orders
+      @@redis.get("#{StraightServer::Config.redis[:prefix]}:gateway_#{id}:#{counter_name}_orders_counter").to_i || 0
+    end
+
+    def increment_order_counter!(counter_name, by=1)
+      raise OrderCountersDisabled unless StraightServer::Config.count_orders
+      @@redis.incrby("#{StraightServer::Config.redis[:prefix]}:gateway_#{id}:#{counter_name}_orders_counter", by)
+    end
+
+    private
 
       # Tries to send a callback HTTP request to the resource specified
       # in the #callback_url. If it fails for any reason, it keeps trying for an hour (3600 seconds)
@@ -141,7 +231,7 @@ module StraightServer
             sleep(delay)
             send_callback_http_request(order, delay: delay*2)
           else
-            StraightServer.logger.warn "Callback request for order #{order.id} faile, see order's #callback_response field for details"
+            StraightServer.logger.warn "Callback request for order #{order.id} failed, see order's #callback_response field for details"
           end
         end
         
@@ -157,6 +247,75 @@ module StraightServer
     include GatewayModule
     plugin :timestamps, create: :created_at, update: :updated_at
     plugin :serialization, :marshal, :exchange_rate_adapter_names
+    plugin :serialization, :marshal
+    plugin :after_initialize
+
+    def self.find_by_hashed_id(s)
+      self.where(hashed_id: s).first
+    end
+
+    def before_create
+      super
+      encrypt_secret
+    end
+
+    def after_create
+      @@websockets[self.id] = {}
+      update(hashed_id: OpenSSL::HMAC.digest('sha256', Config.server_secret, self.id.to_s).unpack("H*").first)
+    end
+
+    def after_initialize
+      @status_check_schedule = Straight::GatewayModule::DEFAULT_STATUS_CHECK_SCHEDULE
+      @@websockets[self.id] ||= {} if self.id
+      initialize_callbacks
+      initialize_exchange_rate_adapters
+      initialize_blockchain_adapters
+      initialize_status_check_schedule
+    end
+    
+    # We cannot allow to store gateway secret in a DB plaintext, this would be completetly unsecure.
+    # Althougth we use symmetrical encryption here and store the encryption key in the
+    # server's in a special file (~/.straight/server_secret), which in turn can also be stolen,
+    # this is still marginally better than doing nothing.
+    #
+    # Also, server admnistrators now have the freedom of developing their own strategy
+    # of storing that secret - it doesn't have to be stored on the same machine.
+    def secret
+      decrypt_secret
+    end
+
+    def self.find_by_id(id)
+      self[id]
+    end
+
+    private
+
+      def encrypt_secret
+        cipher           = OpenSSL::Cipher::AES.new(128, :CBC)
+        cipher.encrypt
+        cipher.key       = OpenSSL::HMAC.digest('sha256', 'nonce', Config.server_secret).unpack("H*").first[0,16]
+        cipher.iv        = iv = OpenSSL::HMAC.digest('sha256', 'nonce', "#{self.id}#{Config.server_secret}").unpack("H*").first[0,16]
+        encrypted        = cipher.update(self[:secret]) << cipher.final()
+        base64_encrypted = Base64.strict_encode64(encrypted).encode('utf-8') 
+        result           = "#{iv}:#{base64_encrypted}"
+        
+        # Check whether we can decrypt. It should not be possible to encrypt the
+        # gateway secret unless we are sure we can decrypt it.
+        if decrypt_secret(result) == self[:secret]
+          self.secret = result
+        else
+          raise "Decrypted and original secrets don't match! Cannot proceed with writing the encrypted gateway secret."
+        end
+      end
+
+      def decrypt_secret(encrypted_field=self[:secret])
+        decipher      = OpenSSL::Cipher::AES.new(128, :CBC)
+        iv, encrypted = encrypted_field.split(':')
+        decipher.decrypt
+        decipher.key  = OpenSSL::HMAC.digest('sha256', 'nonce', Config.server_secret).unpack("H*").first[0,16]
+        decipher.iv   = iv
+        decipher.update(Base64.decode64(encrypted)) + decipher.final
+      end
 
   end
 
@@ -192,19 +351,35 @@ module StraightServer
     attr_accessor :id
 
     attr_accessor :exchange_rate_adapter_names
+    attr_accessor :orders_expiration_period
+   
+    # This affects whether it is possible to create a new order with the gateway.
+    # If it's set to false, then it won't be possible to create a new order, but
+    # it will keep checking on the existing ones.
+    attr_accessor :active
+
+    def self.find_by_hashed_id(s)
+      self.find_by_id(s)
+    end
+
+    def initialize
+      initialize_callbacks
+      initialize_exchange_rate_adapters
+      initialize_blockchain_adapters
+      initialize_status_check_schedule
+    end
 
     # Because this is a config based gateway, we only save last_keychain_id
     # and nothing more.
     def save
-      File.open(@last_keychain_id_file, 'w') {|f| f.write(last_keychain_id) }
+      save_last_keychain_id!
     end
 
     # Loads last_keychain_id from a file in the .straight dir.
     # If the file doesn't exist, we create it. Later, whenever an attribute is updated,
     # we save it to the file.
     def load_last_keychain_id!
-      @last_keychain_id_file = StraightServer::Initializer::STRAIGHT_CONFIG_PATH +
-                               "/#{name}_last_keychain_id"
+      @last_keychain_id_file ||= StraightServer::Initializer::ConfigDir.path + "/#{name}_last_keychain_id"
       if File.exists?(@last_keychain_id_file)
         self.last_keychain_id = File.read(@last_keychain_id_file).to_i
       else
@@ -213,6 +388,17 @@ module StraightServer
       end
     end
 
+    def save_last_keychain_id!
+      @last_keychain_id_file ||= StraightServer::Initializer::ConfigDir.path + "/#{name}_last_keychain_id"
+      File.open(@last_keychain_id_file, 'w') {|f| f.write(last_keychain_id) }
+    end
+
+    # This method is a replacement for the Sequel's model one used in DB version of the gateway
+    # and it finds gateways using the index of @@gateways Array.
+    def self.find_by_id(id)
+      @@gateways[id.to_i-1]
+    end
+
     # This will later be used in the #find_by_id. Because we don't use a DB,
     # the id will actually be the index of an element in this Array. Thus,
     # the order in which gateways follow in the config file is important.
@@ -223,27 +409,23 @@ module StraightServer
     StraightServer::Config.gateways.each do |name, attrs|
       i += 1
       gateway = self.new
-      gateway.pubkey                 = attrs['pubkey']
-      gateway.confirmations_required = attrs['confirmations_required'].to_i
-      gateway.order_class            = attrs['order_class']
-      gateway.secret                 = attrs['secret']
-      gateway.check_signature        = attrs['check_signature']
-      gateway.callback_url           = attrs['callback_url']
-      gateway.default_currency       = attrs['default_currency']
-      gateway.name                   = name
-      gateway.id                     = i
+      gateway.pubkey                         = attrs['pubkey']
+      gateway.confirmations_required         = attrs['confirmations_required'].to_i
+      gateway.order_class                    = attrs['order_class']
+      gateway.secret                         = attrs['secret']
+      gateway.check_signature                = attrs['check_signature']
+      gateway.callback_url                   = attrs['callback_url']
+      gateway.default_currency               = attrs['default_currency']
+      gateway.orders_expiration_period       = attrs['orders_expiration_period']
+      gateway.active                         = attrs['active']
+      gateway.name                     = name
+      gateway.id                       = i
       gateway.exchange_rate_adapter_names = attrs['exchange_rate_adapters']
       gateway.initialize_exchange_rate_adapters
       gateway.load_last_keychain_id!
+      @@websockets[i] = {}
       @@gateways << gateway
-    end
-    
-
-    # This method is a replacement for the Sequel's model one used in DB version of the gateway
-    # and it finds gateways using the index of @@gateways Array.
-    def self.find_by_id(id)
-      @@gateways[id.to_i-1]
-    end
+    end if StraightServer::Config.gateways
 
   end
 
@@ -251,7 +433,7 @@ module StraightServer
   # so they can simply start using a single gateway on their machines, a gateway which attributes are defined
   # in a config file instead of a DB. That way they don't need special tools to access the DB and create
   # a gateway, but can simply edit the config file.
-  Gateway = if StraightServer::Config.gateways_source = 'config'
+  Gateway = if StraightServer::Config.gateways_source == 'config'
     GatewayOnConfig
   else
     GatewayOnDB

data/lib/straight-server/initializer.rb

@@ -2,76 +2,202 @@ module StraightServer
 
   module Initializer
 
-    GEM_ROOT             = File.expand_path('../..', File.dirname(__FILE__))
-    STRAIGHT_CONFIG_PATH = ENV['HOME'] + '/.straight'
+    GEM_ROOT = File.expand_path('../..', File.dirname(__FILE__))
+
+    module ConfigDir
+
+      class << self
+
+        # Determine config dir or set default. Useful when we want to
+        # have different settings for production or staging or development environments.
+        def set!(path=nil)
+          @@config_dir = path and return if path
+          @@config_dir = ENV['HOME'] + '/.straight'
+          ARGV.each do |a|
+            if a =~ /\A--config-dir=.+/
+              @@config_dir = File.expand_path(a.sub('--config-dir=', ''))
+              break
+            elsif a =~ /\A-c .+/
+              @@config_dir = File.expand_path(a.sub('-c ', ''))
+              break
+            end
+          end
+          puts "Setting config dir to #{@@config_dir}"
+        end
+
+        def path
+          @@config_dir
+        end
+
+      end
+
+    end
 
     def prepare
-      create_config_file unless File.exist?(STRAIGHT_CONFIG_PATH + '/config.yml')
+      ConfigDir.set!
+      create_config_files
       read_config_file
       create_logger
       connect_to_db
-      run_migrations if migrations_pending?
+      run_migrations         if migrations_pending?
+      setup_redis_connection if StraightServer::Config.count_orders
+      initialize_routes
     end
 
-    private
+    def add_route(path, &block)
+      @routes[path] = block 
+    end
 
-      def create_config_file
+    def create_config_files
+      FileUtils.mkdir_p(ConfigDir.path) unless File.exist?(ConfigDir.path)
+
+      unless File.exist?(ConfigDir.path + '/addons.yml')
+        puts "\e[1;33mNOTICE!\e[0m \e[33mNo file ~/.straight/addons.yml was found. Created an empty sample for you.\e[0m"
+        puts "No need to restart until you actually list your addons there. Now will continue loading StraightServer."
+        FileUtils.cp(GEM_ROOT + '/templates/addons.yml', ENV['HOME'] + '/.straight/') 
+      end
+
+      unless File.exist?(ConfigDir.path + '/server_secret')
+        puts "\e[1;33mNOTICE!\e[0m \e[33mNo file ~/.straight/server_secret was found. Created one for you.\e[0m"
+        puts "No need to restart so far. Now will continue loading StraightServer."
+        File.open(ConfigDir.path + '/server_secret', "w") do |f|
+          f.puts String.random(16)
+        end
+      end
+
+      unless File.exist?(ConfigDir.path + '/config.yml')
         puts "\e[1;33mWARNING!\e[0m \e[33mNo file ~/.straight/config was found. Created a sample one for you.\e[0m"
         puts "You should edit it and try starting the server again.\n"
 
-        FileUtils.mkdir_p(STRAIGHT_CONFIG_PATH) unless File.exist?(STRAIGHT_CONFIG_PATH)
         FileUtils.cp(GEM_ROOT + '/templates/config.yml', ENV['HOME'] + '/.straight/') 
         puts "Shutting down now.\n\n"
         exit
       end
 
-      def read_config_file
-        YAML.load_file(STRAIGHT_CONFIG_PATH + '/config.yml').each do |k,v|
-          StraightServer::Config.send(k + '=', v)
-        end
-      end
+    end
 
-      def connect_to_db
+    def read_config_file
+      YAML.load_file(ConfigDir.path + '/config.yml').each do |k,v|
+        StraightServer::Config.send(k + '=', v)
+      end
+      StraightServer::Config.server_secret = File.read(ConfigDir.path + '/server_secret').chomp
+    end
 
-        # symbolize keys for convenience
-        db_config = StraightServer::Config.db.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    def connect_to_db
 
-        db_name = if db_config[:adapter] == 'sqlite'
-          STRAIGHT_CONFIG_PATH + "/" + db_config[:name]
-        else
-          db_config[:name]
-        end
+      # symbolize keys for convenience
+      db_config = StraightServer::Config.db.keys_to_sym
 
-        StraightServer.db_connection = Sequel.connect(
-          "#{db_config[:adapter]}://"                                                   +
-          "#{db_config[:user]}#{(":" if db_config[:user])}"                             +
-          "#{db_config[:password]}#{("@" if db_config[:user] || db_config[:password])}" +
-          "#{db_config[:host]}#{(":" if db_config[:port])}"                             +
-          "#{db_config[:port]}#{("/" if db_config[:host] || db_config[:port])}"         +
-          "#{db_name}"
-        )
+      db_name = if db_config[:adapter] == 'sqlite'
+        ConfigDir.path + "/" + db_config[:name]
+      else
+        db_config[:name]
       end
 
-      def run_migrations
-        print "\nPending migrations for the database detected. Migrating..."
-        Sequel::Migrator.run(StraightServer.db_connection, GEM_ROOT + '/db/migrations/')
-        print "done\n\n"
-      end
+      StraightServer.db_connection = Sequel.connect(
+        "#{db_config[:adapter]}://"                                                   +
+        "#{db_config[:user]}#{(":" if db_config[:user])}"                             +
+        "#{db_config[:password]}#{("@" if db_config[:user] || db_config[:password])}" +
+        "#{db_config[:host]}#{(":" if db_config[:port])}"                             +
+        "#{db_config[:port]}#{("/" if db_config[:host] || db_config[:port])}"         +
+        "#{db_name}"
+      )
+    end
+
+    def run_migrations
+      print "\nPending migrations for the database detected. Migrating..."
+      Sequel::Migrator.run(StraightServer.db_connection, GEM_ROOT + '/db/migrations/')
+      print "done\n\n"
+    end
+
+    def migrations_pending?
+      !Sequel::Migrator.is_current?(StraightServer.db_connection, GEM_ROOT + '/db/migrations/')
+    end
+
+    def create_logger
+      require_relative 'logger'
+      StraightServer.logger = StraightServer::Logger.new(
+        log_level:       ::Logger.const_get(Config.logmaster['log_level'].upcase),
+        file:            ConfigDir.path + '/' + Config.logmaster['file'],
+        raise_exception: Config.logmaster['raise_exception'],
+        name:            Config.logmaster['name'],
+        email_config:    Config.logmaster['email_config']
+      )
+    end
 
-      def migrations_pending?
-        !Sequel::Migrator.is_current?(StraightServer.db_connection, GEM_ROOT + '/db/migrations/')
+    def initialize_routes
+      @routes = {}
+      add_route /\A\/gateways\/.+?\/orders(\/.+)?\Z/ do |env|
+        controller = OrdersController.new(env)
+        controller.response
       end
+    end
 
-      def create_logger
-        require_relative 'logger'
-        StraightServer.logger = StraightServer::Logger.new(
-          log_level:       ::Logger.const_get(Config.logmaster['log_level'].upcase),
-          file:            STRAIGHT_CONFIG_PATH + '/' + Config.logmaster['file'],
-          raise_exception: Config.logmaster['raise_exception'],
-          name:            Config.logmaster['name'],
-          email_config:    Config.logmaster['email_config']
-        )
+    # Loads addon modules into StraightServer::Server. To be useful,
+    # an addon most probably has to implement self.extended(server) callback.
+    # That way, it can access the server object and, for example, add routes
+    # with StraightServer::Server#add_route.
+    #
+    # Addon modules can be both rubygems or files under ~/.straight/addons/.
+    # If ~/.straight/addons.yml contains a 'path' key for a particular addon, then it means
+    # the addon is placed under the ~/.straight/addons/. If not, it is assumed it
+    # is already in the LOAD_PATH somehow, with rubygems for example.
+    def load_addons
+      # load ~/.straight/addons.yml
+      addons = YAML.load_file(ConfigDir.path + '/addons.yml')
+      addons.each do |name, addon|
+        StraightServer.logger.info "Loading #{name} addon"
+        if addon['path'] # First, check the ~/.straight/addons dir
+          require ConfigDir.path + '/' + addon['path']
+        else # then assume it's already loaded using rubygems
+          require name
+        end
+        # extending the current server object with the addon
+        extend Kernel.const_get("StraightServer::Addon::#{addon['module']}")
+      end if addons
+    end
+
+    # Finds orders that have statuses < 2 and starts querying the blockchain
+    # for them (unless they are also expired). This is for cases when the server was shut down,
+    # but some orders statuses are not resolved.
+    def resume_tracking_active_orders!
+      StraightServer::Order.where('status < 2').each do |order|
+
+        # Order is expired, but status is < 2! Suspcicious, probably
+        # an unclean shutdown of the server. Let's check and update the status manually once.
+        if order.time_left_before_expiration < 1
+          StraightServer.logger.info "Order #{order.id} seems to be expired, but status remains #{order.status}. Will check for status update manually."
+          order.status(reload: true)
+
+          # if we still see no transactions to that address,
+          # consider the order truly expired and update the status accordingly
+          order.status = StraightServer::Order::STATUSES[:expired] if order.status < 2
+          order.save
+          StraightServer.logger.info "Order #{order.id} status updated, new status is #{order.status}"
+
+        # Order is NOT expired and status is < 2. Let's keep tracking it.
+        else
+          StraightServer.logger.info "Resuming tracking of order #{order.id}, current status is #{order.status}, time before expiration: #{order.time_left_before_expiration} seconds."
+          StraightServer::Thread.new do
+            order.start_periodic_status_check
+          end
+        end
       end
+    end
+
+    # Loads redis gem and sets up key prefixes for order counters
+    # for the current straight environment. 
+    def setup_redis_connection
+      require 'redis'
+      Config.redis = Config.redis.keys_to_sym
+      Config.redis[:connection] = Redis.new(
+        host:     Config.redis[:host],
+        port:     Config.redis[:port],
+        db:       Config.redis[:db],
+        password: Config.redis[:password]
+      )
+      Config.redis[:prefix] ||= "StraightServer:#{Config.environment}"
+    end
 
   end
 

data/lib/straight-server/logger.rb

@@ -6,7 +6,7 @@ module StraightServer
 
       n.times { puts "\n" }
 
-      File.open(StraightServer::Initializer::STRAIGHT_CONFIG_PATH + '/' + Config.logmaster['file'], 'a') do |f|
+      File.open(StraightServer::Initializer::ConfigDir.path + '/' + Config.logmaster['file'], 'a') do |f|
         n.times do
           f.puts "\n"
         end