rhoconnect 3.2.1 → 3.3.1.beta2

data/lib/rhoconnect/jobs/bulk_data_job.rb

@@ -154,7 +154,7 @@ module Rhoconnect
       db.execute_batch(File.open(schema,'r').read)
       
       src_counter = 1
-      bulk_data.sources.members.sort.each do |source_name|
+      bulk_data.sources[0, -1].each do |source_name|
         timer = start_timer("start importing sqlite data for #{source_name}")
         source = Source.load(source_name,{:app_id => bulk_data.app_id,
           :user_id => bulk_data.user_id})

data/lib/rhoconnect/jobs/ping_job.rb

@@ -25,41 +25,51 @@ module Rhoconnect
       # all errors are recorded here
       errors = []
       user = User.load(user_id)
-      user.clients.members.each do |client_id|
-        client = Client.load(client_id,{:source_name => '*'})
-        params.merge!('device_port' => client.device_port, 'device_pin' => client.device_pin, 'phone_id' => client.phone_id)
-        send_push = false
-        if client.device_type and client.device_type.size > 0
-          if client.phone_id and client.phone_id.size > 0
-            unless phone_ids.include? client.phone_id   
-              phone_ids << client.phone_id
-              send_push = true
-            end
-          elsif client.device_pin and client.device_pin.size > 0
-            unless device_pins.include? client.device_pin   
-              device_pins << client.device_pin
-              send_push = true
+      clients = user.clients if user
+      if clients
+        clients.members.each do |client_id|
+          client = Client.load(client_id,{:source_name => '*'})
+          params.merge!(
+            'device_port' => client.device_port, 
+            'device_pin' => client.device_pin, 
+            'phone_id' => client.phone_id
+          )
+          send_push = false
+          if client.device_type and client.device_type.size > 0
+            if client.phone_id and client.phone_id.size > 0
+              unless phone_ids.include? client.phone_id   
+                phone_ids << client.phone_id
+                send_push = true
+              end
+            elsif client.device_pin and client.device_pin.size > 0
+              unless device_pins.include? client.device_pin   
+                device_pins << client.device_pin
+                send_push = true
+              end
+            else
+              log "Skipping ping for non-registered client_id '#{client_id}'..."
+              next
             end
-          else
-            log "Skipping ping for non-registered client_id '#{client_id}'..."
-            next
-          end
-          if send_push
-            klass = Object.const_get(camelize(client.device_type.downcase))
-            if klass
-              params['vibrate'] = params['vibrate'].to_s
-              begin
-                klass.ping(params) 
-              rescue Exception => e
-                errors << e
+            if send_push
+              type = client.device_push_type || client.device_type
+              klass = Object.const_get(camelize(type.downcase))
+              if klass
+                params['vibrate'] = params['vibrate'].to_s
+                begin
+                  klass.ping(params) 
+                rescue Exception => e
+                  errors << e
+                end
               end
+            else
+              log "Dropping ping request for client_id '#{client_id}' because it's already in user's device pin or phone_id list."
             end
           else
-            log "Dropping ping request for client_id '#{client_id}' because it's already in user's device pin or phone_id list."
+            log "Skipping ping for non-registered client_id '#{client_id}'..."
           end
-        else
-          log "Skipping ping for non-registered client_id '#{client_id}'..."
         end
+      else
+        log "Skipping ping for unknown user '#{user_id}' or '#{user_id}' has no registered clients..."
       end
       errors
     end

data/lib/rhoconnect/middleware/admin_user.rb

@@ -0,0 +1,23 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Middleware
+    class AdminUser
+      def initialize(app, opts={})
+        @app = app
+        yield self if block_given?
+      end
+
+      def call(env)
+        begin
+          if Rhoconnect.is_admin_route(env)
+            env[Rhoconnect::CURRENT_USER] = Rhoconnect.extract_api_user(env)
+          end
+        rescue Rhoconnect::ApiException => ae
+          return [422, {'Content-Type' => 'text/plain'}, [ae.message]]
+        end
+        @app.call(env)
+      end  
+    end
+  end
+end

