rhoconnect 4.0.2 → 4.0.3

data/lib/rhoconnect/handler/changes/engine.rb

@@ -65,11 +65,9 @@ module Rhoconnect
         end
         
         def run_cud
-          return if auth_method('login') == false
           operations.each do |op|
             send op.to_sym
           end
-          auth_method('logoff')
         end
 
         # CUD Operations
@@ -145,88 +143,100 @@ module Rhoconnect
 
           # load all clients involved in the current queue
           processed_clients = {}
-          client_ids.each do |client_id|
+          user_sorted_data = {}
+          client_ids.each_with_index do |client_id, index|
             processed_clients[client_id] = Client.load(client_id,{:source_name => @source.name}) unless processed_clients[client_id]
+            client = processed_clients[client_id]
+            user_sorted_data[client.user_id] ||= []
+            # sort by user (so that login/logoff is called exactly once per operation)
+            user_sorted_data[client.user_id] << index
           end
-          
+
           errors,links,deletes,creates,dels = {},{},{},{},{}
-          operation_data.each_with_index do |client_operation_data,index|
-            client_id = client_ids[index]
-            client = processed_clients[client_id]
+          user_sorted_data.each do |user_id, user_entries|
+            # call login
+            # Call on source adapter to process individual object
+            # NOTE: call should be made from the correct model instance
+            model.source = Source.load(@source.name,
+                    {:user_id => user_id,:app_id => APP_NAME})
+            next if auth_method('login') == false
+            user_entries.each do |index|
+              client_operation_data = operation_data[index]
+              client_id = client_ids[index]
+              client = processed_clients[client_id]
             
-            # for now - each client operation data can have only one entry (single source CUD)
-            # TODO: should be fixed for multi-source CUD
-            source_id = client_operation_data[0][0]
-            source_operation_data = client_operation_data[0][1]
-            current_invalid_meta = invalid_meta[index] || {}
-            current_invalid_source_meta = current_invalid_meta[source_id] || {}
-            record_index = 0
-            source_operation_data.each do |source_entry|
-              begin
-                key = source_entry[0]
-                value = source_entry[1]
-                continue_loop = true
-                modified_recs = [{:client_id => client_id, :key => key, :value => value }]
-                record_invalid_meta = current_invalid_source_meta[record_index] || {}
-                # remove processed entries
-                source_operation_data = source_operation_data.drop(1)
-                record_index += 1
+              # for now - each client operation data can have only one entry (single source CUD)
+              # TODO: should be fixed for multi-source CUD
+              source_id = client_operation_data[0][0]
+              source_operation_data = client_operation_data[0][1]
+              current_invalid_meta = invalid_meta[index] || {}
+              current_invalid_source_meta = current_invalid_meta[source_id] || {}
+              record_index = 0
+              source_operation_data.each do |source_entry|
+                begin
+                  key = source_entry[0]
+                  value = source_entry[1]
+                  continue_loop = true
+                  modified_recs = [{:client_id => client_id, :key => key, :value => value }]
+                  record_invalid_meta = current_invalid_source_meta[record_index] || {}
+                  # remove processed entries
+                  source_operation_data = source_operation_data.drop(1)
+                  record_index += 1
                 
-                # skip the rec - if it is a duplicate of some other record
-                next if record_invalid_meta[:duplicate_of]
+                  # skip the rec - if it is a duplicate of some other record
+                  next if record_invalid_meta[:duplicate_of]
                 
-                # prepare duplicate docs
-                duplicates = record_invalid_meta[:duplicates] || {}
-                duplicates.each do |duplicate|
-                  modified_recs << duplicate
-                end
+                  # prepare duplicate docs
+                  duplicates = record_invalid_meta[:duplicates] || {}
+                  duplicates.each do |duplicate|
+                    modified_recs << duplicate
+                  end
                 
-                # raise conflict error if record is marked with one
-                raise Rhoconnect::Model::ObjectConflictErrorException.new(record_invalid_meta[:error]) if record_invalid_meta[:error]
+                  # raise conflict error if record is marked with one
+                  raise Rhoconnect::Model::ObjectConflictErrorException.new(record_invalid_meta[:error]) if record_invalid_meta[:error]
                 
