rhosync 2.1.11 → 2.1.12

data/CHANGELOG

@@ -1,4 +1,9 @@
-## 2.1.11 (not released)
+## 2.1.12
+* #19304885 - fixing race condition in get_lock (lock is released between setnx and get calls)
+* #18508155 - on failed syncs allow the user to retry it up to pre-defined number of times (another approach)
+* #19143845 - added sinatra 1.3.x support
+
+## 2.1.11
 * #17526603 - implement clientreset support for specified sources
 * #18356697 - store lock is never released (support request #1466)
 * use redis 2.2.12 by default

data/Rakefile

@@ -66,7 +66,7 @@ begin
     gemspec.files =  FileList["[A-Z]*", "{bench,bin,generators,lib,spec,tasks}/**/*"]
 
     # TODO: Due to https://www.pivotaltracker.com/story/show/3417862, we can't use JSON 1.4.3
-    gemspec.add_dependency "sinatra", "= 1.2.7"
+    gemspec.add_dependency "sinatra", ">= 1.2.7"
     gemspec.add_dependency "json", "~>1.4.2"
     gemspec.add_dependency "sqlite3-ruby", "~>1.2.5"
     gemspec.add_dependency "rubyzip", "~>0.9.4"

data/lib/rhosync/body_content_type_parser.rb

@@ -0,0 +1,29 @@
+module Rhosync
+  class BodyContentTypeParser
+
+    # Constants
+    #
+    CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+    POST_BODY = 'rack.input'.freeze
+    FORM_INPUT = 'rack.request.form_input'.freeze
+    FORM_HASH = 'rack.request.form_hash'.freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env['CONTENT_TYPE'] && env['CONTENT_TYPE'].match(/^application\/json/) 
+        begin
+          if (body = env[POST_BODY].read).length != 0
+            env.update(FORM_HASH => JSON.parse(body), FORM_INPUT => env[POST_BODY])
+          end
+        rescue JSON::ParserError => jpe
+          log jpe.message + jpe.backtrace.join("\n")
+          return [500, {'Content-Type' => 'text/plain'}, ["Server error while processing client data"]]
+        end
+      end
+      @app.call(env)
+    end
+  end
+end

data/lib/rhosync/client_sync.rb

@@ -40,7 +40,7 @@ module Rhosync
         return _resend_search_result if params[:token] and params[:resend]
         if params[:token] and !_ack_search(params[:token]) 
           formatted_result = _format_search_result
-          @client.flash_data('search*')
+          _delete_search
           return formatted_result
         end
       end
@@ -279,7 +279,7 @@ module Rhosync
     
     def _ack_search(search_token)
       if @client.get_value(:search_token) != search_token
-        @client.flash_data('search*')
+        _delete_search
         @client.put_data(:search_errors,
           {'search-error'=>{'message'=>'Search error - invalid token'}}
         )
@@ -294,7 +294,7 @@ module Rhosync
       @source_sync.search(@client.id,search_params) if params.nil? or !params[:token]
       res,diffsize = compute_search
       formatted_res = _format_search_result(res,diffsize)      
-      @client.flash_data('search*') if diffsize == 0
+      _delete_search if diffsize == 0
       formatted_res
     end
     
@@ -361,6 +361,12 @@ module Rhosync
       end
       @client.flash_data("update_rollback_page")
     end
+
+    def _delete_search
+      [:search, :search_page, :search_token, :search_errors].each do |search_doc|
+        @client.flash_data(search_doc)
+      end
+    end
     
     def _send_errors
       res = {}

data/lib/rhosync/console/server.rb

@@ -15,9 +15,13 @@ module RhosyncConsole
   end  
 
   class Server < Sinatra::Base
