rhoconnect 3.4.5 → 4.0.0.beta.10

data/lib/rhoconnect/async.rb

@@ -9,8 +9,9 @@ module Rhoconnect
       if settings.respond_to?(:fiberpool_size)
         options[:size] = settings.fiberpool_size
       end
-      options[:rescue_exception] = handle_exception 
+      options[:rescue_exception] = handle_exception
       builder.use Rack::FiberPool, options unless test?
+      builder.use Rhoconnect::Middleware::Async, options
       super
     end
 
@@ -28,56 +29,92 @@ module Rhoconnect
     end
   end
 
-  module AsyncHelpers
-    def self.included(klass)
-      (klass.instance_methods & self.instance_methods).each do |method|
-        klass.instance_eval{remove_method method.to_sym}
+  module Middleware
+    class Async
+      def initialize(app, opts={})
+        @app = app
+        yield self if block_given?
       end
-    end
-    
-    def catch_all
-      res = nil
-      begin
-        res = catch(:halt) { yield }
-      rescue ApiException => ae
-        res = [ae.error_code, ae.message]
-      rescue Exception => e
-        log e.message + e.backtrace.join("\n")
-        res = [500, e.message]
-      end
-      res
-    end
-  
-    def execute_api_call(client_call = false)
+
+      def call(env)
         f = Fiber.current
+        # making a copy is crucial here
+        # otherwise 'env' will not be the same
+        # in the deferred execution
+        aenv = env.dup
         operation = proc {
-          self.request.env['REQUEST_THREAD'] = Thread.current
-          if(request.env['RHO_ABORT_PROCESS'])
+          res = nil
+          aenv['REQUEST_THREAD'] = Thread.current
+          if(aenv['RHO_ABORT_PROCESS'])
             res = [500, 'Request is aborted']
           else
-            catch_all do
-              res = yield params, current_user, self
-              if params.has_key? :warning
-                Rhoconnect.log params[:warning]
-                response.headers['Warning'] = params[:warning]
-              end
-              res
-            end
+            res = @app.call(aenv)
           end
+          res
         }
         result = nil
         callback = proc { |proc_res| result = proc_res; f.resume }
-    
+
         EventMachine.defer operation, callback
         Fiber.yield
-        # we can not throw exceptions across threads
-        # so we analyze it in the main thread after the
-        # request has been processed and if result
-        # has error code - then we throw :halt here
-        if Array === result and Fixnum === result.first
-          throw :halt, result
-        end
         result
+      end
     end
   end
+
+#   module AsyncHelpers
+#     #def self.included(klass)
+#     #  (klass.instance_methods & self.instance_methods).each do |method|
+#     #    klass.instance_eval{remove_method method.to_sym}
+#     #  end
+#     #end
+#
+#     def catch_all
+#       res = nil
+#       begin
+#         res = catch(:halt) { yield }
+#       rescue ApiException => ae
+#         res = [ae.error_code, ae.message]
+#       rescue Exception => e
+#         log e.message + e.backtrace.join("\n")
+#         res = [500, e.message]
+#       end
+#       res
+#     end
+#
+#     def execute_api_call(&block)
+#       f = Fiber.current
+#       operation = proc {
+#         catch_all do
+#           puts " we are processing the route #{self.inspect}"
+#           method = self.class.send(:generate_method, "calling_method", &block)
+#           #method = instance_method "calling_method"
+#           #remove_method "calling_method"
+#
+#           #method = Sinatra::Base.generate_method("calling_method", &block)
+#           proc = method.bind(self)
+#           res = proc.call
+#           #res = yield
+#           if params.has_key? :warning
+#             Rhoconnect.log params[:warning]
+#             response.headers['Warning'] = params[:warning]
+#           end
+#           res
+#         end
+#       }
+#       result = nil
+#       callback = proc { |proc_res| result = proc_res; f.resume }
+#
+#       EventMachine.defer operation, callback
+#       Fiber.yield
+#       # we can not throw exceptions across threads
+#       # so we analyze it in the main thread after the
+#       # request has been processed and if result
+#       # has error code - then we throw :halt here
+#       if Array === result and Fixnum === result.first
+#         throw :halt, result
+#       end
+#       result
+#     end
+#   end
 end

data/lib/rhoconnect/bulk_data/bulk_data.rb

@@ -2,7 +2,7 @@ require 'resque'
 require 'rhoconnect/jobs/bulk_data_job'
 
 module Rhoconnect
-  class BulkData < Model
+  class BulkData < StoreOrm
     field :name, :string
     field :state, :string
     field :app_id, :string
