rhoconnect 3.4.5 → 4.0.0.beta.10

data/generators/templates/application/application.rb

@@ -1,43 +0,0 @@
-class Application < Rhoconnect::Base
-  class << self
-    def authenticate(username,password,session)
-      true # do some interesting authentication here...
-    end
-
-    def ans_authenticate(username,password)
-      true # optionally handle rhoconnect push authentication...
-    end
-    
-    # Add hooks for application startup here
-    # Don't forget to call super at the end!
-    def initializer(path)
-      super
-    end
-    
-    # Calling super here returns rack tempfile path:
-    # i.e. /var/folders/J4/J4wGJ-r6H7S313GEZ-Xx5E+++TI
-    # Note: This tempfile is removed when server stops or crashes...
-    # See http://rack.rubyforge.org/doc/Multipart.html for more info
-    # 
-    # Override this by creating a copy of the file somewhere
-    # and returning the path to that file (then don't call super!):
-    # i.e. /mnt/myimages/soccer.png
-    def store_blob(object,field_name,blob)
-      super #=> returns blob[:tempfile]
-    end
-  end
-end
-
-Application.initializer(ROOT_PATH)
-
-# Support passenger smart spawning/fork mode:
-if defined?(PhusionPassenger)
-  PhusionPassenger.on_event(:starting_worker_process) do |forked|
-    if forked
-      # We're in smart spawning mode.
-      Store.db.client.reconnect
-    else
-      # We're in conservative spawning mode. We don't need to do anything.
-    end
-  end
-end

data/lib/rhoconnect/client_sync.rb

