rhoconnect 3.4.5 → 4.0.0.beta.10

data/lib/rhoconnect/license.rb

@@ -1,4 +1,5 @@
 require 'openssl'
+require 'pathname'
 
 module Rhoconnect
   class LicenseException < RuntimeError; end
@@ -6,7 +7,7 @@ module Rhoconnect
   
   class License
     attr_reader :rhoconnect_version, :licensee, :seats, :issued
-    #attr_accessor :license
+    attr_accessor :license
 
     # ships with rhoconnect
     RHO_PUBLICKEY = "99068e3a2708e6fe918252be8880eac539a1d2b2402651d75de5c7a2333a1cb2"
@@ -19,8 +20,15 @@ module Rhoconnect
         elsif ENV['RHOSYNC_LICENSE']
           @license = ENV['RHOSYNC_LICENSE']
         else
+          app_config = Rhoconnect.get_config(Rhoconnect.base_directory)
           settings = Rhoconnect.get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
-          @license = IO.read(File.join(Rhoconnect.base_directory,settings[:licensefile])).strip
+          licensefile = settings[:licensefile] 
+          if licensefile
+            path_to_license = (Pathname.new(licensefile).absolute?) ? licensefile : File.join(Rhoconnect.base_directory, licensefile)
+          else
+            path_to_license = File.join(File.dirname(__FILE__), '..', '..', 'generators', 'templates', 'application', 'settings', 'license.key')
+          end
+          @license = IO.read(path_to_license).strip
         end
         _decrypt
       rescue Exception => e

data/lib/rhoconnect/middleware/current_user.rb

@@ -9,9 +9,22 @@ module Rhoconnect
       end
 
       def call(env)
-        env[Rhoconnect::CURRENT_USER] = Rhoconnect.extract_current_user(env)
+        #puts "env is *** #{env.inspect}"
+        env[Rhoconnect::CURRENT_USER] = extract_current_user(env)
         @app.call(env)
       end
+
+      def extract_current_user(env)
+        user = nil
+        if User.is_exist?(env['rack.session'][:login])
+          user = User.load(env['rack.session'][:login])
+        end
+        if user and (user.admin == 1 || env['rack.session'][:app_name] == APP_NAME)
+          user
+        else  
+          nil
+        end
+      end
     end
   end
 end

data/lib/rhoconnect/middleware/helpers.rb

@@ -4,6 +4,15 @@ module Rhoconnect
   CURRENT_REQUEST = 'CURRENT_REQUEST'.freeze
   CURRENT_APP = 'CURRENT_APP'.freeze
   CURRENT_USER = 'CURRENT_USER'.freeze
+  CURRENT_SOURCE = 'CURRENT_SOURCE'.freeze
+  CURRENT_CLIENT = 'CURRENT_CLIENT'.freeze
+  QUERY_RES = 'QUERY_RES'.freeze
+
+  UNKNOWN_CLIENT = "Unknown client".freeze
+  UNKNOWN_SOURCE = "Unknown source".freeze
+
+  # TODO : Remove in Rhoconnect 4.0
+  SYNC_VERSION = 3
   
   # header names, in the form of server's HTTP variables
   # X-RhoConnect-API-TOKEN
@@ -14,96 +23,4 @@ module Rhoconnect
   PAGE_TOKEN_HEADER = 'X-Rhoconnect-PAGE-TOKEN'
   # X-RhoConnect-PAGE-OBJECT-COUNT
   PAGE_OBJECT_COUNT_HEADER = 'X-Rhoconnect-PAGE-OBJECT-COUNT'