-    set :views,  RhosyncConsole::root_path("app","views")
-    set :public, RhosyncConsole::root_path("app","public")
-    set :static, true    
+    set :views,           RhosyncConsole::root_path("app","views")
+    if Sinatra.const_defined?("VERSION") && Gem::Version.new(Sinatra::VERSION) >= Gem::Version.new("1.3.0")
+      set :public_folder, RhosyncConsole::root_path("app","public")
+    else
+     	set :public,        RhosyncConsole::root_path("app","public")
+    end
+    set :static,          true
     use Rack::Session::Cookie
     before do
       headers['Expires'] = 'Sun, 19 Nov 1978 05:00:00 GMT'

data/lib/rhosync/read_state.rb

@@ -1,6 +1,7 @@
 module Rhosync  
   class ReadState < Model
     field :refresh_time, :integer
+    field :prev_refresh_time, :integer
     field :retry_counter, :integer
   
     def self.create(fields)
@@ -9,6 +10,7 @@ module Rhosync
       fields.delete(:user_id)
       fields.delete(:source_name)
       fields[:refresh_time] ||= Time.now.to_i
+      fields[:prev_refresh_time] ||= Time.now.to_i
       fields[:retry_counter] ||= 0
       super(fields,{})
     end

data/lib/rhosync/server.rb

@@ -4,6 +4,7 @@ require 'erb'
 require 'json'
 require 'fileutils'
 require 'rhosync'
+require 'rhosync/body_content_type_parser'
 
 module Rhosync
   
@@ -17,15 +18,17 @@ module Rhosync
     
   class Server < Sinatra::Base
     libdir = File.dirname(File.expand_path(__FILE__))
-    set :views,  "#{libdir}/server/views"
-    set :public, "#{libdir}/server/public"
-    set :static, true
+    set :views,           "#{libdir}/server/views"
+    if Sinatra.const_defined?("VERSION") && Gem::Version.new(Sinatra::VERSION) >= Gem::Version.new("1.3.0")
+      set :public_folder, "#{libdir}/server/public"
+    else
+     	set :public,        "#{libdir}/server/public"
+    end
+    set :static,          true
+    set :stats,           false
     
     # default secret
     @@secret = '<changeme>'
-    
-    # stats middleware disabled by default
-    @@stats = false
                                                                                          
     # Setup route and mimetype for bulk data downloads
     # TODO: Figure out why "mime :data, 'application/octet-stream'" doesn't work
@@ -60,7 +63,7 @@ module Rhosync
       def login
         if params[:login] == 'rhoadmin'
           user = User.authenticate(params[:login], params[:password])
-        elsif current_app and current_app.can_authenticate?
+        elsif current_app and current_app.can_authenticate? and params[:login]
           user = current_app.authenticate(params[:login], params[:password], session)
         end
         if user
@@ -142,26 +145,25 @@ module Rhosync
     
     # hook into new so we can enable middleware
     def self.new
-      if @@stats == true
+      use Rhosync::BodyContentTypeParser
+      if settings.respond_to?(:stats) and settings.send(:stats) == true
         use Rhosync::Stats::Middleware 
-        Rhosync.stats = true
+       	Rhosync.stats = true
+      else
+       	Rhosync::Server.disable :stats
+       	Rhosync.stats = false
       end
+      Rhosync::Server.set :secret, @@secret unless settings.respond_to?(:secret)
       use Rack::Session::Cookie, 
-            :key => 'rhosync_session',
-            :expire_after => 31536000,
-            :secret => @@secret     
-      super
-    end
-    
-    def self.set(option, value=self, &block)
-      @@stats = value if option == :stats and (value.is_a?(TrueClass) or value.is_a?(FalseClass))
-      @@secret = value if option == :secret and value.is_a?(String)
+          :key => 'rhosync_session',
+          :expire_after => 31536000,
+          :secret => Rhosync::Server.secret
       super
     end
         
     def initialize
       # Whine about default session secret
-      check_default_secret!(@@secret)
+      check_default_secret!(Rhosync::Server.secret)
       super
     end
     
@@ -173,11 +175,6 @@ module Rhosync
           cud = JSON.parse(params["cud"])
           params.delete("cud")
           params.merge!(cud)