@@ -23,7 +23,7 @@ module Rhoconnect
     def delete
       sources[0, -1].each do |source|
         s = Source.load(source,{:app_id => app_id, :user_id => user_id})
-        Store.flash_data(s.docname(:md_copy)) if s
+        s.flush_data(:md_copy) if s
       end
       super
     end
@@ -32,8 +32,10 @@ module Rhoconnect
       sources[0, -1].each do |source|
         s = Source.load(source,{:app_id => app_id, :user_id => user_id})
         if s
-          SourceSync.new(s).process_query(nil)
-          s.clone(:md,:md_copy) unless s.sync_type.to_sym == :bulk_sync_only
+          rh = lambda { @model.query(params[:query])}
+          model = Rhoconnect::Model::Base.create(s)
+          Rhoconnect::Handler::Query::Engine.new(model, rh, {}).do_sync
+          s.clone(:md, s.docname(:md_copy)) unless s.sync_type.to_sym == :bulk_sync_only
         end
       end
     end

data/lib/rhoconnect/client.rb

@@ -1,7 +1,7 @@
 module Rhoconnect  
   class InvalidSourceNameError < RuntimeError; end
   
-  class Client < Model
+  class Client < StoreOrm
     field :device_type,       :string
     field :device_push_type,  :string
     field :device_pin,        :string
@@ -15,6 +15,32 @@ module Rhoconnect
     
     include Document
     include LockOps
+
+    define_valid_doctypes([:cd, 
+                :cd_size, 
+                :page, 
+                :delete_page, 
+                :create_links,
+                :create_links_page,
+                :metadata_page,
+                :total_count_page,
+                :page_token,
+                :schema_sha1, 
+                :schema_page,
+                :metadata_sha1,
+                :metadata_page,
+                :search,
+                :search_token,
+                :search_page,
+                :search_errors,
+                :create_errors,
+                :create_errors_page,
+                :update_errors,
+                :update_errors_page,
+                :update_rollback,
+                :update_rollback_page,
+                :delete_errors,
+                :delete_errors_page])
     
     def self.create(fields,params={})
       Rhoconnect.license.check_and_use_seat
@@ -41,17 +67,20 @@ module Rhoconnect
     
     def doc_suffix(doctype)
       doctype = doctype.to_s
-      if doctype == '*'
-        "#{self.user_id}:#{self.id}:*"
-      elsif self.source_name 
+      if self.source_name 
         "#{self.user_id}:#{self.id}:#{self.source_name}:#{doctype}"
       else
         raise InvalidSourceNameError.new('Invalid Source Name For Client')   
       end          
     end
     
+    def store_index(doctype)
+      source = Source.load(self.source_name,{:app_id => app_id,:user_id => self.user_id})
+      index = compute_store_index(doctype, source, user_id)
+    end
+
     def delete
-      flash_data('*')
+      flush_all_documents
       Rhoconnect.license.free_seat
       if Rhoconnect.stats
         Rhoconnect::Stats::Record.set('clients') { Store.decr('client:count') }
@@ -60,12 +89,33 @@ module Rhoconnect
       end
       super
     end
-    
+
+    def flush_all_documents
+      app.sources.each do |sourcename|
+        flush_source_documents(sourcename)
+      end  
+    end
+
+    def flush_source_documents(source_name)
+      self.class.valid_doctypes.each do |doctype|
+        flush_source_data(doctype, source_name)
+      end
+    end
+
+    def flush_source_data(doctype, from_source)
+      verify_doctype(doctype)
+      self.source_name=from_source
+      docnamestr = docname('') + doctype.to_s
+      Store.flush_data(docnamestr)
+    end
+
     def switch_user(new_user_id)
-      flash_data('*')
+      loaded_source = self.source_name
+      flush_all_documents
       User.load(self.user_id).clients.delete(self.id)
       User.load(new_user_id).clients << self.id
       self.user_id = new_user_id
+      self.source_name = loaded_source
     end
     
     def update_clientdoc(sources)
@@ -73,9 +123,9 @@ module Rhoconnect
       # source masterdoc and source schema might have changed!
       sources.each do |source|
         s = Source.load(source,{:app_id => app_id,:user_id => user_id})
+        self.source_name = source
         unless s.sync_type.to_sym == :bulk_sync_only
-          self.source_name = source
-          Store.clone(s.docname(:md_copy),self.docname(:cd))
+          s.clone(:md_copy,self.docname(:cd))
         end
         self.put_value(:schema_sha1,s.get_value(:schema_sha1))
       end

data/lib/rhoconnect/condition/admin_required.rb

