configuration parameters in config file and helpers in helper file. Some code refactoring and startup config default values changed

Author: janika

.gitignore

@@ -1,2 +1,4 @@
 tmp/*
 models/*
+.loadpath
+.project

configure.rb

@@ -0,0 +1,26 @@
+configure do
+  set :environment, :development 
+  set :raise_errors, true
+  set :dump_errors, true
+  set :show_exceptions, false
+
+  $recognizer_pool = {:idle => []}
+  CONFIG = {
+    :nr_of_initial_recognizers => 4, #the number of recognizers initialized when server is started
+    :max_idle_recognizers => 4, #number of recognizer instances that are allowed to be idle
+    :max_recognizers => 4, #total amount of allowed recognizers
+    :session_life_cycle => 10 * 60, #the amount of seconds the session result is kept in memory
+    :max_session_open_time => 3 * 60, #amount of seconds during which the session is kept open and speech is received
+    :timeout_in_seconds => 10, #session closed if after ending feed during 10 seconds no final result is given from recognizer
+    :timeout_for_recognition_failure => 60 #session is closed by system if after 60 seconds no result is generated for session
+  }
+
+  CONFIG[:nr_of_initial_recognizers].times do 
+    RecognizerPool.pool[:idle] << Recognizer.new
+  end
+  
+  scheduler = Rufus::Scheduler.start_new
+  scheduler.every '120s' do
+    RecognizerPool.organize_pool
+  end
+end

helpers.rb

@@ -0,0 +1,58 @@
+helpers do
+  
+  def render_error(message)
+    if response_type == "application/json"
+      error_to_json(message)
+    else
+      error_to_xml(message)
+    end
+  end
+  
+  def error_to_json(message)
+    {:error => {:message => message}}.to_json
+  end
+  
+  def error_to_xml(message)
+    builder do |xml|
+      xml.instruct! :xml, :version => '1.0'
+      xml.error do
+        xml.message message
+      end
+    end
+  end
+  
+  def set_headers
+    headers "Content-Type"=>"text/xml;charset=utf-8;"
+  end
+  
+  def render_with_type(session)
+    if response_type == "application/json"
+      session.to_json
+    else
+      session.to_xml
+    end
+  end
+  
+  def response_type
+    env['HTTP_ACCEPT']
+  end
+  
+  def work_with_session(close = false)
+    begin
+      session = RecognizerPool.find_by_session_id(params[:id])
+      if session
+        if session.closed?
+          render_error("Session with id #{params[:id]} is already closed")
+        else
+          close ? session.close! : session.recognize(request.body)
+          render_with_type(session)
+        end
+      else
+        render_error("Session with id #{params[:id]} not found")
+      end
+    rescue Exception => e
+      render_error(e.message)
+    end
+  end
+  
+end

lib/recognizer_pool.rb

@@ -1,10 +1,4 @@
-module RecognizerPool
-  MAX_IDLE_RECOGNIZERS = 2
-  NUMBER_OF_INITIAL_RECOGNIZERS = 1
-  MAX_RECOGNIZERS = 5
-  LIFE_CYCLE_IN_SECONDS = 3 * 60
-  MAX_OPEN_TIME_IN_SECONDS = 30
-  
+module RecognizerPool 
   def self.pool
     $recognizer_pool
   end
@@ -29,29 +23,29 @@ def self.add_new_to_active_pool(session)
   def self.get_recognizer
     if pool[:idle].size > 0
       pool[:idle].pop
-    elsif (active_recognizers.size) < MAX_RECOGNIZERS
+    elsif (active_recognizers.size) < CONFIG[:max_recognizers]
       Recognizer.new
     end
   end
 
   def self.active_recognizers
     pool.collect do |session| 
       if session[0] != :idle && !session[1].recognizer.nil?
-	session[1].recognizer
+      	session[1].recognizer
       end
     end.compact
   end
 
   def self.make_recognizer_idle_if_necessary(recognizer)
-    pool[:idle] << recognizer if (pool[:idle].size < MAX_IDLE_RECOGNIZERS)
+    pool[:idle] << recognizer if (pool[:idle].size < CONFIG[:max_idle_recognizers])
   end
 
   def self.organize_pool
     pool.each_pair do |key, session|
       if key != :idle
-	if (Time.now - session.created_at) >  LIFE_CYCLE_IN_SECONDS
+	if (Time.now - session.created_at) >  CONFIG[:session_life_cycle]
 	  pool.delete(key)
-	elsif !session.closed? && (Time.now - session.created_at) >  MAX_OPEN_TIME_IN_SECONDS
+	elsif !session.closed? && (Time.now - session.created_at) >  CONFIG[:max_session_open_time]
 	  session.close!
 	  session.system_message = "Session time limit exceeded"
 	elsif session.recognition_failing?
@@ -64,7 +58,7 @@ def self.organize_pool
   end
 
   def self.add_new_recognizer_to_idle_pool_if_necessary
-    if pool[:idle].empty? && ((active_recognizers.size) < MAX_RECOGNIZERS)
+    if pool[:idle].empty? && ((active_recognizers.size) < CONFIG[:max_recognizers])
       pool[:idle] << Recognizer.new
     end
   end

lib/recognizer_session.rb

@@ -32,13 +32,13 @@ def close!(end_recognizer_feed = true)
   end
 
   def recognition_failing?
-    !closed? && ((Time.now - self.created_at) > TIMEOUT_FOR_RECOGNITION_FAILURE) && (self.result.nil? || self.result.size == 0)
+    !closed? && ((Time.now - self.created_at) > CONFIG[:timeout_for_recognition_failure]) && (self.result.nil? || self.result.size == 0)
   end
 
   def end_feed
     begin
-      timeout(TIMEOUT_IN_SECONDS) {
-	self.recognizer.end_feed
+      timeout(CONFIG[:timeout_in_seconds]) {
+	     self.recognizer.end_feed
       }
     rescue Timeout::Error
       self.system_message = "execution expired"
@@ -49,8 +49,8 @@ def end_feed
 
   def work_with_data(data)   
     while buff = data.read(BUFFER_SIZE)
-      self.recognizer.feed_data(buff)
-      self.result =  self.recognizer.result
+    	self.recognizer.feed_data(buff)
+      self.result = self.recognizer.result
     end
   end
 

recognizer_api.rb

@@ -1,25 +1,10 @@
 $:.unshift(File.join(File.dirname(__FILE__), "lib"))
-%w(gst rubygems builder sinatra timeout recognizer bundler recognizer_pool recognizer_session rufus/scheduler json).each{|lib| require lib}
-Gst.init
-Bundler.require
-
-configure do
-  set :environment, :development 
-  set :raise_errors, true
-  set :dump_errors, true
-  set :show_exceptions, false
 
-  $recognizer_pool = {:idle => []}
+%w(gst rubygems builder sinatra timeout recognizer bundler recognizer_pool 
+recognizer_session rufus/scheduler json benchmark configure helpers).each{|lib| require lib}
 
-  RecognizerPool::NUMBER_OF_INITIAL_RECOGNIZERS.times do 
-    RecognizerPool.pool[:idle] << Recognizer.new
-  end
-  
-  scheduler = Rufus::Scheduler.start_new
-  scheduler.every '30s' do
-    RecognizerPool.organize_pool
-  end
-end
+Gst.init
+Bundler.require
 
 post '/recognizer' do
   begin
@@ -32,39 +17,11 @@
 end
 
 put '/recognizer/:id' do
-  begin
-    session = RecognizerPool.find_by_session_id(params[:id])
-    if session
-      if session.closed?
-	render_error("Session with id #{params[:id]} is already closed")
-      else
-	session.recognize(request.body)
-	render_with_type(session)
-      end
-    else
-      render_error("Session with id #{params[:id]} not found")
-    end
-  rescue Exception => e
-    render_error(e.message)
-  end
+  work_with_session
 end
 
 put '/recognizer/:id/end' do
-  begin
-    session = RecognizerPool.find_by_session_id(params[:id])
-    if session
-      if session.closed?
-	render_error("Session with id #{params[:id]} is already closed")
-      else
-	session.close!
-	render_with_type(session)
-      end
-    else
-      render_error("Session with id #{params[:id]} not found")
-    end
-  rescue Exception => e
-    render_error(e.message)
-  end
+  work_with_session(true)
 end
 
 get '/recognizer/:id' do
@@ -80,45 +37,5 @@
   end
 end
 
-helpers do
-  
-  def render_error(message)
-    if response_type == "application/json"
-      error_to_json(message)
-    else
-      error_to_xml(message)
-    end
-  end
-  
-  def error_to_json(message)
-    {:error => {:message => message}}.to_json
-  end
-  
-  def error_to_xml(message)
-    builder do |xml|
-      xml.instruct! :xml, :version => '1.0'
-      xml.error do
-	xml.message message
-      end
-    end
-  end
-  
-  def set_headers
-    headers "Content-Type"=>"text/xml;charset=utf-8;"
-  end
-  
-  def render_with_type(session)
-    if response_type == "application/json"
-      session.to_json
-    else
-      session.to_xml
-    end
-  end
-  
-  def response_type
-    env['HTTP_ACCEPT']
-  end
-end
-
 
 

spec/lib/recognizer_pool_spec.rb

@@ -50,19 +50,19 @@
 
     it "should return nil if max recognizers exceeded" do
       $recognizer_pool = {:idle => []}
-      RecognizerPool::MAX_RECOGNIZERS = 0
+      CONFIG[:max_recognizers] = 0
       RecognizerPool.get_recognizer.should be_nil
     end
   end
 
   describe "organize_pool" do
     before(:each) do 
-      RecognizerPool::MAX_RECOGNIZERS = 1
+      CONFIG[:max_recognizers] = 1
       $recognizer_pool = {:idle => []}
     end
 
     it "should close session if open time exceeded" do
-      time = (Time.now - (RecognizerPool::MAX_OPEN_TIME_IN_SECONDS + 10))
+      time = (Time.now - (CONFIG[:max_session_open_time] + 10))
       session = RecognizerSession.new
       session.stub!(:created_at).and_return(time)
       RecognizerPool.add_new_to_active_pool(session)
@@ -94,7 +94,7 @@
     end
 
     it "should remove session if maximum life time exceeded" do
-      time = (Time.now - (RecognizerPool::LIFE_CYCLE_IN_SECONDS + 10))
+      time = (Time.now - (CONFIG[:session_life_cycle] + 10))
       session = RecognizerSession.new
       session.stub!(:created_at).and_return(time)
       RecognizerPool.add_new_to_active_pool(session)
@@ -137,7 +137,7 @@
     end
 
     it "should not create new recognizer if max recognizers limit exceeded" do
-      RecognizerPool::MAX_RECOGNIZERS = 2
+      CONFIG[:max_recognizers] = 2
       $recognizer_pool = {:idle => []}
       current_idle_pool_size = RecognizerPool.pool[:idle].size
       RecognizerPool.should_receive(:active_recognizers).and_return([mock, mock])
@@ -156,10 +156,10 @@
       session_2 =  RecognizerSession.new
       session_2.recognizer = recognizer_2
       $recognizer_pool = {
-	"1" => session_1,
-	"2" => session_2,
-	"3" => RecognizerSession.new,
-	:idle => [mock]}
+      	"1" => session_1,
+      	"2" => session_2,
+      	"3" => RecognizerSession.new,
+      	:idle => [mock]}
       active = RecognizerPool.active_recognizers
       active.size.should == 2
       active.include?(recognizer_1).should be_true
@@ -169,7 +169,7 @@
 
   describe "make_recognizer_idle_if_necessary" do
     before(:each) do
-      RecognizerPool::MAX_IDLE_RECOGNIZERS = 1
+      CONFIG[:max_idle_recognizers] = 1
     end
 
     it "should add to idle pool" do

spec/lib/recognizer_session_spec.rb

@@ -64,7 +64,7 @@
   describe "recognition_failing?" do
     it "should be true" do
       session = RecognizerSession.new
-      time = (Time.now - (RecognizerSession::TIMEOUT_FOR_RECOGNITION_FAILURE + 10))
+      time = (Time.now - (CONFIG[:timeout_for_recognition_failure] + 10))
       session.stub!(:created_at).and_return(time)
       session.recognition_failing?.should be_true
     end

spec/recognizer_api_spec.rb

@@ -10,11 +10,11 @@ def app
   describe "POST recognizer" do
     it "should be add active to recognizer pool" do
       RecognizerPool.pool.size.should == 1
-      RecognizerPool.pool[:idle].size.should == RecognizerPool::NUMBER_OF_INITIAL_RECOGNIZERS
+      RecognizerPool.pool[:idle].size.should == CONFIG[:nr_of_initial_recognizers]
       post '/recognizer'
       last_response.should be_ok
       RecognizerPool.pool.size.should == 2
-      RecognizerPool.pool[:idle].size.should == (RecognizerPool::NUMBER_OF_INITIAL_RECOGNIZERS - 1)
+      RecognizerPool.pool[:idle].size.should == (CONFIG[:nr_of_initial_recognizers] - 1)
     end
 
     it "should be success" do