-        end
-        #application/json; charset=UTF-8
-        if request.env['CONTENT_TYPE'] && request.env['CONTENT_TYPE'].match(/^application\/json/)
-          params.merge!(JSON.parse(request.body.read))
-          request.body.rewind
         end      
       rescue JSON::ParserError => jpe
         log jpe.message + jpe.backtrace.join("\n")
@@ -189,7 +186,6 @@ module Rhosync
       if params[:version] and params[:version].to_i < 3
         throw :halt, [404, "Server supports version 3 or higher of the protocol."]
       end
-      #log "request params: #{params.inspect}"
     end
 
     %w[get post].each do |verb|

data/lib/rhosync/source.rb

@@ -265,40 +265,50 @@ module Rhosync
     end
          
     def if_need_refresh(client_id=nil,params=nil)
-      need_refresh = check_refresh_time
+      need_refresh = lock(:md) do |s|
+        check = check_refresh_time
+        self.read_state.prev_refresh_time = self.read_state.refresh_time if check
+        self.read_state.refresh_time = Time.now.to_i + self.poll_interval if check
+        check
+      end
       yield client_id,params if need_refresh
     end
     
-    def update_refresh_time(query_failure = false)
-      if self.poll_interval == 0
-        self.read_state.refresh_time = Time.now.to_i + self.poll_interval
-        return
-      end
-      
-      allowed_update = true
-      # reset number of retries on succesfull query
-      # or if last refresh was more than 'poll_interval' time ago
-      if not query_failure or (Time.now.to_i - self.read_state.refresh_time >= self.poll_interval)
-        self.read_state.retry_counter = 0 
-      end
+    def rewind_refresh_time(query_failure)
+      return if self.poll_interval == 0
+      lock(:md) do |s|        
+        rewind_time = false
+        # reset number of retries 
+        # and prev_refresh_time on succesfull query
+        # or if last refresh was more than 'poll_interval' time ago
+        if not query_failure or ((Time.now.to_i - self.read_state.prev_refresh_time) >= self.poll_interval)
+          # we need to reset the prev_refresh_time here
+          # otherwise in case of expired poll interval
+          # and repeating failures - it will reset the counter 
+          # on every error
+          self.read_state.prev_refresh_time = Time.now.to_i
+          self.read_state.retry_counter = 0
+        end
       
-      # do not reset the refresh time on failure
-      # if retry limit is not reached
-      if query_failure
-        if self.read_state.retry_counter < self.retry_limit
-          allowed_update = false
-          self.read_state.increment!(:retry_counter)
-        # we have reached the limit - update the refresh time
-        # and reset the counter
-        else
-          self.read_state.retry_counter = 0 
+        # rewind the refresh time on failure
+        # if retry limit is not reached
+        if query_failure
+          if self.read_state.retry_counter < self.retry_limit
+            self.read_state.increment!(:retry_counter)
+            rewind_time = true
+            # we have reached the limit - do not rewind the refresh time
+            # and reset the counter
+          else
+            self.read_state.retry_counter = 0
+          end
         end
-      end
-      if allowed_update
-        self.read_state.refresh_time = Time.now.to_i + self.poll_interval
-      end
+        
+        if rewind_time
+          self.read_state.refresh_time = self.read_state.prev_refresh_time
+        end
+      end 
     end
-          
+        
     private
     def poll_interval_key
       "source:#{self.name}:poll_interval"

data/lib/rhosync/source_adapter.rb

@@ -41,16 +41,20 @@ module Rhosync
     
     def sync
       if @result and @result.empty?
-        @source.flash_data(:md)
-        @source.put_value(:md_size,0)
+        @source.lock(:md) do |s|
+          s.flash_data(:md)
+          s.put_value(:md_size,0)
+        end
       else
         if @result
           Store.put_data(@tmp_docname,@result) 
           @stash_size += @result.size
         end  
-        @source.flash_data(:md)
-        Store.rename(@tmp_docname,@source.docname(:md))
-        @source.put_value(:md_size,@stash_size)
+        @source.lock(:md) do |s|
+          s.flash_data(:md)
+          Store.rename(@tmp_docname,s.docname(:md))
+          s.put_value(:md_size,@stash_size)
+        end
       end
     end
     