data/lib/rhoconnect/middleware/body_content_type_parser.rb

@@ -0,0 +1,35 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Middleware
+    class BodyContentTypeParser
+      # Constants
+      #
+      CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+      POST_BODY = 'rack.input'.freeze
+      FORM_INPUT = 'rack.request.form_input'.freeze
+      FORM_HASH = 'rack.request.form_hash'.freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env[CONTENT_TYPE] && env[CONTENT_TYPE].match(/^application\/json/) 
+          begin
+            if (body = env[POST_BODY].read).length != 0
+              # for some reason , if we do not do this
+              # Ruby 1.9 will fail
+              env[POST_BODY] = StringIO.new(body)
+              env.update(FORM_HASH => JSON.parse(body), FORM_INPUT => env[POST_BODY])
+            end
+          rescue JSON::ParserError => jpe
+            log jpe.message + jpe.backtrace.join("\n")
+            return [500, {'Content-Type' => 'text/plain'}, ["Server error while processing client data"]]
+          end
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rhoconnect/{cors.rb → middleware/cors.rb}

@@ -1,4 +1,5 @@
 require 'logger'
+require 'rhoconnect/middleware/helpers'
 
 module Rack
   class Cors

data/lib/rhoconnect/middleware/current_app.rb

@@ -0,0 +1,16 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Middleware
+    class CurrentApp
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env[Rhoconnect::CURRENT_APP] = App.load(APP_NAME)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rhoconnect/middleware/current_request.rb