-                # Call on source adapter to process individual object
-                # NOTE: call should be made from the correct model instance
-                model.source = Source.load(@source.name,
-                    {:user_id => client.user_id,:app_id => APP_NAME})
-                case operation
-                when 'create'
-                  _process_create(modified_recs,key,value)
-                when 'update'
-                  _process_update(modified_recs,key,value)
-                when 'delete'
-                  _process_delete(modified_recs,key,value)
+                  case operation
+                  when 'create'
+                    _process_create(modified_recs,key,value)
+                  when 'update'
+                    _process_update(modified_recs,key,value)
+                  when 'delete'
+                    _process_delete(modified_recs,key,value)
+                  end
+                rescue Exception => e
+                  log "Model raised #{operation} exception: #{e}"
+                  log e.backtrace.join("\n")
+                  continue_loop = false
+                  modified_recs.each do |modified_rec|
+                    modified_rec[:errors] ||= {}
+                    modified_rec[:errors][modified_rec[:key]] = modified_rec[:value]
+                    modified_rec[:errors]["#{modified_rec[:key]}-error"] = {'message'=>e.message}
+                  end
                 end
-              rescue Exception => e
-                log "Model raised #{operation} exception: #{e}"
-                log e.backtrace.join("\n")
-                continue_loop = false
-                modified_recs.each do |modified_rec|
-                  modified_rec[:errors] ||= {}
-                  modified_rec[:errors][modified_rec[:key]] = modified_rec[:value]
-                  modified_rec[:errors]["#{modified_rec[:key]}-error"] = {'message'=>e.message}
-                end
-              end
               
-              { :errors => errors, 
-                :links => links, 
-                :deletes => deletes, 
-                :creates => creates, 
-                :dels => dels }.each do |doc_name, doc|
-                modified_recs.each do |modified_rec|
-                  doc[modified_rec[:client_id]] ||= {}
-                  next unless modified_rec[doc_name]
-                  doc[modified_rec[:client_id]].merge!(modified_rec[doc_name])
+                { :errors => errors, 
+                  :links => links, 
+                  :deletes => deletes, 
+                  :creates => creates, 
+                  :dels => dels }.each do |doc_name, doc|
+                  modified_recs.each do |modified_rec|
+                    doc[modified_rec[:client_id]] ||= {}
+                    next unless modified_rec[doc_name]
+                    doc[modified_rec[:client_id]].merge!(modified_rec[doc_name])
+                  end
                 end
+                break unless continue_loop
               end
-              break unless continue_loop
-            end
           
-            # Record rest of queue (if something in the middle failed)
-            if not source_operation_data.empty?
-              @source.push_queue(queue_name,client_id,[[source_id, source_operation_data]],true)
+              # Record rest of queue (if something in the middle failed)
+              if not source_operation_data.empty?
+                @source.push_queue(queue_name,client_id,[[source_id, source_operation_data]],true)
+              end
             end
+            # call logoff
+            auth_method('logoff')
           end
-          
+
           { "delete_page" => deletes,
             "#{operation}_links" => links,
             "#{operation}_errors" => errors }.each do |doctype,client_docs|

data/lib/rhoconnect/store.rb

@@ -3,12 +3,12 @@ require 'set'
 require 'connection_pool'
 
 module Rhoconnect
-  
+
   class StoreLockException < RuntimeError; end
 
   class Store
     @@dbs = nil
-    
+
     class << self
       def nullify
         @@dbs = nil
@@ -60,15 +60,15 @@ module Rhoconnect
         end
       end
       alias_method :flash_data, :flush_data
-      
+
       def doc_type(dockey)
         get_store(0).db.type(dockey) if dockey
       end
-      
+
       def set_db_doc(dockey, data, append=false)
         get_store(0).set_db_doc(dockey, data, append)
       end
-      
+
       def get_db_doc(dockey)
         doc = ""
         @@dbs.each do |store|
@@ -83,11 +83,11 @@ module Rhoconnect
       def keys(pattern)
         get_store(0).keys(pattern)
       end
-      
+
       def put_object(dockey, key, data={})
         get_store(0).put_object(dockey, key, data)
       end