data/lib/rhosync/source_sync.rb

@@ -59,19 +59,19 @@ module Rhosync
     end
     
     def do_query(params=nil)
-      @source.lock(:md) do
-        @source.if_need_refresh do
-          Stats::Record.update("source:query:#{@source.name}") do
-            if _auth_op('login')
-              result = self.read(nil,params)
-              _auth_op('logoff')
-            end
-            # update refresh time
-            query_failure = Store.get_keys(@source.docname(:errors)).size > 0
-            @source.update_refresh_time(query_failure)
+      result = nil
+      @source.if_need_refresh do
+        Stats::Record.update("source:query:#{@source.name}") do
+          if _auth_op('login')
+            result = self.read(nil,params)
+            _auth_op('logoff')
           end
+          # re-wind refresh time in case of error
+          query_failure = Store.exists?(@source.docname(:errors))
+          @source.rewind_refresh_time(query_failure)
         end
       end
+      result
     end
     
     # Enqueue a job for the source based on job type

data/lib/rhosync/store.rb

@@ -180,10 +180,23 @@ module Rhosync
     
       # Deletes all keys matching a given mask
       def flash_data(keymask)
-        @@db.keys(keymask).each do |key|
-          @@db.del(key)
+        if keymask[/[*\[\]?]/]
+          # If the keymask contains any pattern matching characters
+          # Use keys command to find all keys matching pattern (this is extremely expensive)
+          # Then delete matches
+          @@db.keys(keymask).each do |key|
+            @@db.del(key)
+          end
+        else
+          # The keymask doesn't contain pattern matching characters
+          # A delete call is all that is needed
+          @@db.del(keymask)
         end
       end
+      
+      def exists?(key)
+        @@db.exists(key)
+      end
     
       # Returns array of keys matching a given keymask
       def get_keys(keymask)
@@ -209,19 +222,27 @@ module Rhosync
         ts = current_time+(Rhosync.lock_duration || timeout)+1
         loop do 
           if not @@db.setnx(lock_key,ts)
-            if raise_on_expire or Rhosync.raise_on_expired_lock
-              if @@db.get(lock_key).to_i <= current_time
-                # lock expired before operation which set it up completed
-                # this process cannot continue without corrupting locked data 
-                raise StoreLockException, "Lock \"#{lock_key}\" expired before it was released"
-              end
-            else  
-              if @@db.get(lock_key).to_i <= current_time and 
-                @@db.getset(lock_key,ts).to_i <= current_time
-                # previous lock expired and we replaced it with our own
-                break
-              end
-            end
+            current_lock = @@db.get(lock_key)
+            # ensure lock wasn't released between the setnx and get calls
+            if current_lock
+             	current_lock_timeout = current_lock.to_i
+             	if raise_on_expire or Rhosync.raise_on_expired_lock
+             	  if current_lock_timeout <= current_time
+             	    # lock expired before operation which set it up completed
+             	    # this process cannot continue without corrupting locked data 
+             	    raise StoreLockException, "Lock \"#{lock_key}\" expired before it was released"
+             	  end
+             	else  
+             	  if current_lock_timeout <= current_time and 
+             	    @@db.getset(lock_key,ts).to_i <= current_time
+             	    # previous lock expired and we replaced it with our own
+             	    break
+             	  end
+           	  end
+         	  # lock was released between setnx and get - try to acquire it again
+       	    elsif @@db.setnx(lock_key,ts)
+         	    break
+     	      end
             sleep(1)
             current_time = Time.now.to_i
           else

data/lib/rhosync/version.rb

@@ -1,3 +1,3 @@
 module Rhosync
-  VERSION = '2.1.11'
+  VERSION = '2.1.12'
 end

data/spec/api/stats_spec.rb

@@ -3,12 +3,16 @@ require File.join(File.dirname(__FILE__),'api_helper')
 describe "RhosyncApiStats" do
   it_should_behave_like "ApiHelper"
   
