rhoconnect 4.0.0.beta.12 → 4.0.0.beta.24

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

@@ -0,0 +1,36 @@
+module Rhoconnect
+	module Handler
+		module Changes
+			module Hooks
+				def self.handler_installed(controller, rc_handler, verb, route_url, options)
+	  			queue_key = "#{verb}:#{route_url}"
+	  			# QUEUE key is unique per route
+	  			# standard routes - should go to the standard :create, :update, :delete queues
+	  			case queue_key
+	  			when "post:/", "put:/:id", "delete:/id"
+	  				queue_key = nil
+	  			end
+
+	  			queue_names = []
+	  			case rc_handler.to_sym
+	  			when :cud
+	  				queue_names << (queue_key ? "create:#{queue_key}" : "create")
+	  				queue_names << (queue_key ? "update:#{queue_key}" : "update")
+	  				queue_names << (queue_key ? "delete:#{queue_key}" : "delete")
+	  			when :create
+	  				queue_names << (queue_key ? "create:#{queue_key}" : "create")
+	  			when :update
+	  				queue_names << (queue_key ? "update:#{queue_key}" : "update")
+	  			when :delete
+	  				queue_names << (queue_key ? "delete:#{queue_key}" : "delete")
+	  			else
+	  				return true
+	  			end
+
+	  			Source.define_valid_queues(queue_names)
+	  			options[:add_parameter] = {:queue_key => queue_key} if queue_key
+	  		end
+			end
+		end
+	end
+end

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

@@ -28,9 +28,19 @@ module Rhoconnect
         end
 
         private
-        def _receive_cud(operation,params)
+        def _receive_cud(operation,cud_params)
           return 0 if not operations.include?(operation)
-          @source.push_queue(operation,@client.id,params,true)
+          # build an Array if Hash (new operations are sequential)
+          obj_queue = cud_params
+          if cud_params.is_a?Hash
+            obj_queue = []
+            cud_params.each_pair do |key,obj|
+              obj_queue << [key, obj]
+            end
+          end
+          queue_key = params[:queue_key]
+          queue_name = (queue_key ? "#{operation}:#{queue_key}" : "#{operation}")
+          @source.push_queue(queue_name,@client.id,[[@source.name, obj_queue]],true)
           return 1
         end
         

data/lib/rhoconnect/handler/helpers.rb

@@ -1,4 +1,4 @@
-require 'rhoconnect/handler/helpers/auth_method.rb'
-require 'rhoconnect/handler/helpers/binding.rb'
-require 'rhoconnect/handler/helpers/source_job.rb'
-require 'rhoconnect/handler/helpers/bulk_data.rb'
+require 'rhoconnect/handler/helpers/auth_method'
+require 'rhoconnect/handler/helpers/binding'
+require 'rhoconnect/handler/helpers/source_job'
+require 'rhoconnect/handler/helpers/bulk_data'

data/lib/rhoconnect/jobs/source_job.rb

@@ -18,7 +18,7 @@ module Rhoconnect
         handler_cud = lambda { @model.send params[:operation].to_sym, params["#{params[:operation]}_object".to_sym] }
         @model = Rhoconnect::Model::Base.create(source)
         source_cud = Rhoconnect::Handler::Changes::Engine.new(['create', 'update', 'delete'], @model, handler_cud, params)
-        source_cud.do_cud
+        source_cud.run_cud
       end    
     end
   end

data/lib/rhoconnect/model/base.rb

@@ -1,3 +1,6 @@
+require 'rhoconnect/model/helpers'
+require 'rhoconnect/handler/helpers/binding'
+
 module Rhoconnect
   module Model
     class Exception < RuntimeError; end
@@ -12,6 +15,19 @@ module Rhoconnect
     class Base
       attr_accessor :session, :source
 
+      extend Rhoconnect::Model::Helpers
+      include Rhoconnect::Handler::Helpers::Binding
+
+      class << self
+        def enable(procname, options = {}, &block)
+          # installer suppose to do what's needed
+          if block_given?
+            options[:handler] = block
+          end
+          options = send "install_#{procname}", options
+        end
+      end
+
       def initialize(source)
         @source = source
       end
@@ -88,13 +104,13 @@ module Rhoconnect
       def search(params=nil); end
 
       def sync
-        if @result and @result.empty?
+        if @result and @result.is_a?(Hash) and @result.empty?
           @source.lock(:md) do |s|
             s.flush_data(:md)
             s.put_value(:md_size,0)
           end
         else
-          if @result
+          if @result and @result.is_a?(Hash)
             @source.put_tmp_data(@tmp_docname,@result)
             @stash_size += @result.size
           end