-  
+
       # Adds set with given data, replaces existing set
       # if it exists or appends data to the existing set
       # if append flag set to true
@@ -99,32 +99,32 @@ module Rhoconnect
       def put_tmp_data(dockey,data={},append=false)
         get_store(0).put_tmp_data(dockey, data, append)
       end
-      
+
       def put_list(dockey, data=[], append=false)
         get_store(0).put_list(dockey, data, append)
       end
-      
+
       # updates objects for a given doctype, source, user
       # create new objects if necessary
       def update_objects(dockey, data={})
         get_store(0).update_objects(dockey, data)
       end
-      
+
       # Removes objects from a given doctype,source,user
       def delete_objects(dockey,data=[])
         get_store(0).delete_objects(dockey, data)
       end
-      
+
       # Deletes data from a given doctype,source,user
       def delete_data(dockey,data={})
         get_store(0).delete_data(dockey, data)
       end
-    
+
       # Adds a simple key/value pair
       def put_value(dockey,value)
         get_store(0).put_value(dockey, value)
       end
-    
+
       # Retrieves value for a given key
       def get_value(dockey)
         get_store(0).get_value(dockey)
@@ -133,32 +133,32 @@ module Rhoconnect
       def delete_value(dockey)
         get_store(0).delete_value(dockey)
       end
-      
+
       def incr(dockey)
         get_store(0).incr(dockey)
       end
-      
+
       def decr(dockey)
         get_store(0).decr(dockey)
       end
-      
+
       def update_count(dockey, count)
         get_store(0).update_count(dockey, count)
       end
-      
+
       def get_object(dockey, key)
         get_store(0).get_object(dockey, key)
       end
-      
+
       def get_objects(dockey, keys)
         get_store(0).get_objects(dockey, keys)
       end
-  
+
       # Retrieves set for given dockey,source,user
       def get_data(dockey,type=Hash)
         get_store(0).get_data(dockey, type)
       end
-      
+
       def get_list(dockey)
         get_store(0).get_list(dockey)
       end
@@ -187,7 +187,7 @@ module Rhoconnect
       def zrange(dockey, start, stop)
         get_store(0).zrange(dockey, start, stop)
       end
-  
+
       # Retrieves diff data hash between two sets
       # each entry is in the form of DIFF_OBJ_ELEMENT => [OBJ_KEY, OBJ_DATA_PAIRS]
       def get_diff_data(src_dockey,dst_dockey,p_size=nil)
@@ -202,33 +202,33 @@ module Rhoconnect
       def get_diff_data_bruteforce(src_dockey,dst_dockey,p_size=nil)
         get_store(0).get_diff_data_bruteforce(src_dockey, dst_dockey, p_size)
       end
-      
+
       def get_inserts_deletes(inserts_elements_map, deletes_elements_map)
         get_store(0).get_inserts_deletes(inserts_elements_map, deletes_elements_map)
       end
-      
+
       def update_elements(dockey, inserts_elements_map, deletes_elements_map)
         get_store(0).update_elements(dockey, inserts_elements_map, deletes_elements_map)
       end
-      
+
       # Lock a given key and release when provided block is finished
       def lock(dockey,timeout=0,raise_on_expire=false, &block)
         get_store(0).lock(dockey, timeout, raise_on_expire, &block)
       end
-      
+
       def get_lock(dockey,timeout=0,raise_on_expire=false)
         get_store(0).get_lock(dockey, timeout, raise_on_expire)
       end
-      
+
       def release_lock(dockey,lock,raise_on_expire=false)
         get_store(0).release_lock(dockey, lock, raise_on_expire)
       end
-      
+
       # Create a copy of srckey in dstkey
       def clone(srckey,dstkey)
         get_store(0).clone(srckey, dstkey)
       end
-      
+
       # Rename srckey to dstkey
       def rename(srckey,dstkey)
         get_store(0).rename(srckey, dstkey)
@@ -238,38 +238,38 @@ module Rhoconnect
       def rename_tmp_data(srckey,dstkey)
         get_store(0).rename_tmp_data(srckey, dstkey)
       end
-      
-      
+
+
       def put_zdata(dockey,assoc_key,data=[],append=false)
         get_store(0).put_zdata(dockey, assoc_key, data, append)
       end
