rhoconnect 3.2.1 → 3.3.1.beta2

data/lib/rhoconnect/ping/blackberry.rb

@@ -7,17 +7,17 @@ module Rhoconnect
         settings = get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
         host = settings[:mdsserver]
       	port = settings[:mdsserverport]
-        
-        headers = { "X-WAP-APPLICATION-ID" => "/",
-                    "X-RIM-PUSH-DEST-PORT" => params['device_port'],
-                    "CONTENT-TYPE" => 'multipart/related; type="application/xml"; boundary=asdlfkjiurwghasf'}
+        if (host and port)
+          headers = { "X-WAP-APPLICATION-ID" => "/",
+                      "X-RIM-PUSH-DEST-PORT" => params['device_port'],
+                      "CONTENT-TYPE" => 'multipart/related; type="application/xml"; boundary=asdlfkjiurwghasf'}
                     
-        Net::HTTP.new(host,port).start do |http|
-          request = Net::HTTP::Post.new('/pap',headers)
-          request.body = pap_message(params)
-          http.request(request)
+          Net::HTTP.new(host,port).start do |http|
+            request = Net::HTTP::Post.new('/pap',headers)
+            request.body = pap_message(params)
+            http.request(request)
+          end
         end
-
       rescue Exception => error
         log "Error while sending ping: #{error}"
         raise error

data/lib/rhoconnect/ping/rhoconnect_push.rb

@@ -0,0 +1,45 @@
+require 'uri'
+
+module Rhoconnect
+  class RhoconnectPush
+  	class InvalidPushServer < Exception; end
+    class InvalidPushRequest < Exception; end
+
+    def self.ping(params)
+      begin
+    		settings = get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
+        if settings and settings[:push_server]
+    			server = URI.join(settings[:push_server], "/messageQueue/#{params['device_pin']}")
+		      RestClient.post(
+            server.to_s,self.push_message(params),:content_type => :json
+          ) do |response, request, result, &block|
+            case response.code
+            when 200, 204
+              response.return!(request, result, &block)
+            when 400
+              raise InvalidPushRequest.new("Invalid push request.")
+            end
+          end
+		    else
+		    	raise InvalidPushServer.new("Missing or invalid `:push_server` in settings/settings.yml.")
+        end
+	    rescue Exception => error
+        log "RhoConnect Push Error: #{error}"
+        log error.backtrace.join("\n")
+        raise error
+      end
+    end
+
+    # Generates push package
+  	def self.push_message(params)
+			data											= {}
+			data['collapseId']				= params['badge'].to_i if params['badge']
+			data['data']							= {}
+			data['data']['message'] 	= params['message'] if params['message'] 
+			data['data']['sound'] 		= params['sound'] if params['sound']
+			data['data']['vibrate']		= params['vibrate'] if params['vibrate']
+			data['data']['do_sync'] 	= params['sources'] if params['sources']
+			data.to_json
+  	end
+  end
+end

data/lib/rhoconnect/server.rb

@@ -4,9 +4,9 @@ require 'erb'
 require 'json'
 require 'fileutils'
 require 'rhoconnect'
-require 'rhoconnect/x_domain_session_wrapper'
-require 'rhoconnect/body_content_type_parser'
-require 'rhoconnect/cors'
+
+# all middlewares
+Dir[File.join(File.dirname(__FILE__),'middleware','**','*.rb')].each { |mw| require mw }
 
 module Rhoconnect
   