-    
-    # old-way admin routes
-  OLD_API_URI_REGEXP = /\/api\//
-  # new way system routes will be:
-  # /rc/<version>/system/<method>
-  # /rc/<version>/<resource>/<method>
-  SYSTEM_API_URI_REGEXP = /\/rc\/\w+\/\w+/
-  # also, /app/v1/<Controller>/push_* are still remain Admin routes
-  PUSH_API_URI_REGEXP = /\/app\/\w+\/\w+\/push\w+/
-  # also, /app/v1/<Controller>/fast_* are still remain Admin routes
-  FAST_CUD_API_URI_REGEXP = /\/app\/\w+\/\w+\/fast\w+/
-
-  def is_clients_non_admin_route(env)
-    # FIXME : not all routes for Clients protocol are admin routes
-    full_path = env['SCRIPT_NAME'] + env['PATH_INFO']
-    /\/rc\/\w+\/clients/.match(full_path) and not ((env[CURRENT_REQUEST].request_method == 'GET') ||
-      (env[CURRENT_REQUEST].request_method == 'POST' and /\/rc\/\w+\/clients\/\w+\/sources/.match(full_path)))
-  end
-
-  def is_client_route(env)
-    # FIXME - once Controllers concept is implemented
-    # remove this - since the inclusion of Admin Middleware
-    # will automatically imply what routes are Admin and which are not
-    full_path = env['SCRIPT_NAME'] + env['PATH_INFO']
-    # login route and index route doesn't need a token
-    return true if /\/login/.match(full_path) || full_path == '/'
-    # old application routes are not admin 
-    return true if full_path == '/application'
-    return true if full_path == '/api/application'
-    return true if /\/application\//.match(full_path)
-    # some of the clients routes are not admin
-    return true if is_clients_non_admin_route(env)
-    # push_objects and push_deletes methods are admin
-    return false if PUSH_API_URI_REGEXP.match(full_path)
-    # fast_insert/update/delete methods are admin
-    return false if FAST_CUD_API_URI_REGEXP.match(full_path) 
-    # old api methods + every method in /rc/v1/app namespace
-    return true if /\/app\//.match(full_path)
-    # all other methods in the /rc/v1/ are admin routes
-    return false if SYSTEM_API_URI_REGEXP.match(full_path)
-    # all old /api methods are admin as well
-    return false if OLD_API_URI_REGEXP.match(full_path)
-    
-    # everything else should not be admin
-    true
-  end
-  
-  def is_admin_route(env)
-    not is_client_route(env) 
-  end
-  
-  def is_login_required(env)
-    # FIXME - once Controllers concept is implemented
-    # remove this - since the inclusion of LoginRequired Middleware
-    # will automatically imply what routes require Login and which are not
-    full_path = env['SCRIPT_NAME'] + env['PATH_INFO']
-    return false if full_path == '/' or /login/.match(full_path)
-    # all methods in app namespace
-    return true if  /\/app\//.match(full_path)
-    # old application routes are not admin 
-    return true if full_path == '/application'
-    return true if full_path == '/api/application'
-    return true if /\/application\//.match(full_path)
-    # also methods that operate on clients should have an associated user
-    return true if is_clients_non_admin_route(env)
-    
-    # for every other route login is not required
-    # because it's either an admin route (where api_user must be supplied anyway)
-    # or it's a custom route extending RhoConnect server
-    false
-  end
-
-  def extract_current_user(env)
-    user = nil
-    if User.is_exist?(env['rack.session'][:login])
-      user = User.load(env['rack.session'][:login])
-    end
-    if user and (user.admin == 1 || env['rack.session'][:app_name] == APP_NAME)
-      user
-    else  
-      nil
-    end
-  end
-  
-  def extract_api_user(env)
-    r = env[CURRENT_REQUEST]
-    # API_TOKEN is either a param or a header
-    u = ApiToken.load(env[API_TOKEN_HEADER])
-    u = ApiToken.load(r.params['api_token']) unless u
-    raise Rhoconnect::ApiException.new(422, "No API token provided") unless u
-    u.user 
-  end
-end
+end

data/lib/rhoconnect/middleware/x_domain_session_wrapper.rb

@@ -21,7 +21,7 @@ module Rhoconnect
         if is_sync_protocol(env)
           env['HTTP_COOKIE'] = env['HTTP_COOKIE'] || CGI.unescape(get_session_from_url(env))
         end
-
+        #puts "and here #{@app.inspect} #{env.inspect}"
         status, headers, body = @app.call(env)
 
         if is_sync_protocol(env)

data/lib/rhoconnect/model/base.rb