-      
+
       # Retrieves set for given dockey,associated key (client_id), obj_hashes
       def get_zdata(dockey)
         get_store(0).get_zdata(dockey)
       end
-      
+
       # Deletes all keys and their hashes from the Redis DB
       def flush_zdata(dockey)
         get_store(0).flush_zdata(dockey)
       end
-      
+
       def exists?(key)
         get_store(0).exists?(key)
       end
-      
+
       alias_method :set_value, :put_value
       alias_method :set_data, :put_data
     end
   end
-  
+
   class RedisImpl
     RESERVED_ATTRIB_NAMES = ["attrib_type", "id"] unless defined? RESERVED_ATTRIB_NAMES
     @db = nil
-    
+
     def create(server=nil)
       @db ||= _get_redis(server)
-      raise "Error connecting to Redis store." unless @db and 
+      raise "Error connecting to Redis store." unless @db and
         (@db.is_a?(Redis) or @db.is_a?(Redis::Client) or @db.is_a?(ConnectionPool::Wrapper))
     end
 
@@ -280,19 +280,19 @@ module Rhoconnect
     def flush_all
       @db.flushdb
     end
-    
+
     def start_transaction
       @db.multi
     end
-    
+
     def execute_transaction
       @db.exec
     end
-    
+
     def doc_type(dockey)
       @db.type(dockey) if dockey
     end
-    
+
     def set_db_doc(dockey, data, append=false)
       if data.is_a?(String)
         put_value(dockey, data)
@@ -300,7 +300,7 @@ module Rhoconnect
         put_data(dockey, data, append)
       end
     end
-    
+
     def get_db_doc(dockey)
       doctype = doc_type(dockey)
       if doctype == 'string'
@@ -311,7 +311,7 @@ module Rhoconnect
         get_data(dockey).to_json
       end
     end
-    
+
     def put_object(dockey, key, data={})
       _put_objects(dockey, {key => data})
     end
@@ -337,7 +337,7 @@ module Rhoconnect
       end
       true
     end
-    
+
     def put_list(dockey, data=[], append=false, ttl=0)
       if dockey and data
         flush_data(dockey) unless append
@@ -350,15 +350,15 @@ module Rhoconnect
       end
       true
     end
-    
+
     # updates objects for a given doctype, source, user
     # create new objects if necessary
     def update_objects(dockey, data={})
       return 0 unless dockey and data
-      
+
       new_object_count = 0
       objs = get_objects(dockey, data.keys) || {}
-      
+
       collected_adds = {}
       collected_rems = {}
       my_bucket = nil
@@ -367,7 +367,7 @@ module Rhoconnect
           is_create = objs[key].nil?
           new_object_count += 1 if is_create
           obj_bucket = _add_bucket_index(dockey, "#{_create_obj_index(key)}")
-          
+
           # collect SREM (if object exists in DB)
           unless is_create
             old_element = set_obj_element(key,objs[key])
@@ -377,7 +377,7 @@ module Rhoconnect
           # update the object and collect SADD
           objs[key] ||= {}
           objs[key].merge!(obj)
-          
+
           new_element = set_obj_element(key,objs[key])
           collected_adds[obj_bucket] ||= []
           collected_adds[obj_bucket] << new_element
@@ -391,22 +391,22 @@ module Rhoconnect
           @db.sadd(bucket, bucket_data)
         end
       end
-      
-      
+
+
       #data1 = @db.smembers(my_bucket)
       #puts "data1 is #{data1.inspect}"
-      
+
       new_object_count
     end
-    
+
     # Removes objects from a given doctype,source,user
     def delete_objects(dockey,data=[])
       return 0 unless dockey and data
-      
+
       objs = get_objects(dockey, data)
       _delete_objects(dockey, objs)
     end
-    
+
     # Deletes data from a given doctype,source,user
     def delete_data(dockey,data={})
       if dockey and data
@@ -414,18 +414,18 @@ module Rhoconnect
       end
       true
     end
-  
+
     # Adds a simple key/value pair
     def put_value(dockey,value)
       if dockey
-        if value	
+        if value
           @db.set(dockey,value.to_s)
         else