@@ -34,23 +34,30 @@ module Rhoconnect
     set :use_middleware, Proc.new {
       return false if @middleware_configured # Middleware might be configured only once!
 
-      use XDomainSessionWrapper
+      use Rhoconnect::Middleware::XDomainSessionWrapper
       use Rack::Cors do |cfg|
         cfg.allow do |allow|
-          allow.origins /.*/
+          allow.origins(/.*/)
           allow.resource '/application',   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
           allow.resource '/application/*', :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
           allow.resource '/api/application',   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
           allow.resource '/api/application/*', :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+          allow.resource "/app/#{Rhoconnect::API_VERSION}/*",   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+          allow.resource "/rc/#{Rhoconnect::API_VERSION}/app/*",   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
         end
       end
-      use Rhoconnect::BodyContentTypeParser
-      use Rhoconnect::Stats::Middleware
+      use Rhoconnect::Middleware::BodyContentTypeParser
+      use Rhoconnect::Middleware::Stats
       Rhoconnect::Server.set :secret, @secret unless settings.respond_to?(:secret)
       use Rack::Session::Cookie,
         :key => 'rhoconnect_session', :expire_after => Rhoconnect.cookie_expire,
         :secret => Rhoconnect::Server.secret
-
+      use Rhoconnect::Middleware::CurrentRequest
+      use Rhoconnect::Middleware::CurrentApp
+      use Rhoconnect::Middleware::CurrentUser
+      use Rhoconnect::Middleware::AdminUser
+      use Rhoconnect::Middleware::LoginRequired
+      
       @middleware_configured ||= true
     }
 
@@ -59,14 +66,9 @@ module Rhoconnect
         request.env['PATH_INFO'].split('/').last
       end
 
-      def check_api_token
-        request_action == 'login' or request_action == 'get_api_token' or 
-          (params[:api_token] and ApiToken.is_exist?(params[:api_token]))
-      end
-
-      def do_login
+      def check_login
         begin
-          login ? status(200) : status(401)
+          yield
         rescue LoginException => le
           throw :halt, [401, le.message]
         rescue Exception => e
@@ -74,9 +76,21 @@ module Rhoconnect
         end
       end
 
-      def login_required
-        current_user.nil?
-      end  
+      def do_login
+        check_login do
+          if login 
+            status(200) 
+          else
+            raise LoginException.new("Unable to authenticate '#{params[:login]}'")
+          end
+        end
+      end
+
+      def do_ans_login
+        check_login do
+          ans_login ? status(204) : status(401)
+        end
+      end
 
       def login
         if params[:login].nil? or params[:login].empty? 
@@ -95,33 +109,42 @@ module Rhoconnect
         end
       end
 
+      def ans_login
+        if current_app and current_app.can_ans_authenticate?
+          auth = Rack::Auth::Basic::Request.new(request.env)
+          current_app.ans_authenticate(
+            auth.credentials.first, auth.credentials.last
+          ) if auth.provided? and auth.basic? and auth.credentials
+        else
+          false
+        end
+      end
+
       def logout
         session[:login] = nil
       end
 
       def current_user
-        if @user.nil? and User.is_exist?(session[:login]) 
-          @user = User.load(session[:login])
-        end
-        if @user and (@user.admin == 1 || session[:app_name] == APP_NAME)
-          @user
-        else  
-          nil
-        end  
+        @env[Rhoconnect::CURRENT_USER]
       end
 
-      def api_user
-        if request_action == 'get_api_token' or request_action == 'login'
-          current_user
-        else
-          u = ApiToken.load(params[:api_token])
-          raise "Wrong API token - #{params[:api_token].inspect}" unless u
-          u.user 
-        end
+      def current_app
+        @env[Rhoconnect::CURRENT_APP]
       end
 
-      def current_app
-        App.load(APP_NAME)
+      def current_client
+        if @client.nil?
+          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 => current_source.name} : {:source_name => '*'})
+            if @client and current_user and @client.user_id != current_user.login
+              @client.switch_user(current_user.login) 
+            end
+          end
+        end
+        @client  
       end
 
       def current_source
@@ -144,17 +167,6 @@ module Rhoconnect
         end
       end
 
-      def current_client
-        if @client.nil? and params[:client_id]
-          @client = Client.load(params[:client_id].to_s,
-            params[:source_name] ? {:source_name => current_source.name} : {:source_name => '*'})
-          if @client and current_user and @client.user_id != current_user.login
-            @client.switch_user(current_user.login) 
-          end
-          @client
-        end  
-      end
-      
       def current_client_sync
         ClientSync.new(current_source,current_client,params[:p_size])
       end