@@ -0,0 +1,27 @@
+module Rhoconnect
+  module Condition
+    module AdminRequired
+      def self.extended(base)
+        base.include_admin_required_condition
+      end
+
+      def include_admin_required_condition
+        set(:admin_required) do |value|
+          condition do
+            if value
+              begin
+                api_token = ApiToken.load(env[API_TOKEN_HEADER])
+                api_token = ApiToken.load(params[:api_token]) unless api_token
+                raise Rhoconnect::ApiException.new(422, "No API token provided") unless api_token
+                raise Rhoconnect::ApiException.new(422, "Invalid/missing API user") unless api_token.user and api_token.user.admin == 1
+                env[Rhoconnect::CURRENT_USER] = api_token.user
+              rescue Rhoconnect::ApiException => ae
+                throw :halt, [422, {'Content-Type' => 'text/plain'}, ae.message]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/condition/client_required.rb

@@ -0,0 +1,50 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Condition
+    # Sinatra condition
+    module ClientRequired
+      def self.extended(base)
+        base.include_client_required_condition
+      end
+
+      def include_client_required_condition
+        include ClientRequiredHelpers
+        set(:client_required) do |value|
+          condition do
+            if value
+              catch_all do
+                client = extract_current_client
+                # client should be valid here
+                raise ArgumentError.new(UNKNOWN_CLIENT) unless client
+                env[CURRENT_CLIENT] = client
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module ClientRequiredHelpers
+      # helper method
+      def extract_current_client
+        client = nil
+        # TODO: This is removed when V3 is deprecated
+        if params["cud"]
+          cud_client_id = JSON.parse(params["cud"])["client_id"]
+          params.merge!(:client_id => cud_client_id) if cud_client_id
+        end
+        client_id = @env[Rhoconnect::CLIENT_ID_HEADER]
+        client_id = params[:client_id] unless client_id
+        if client_id
+          client = Client.load(client_id.to_s,
+                               params[:source_name] ? {:source_name => params[:source_name]} : {:source_name => '*'})
+          if client and current_user and client.user_id != current_user.login
+            client.switch_user(current_user.login)
+          end
+        end
+        client
+      end
+    end
+  end
+end

data/lib/rhoconnect/condition/login_required.rb

@@ -0,0 +1,22 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Condition
+    module LoginRequired
+      def self.extended(base)
+        base.include_login_required_condition
+      end
+
+      def include_login_required_condition
+        set(:login_required) do |value|
+          #puts "lgin kls is #{self.to_s}"
+          condition do
+            if value
+              throw :halt, [401, {'Content-Type' => 'text/plain'}, "Not authenticated"] if @env[Rhoconnect::CURRENT_USER].nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/condition/source_required.rb

@@ -0,0 +1,49 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Condition
+    module SourceRequired
+      def self.extended(base)
+        base.include_source_required_condition
+      end
+
+      def include_source_required_condition
+        set(:source_required) do |value|
+          condition do
+            if value
+              catch_all do
+                source = nil
+                user = current_user
+                # TODO - this should be removed when old routes are removed
+                if params["cud"]
+                  cud_source_name = JSON.parse(params["cud"])["source_name"]
+                  params.merge!({:source_name => cud_source_name}) if cud_source_name
+                end
+                # resource name is the source
+                if params[:source_name] and user
+                  source = Source.load(params[:source_name],
+                    {:user_id => user.login,:app_id => APP_NAME})
+
+                  # if source does not exist create one for dynamic adapter
+                  unless source
+                    sconfig = Rhoconnect.source_config(params[:source_name])
+                    source = Source.create(sconfig.merge!({:name => params[:source_name]}),{:user_id => user.login, :app_id => APP_NAME})
+                    current_app.sources << source.name
+                  end
+                else
+                  Rhoconnect.log "ERROR: Can't load source, no source_name provided.\n"
+                  raise ArgumentError.new(UNKNOWN_SOURCE)
+                end
+                #puts "loaded source: #{source.inspect}"
+                env[CURRENT_SOURCE] = source
+                # by default - all routes should have an access to the model
+                # if the route require source
+                @model = Rhoconnect::Model::Base.create(source)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/condition/verbs.rb

@@ -0,0 +1,17 @@
+module Rhoconnect
+  module Condition
+    module Verbs
+      def self.extended(base)
+      	base.include_verbs_condition
+      end
+
+      def include_verbs_condition
+        set(:verbs) do |*verbs|
+          condition do
+            verbs.any?{|v| v == request.request_method }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/condition/verify_success.rb