-          @db.del(dockey)	
+          @db.del(dockey)
         end
       end
     end
-  
+
     # Retrieves value for a given key
     def get_value(dockey)
       @db.get(dockey) if dockey
@@ -438,20 +438,20 @@ module Rhoconnect
     def incr(dockey)
       @db.incr(dockey)
     end
-    
+
     def decr(dockey)
       @db.decr(dockey)
     end
-    
+
     def update_count(dockey, count)
       @db.incrby(dockey, count)
     end
-    
+
     def get_object(dockey, key)
       res = _get_objects(dockey, [key])
       (res and res.size > 0) ? res.values[0] : nil
     end
-    
+
     def get_objects(dockey, keys)
       _get_objects(dockey, keys)
     end
@@ -480,7 +480,7 @@ module Rhoconnect
       end
       res
     end
-    
+
     def get_list(dockey)
       res = []
       if dockey
@@ -557,7 +557,7 @@ module Rhoconnect
       end
       [inserts, deletes]
     end
-    
+
     def get_inserts_deletes(inserts_elements_map, deletes_elements_map)
       inserts_obj_hash = {}
       inserts_elements_map.each do |element,keypairs|
@@ -565,7 +565,7 @@ module Rhoconnect
         next unless (key and obj_pairs)
         inserts_obj_hash[key] = Set.new(obj_pairs)
       end
-      
+
       deletes_obj_hash = {}
       deletes_elements_map.each do |element,keypairs|
         key,obj_pairs = keypairs[0],keypairs[1]
@@ -575,7 +575,7 @@ module Rhoconnect
       # modified attributes
       inserts = {}
       deletes = {}
-      
+
       inserts_obj_hash.each do |key, obj_set|
         deletes_pairs = nil
         inserts_pairs = nil
@@ -603,40 +603,40 @@ module Rhoconnect
           deletes[key] = split_obj_pairs(obj_set.to_a)
         end
       end
-      
-      [inserts, deletes]   
+
+      [inserts, deletes]
     end
-    
+
     def update_elements(dockey, inserts_elements_map, deletes_elements_map)
       indices_to_cleanup = Set.new
       @db.pipelined do
         collected_adds = {}
         collected_rems = {}
-        
+
         inserts_elements_map.each do |element,keypairs|
           key = keypairs[0]
           next if not key or not element or element.size == 0
-        
+
           obj_bucket_index = _create_obj_index(key)
           bucket_name = "#{dockey}:#{obj_bucket_index}"
           _add_bucket_index(dockey, obj_bucket_index)
-          
+
           collected_adds[bucket_name] ||= []
           collected_adds[bucket_name] << element
         end
-        
+
         deletes_elements_map.each do |element,keypairs|
           key = keypairs[0]
           next if not key or not element or element.size == 0
-        
+
           obj_bucket_index = _create_obj_index(key)
           bucket_name = "#{dockey}:#{obj_bucket_index}"
           indices_to_cleanup << bucket_name
-          
+
           collected_rems[bucket_name] ||= []
           collected_rems[bucket_name] << element
         end
-        
+
         # now, perform SREM first, then SADD
         collected_rems.each do |bucket, bucket_data|
           @db.srem(bucket, bucket_data)
@@ -644,7 +644,7 @@ module Rhoconnect
         collected_adds.each do |bucket,bucket_data|
           @db.sadd(bucket, bucket_data)
         end
-      end 
+      end
       # now, cleanup buckets if necessary
       _cleanup_buckets(dockey, indices_to_cleanup.to_a)
     end
@@ -669,7 +669,7 @@ module Rhoconnect
       end
     end
     alias_method :flash_data, :flush_data
-    
+
     # Lock a given key and release when provided block is finished
     def lock(dockey,timeout=0,raise_on_expire=false, &block)
       m_lock = get_lock(dockey,timeout,raise_on_expire)
@@ -677,12 +677,12 @@ module Rhoconnect
       release_lock(dockey,m_lock)
       res
     end
-    
+
     def get_lock(dockey,timeout=0,raise_on_expire=false)
       lock_key = _lock_key(dockey)