@@ -139,8 +155,21 @@ module Rhoconnect
         Rhoconnect.expire_bulk_data(current_user.login,partition)
       end
 
+      def run_validators(operation, operations_data, client_ids)
+        # run custom code
+        invalid_meta = validate(operation, operations_data, client_ids)
+        invalid_meta ||= {}
+        # run pre-installed validators
+        self.class.validators.each do |validator, options|
+          if options.has_key? operation.to_sym
+            invalid_meta = send validator.to_sym, options, invalid_meta, operation, operations_data, client_ids
+          end
+        end
+        invalid_meta
+      end
+
       # do pre-processing before CUD operation
-      def validate(operation,operations_hashes,client_ids)
+      def validate(operation,operations_data,client_ids)
         {}
       end
 
@@ -154,11 +183,6 @@ module Rhoconnect
 
       def logoff; end
 
-      # re-define in subc;ass to provide your own filename
-      def store_blob(obj,field_name,blob)
-        blob[:tempfile].path if blob[:tempfile]
-      end
-
       # plugin callbacks implementation
       def push_objects(params)
         timeout = params[:timeout] || 10

data/lib/rhoconnect/model/helpers.rb

@@ -0,0 +1,15 @@
+require 'rhoconnect/model/helpers/find_duplicates_on_update'
+
+module Rhoconnect
+	module Model
+		module Helpers
+			def self.extended(base)
+				base.send :include, Rhoconnect::Model::Helpers::FindDuplicatesOnUpdate
+			end
+
+			def validators
+				@validators ||= {}
+			end
+		end
+	end
+end

data/lib/rhoconnect/model/helpers/find_duplicates_on_update.rb

@@ -0,0 +1,85 @@
+module Rhoconnect
+	module Model
+		module Helpers
+			module FindDuplicatesOnUpdate
+
+				def self.included(base)
+					base.extend Rhoconnect::Model::Helpers::FindDuplicatesOnUpdate::ClassMethods
+				end
+
+				def find_duplicates_on_update(options, invalid_meta, operation, operation_data, client_ids)
+	        invalid_meta ||= {}
+	        processed_ids = {}
+	        processed_objs = {}
+	        operation_data.each_with_index do |client_operation_data,index|
+	          client_id = client_ids[index]
+	          client_operation_data.each do |source_operation_entry|
+	            source_id = source_operation_entry[0]
+	            list_of_objs = source_operation_entry[1]
+	            list_of_objs.each_with_index do |obj_entry, objindex|
+	              key = obj_entry[0]
+	              objvalue = obj_entry[1]
+
+	              processed_objs[source_id] ||= {}
+	              processed_source_objs = processed_objs[source_id]
+	              obj_not_a_duplicate = true
+	              if processed_source_objs.has_key? key
+	                processed_records = processed_source_objs[key]
+	                processed_records.each do |processed_record|
+	                  master_obj = processed_record[:value]
+	                  master_client_id = processed_record[:client_id]
+	                  master_queue_index = processed_record[:queue_index].to_i
+	                  master_obj_index = processed_record[:index].to_i
+
+	                  if master_obj == objvalue
+	                    obj_not_a_duplicate = false
+	                		if options[:raise_error]
+	                		  invalid_meta[index] ||= {}
+	                		  invalid_meta[index][source_id] ||= {}
+	                		  invalid_meta[index][source_id][objindex] ||= {}
+	                		  invalid_meta[index][source_id][objindex][:error] = "Error during #{operation}: object confict detected"
+	                		else
+		                    invalid_meta[index] ||= {}
+		                    invalid_meta[index][source_id] ||= {}
+		                    invalid_meta[index][source_id][objindex] ||= {}
+		                    invalid_meta[index][source_id][objindex][:duplicate_of] = true
+		                
+		                    invalid_meta[master_queue_index] ||= {}
+		                    invalid_meta[master_queue_index][source_id] ||= {}
+		                    invalid_meta[master_queue_index][source_id][master_obj_index] ||= {}
+		                    invalid_meta[master_queue_index][source_id][master_obj_index][:duplicates] ||= []
+		                    invalid_meta[master_queue_index][source_id][master_obj_index][:duplicates] <<  {:client_id => client_id, :key => key, :value => objvalue} 
+		                  end 
+	                    break
+	                  end
+	                end
+	              end
+	              # objects are not equal - add to already processed
+	              if obj_not_a_duplicate
+	                processed_source_objs[key] ||= []
+	                processed_source_objs[key] << {:value => objvalue, :client_id => client_id, :queue_index => index, :index => objindex}
+	              end
+	            end
+	          end
+	        end
+	        if options[:handler] and invalid_meta.size > 0
+	        	proc = bind_handler :find_duplicates_on_update, options[:handler]
+            invalid_meta = proc.call options, invalid_meta, operation, operation_data, client_ids
+          end
+	        invalid_meta  
+	      end
+
+	     	# methods that needs to be 'extended', not 'included'
+		  	module ClassMethods
+		    	def install_find_duplicates_on_update(options)
+		    		options ||= {}
+		    		options[:update] = true
+		      	@validators ||= {}
+		      	@validators[:find_duplicates_on_update] = options
+		      	options
+		    	end
+				end
+			end
+		end
+	end
+end