@@ -0,0 +1,229 @@
+module Rhoconnect
+  module Model
+    class Exception < RuntimeError; end
+    # raise this to cause client to be logged out during a sync
+    class LoginException < Rhoconnect::Model::Exception; end
+    class LogoffException < Rhoconnect::Model::Exception; end
+    # raise these to trigger rhoconnect sending an error to the client
+    class ServerTimeoutException < Rhoconnect::Model::Exception; end
+    class ServerErrorException < Rhoconnect::Model::Exception; end
+    class ObjectConflictErrorException < Rhoconnect::Model::Exception; end
+
+    class Base
+      attr_accessor :session, :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      # public API Method for loading an instance of the Model
+      def self.load(username)
+        source = Source.load(self.name,
+                      {:user_id => username,:app_id => APP_NAME})
+        self.create(source)
+      end
+
+      # public API method to load the Model's data
+      def get_data(docname = :md)
+        source.get_data(docname)
+      end
+
+      def self.create(source)
+        model=nil
+        if source
+          begin
+            if source.name
+              source.name = source.name.dup if source.name.frozen?
+              source.name.strip!
+            end
+            # certain models are pre-defined and reserved
+            # load them and instantiate
+            if Rhoconnect.predefined_sources.has_key?(source.name)
+              model = (Object.const_get(source.name)).new(source)
+            elsif Object.const_defined?(source.name) && Object.const_get(source.name).to_s.split("::").first != 'Rhoconnect'
+              # fix until source adpaters are phased out, checking for Rhoconnect namespace
+              # so that backend models with same name as Rhoconnect models are instantiated correctly
+              kls = Object.const_get(source.name)
+              unless kls
+                require under_score(source.name)
+                model = (Object.const_get(source.name)).new(source)
+              else
+                model = kls.new(source)
+              end
+            else
+              model=Rhoconnect::Model::DynamicAdapterModel.new(source)
+            end
+          rescue ArgumentError => e
+            # Backward compatibility with code generated by gems < 2.2.0
+            log "ERROR: credential parameter in `initialize` method is deprecated and removed in version >= 2.2.0."
+            raise e
+          rescue Exception => e
+            log "Failure to create model from class #{source.name}: #{e.inspect.to_s}"
+            raise e
+          end
+        end
+        model
+      end
+
+      def login; end
+
+      def query(params=nil); end
+
+      def search(params=nil); end
+
+      def sync
+        if @result and @result.empty?
+          @source.lock(:md) do |s|
+            s.flush_data(:md)
+            s.put_value(:md_size,0)
+          end
+        else
+          if @result
+            @source.put_tmp_data(@tmp_docname,@result)
+            @stash_size += @result.size
+          end
+          @source.lock(:md) do |s|
+            s.flush_data(:md)
+            s.rename_tmp_data(@tmp_docname,:md)
+            s.put_value(:md_size,@stash_size)
+          end
+        end
+      end
+
+      def before_query
+        @tmp_docname = :md.to_s + get_random_uuid
+        @stash_size = 0
+      end
+
+      def after_query
+        res = nil
+        if @source.is_pass_through?
+          res = @result
+        else
+          self.sync
+          res = true
+        end
+        res
+      end
+
+      def do_query(params=nil)
+        before_query
+        params ? self.query(params) : self.query
+        after_query
+      end
+
+      def stash_result
+        return if @result.nil?
+        @source.put_tmp_data(@tmp_docname,@result,true)
+        @stash_size += @result.size
+        @result = nil
+      end
+
+      def expire_bulk_data(partition = :user)
+        Rhoconnect.expire_bulk_data(current_user.login,partition)
+      end
+
+      # do pre-processing before CUD operation
+      def validate(operation,operations_hashes,client_ids)
+        {}
+      end
+
+      def create(create_hash); end
+
+      def update(update_hash); end
+
+      def delete(delete_hash); end
+
+      def ask(params=nil); end
+
+      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
+        raise_on_expire = params[:raise_on_expire] || false
+        rebuild_md = params[:rebuild_md].nil? ? true : params[:rebuild_md]
+        objects = params[:objects]
+
+        @source.lock(:md,timeout,raise_on_expire) do |s|
+          diff_count = 0
+          # in case of rebuild_md
+          # we clean-up and rebuild the whole :md doc
+          # on every request
+          if(rebuild_md)
+            doc = @source.get_data(:md)
+            orig_doc_size = doc.size
+            objects.each do |id,obj|
+              doc[id] ||= {}
+              doc[id].merge!(obj)
+            end if objects
+            diff_count = doc.size - orig_doc_size
+            @source.put_data(:md,doc)
+          else
+            # if rebuild_md == false
+            # we only operate on specific set values
+            # which brings a big optimization
+            # in case of small transactions
+            diff_count = @source.update_objects(:md, objects)
+          end
+
+          @source.update_count(:md_size,diff_count)
+        end
+        @source.announce_changes
+      end
+
+      def push_deletes(params)
+        timeout = params[:timeout] || 10
+        raise_on_expire = params[:raise_on_expire] || false
+        rebuild_md = params[:rebuild_md].nil? ? true : params[:rebuild_md]
+        objects = params[:objects]
+
+        @source.lock(:md,timeout,raise_on_expire) do |s|
+          diff_count = 0
+          if(rebuild_md)
+            # in case of rebuild_md
+            # we clean-up and rebuild the whole :md doc
+            # on every request
+            doc = @source.get_data(:md)
+            orig_doc_size = doc.size
+            objects.each do |id|
+              doc.delete(id)
+            end if objects
+            diff_count = doc.size - orig_doc_size
+            @source.put_data(:md,doc)
+          else
+            # if rebuild_md == false
+            # we only operate on specific set values
+            # which brings a big optimization
+            # in case of small transactions
+            diff_count = -@source.remove_objects(:md, objects)
+          end
+
+          @source.update_count(:md_size,diff_count)
+        end
+        @source.announce_changes
+      end
+
+      protected
+      def current_user
+        @source.user
+      end
+
+    end
+  end
+
+  # to preserve backward compatibility
+  # TODO: Remove in 4.1
+  SourceAdapter = Rhoconnect::Model::Base
+  SourceAdapterException = Rhoconnect::Model::Exception
+  SourceAdapterLoginException = Rhoconnect::Model::LoginException
+  SourceAdapterLogoffException = Rhoconnect::Model::LogoffException
+  SourceAdapterServerTimeoutException = Rhoconnect::Model::ServerTimeoutException
+  SourceAdapterServerErrorException = Rhoconnect::Model::ServerErrorException
+  SourceAdapterObjectConflictErrorException = Rhoconnect::Model::ObjectConflictErrorException
+end