-      current_time = Time.now.to_i   
+      current_time = Time.now.to_i
       ts = current_time+(Rhoconnect.lock_duration || timeout)+1
-      loop do 
+      loop do
         if not @db.setnx(lock_key,ts)
           current_lock = @db.get(lock_key)
           # ensure lock wasn't released between the setnx and get calls
@@ -691,11 +691,11 @@ module Rhoconnect
            	if raise_on_expire or Rhoconnect.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 
+           	    # 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 
+           	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
@@ -713,21 +713,21 @@ module Rhoconnect
       end
       return ts
     end
-    
+
     # Due to redis bug #140, setnx always returns true so this doesn't work
     # def get_lock(dockey,timeout=0)
     #   lock_key = _lock_key(dockey)
-    #   until @db.setnx(lock_key,1) do 
-    #     sleep(1) 
+    #   until @db.setnx(lock_key,1) do
+    #     sleep(1)
     #   end
     #   @db.expire(lock_key,timeout+1)
     #   Time.now.to_i+timeout+1
     # end
-    
+
     def release_lock(dockey,lock,raise_on_expire=false)
       @db.del(_lock_key(dockey)) if raise_on_expire or Rhoconnect.raise_on_expired_lock or (lock >= Time.now.to_i)
     end
-    
+
     # Create a copy of srckey in dstkey
     def clone(srckey,dstkey)
       buckets = _get_bucket_indices(srckey)
@@ -742,7 +742,7 @@ module Rhoconnect
         @db.sdiffstore(dstkey,srckey,'')
       end
     end
-    
+
     # Rename temp doc srckey to persist dstkey
     def rename_tmp_data(srckey,dstkey)
       rename(srckey,dstkey,true)
@@ -762,18 +762,18 @@ module Rhoconnect
           if make_persist
             @db.persist("#{dstkey}:indices")
             buckets.each do |bucket_index|
-              @db.persist("#{dstkey}:#{bucket_index}")  
+              @db.persist("#{dstkey}:#{bucket_index}")
             end
           end
         end
       else
-        if @db.exists(srckey) 
+        if @db.exists(srckey)
           @db.rename(srckey,dstkey)
           @db.persist(dstkey) if make_persist
         end
       end
     end
-    
+
     def put_zdata(dockey,assoc_key,data=[],append=false)
       return true unless (dockey and assoc_key and data)
       flush_zdata(dockey) unless append
@@ -795,7 +795,7 @@ module Rhoconnect
       end if data
       true
     end
-    
+
     # Retrieves set for given dockey,associated key (client_id), obj_hashes
     def get_zdata(dockey)
       data = @db.zrange(dockey, 0, -1)
@@ -822,7 +822,7 @@ module Rhoconnect
       end if data
       [ret, assoc_keys]
     end
-    
+
     # Deletes all keys and their hashes from the Redis DB
     def flush_zdata(dockey)
       data = @db.zrange(dockey, 0, -1)
@@ -831,7 +831,7 @@ module Rhoconnect
       end
       @db.zremrangebyrank(dockey, 0, -1)
     end
-    
+
     def exists?(key)
       @db.exists(key) || @db.exists("#{key}:indices")
     end
@@ -860,10 +860,10 @@ module Rhoconnect
     def zrange(dockey, start, stop)
       @db.zrange(dockey, start, stop)
     end
-    
+
     alias_method :set_value, :put_value
     alias_method :set_data, :put_data
-    
+
     # This method should never be accessed by anything except specs
     def db
       return @db
@@ -884,6 +884,7 @@ module Rhoconnect
         host,port,db,password = server.split(':')
         ConnectionPool::Wrapper.new(:size => Rhoconnect.connection_pool_size,
                                     :timeout => Rhoconnect.connection_pool_timeout) do
+          host = '127.0.0.1' if host == 'localhost'
           Redis.connect(:thread_safe => true, :host => host,
             :port => port, :db => db, :password => password, :timeout => Rhoconnect.redis_timeout)
         end
@@ -896,15 +897,15 @@ module Rhoconnect
         end
       end
     end
-    
+
     def _lock_key(dockey)
       "lock:#{dockey}"
     end
-        
+
     def _is_reserved?(attrib,value) #:nodoc:
       RESERVED_ATTRIB_NAMES.include? attrib
     end