@@ -0,0 +1,19 @@
+module Rhoconnect
+  module Condition
+    module VerifySuccess
+      def self.extended(base)
+        base.include_verify_success_condition
+      end
+
+    	def include_verify_success_condition
+    	  set(:verify_success) do |value|
+    	  	condition do
+    	  	  if value
+    	  	  	success?
+    	  	  end
+    	  	end
+    	  end
+    	end
+    end
+  end
+end

data/lib/rhoconnect/controller/app_base.rb

@@ -0,0 +1,74 @@
+module Rhoconnect
+  module Controller
+    class AppBase < Rhoconnect::Controller::Base
+      set_default :admin_required, false
+      set_default :login_required, false
+      set_default :source_required, false
+      set_default :client_required, false
+
+      def self.inherited(subclass)
+        subclass.set_default :admin_required, false
+        subclass.set_default :login_required, false
+        subclass.set_default :source_required, false
+        subclass.set_default :client_required, false
+        super
+      end
+
+      register Rhoconnect::Handler::Search
+      register Rhoconnect::Handler::BulkData
+
+      # main app controller
+      def self._rest_name
+        "app"
+      end
+
+      private
+      def self._prefix
+        "rc/#{Rhoconnect::API_VERSION}"
+      end
+    end
+  end
+
+  # aliasing Rhoconnect::Base class name to provide backward compatibility
+  # TODO: deprecate this class along with application.rb support
+  # and remove in 4.1
+  class Base < Rhoconnect::Controller::AppBase
+    def self.initializer(path=nil)
+      require 'rhoconnect/application/init'
+
+      # post deprecation warning !!!
+      warning_for_deprecated_application = <<_MIGRATE_TO_NEW_RHOCONNECT
+
+***** WARNING *****
+RhoConnect has detected that you're using deprecated Application class.
+
+  Application class support will be removed in RhoConnect 4.1.
+  Please, migrate your Application class into ApplicationController.
+
+  For more details, see RhoConnect Migration guidelines at 
+  docs.rhomobile.com
+
+_MIGRATE_TO_NEW_RHOCONNECT
+      puts warning_for_deprecated_application
+
+      # !!! Add routes here - because otherwise they will be added in all apps
+      # even those that has new style Application class
+      self.register Rhoconnect::EndPoint
+
+      # Application login
+      post "/login", { :rc_handler => :authenticate, :deprecated_route => {:verb => :post, :url => ['/application/clientlogin', '/api/application/clientlogin']},
+                      :client_required => false } do
+        Application.authenticate(params[:login], params[:password], session)
+      end
+
+      # Push service login
+      get "/rps_login", :rc_handler => :rps_authenticate, :client_required => false do
+        if Application.singleton_methods.map(&:to_sym).include?(:rps_authenticate)
+          Application.rps_authenticate(params[:login], params[:password])
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/base.rb

@@ -0,0 +1,68 @@
+module Rhoconnect
+  module Controller
+    class Base < Rhoconnect::Server
+      def self.rest_path
+        "/#{_prefix}/#{_rest_name}"
+      end
+      
+      def self._rest_name
+        ret = self.name
+        # remove the namespace
+        stripped = ret.split("::").last
+        ret = stripped unless stripped.nil?
+        
+        ret.gsub!(/Controller/){}
+      end
+      
+      def self._prefix
+        "app/#{Rhoconnect::API_VERSION}"
+      end
+      
+      def self.get(route, params = {}, &block)
+        _add_route(route, :get, params, &block)  
+      end
+      
+      def self.post(route, params = {}, &block)
+        _add_route(route, :post, params, &block)  
+      end
+      
+      def self.put(route, params = {}, &block)
+        _add_route(route, :put, params, &block)  
+      end
+      
+      def self.delete(route, params = {}, &block)
+        _add_route(route, :delete, params, &block)  
+      end
+      
+      private
+        def self._add_route(route, verb, params, &block)
+          resource_route = route
+          @default_settings ||= {}
+          @default_settings.each do |setting, value|
+            params[setting] = value unless params.has_key?(setting)
+          end
+          api4 "#{self.rest_path}", resource_route, verb, params, &block
+        end
+    end
+    
+    # the only purpose of this class is to prepend
+    # rest route with /rc/version prefix
+    # as opposed to Application-specific resources
+    class APIBase < Rhoconnect::Controller::Base
+      def self._rest_name
+        ret = self.name
+        # remove the namespace
+        stripped = ret.split("::").last
+        ret = stripped unless stripped.nil?
+        
+        ret.gsub!(/Controller/){}
+        ret.downcase 
+      end
+
+      private
+      def self._prefix
+        "rc/#{Rhoconnect::API_VERSION}"
+      end
+    end
+  end
+end