data/lib/rhoconnect/model/dynamic_adapter_model.rb

@@ -0,0 +1,90 @@
+require 'json'
+require 'rest_client'
+require 'uri'
+
+module Rhoconnect
+  module Model
+    class DynamicAdapterModel < Rhoconnect::Model::Base
+      attr_accessor :uri, :partition
+      
+      def initialize(source, partition=nil, uri=nil)
+        @source = source
+        @uri = uri || Rhoconnect.appserver
+        @partition = partition || @source.user_id
+        
+        if @uri
+          @uri = URI.parse(@uri)
+          user = @uri.user
+          @uri.user = nil
+          @uri = @uri.to_s 
+        end
+        
+        @token = Rhoconnect.api_token || user   
+        raise Exception.new("Please provide a :token or set it in uri") unless @token
+        super(source)
+      end
+      
+      def self.authenticate(login,password)
+        hsh = {:login => login, :password => password, :api_token => Rhoconnect.api_token}.to_json
+        headers = {:content_type => :json, :accept => :json}
+        RestClient.post "#{Rhoconnect.appserver}/rhoconnect/authenticate", hsh, headers
+      end
+      
+      def query(params=nil)
+        @result={}
+        @result = JSON.parse(send_objects('query',@source.name, @partition, params))
+      end
+      
+      def create(create_hash)
+        send_objects('create',@source.name, @partition, create_hash)
+      end
+      
+      def update(update_hash)
+        send_objects('update',@source.name, @partition, update_hash)
+      end
+      
+      def delete(delete_hash)
+        send_objects('delete',@source.name, @partition, delete_hash)
+      end
+      
+      #protected
+      
+      def validate_args(action, source_name, partition, obj = {}) # :nodoc:
+        raise Exception.new("Please set uri in your settings or through console") unless @uri
+        raise ArgumentError.new("Missing object id for #{obj.inspect}") if ['update','delete'].include? action and not obj.has_key?('id')
+        raise ArgumentError.new("Missing source_name.") if source_name.empty?
+        #raise ArgumentError.new("Missing partition for #{model}.") unless partition or partition.blank?
+      end
+
+      def send_objects(action, source_name, partition, obj = {}) # :nodoc:
+        validate_args(action, source_name, partition, obj)
+        process(:post, "/rhoconnect/#{action}", 
+          {
+            :resource => source_name,
+            :partition => partition,
+            :attributes => obj 
+          }
+        )
+      end
+          
+      def resource(path) # :nodoc:
+        RestClient::Resource.new(@uri)[path]
+      end
+
+      def process(method, path, payload = nil) # :nodoc:
+        headers = api_headers
+        payload  = payload.merge!(:api_token => @token).to_json
+        args     = [method, payload, headers].compact
+        response = resource(path).send(*args)
+        response
+      end
+
+      def api_headers   # :nodoc:
+        {
+          :content_type => :json, 
+          :accept => :json
+        }
+      end
+    end
+  end
+end

data/lib/rhoconnect/model/js_base.rb