+  def app
+    @app = Rhosync::Server.new
+  end
+  
   before(:each) do
-    Rhosync.stats = true
+    Rhosync::Server.set :stats, true
   end
   
   after(:each) do
-    Rhosync.stats = false
+    Rhosync::Server.set :stats, false
   end
   
   it "should retrieve metric names" do
@@ -55,6 +59,7 @@ describe "RhosyncApiStats" do
   end
   
   it "should raise error if stats not enabled" do
+    Rhosync::Server.set :stats, false
     Rhosync.stats = false
     post "/api/stats", {
       :api_token => @api_token, 

data/spec/server/server_spec.rb

@@ -48,10 +48,10 @@ describe "Server" do
     User.load('new_user').should_not be_nil
   end
 
-  it "should failt to login if wrong content-type" do
+  it "should fail to login if wrong content-type" do
     User.load('unknown').should be_nil
     post "/login", {"login" => 'unknown', "password" => 'testpass'}.to_json, {'CONTENT_TYPE'=>'application/x-www-form-urlencoded'} 
-    last_response.should be_ok
+    last_response.should_not be_ok
     User.load('unknown').should be_nil
   end
   
@@ -255,11 +255,10 @@ describe "Server" do
       last_response.body.should == "Server error while processing client data"
     end
     
-    it "should handle client posting broken body" do
-      broken_json = ['foo']
-      post "/application", broken_json, {'CONTENT_TYPE'=>'application/json'}
-      last_response.status.should == 500
-      last_response.body.should == "Internal server error"
+    it "should not login if login is empty" do
+      post "/application/clientlogin", ''
+      last_response.status.should == 401
+      last_response.body.should == ""
     end
     
     it "should get inserts json" do

data/spec/source_sync_spec.rb

@@ -219,13 +219,13 @@ describe "SourceSync" do
         # 1) if retry_limit is set to N - then, first N retries should not update refresh_time
         @s.read_state.retry_counter.should == 1
         @s.read_state.refresh_time.should <= Time.now.to_i
-        
+
         # try once more and fail again
         set_test_data('test_db_storage',{},msg,"query error")
         res = @ss.do_query
         verify_result(@s.docname(:md) => {},
           @s.docname(:errors) => {'query-error'=>{'message'=>msg}})
-        
+
         # 2) if retry_limit is set to N and number of retries exceeded it - update refresh_time
         @s.read_state.retry_counter.should == 0
         @s.read_state.refresh_time.should > Time.now.to_i
@@ -241,7 +241,7 @@ describe "SourceSync" do
         # 1) if retry_limit is set to N - then, first N retries should not update refresh_time
         @s.read_state.retry_counter.should == 1
         @s.read_state.refresh_time.should <= Time.now.to_i
-        
+
         # try once more (with success)
         expected = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',expected)
@@ -251,7 +251,40 @@ describe "SourceSync" do
         @s.read_state.retry_counter.should == 0
         @s.read_state.refresh_time.should > Time.now.to_i
       end
-      
+
+      it "should reset the retry counter if prev_refresh_time was set more than poll_interval secs ago" do
+        @s.retry_limit = 3
+        @s.poll_interval = 2
+        msg = "Error during query"
+        set_test_data('test_db_storage',{},msg,"query error")
+        res = @ss.do_query
+        verify_result(@s.docname(:md) => {},
+          @s.docname(:errors) => {'query-error'=>{'message'=>msg}})
+        # 1) if retry_limit is set to N - then, first N retries should not update refresh_time
+        @s.read_state.retry_counter.should == 1
+        @s.read_state.refresh_time.should <= Time.now.to_i
+
+        # 2) Make another error - results are the same
+        set_test_data('test_db_storage',{},msg,"query error")
+        res = @ss.do_query
+        verify_result(@s.docname(:md) => {},
+          @s.docname(:errors) => {'query-error'=>{'message'=>msg}})
+        # 1) if retry_limit is set to N - then, first N retries should not update refresh_time
+        @s.read_state.retry_counter.should == 2
+        @s.read_state.refresh_time.should <= Time.now.to_i
+
+        # wait until time interval exprires and prev_refresh_time is too old - 
+        # this should reset the counter on next request with error
+        # and do not update refresh_time
+        sleep(3)
+        set_test_data('test_db_storage',{},msg,"query error")
+        res = @ss.do_query
+        verify_result(@s.docname(:md) => {},
+          @s.docname(:errors) => {'query-error'=>{'message'=>msg}})
+        @s.read_state.retry_counter.should == 1
+        @s.read_state.refresh_time.should <= Time.now.to_i
+      end
+
       it "should do query with exception raised and update refresh time if retry_limit is 0" do
         @s.retry_limit = 0
         msg = "Error during query"
@@ -263,7 +296,7 @@ describe "SourceSync" do
         @s.read_state.retry_counter.should == 0
         @s.read_state.refresh_time.should > Time.now.to_i
       end
-      
+
       it "should do query with exception raised and update refresh time if poll_interval == 0" do
         @s.retry_limit = 1
         @s.poll_interval = 0
@@ -292,6 +325,7 @@ describe "SourceSync" do
         verify_result("source:#{@test_app_name}:__shared__:#{@s_fields[:name]}:md" => expected)
         Store.db.keys("read_state:#{@test_app_name}:__shared__*").sort.should ==
           [ "read_state:#{@test_app_name}:__shared__:SampleAdapter:refresh_time",
+            "read_state:#{@test_app_name}:__shared__:SampleAdapter:prev_refresh_time",
             "read_state:#{@test_app_name}:__shared__:SampleAdapter:retry_counter",
             "read_state:#{@test_app_name}:__shared__:SampleAdapter:rho__id"].sort
       end

data/spec/store_spec.rb

@@ -167,6 +167,29 @@ describe "Store" do
       Store.get_data(@s.docname(:md)).should == {}
     end
     
+    it "should flash_data for all keys matching pattern" do
+      keys = ['test_flash_data1','test_flash_data2']
+      keys.each {|key| Store.put_data(key,@data)}
+      Store.flash_data('test_flash_data*')
+      keys.each {|key| Store.get_data(key).should == {} }
+    end
+    
+    it "should flash_data without calling KEYS when there aren't pattern matching characters in the provided keymask" do
+      key = 'test_flash_data'
+      Store.put_data(key,@data)
+      Store.db.should_not_receive(:keys)
+      Store.db.should_receive(:del).once.with(key).and_return(true)
+      Store.flash_data(key)
+    end
+    
+    it "should flash_data and call KEYS when there are pattern matching characters in the provided keymask" do
+      keys = ['test_flash_data1','test_flash_data2']
+      keys.each {|key| Store.put_data(key,@data)}
+      Store.db.should_receive(:keys).exactly(1).times.with("test_flash_data*").and_return(keys)
+      Store.db.should_receive(:del).exactly(2).times.with(/^test_flash_data[12]$/).and_return(true)
+      Store.flash_data("test_flash_data*")
+    end
+    
     it "should get_keys" do
       expected = ["doc1:1:1:1:source1", "doc1:1:1:1:source2"]
       Store.put_data(expected[0],@data)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rhosync
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 19
   prerelease: 
   segments: 
   - 2
   - 1
-  - 11
-  version: 2.1.11
+  - 12
+  version: 2.1.12
 platform: ruby
 authors: 
 - Rhomobile
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-04 00:00:00 Z
+date: 2011-10-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sinatra
@@ -23,7 +23,7 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 17
         segments: 
@@ -372,6 +372,7 @@ files:
 - lib/rhosync/api/upload_file.rb
 - lib/rhosync/api_token.rb
 - lib/rhosync/app.rb
+- lib/rhosync/body_content_type_parser.rb
 - lib/rhosync/bulk_data.rb
 - lib/rhosync/bulk_data/bulk_data.rb
 - lib/rhosync/bulk_data/syncdb.index.schema