data/lib/rhoconnect/model/js_base.rb

@@ -9,7 +9,7 @@ module Rhoconnect
       def method_missing(method_name,*args)
         obj = Object.const_get(self.class.to_s)
         if obj.js_method_list.include? method_name.to_s
-          package_and_publish(method_name,args)
+          self.class.package_and_publish(self,method_name,current_user,args)
         else
           log "METHOD #{method_name} NOT DEFINED IN JS MODEL #{self.class.to_s}"
           return "#{method_name} method not defined for #{self.class.to_s}"
@@ -68,49 +68,44 @@ module Rhoconnect
         rho_methods('storeBlob',blob)
       end
 
-      private
+      def self.partition_name(user_id)
+        class_rho_methods('partitionName',{:user_id => user_id})
+      end
+
+      def self.class_rho_methods(name,args=nil)
+        if has_method? name
+          package_and_publish(self,name,nil,args)
+        else
+          send(name,args)
+        end
+      end
+
+      def self.has_method?(name)
+        self.js_method_list.include? name
+      end
 
       def rho_methods(name,args=nil)
-        obj = Object.const_get(self.class.to_s)
-        if obj.js_method_list.include? name
-          package_and_publish(name,args)
+        if self.class.has_method? name
+          self.class.package_and_publish(self,name,self.current_user,args)
         else
-          sup.send(name,args)
+          send(name,args)
         end
       end
 
-      def package_and_publish(method_name,args=nil)
+      def self.package_and_publish(caller,method_name,user,args=nil)
         json = {
-           :klss   => self.class.actual_name,
+           :klss   => self.actual_name,
            :function => method_name,
            :args  => args,
-           :user  => current_user.login,
            :route => 'request'
          }
-         NodeChannel.publish_channel_and_wait(json,self)
+         json[:user] = user.login if user
+         NodeChannel.publish_channel_and_wait(json,caller)
       end
     end
   end
 end
 
-#allows me to call super method by passing string
-class SuperProxy
-  def initialize(obj)
-    @obj = obj
-  end
-
-  def method_missing(meth, *args)
-    @obj.class.superclass.superclass.instance_method(meth).bind(@obj).call(*args)
-  end
-end
-
-class Object
-  private
-  def sup
-    SuperProxy.new(self)
-  end
-end
-
 class String
   def classify
     result = self.split("_").inject("") do |res,index|

data/lib/rhoconnect/server.rb

@@ -31,17 +31,13 @@ module Rhoconnect
         @default_settings ||= {}
         @default_settings[setting] = value
       end
+    end
 
-      # these methods will be called by the subclasses
-      # to prevent double inclusion
-      # of the base middleware
-      # def reset_rc_base!
-      #   #@middleware_configured = true
-      # end
-
-      # def self.inherited(subclass)
-      #   subclass.reset_rc_base!
-      # end
+    def self.paths(verb = nil)
+      @paths ||= {}
+      return @paths if verb.nil?
+      @paths[verb] ||= []
+      @paths[verb]
     end
 
     # Setup route and mimetype for bulk data downloads
@@ -56,10 +52,12 @@ module Rhoconnect
     extend Rhoconnect::Condition::ClientRequired
     extend Rhoconnect::Condition::Verbs
     extend Rhoconnect::Condition::VerifySuccess
+    extend Rhoconnect::Condition::AddParameter
 
     # RC Handlers
     include Rhoconnect::Handler::Query::ExecuteMethods
     include Rhoconnect::Handler::Changes::ExecuteMethods
+    register Rhoconnect::Handler::Changes::Hooks
     include Rhoconnect::Handler::Search::ExecuteMethods
     include Rhoconnect::Handler::PluginCallbacks::ExecuteMethods
     include Rhoconnect::Handler::Authenticate::ExecuteMethods
@@ -230,7 +228,10 @@ _INSTALL_ASYNC_GEMS
       rc_handler = options[:rc_handler]
       options.delete(:rc_handler)
       rc_handler_method = nil