@@ -0,0 +1,121 @@
+module Rhoconnect
+  module Model
+    class JsBase < Rhoconnect::Model::Base
+      class << self
+        attr_accessor :js_method_list,:actual_name
+      end
+      attr_accessor :result
+
+      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)
+        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}"
+        end
+      end
+
+      def self.register_models(models)
+        app = App.load(APP_NAME)
+        models.each do |key,val|
+          a_name = key
+          klassified = key.classify
+          unless Object.const_defined?(klassified)
+            klass = Object.const_set(klassified, Class.new(Rhoconnect::Model::JsBase))
+            klass.js_method_list = val
+            klass.actual_name = a_name
+          end
+          source = Source.load(klassified,{:app_id=>APP_NAME,:user_id=>'*'})
+          unless source
+            sconfig = Rhoconnect.source_config(klassified)
+            Source.create(sconfig.merge!(:name => klassified),{:app_id => APP_NAME})
+            app.sources << klassified
+          end
+        end
+      end
+
+      def login
+        rho_methods('login')
+      end
+
+      def query(params=nil)
+        @result = rho_methods('query',params)
+      end
+
+      def search(params=nil)
+        rho_methods('search',params)
+      end
+
+      def create(create_hash)
+       rho_methods('create',create_hash)
+      end
+
+      def update(update_hash)
+        rho_methods('update',update_hash)
+      end
+
+      def delete(delete_hash)
+        rho_methods('delete',delete_hash)
+      end
+
+      def logoff
+        rho_methods('logoff')
+      end
+
+      def store_blob(obj,field_name,blob)
+        raise "store_blob not implemented in JavaScript yet."
+        # TODO: add method handling here
+      end
+
+      private
+
+      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)
+        else
+          sup.send(name,args)
+        end
+      end
+
+      def package_and_publish(method_name,args=nil)
+        json = {
+           :klss   => self.class.actual_name,
+           :function => method_name,
+           :args  => args,
+           :route => 'request'
+         }
+         NodeChannel.publish_channel_and_wait(json,self.class)
+      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|
+      res += index.capitalize
+      res
+    end
+    result
+  end
+end

data/lib/rhoconnect/ping/android.rb

@@ -24,7 +24,7 @@ module Rhoconnect
         send_ping_to_device(authtoken, params)
       rescue InvalidAuthToken => error
         if not already_retried
-          Store.flash_data(C2DM_AUTHTOKEN_KEY)
+          Store.flush_data(C2DM_AUTHTOKEN_KEY)
           already_retried = true
           retry
         end

data/lib/rhoconnect/predefined_adapters/bench_adapter.rb

@@ -6,7 +6,7 @@ module Rhoconnect
   # register the adapter as pre-defined
   Rhoconnect.register_predefined_source('RhoInternalBenchmarkAdapter')
   
-  class RhoInternalBenchmarkAdapter < Rhoconnect::SourceAdapter
+  class RhoInternalBenchmarkAdapter < Rhoconnect::Model::Base
      def initialize(source) 
        super(source)
      end
@@ -22,10 +22,10 @@ module Rhoconnect
         #end
         sleep @source.simulate_time
       end
-      Rhoconnect::Store.lock(lock_name,1) do
+      #Rhoconnect::Store.lock(lock_name,1) do
         @result = Rhoconnect::Store.get_data(db_name)
-      end
-      @result
+      #end
+      #@result
     end
 
     def create(create_hash)
@@ -54,12 +54,15 @@ module Rhoconnect
       Rhoconnect::Store.lock(lock_name,1) do
         Rhoconnect::Store.delete_data(db_name,{id=>delete_hash}) if id
       end
+      id
     end
 
     def db_name
       res = ''
       if @source.user_id[0..1] == 'nq'
         res = "test_db_storage:#{@source.app_id}:nquser"
+      elsif @source.user_id[0..1] == 'mq'
+        res = "test_db_storage:#{@source.app_id}:mquser"
       else
         res = "test_db_storage:#{@source.app_id}:benchuser"
       end

data/lib/rhoconnect/read_state.rb

@@ -1,5 +1,5 @@
 module Rhoconnect  
-  class ReadState < Model
+  class ReadState < StoreOrm
     field :refresh_time, :integer
     field :prev_refresh_time, :integer
     field :retry_counter, :integer
@@ -20,11 +20,11 @@ module Rhoconnect
     end
     
     def self.delete(app_id)
-      Store.flash_data("#{class_prefix(self)}:#{app_id}:*")
+      Store.flush_data("#{class_prefix(self)}:#{app_id}:*")
     end
     
     def self.delete_user(params)
-      Store.flash_data("#{class_prefix(self)}:#{params[:app_id]}:#{params[:user_id]}:#{params[:source_name]}:*")
+      Store.flush_data("#{class_prefix(self)}:#{params[:app_id]}:#{params[:user_id]}:#{params[:source_name]}:*")
     end
 
     private