@@ -183,18 +195,22 @@ module Rhoconnect
         end
       end
       
+      def mark_deprecated_call_and_reroute_api4(verb, new_route, old_verb, old_route, client_call, &block)
+        warning_message = "Use of the #{old_verb.to_s.upcase} #{old_route} is deprecated. Use Rhoconnect API #{Rhoconnect::API_VERSION} instead."
+        response.headers['Warning'] = warning_message
+        Rhoconnect.log warning_message
+        
+        execute_api_call(client_call, &block)
+      end
+      
       def execute_api_call(client_call = false)
-        if client_call or check_api_token
-          catch_all do
-            res = yield params, (client_call ? current_user : api_user), self
-            if params.has_key? :warning
-              Rhoconnect.log params[:warning]
-              response.headers['Warning'] = params[:warning]
-            end
-            res
+        catch_all do
+          res = yield params, current_user, self
+          if params.has_key? :warning
+            Rhoconnect.log params[:warning]
+            response.headers['Warning'] = params[:warning]
           end
-        else
-          throw :halt, [422, "No API token provided"]
+          res
         end
       end
     end
@@ -269,47 +285,24 @@ _INSTALL_ASYNC_GEMS
     before do
       cache_control :no_cache
       headers({'pragma'=>'no-cache'})
-      
-      if params[:version] and params[:version].to_i < 3
-        throw :halt, [404, "Server supports version 3 or higher of the protocol."]
-      end
     end
-    
+
     get '/' do
       redirect "/console/"
     end
     
-    %w[get post].each do |verb|
-      send(verb, "/*application*") do
-        unless request_action == 'clientlogin'
-          throw :halt, [401, "Not authenticated"] if login_required
-        end
-        pass
-      end
-    end
-    
-    # old routes
-    post '/login' do
-      mark_deprecated_call_and_reroute(:login, :admin, self, params)
-    end
-    get '/application' do
-      mark_deprecated_call_and_reroute(:query, :application, self, params)
-    end
-    post '/application' do
-      mark_deprecated_call_and_reroute(:queue_updates, :application, self, params)
-    end
-    # confusion routes - only because Rhodes didn't switch 
-    # to new style API yet
-    get '/api/application' do
-      mark_deprecated_call_and_reroute(:query, :application, self, params)
-    end
-    post '/api/application' do
-      mark_deprecated_call_and_reroute(:queue_updates, :application, self, params)
-    end
-      
     def self.api(name, namespace = nil, verb = :post, &block)
+      # this method is deprecated - so we should warn the users
+      # that it will be removed in 4.0
+      warning_for_server_api = <<_DEPRECATE_SERVER_API
+***** WARNING *****
+      Server.api method is deprecated and will be removed in Rhoconnect 4.0
+      Please change your implementation to Server.api4
+_DEPRECATE_SERVER_API
+      puts warning_for_server_api
+                
       old_api_prefix = (namespace == :application) ? :application : :api
-      client_call = (namespace == :application) ? true : false
+      client_call = (namespace == :application) ? true : false      
       send verb, "/#{old_api_prefix}/#{name}" do 
         mark_deprecated_call_and_reroute(name, namespace, params, &block)
       end
@@ -318,6 +311,20 @@ _INSTALL_ASYNC_GEMS
         execute_api_call(client_call, &block)
       end
     end
+    
+    def self.api4(method_name, verb, route, admin = true, deprecated_route = nil, &block)
+      unless deprecated_route.nil?
+        deprecated_urls = deprecated_route[:url].is_a?(String) ? [deprecated_route[:url]] : deprecated_route[:url]
+        deprecated_urls.each do |deprecated_url|
+          send deprecated_route[:verb], deprecated_url do 
+            mark_deprecated_call_and_reroute_api4(verb, route, deprecated_route[:verb], deprecated_url, !admin, &block)
+          end
+        end
+      end
+      send verb, route do
+        execute_api_call(!admin, &block)
+      end
+    end
   end
 end
 

data/lib/rhoconnect/source.rb