-      rc_handler_method = "execute_#{rc_handler}_handler".to_sym if rc_handler
+      if rc_handler
+        rc_handler_method = "execute_#{rc_handler}_handler"
+        invoke_hook(:handler_installed, self, rc_handler, verb, route_url, options)
+      end 
       unless deprecated_route.nil?
         deprecated_urls = deprecated_route[:url].is_a?(String) ? [deprecated_route[:url]] : deprecated_route[:url]
         deprecated_urls.each do |deprecated_url|
@@ -245,8 +246,10 @@ _INSTALL_ASYNC_GEMS
           dep_info[:verb] = verb
           dep_info[:route_url] = route_url
 
-          Rhoconnect::DefaultServer.registered_routes(d_verb)[deprecated_url] ||= {}
-          Rhoconnect::DefaultServer.registered_routes(d_verb)[deprecated_url][self.name] = dep_info
+          #Rhoconnect::DefaultServer.paths[d_verb] ||= []
+          Rhoconnect::DefaultServer.paths(d_verb) << deprecated_url
+          Rhoconnect::DefaultServer.deprecated_routes(d_verb)[deprecated_url] ||= {}
+          Rhoconnect::DefaultServer.deprecated_routes(d_verb)[deprecated_url][self.name] = dep_info
           Rhoconnect::DefaultServer.send d_verb, deprecated_url, options do
             klass = nil
             req_verb = env['REQUEST_METHOD'].downcase.to_sym
@@ -254,7 +257,7 @@ _INSTALL_ASYNC_GEMS
             # retrieve controller-specific deprecation handler
             if params[:source_name]
               controller_name = "#{params[:source_name]}Controller"
-              dep_info = Rhoconnect::DefaultServer.registered_routes(req_verb)[req_path][controller_name]
+              dep_info = Rhoconnect::DefaultServer.deprecated_routes(req_verb)[req_path][controller_name]
               if dep_info
                 klass = dep_info[:klass]
                 verb = dep_info[:verb]
@@ -270,6 +273,8 @@ _INSTALL_ASYNC_GEMS
 
       # turn block into UnboundMethod - so that we can bind it later with
       # particular Controller instance
+      #self.paths[verb] ||= []
+      self.paths(verb) << route_url
       route_handler = send(:generate_method, :route_handler, &block)
       route verb.to_s.upcase, route_url, options do
         execute_api_call(route_handler, rc_handler_method)
@@ -283,10 +288,10 @@ _INSTALL_ASYNC_GEMS
     helpers Rhoconnect::Handler::Helpers::BulkData
 
     # to prevent registering the same route several times
-    def self.registered_routes(verb)
-      @registered_routes ||= {}
-      @registered_routes[verb] ||= {}
-      @registered_routes[verb]
+    def self.deprecated_routes(verb)
+      @deprecated_routes ||= {}
+      @deprecated_routes[verb] ||= {}
+      @deprecated_routes[verb]
     end
 
     get '/' do

data/lib/rhoconnect/source.rb

@@ -117,14 +117,7 @@ module Rhoconnect
                           :metadata,
                           :metadata_sha1,
                           :schema,
-                          :schema_sha1,
-                          :create,
-                          :update,
-                          :delete])
-    # we can not enforce valid doctypes at this point
-    # because QUERY creates temporary md docs
-    # TODO: re-work it to eliminate this obstacle
-    #enforce_valid_doctypes=false
+                          :schema_sha1])
 
     def initialize(fields)
       self.name = fields['name'] || fields[:name]
@@ -286,19 +279,19 @@ module Rhoconnect
 
     def flush_store_data
       delete_user_read_state
-      # queues should be processed separately first
-      [:create, :update, :delete].each do |doctype|
-        flush_queue(doctype)
-      end
-      # then, all other doctypes
-      self.class.valid_doctypes.each do |doctype|
-        flush_data(doctype)
+      self.class.valid_doctypes.each do |docname, doctype|
+        case doctype
+        when :queue
+          flush_queue(docname)
+        when :document
+          flush_data(docname)
+        end
       end
     end
 
     def queue_docname(dockey)
       # currently, all queues are bound by user - not shared
-      docname(dockey)
+      "#{self.class.class_prefix(self.class)}:#{self.app_id}:#{self.name}:#{dockey.to_s}"
     end
 
     # this data is not sharded
@@ -338,7 +331,7 @@ module Rhoconnect
       end
     end
 
-    def push_queue(doctype,assoc_key, data={},append=false)
+    def push_queue(doctype,assoc_key, data=[],append=false)
       verify_doctype(doctype)
       lock_queue_doc(doctype) do |s|
         Store.get_store(0).put_zdata(s.queue_docname(doctype),assoc_key, data,append)