-    
+
     # operations with docs that are split into buckets
     def _delete_doc(dockey)
       # check if this doc has buckets
@@ -918,57 +919,57 @@ module Rhoconnect
           end
         end
       end
-      
-      # delete main doc 
+
+      # delete main doc
       @db.del(dockey)
     end
-    
+
     # create object's bucket index
     # using SHA1 hashing
     def _create_obj_index(key)
       Digest::SHA1.hexdigest(key)[0..1]
     end
-    
+
     def _add_bucket_index(dockey, bucket_index)
       bucket_name = "#{dockey}:#{bucket_index}"
       @db.hsetnx("#{dockey}:indices", bucket_index, bucket_name)
       bucket_name
     end
-    
+
     def _remove_bucket_index(dockey, bucket_index)
       @db.hdel("#{dockey}:indices", bucket_index)
     end
-    
+
     def _get_bucket_indices(dockey)
       @db.hkeys("#{dockey}:indices")
     end
-    
+
     def _get_buckets(dockey)
       @db.hvals("#{dockey}:indices")
     end
-    
+
     def _cleanup_buckets(dockey, indices_to_cleanup)
       indices_to_cleanup.each do |index|
         bucket_name = "#{dockey}:#{index}"
         _remove_bucket_index(dockey, index) unless @db.exists(bucket_name)
       end if indices_to_cleanup
     end
-    
+
     def _put_objects(dockey, data={}, ttl=0)
       return if data.empty? or not dockey
-      
+
       collected_adds = {}
       @db.pipelined do
         data.each do |key,obj|
           raise ArgumentError, "Invalid value object: #{obj.inspect}. Hash is expected." unless obj.is_a?(Hash)
           next if obj.empty? or not key
-            
+
           obj_bucket_index = _create_obj_index(key)
           bucket_name = "#{dockey}:#{obj_bucket_index}"
           _add_bucket_index(dockey, obj_bucket_index)
           collected_adds[bucket_name] ||= []
           collected_adds[bucket_name] << set_obj_element(key, obj)
-          
+
         end
         # all SADD operations on a bucket key
         # are combined into one - it proves to perform faster
@@ -981,10 +982,10 @@ module Rhoconnect
         @db.expire("#{dockey}:indices", ttl) if ttl > 0
       end
     end
-    
+
     def _delete_objects(dockey, data={})
       return 0 if data.empty? or not dockey
-      
+
       deleted_object_count = 0
       indices_to_cleanup = Set.new
       collected_rems = {}
@@ -994,12 +995,12 @@ module Rhoconnect
           obj_bucket_index = _create_obj_index(key)
           bucket_name = "#{dockey}:#{obj_bucket_index}"
           indices_to_cleanup << obj_bucket_index
-          
+
           collected_rems[bucket_name] ||= []
           collected_rems[bucket_name] << set_obj_element(key, obj)
           deleted_object_count += 1
         end
-        
+
         # all SREM operations on a bucket
         # are combined into one
         collected_rems.each do |bucket,bucket_data|
@@ -1009,7 +1010,7 @@ module Rhoconnect
       _cleanup_buckets(dockey, indices_to_cleanup.to_a)
       deleted_object_count
     end
-    
+
     def _get_objects(dockey, keys)
       return nil unless dockey
       res = nil
@@ -1038,8 +1039,8 @@ module Rhoconnect
       end if members
       res
     end
-    
-    # operations on object elements      
+
+    # operations on object elements
     def get_obj_element(elem)
       key,pairs = get_obj_key_and_pairs(elem)
       return unless (key and pairs)
@@ -1060,7 +1061,7 @@ module Rhoconnect
     end
 
 # Set Obj Element MUST ensure the order of attribs
-# in Ruby 1.9.x Hash keys are sorted (always in the same order), so 
+# in Ruby 1.9.x Hash keys are sorted (always in the same order), so
 # we do not need to do redundant sorting
     def set_obj_element(key, obj)
       return unless (key and key.size > 0 and obj and obj.size > 0)
@@ -1073,4 +1074,4 @@ module Rhoconnect
       elem
     end
   end
-end 
+end