@@ -0,0 +1,16 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Middleware
+    class CurrentRequest
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env[Rhoconnect::CURRENT_REQUEST] = Rack::Request.new(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rhoconnect/middleware/current_user.rb

@@ -0,0 +1,17 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Middleware
+    class CurrentUser
+      
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env[Rhoconnect::CURRENT_USER] = Rhoconnect.extract_current_user(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rhoconnect/middleware/helpers.rb

@@ -0,0 +1,105 @@
+module Rhoconnect
+  # Constants
+  #
+  CURRENT_REQUEST = 'CURRENT_REQUEST'.freeze
+  CURRENT_APP = 'CURRENT_APP'.freeze
+  CURRENT_USER = 'CURRENT_USER'.freeze
+  
+  # header names, in the form of server's HTTP variables
+  # X-RhoConnect-API-TOKEN
+  API_TOKEN_HEADER = 'HTTP_X_RHOCONNECT_API_TOKEN'.freeze
+  # X-RhoConnect-CLIENT-ID
+  CLIENT_ID_HEADER = 'HTTP_X_RHOCONNECT_CLIENT_ID'.freeze
+    
+    # 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

data/lib/rhoconnect/middleware/login_required.rb

@@ -0,0 +1,22 @@
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Middleware
+    class LoginRequired
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        begin
+          if Rhoconnect.is_login_required(env)
+            raise LoginException.new("Not authenticated") if env[Rhoconnect::CURRENT_USER].nil?
+          end
+          @app.call(env)
+        rescue LoginException => le
+          return [401, {'Content-Type' => 'text/plain'}, le.message]
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/{stats/middleware.rb → middleware/stats.rb}

@@ -1,6 +1,8 @@
+require 'rhoconnect/middleware/helpers'
+
 module Rhoconnect
-  module Stats
-    class Middleware
+  module Middleware
+    class Stats
       def initialize(app)
         @app = app
       end
@@ -13,7 +15,7 @@ module Rhoconnect
           metric = "http:#{env['REQUEST_METHOD']}:#{env['PATH_INFO']}"
           source_name = env['rack.request.query_hash']["source_name"] if env['rack.request.query_hash']
           metric << ":#{source_name}" if source_name
-          Record.save_average(metric,finish - start)
+          Rhoconnect::Stats::Record.save_average(metric,finish - start)
           [status, headers, body]
         else
           status, headers, body = @app.call(env)

data/lib/rhoconnect/middleware/x_domain_session_wrapper.rb

@@ -0,0 +1,58 @@
+require "cgi"
+require 'rhoconnect/middleware/helpers'
+
+module Rhoconnect
+  module Middleware
+    class XDomainSessionWrapper
+      def initialize(app, opts={})
+        @app = app
+        @session_cookie = opts[:session_cookie] || 'rhoconnect_session'
+        @api_uri_regexp = opts[:api_uri_regexp] || /\A\/api\/application/
+        @login_uri_regexp = opts[:login_uri_regexp] || /\A\/api\/application\/clientlogin/
+        yield self if block_given?
+      end
+
+      def is_sync_protocol(env)
+        # if it is rhoconnect protocol URI
+        @api_uri_regexp.match(env['PATH_INFO'])
+      end
+
+      def call(env)
+        if is_sync_protocol(env)
+          env['HTTP_COOKIE'] = env['HTTP_COOKIE'] || CGI.unescape(get_session_from_url(env))
+        end
+
+        status, headers, body = @app.call(env)
+
+        if is_sync_protocol(env)
+          cookies = headers['Set-Cookie'].to_s
+          #puts "<----- Cookies: #{cookies}"
+          # put cookies to body as JSON on login success
+          if @login_uri_regexp.match(env['PATH_INFO']) && status == 200
+            body = session_json_from(cookies)
+            headers['Content-Length'] = body.length.to_s
+          end
+        end
+
+        # The Body itself should not be an instance of String,as this will break in Ruby 1.9
+        body = ["#{body}"] if body.is_a?(String)
+        [status, headers, body]
+      end
+
+      def session_json_from(cookies)
+        rexp = Regexp.new(@session_cookie +'=[^\s]*')
+        sc = cookies.to_s.slice rexp
+        "{\"" +@session_cookie +"\": \"#{CGI.escape sc.to_s}\"}"
+      end
+
+      def get_session_from_url(env)
+        rexp = Regexp.new(@session_cookie +'=.*\Z')
+        qs = env['QUERY_STRING'].to_s.slice rexp
+        qs = qs.to_s.split(/&/)[0]
+        nv = qs.to_s.split(/=/)
+        return nv[1] if nv.length > 1
+        ''
+      end
+    end
+  end
+end

data/lib/rhoconnect/ping.rb

@@ -1,3 +1,4 @@
 require 'rhoconnect/ping/android'
 require 'rhoconnect/ping/apple'
 require 'rhoconnect/ping/blackberry'
+require 'rhoconnect/ping/rhoconnect_push'

data/lib/rhoconnect/ping/apple.rb

@@ -8,24 +8,26 @@ module Rhoconnect
       cert = File.read(cert_file) if File.exists?(cert_file)
     	passphrase = settings[:iphonepassphrase]
     	host = settings[:iphoneserver]
-    	port = settings[:iphoneport] 
-      begin
-        ssl_ctx = OpenSSL::SSL::SSLContext.new
-    		ssl_ctx.key = OpenSSL::PKey::RSA.new(cert, passphrase)
-    		ssl_ctx.cert = OpenSSL::X509::Certificate.new(cert)
+    	port = settings[:iphoneport]
+    	if(cert and host and port) 
+        begin
+          ssl_ctx = OpenSSL::SSL::SSLContext.new
+      		ssl_ctx.key = OpenSSL::PKey::RSA.new(cert, passphrase)
+      		ssl_ctx.cert = OpenSSL::X509::Certificate.new(cert)
 
-    		socket = TCPSocket.new(host, port)
-    		ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_ctx)
-    		ssl_socket.sync = true
-    		ssl_socket.connect
+      		socket = TCPSocket.new(host, port)
+      		ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_ctx)
+      		ssl_socket.sync = true
+      		ssl_socket.connect
 
-    		ssl_socket.write(apn_message(params))
-    		ssl_socket.close
-    		socket.close
-  		rescue SocketError => error
-  		  log "Error while sending ping: #{error}"
-  		  raise error
-  		end
+      		ssl_socket.write(apn_message(params))
+      		ssl_socket.close
+      		socket.close
+    		rescue SocketError => error
+    		  log "Error while sending ping: #{error}"
+    		  raise error
+    		end
+		  end
     end
 
     # Generates APNS package