@@ -186,7 +186,11 @@ module Rhoconnect
       blob_attribs = []
       schema['property'].each do |key,value|
         values = value ? value.split(',') : []
-        blob_attribs << key if values.include?('blob')
+        if values.include?('blob')
+          attrib = key.dup
+          attrib << "," + (values.include?('overwrite') ? '1' : '0')
+          blob_attribs << attrib 
+        end
       end
       blob_attribs.sort.join(',')
     end

data/lib/rhoconnect/source_sync.rb

@@ -91,7 +91,7 @@ module Rhoconnect
     def do_query(params=nil)
       result = nil
       @source.if_need_refresh do
-        Stats::Record.update("source:query:#{@source.name}") do
+        Rhoconnect::Stats::Record.update("source:query:#{@source.name}") do
           if _auth_op('login')
             result = self.read(nil,params)
             _auth_op('logoff')
@@ -239,7 +239,7 @@ module Rhoconnect
     end
     
     def _measure_and_process_cud(operation)
-      Stats::Record.update("source:#{operation}:#{@source.name}") do
+      Rhoconnect::Stats::Record.update("source:#{operation}:#{@source.name}") do
         _process_cud(operation)
       end
     end
@@ -354,9 +354,10 @@ module Rhoconnect
       if operation == 'delete'
         # Clean up deleted objects from master document and corresponding client document
         total_dels = {}
+        objs = {}
         dels.each do |client_id,client_doc|
           next if client_doc.empty?
-          client = processed_clients[client_id]
+          client = processed_clients[client_id]         
           client.delete_data(:cd,client_doc)
           client.update_count(:cd_size,-client_doc.size)
           total_dels.merge!(client_doc)

data/lib/rhoconnect/stats/record.rb

@@ -1,8 +1,8 @@
 module Rhoconnect
-  module Stats
+  class Stats
     class Record
       class << self
-        
+      
         # Add a value to a metric.  If zset already has a member, 
         # update the existing member with an incremented value by default.
         # Also supports updating the value with a block (useful for averages)
@@ -25,11 +25,11 @@ module Rhoconnect
             Store.db.zremrangebyscore(key(metric), 0, start - record_size(metric))
           end
         end
-        
+      
         def add(metric, value = 1)
           set(metric,value) { |current,value| current.to_i + value } 
         end
-        
+      
         # Saves the accumulated average for a resolution in a metric
         def save_average(metric, value)
           set(metric,value) do |current,value| 
@@ -42,7 +42,7 @@ module Rhoconnect
             "#{current + 1},#{sum}"
           end  
         end
-        
+      
         def update(metric)
           if Rhoconnect.stats
             start = Time.now.to_f
@@ -54,51 +54,51 @@ module Rhoconnect
             yield
           end
         end
-        
+      
         def keys(glob='*')
           Store.db.keys(key(glob)).collect {|c| c[5..-1]}
         end
-        
+      
         def reset(metric)
           Store.db.del(key(metric))
         end
-        
+      
         def reset_all
           Store.flash_data('stat:*')
         end
-        
+      
         # Returns simple string metric
         def get_value(metric)
           Store.get_value(key(metric))
         end
-        
+      
         # Sets a string metric
         def set_value(metric, value)
           Store.set_value(key(metric), value)
         end
-      
+    
         # Returns the metric data, uses array indexing
         def range(metric, start, finish = -1)
           Store.db.zrange(key(metric), start, finish)
         end
-        
+      
         # Returns the resolution for a given metric, default 60 seconds
         def resolution(metric)
           resolution = STATS_RECORD_RESOLUTION rescue nil
           resolution || 60 #=> 1 minute aggregate
         end
-        
+      
         # Returns the # of records to save for a given metric
         def record_size(metric)
           size = STATS_RECORD_SIZE rescue nil
           size || 60 * 24 * 31 #=> 44640 minutes
         end
-        
+      
         # Returns redis object type for a record
         def rtype(metric)
           Store.db.type(key(metric))
         end
-        
+      
         def key(metric)
           "stat:#{metric}"
         end