@@ -1,434 +0,0 @@
-module Rhoconnect
-  class ClientSync
-    attr_accessor :source,:client,:p_size,:source_sync
-    
-    UNKNOWN_CLIENT = "Unknown client"
-    UNKNOWN_SOURCE = "Unknown source"
-    
-    # TODO : Remove in Rhoconnect 4.0
-    SYNC_VERSION = 3
-    
-    def initialize(source,client,p_size=nil)
-      raise ArgumentError.new(UNKNOWN_CLIENT) unless client
-      raise ArgumentError.new(UNKNOWN_SOURCE) unless source
-      @source,@client,@p_size = source,client,p_size ? p_size.to_i : 500
-      @client.last_sync = Time.now if @client
-      @source_sync = SourceSync.new(@source)
-    end
-    
-    def receive_cud(cud_params={},query_params=nil)
-      if @source.is_pass_through?
-        @source_sync.pass_through_cud(cud_params,query_params)
-      else
-        _process_blobs(cud_params)
-        processed = 0
-        ['create','update','delete'].each do |op|
-          key,value = op,cud_params[op]
-          processed += _receive_cud(key,value) if value
-        end
-        @source_sync.process_cud
-      end
-    end
-    
-    def send_cud(token=nil,query_params=nil)
-      res = []
-      if not _ack_token(token) and not @source.is_pass_through?
-        res = resend_page(token)
-      else
-        query_result = @source_sync.process_query(query_params)
-        if @source.is_pass_through?
-          res = send_pass_through_data(query_result)
-        else
-          res = send_new_page
-        end
-      end
-      _format_result(res[0],res[1],res[2],res[3])
-    end
-    
-    def search(params)
-      if params
-        return _resend_search_result if params[:token] and params[:resend]
-        if params[:token] and !_ack_search(params[:token]) 
-          formatted_result = _format_search_result
-          _delete_search
-          return formatted_result
-        end
-      end
-      _do_search(params)
-    end
-    
-    def build_page
-      res = {}
-      yield res
-      res.reject! {|key,value| value.nil? or value.empty?}
-      res.merge!(_send_errors)
-      res
-    end
-    
-    def send_new_page
-      token,progress_count,total_count,res = '',0,0,{}
-      if schema_changed?
-        _expire_bulk_data
-        token = compute_token(@client.docname(:page_token))
-        res = {'schema-changed' => 'true'}
-      else  
-        compute_errors_page
-        res = build_page do |r|
-          total_count,r['insert'],r['delete'] = compute_page
-          r['links'] = compute_links_page
-          r['metadata'] = compute_metadata
-        end
-        if res['insert'] or res['delete'] or res['links']
-          token = compute_token(@client.docname(:page_token))
-        else
-          _delete_errors_page 
-        end
-      end
-      # TODO: progress count can not be computed properly
-      # without comparing what has actually changes
-      # so we need to obsolete it in the future versions
-      progress_count = 0
-      [token,progress_count,total_count,res]
-    end
-    
-    def send_pass_through_data(data)
-      data ||= {}
-      data.each_key do |object_id| 
-        data[object_id].each { |attrib,value| data[object_id][attrib] = '' if value.nil? }
-      end
-      token = ''
-      compute_errors_page
-      res = build_page do |r|
-        r['insert'] = data
-        r['metadata'] = compute_metadata
-      end
-      if res['insert']
-        token = compute_token(@client.docname(:page_token))
-      else
-        _delete_errors_page 
-      end    
-      [token,0,data.size,res]
-    end
-    
-    # Resend token for a client, also sends exceptions
-    def resend_page(token=nil)
-      token,progress_count,total_count,res = '',0,0,{}
-      schema_page = @client.get_value(:schema_page)
-      if schema_page
-        res = {'schema-changed' => 'true'}
-      else  
-        res = build_page do |r|
-          r['insert'] = @client.get_data(:page)
-          r['delete'] = @client.get_data(:delete_page)
-          r['links'] = @client.get_data(:create_links_page)
-          r['metadata'] = @client.get_value(:metadata_page)
-          progress_count = 0
-          total_count = @client.get_value(:total_count_page).to_i
-        end
-      end
-      token = @client.get_value(:page_token)
-      [token,progress_count,total_count,res]
-    end
-    
-    # Checks if schema changed
-    def schema_changed?
-      if @source_sync.adapter.respond_to?(:schema)
-        schema_sha1 = @source.get_value(:schema_sha1)
-        if @client.get_value(:schema_sha1).nil?
-          @client.put_value(:schema_sha1,schema_sha1)
-          return false
-        elsif @client.get_value(:schema_sha1) == schema_sha1
-          return false
-        end
-        @client.put_value(:schema_sha1,schema_sha1)
-        @client.put_value(:schema_page,schema_sha1)
-        return true
-      else
-        return false
-      end
-    end
-
-    # Computes the metadata sha1 and returns metadata if client's sha1 doesn't 
-    # match source's sha1
-    def compute_metadata
-      metadata_sha1,metadata = @source.lock(:metadata) do |s|
-        [s.get_value(:metadata_sha1),s.get_value(:metadata)]
-      end
-      return if @client.get_value(:metadata_sha1) == metadata_sha1
-      @client.put_value(:metadata_sha1,metadata_sha1)
-      @client.put_value(:metadata_page,metadata)
-      metadata
-    end
-    
-    
-    # Computes diffs between master doc and client doc, trims it to page size, 
-    # stores page, and returns page as hash  
-    def compute_page
-      inserts_elements_map,deletes_elements_map,total_count = @source.lock(:md) do |s| 
-        inserts_elements_map = Store.get_diff_data(@client.docname(:cd),s.docname(:md),@p_size)
-        total_count = s.get_value(:md_size).to_i
-        deletes_elements_map = Store.get_diff_data(s.docname(:md),@client.docname(:cd),@p_size)
-        [inserts_elements_map,deletes_elements_map,total_count]
-      end
-      # until sync is not done - set cd_size to 0
-      # once there are no changes, then, set cd_size to md_size
-      cd_size = inserts_elements_map.size > 0 ? 0 : total_count
-      @client.put_value(:cd_size, cd_size)
-      
-      # now, find the exact changes
-      inserts,deletes = Store.get_inserts_deletes(inserts_elements_map,deletes_elements_map)
-      
-      @client.put_data(:page,inserts)
-      @client.put_data(:delete_page,deletes,true)
-      @client.put_value(:total_count_page,total_count)
-      Store.update_elements(@client.docname(:cd),inserts_elements_map,deletes_elements_map)
-      
-      [total_count,inserts,deletes]
-    end
-    
-    # Computes search result, updates md for source and cd for client with the result
-    def compute_search
-      cd_inserts_elements_map = Store.get_diff_data(@client.docname(:cd),@client.docname(:search),@p_size)
-      
-      Store.update_elements(@client.docname(:cd), cd_inserts_elements_map, {})
-      @client.update_count(:cd_size,cd_inserts_elements_map.size)
-      # remove previous search page and build new one
-      @client.flash_data(:search_page)
-      Store.update_elements(@client.docname(:search_page),cd_inserts_elements_map,{})
-      client_res = @client.get_data(:search_page)
-      
-      @source.lock(:md) do |s|
-        md_inserts_elements_map = Store.get_diff_data(s.docname(:md),@client.docname(:cd))
-        Store.update_elements(s.docname(:md), md_inserts_elements_map, {})
-        s.update_count(:md_size,md_inserts_elements_map.size)
-      end
-      
-      [client_res,client_res.size]
-    end
-    
-    # Computes errors for client and stores a copy as errors page
-    def compute_errors_page
-      ['create','update','delete'].each do |operation|
-        @client.lock("#{operation}_errors") do |c| 
-          c.rename("#{operation}_errors","#{operation}_errors_page")
-        end
-      end
-      @client.lock("update_rollback") do |c|
-        c.rename("update_rollback","update_rollback_page")
-      end
-    end
-    
-    # Computes create links for a client and stores a copy as links page
-    def compute_links_page
-      @client.lock(:create_links) do |c| 
-        c.rename(:create_links,:create_links_page)
-        c.get_data(:create_links_page)
-      end
-    end
-        
-    class << self
-      # Resets the store for a given app,client
-      def reset(client, params=nil)
-        return unless client
-        if params == nil or params[:sources] == nil
-          client.flash_data('*')
-        else
-          params[:sources].each do |source|
-            client.flash_source_data('*', source['name'])
-          end
-        end
-      end
-    
-      def search_all(client,params=nil)
-        raise ArgumentError.new(UNKNOWN_CLIENT) unless client
-        return [] unless params[:sources]
-        res = []
-        params[:sources].each do |source|
-          s = Source.load(source['name'],{:app_id => client.app_id,
-            :user_id => client.user_id})
-          client.source_name = source['name']
-          cs = ClientSync.new(s,client,params[:p_size])
-          params[:token] = source['token'] if source['token']
-          search_res = cs.search(params)
-          res << search_res if search_res
-        end
-        res
-      end
-      
-      def bulk_data(partition,client,sources=nil)
-        raise ArgumentError.new(UNKNOWN_CLIENT) unless client
-        name = BulkData.get_name(partition,client.user_id)
-        data = BulkData.load(name)
-
-        partition_sources = client.app.partition_sources(partition,client.user_id)	
-        sources ||= partition_sources
-        return {:result => :nop} if sources.length <= 0
-
-        do_bd_sync = data.nil?
-        do_bd_sync = (data.completed? and 
-            (data.refresh_time <= Time.now.to_i or !data.dbfiles_exist?)) unless do_bd_sync
-
-        if do_bd_sync  
-          data.delete if data
-          data = BulkData.create(:name => name,
-            :app_id => client.app_id,
-            :user_id => client.user_id,
-            :partition_sources => partition_sources,
-            :sources => sources,
-            :refresh_time => Time.now.to_i + Rhoconnect.bulk_sync_poll_interval)
-          BulkData.enqueue("data_name" => name)
-        end
-        
-        if data and data.completed? and data.dbfiles_exist?
-          client.update_clientdoc(sources)
-          sources.each do |src|
-            s = Source.load(src, {:user_id => client.user_id, :app_id => client.app_id})
-            errordoc = s.docname(:errors)
-            errors = {}
-            Store.lock(errordoc) do
-              errors = Store.get_data(errordoc)
-            end
-            unless errors.empty?
-              # FIXME: :result => :bulk_sync_error, :errors => "#{errors}"
-              log "Bulk sync errors are found in #{src}: #{errors}"
-              # Delete all related bulk files
-              data.delete_files
-              return {:result => :url, :url => ''}
-            end
-          end
-          {:result => :url, :url => data.url}
-        elsif data
-          {:result => :wait}
-        end
-      end
-    end
-    
-    private
-    
-    # expires the bulk data for the client
-    def _expire_bulk_data
-      [:user,:app].each do |partition|
-        Rhoconnect.expire_bulk_data(@client.user_id,partition)
-      end
-    end
-    
-    def _resend_search_result
-      res = @client.get_data(:search_page)
-       _format_search_result(res,res.size)
-    end
-    
-    def _ack_search(search_token)
-      if @client.get_value(:search_token) != search_token
-        _delete_search
-        @client.put_data(:search_errors,
-          {'search-error'=>{'message'=>'Search error - invalid token'}}
-        )
-        return false
-      end
-      true
-    end
-    
-    def _delete_search
-      [:search, :search_page, :search_token, :search_errors].each do |search_doc|
-     	  @client.flash_data(search_doc)
-     	end
-    end
-    
-    def _do_search(params={})
-      # call source adapter search unless client is sending token for ack
-      search_params = params[:search] if params
-      res = @source_sync.search(@client.id,search_params) if params.nil? or !params[:token]
-      res,diffsize =  @source.is_pass_through? ? [res,res.size] : compute_search 
-      formatted_res = _format_search_result(res,diffsize)      
-      _delete_search if diffsize == 0
-      formatted_res
-    end
-    
-    def _format_search_result(res={},diffsize=nil)
-      error = @client.get_data(:search_errors)
-      if not error.empty?
-        [ {'version'=>SYNC_VERSION},
-          {'source'=>@source.name},
-          {'search-error'=>error} ]
-      else  
-        search_token = @client.get_value(:search_token)
-        search_token ||= ''
-        return [] if res.empty?
-        [ {'version'=>SYNC_VERSION},
-          {'token' => search_token},
-          {'source'=>@source.name},
-          {'count'=>res.size},
-          {'insert'=>res} ]
-       end
-    end
-    
-    def _receive_cud(operation,params)
-      return 0 if not ['create','update','delete'].include?(operation)
-      @source.lock(operation) { |s| s.put_zdata(operation,@client.id,params,true) }
-      return 1
-    end
-    
-    def _process_blobs(params)
-      unless params[:blob_fields].nil?
-        [:create,:update].each do |utype|
-          objects = params[utype] || {}
-          objects.each do |id,obj|
-            params[:blob_fields].each do |field|
-        		  blob = params["#{field}-#{id}"]
-        		  obj[field] = @client.app.store_blob(obj,field,blob)
-      		  end
-        	end
-      	end
-      end
-    end
-    
-    def _ack_token(token)
-      stored_token = @client.get_value(:page_token)
-      if stored_token 
-        if token and stored_token == token
-          @client.put_value(:page_token,nil)
-          @client.flash_data(:schema_page)
-          @client.flash_data(:metadata_page)
-          @client.flash_data(:create_links_page)
-          @client.flash_data(:page)
-          @client.flash_data(:delete_page)
-          _delete_errors_page
-          return true
-        end
-      else
-        return true    
-      end    
-      false
-    end
-    
-    def _delete_errors_page
-      ['create','update','delete'].each do |operation|
-        @client.flash_data("#{operation}_errors_page")
-      end
-      @client.flash_data("update_rollback_page")
-    end
-    
-    def _send_errors
-      res = {}
-      ['create','update','delete'].each do |operation|
-        res["#{operation}-error"] = @client.get_data("#{operation}_errors_page")
-      end
-      res["source-error"] = @source.lock(:errors) { |s| s.get_data(:errors) }
-      res["update-rollback"] = @client.get_data(:update_rollback_page)
-      res.reject! {|key,value| value.nil? or value.empty?}
-      res
-    end
-    
-    def _format_result(token,progress_count,total_count,res)
-      count = 0
-      count += res['insert'].length if res['insert']
-      count += res['delete'].length if res['delete']
-      [ {'version'=>SYNC_VERSION},
-        {'token'=>(token ? token : '')},
-        {'count'=>count},
-        {'progress_count'=>progress_count},
-        {'total_count'=>total_count},
-        res ]
-    end
-  end
-end

data/lib/rhoconnect/dynamic_adapter.rb

@@ -1,91 +0,0 @@
-require 'json'
-require 'rest_client'
-require 'uri'
-
-module Rhoconnect
-  
-  class DynamicAdapter < SourceAdapter
-    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

data/lib/rhoconnect/middleware/admin_user.rb

@@ -1,23 +0,0 @@
-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/current_request.rb

@@ -1,16 +0,0 @@
-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/login_required.rb

@@ -1,22 +0,0 @@
-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