rhoconnect 3.4.5 → 4.0.0.beta.10

data/lib/rhoconnect/controller/clients_controller.rb

@@ -0,0 +1,79 @@
+module Rhoconnect
+  module Controller
+    class ClientsController < Rhoconnect::Controller::APIBase
+      set_default :admin_required, true
+      set_default :login_required, false
+      set_default :source_required, false
+      set_default :client_required, false
+
+      register Rhoconnect::EndPoint
+          
+      post "/", :admin_required => false, :login_required => true, \
+          :deprecated_route => {:verb => :get, :url => ['/application/clientcreate', '/api/application/clientcreate']} do
+        content_type :json
+        client = Client.create(:user_id => current_user.id,:app_id => current_app.id)
+        client.update_fields(params)
+        { "client" => { "client_id" =>  client.id.to_s } }.to_json
+      end
+      
+      post "/:client_id/register", :admin_required => false, :login_required => true, \
+                    :deprecated_route => {:verb => :post, :url => ['/application/clientregister', '/api/application/clientregister'] } do
+        cur_client = extract_current_client
+        if cur_client.nil? and current_user and current_app
+          fields = {:user_id => current_user.id}
+          fields[:id] = params[:client_id].to_s
+          fields[:app_id] = current_app.id
+          cur_client = Client.create(fields)
+        end
+        cur_client.update_fields(params)
+        status 200
+      end
+      
+      post "/:client_id/reset", :admin_required => false, :login_required => true, :client_required => true, \
+                  :deprecated_route => {:verb => :get, :url => ['/application/clientreset', '/api/application/clientreset']} do
+        # Resets the store for a given app,client
+        if params == nil or params[:sources] == nil
+          current_client.flush_all_documents
+        else
+          params[:sources].each do |source|
+            current_client.flush_source_documents(source['name'])
+          end
+        end
+        status 200
+      end
+      
+      get "/:client_id/sources/:source_id/docs/:doc" do
+        c = Client.load(params[:client_id],{:source_name => params[:source_id]})
+        c.get_db_doc(params[:doc])
+      end
+      
+      post "/:client_id/sources/:source_id/docs/:doc" do
+        c = Client.load(params[:client_id],{:source_name => params[:source_id]})
+        append_to_doc = params[:append]
+        append_to_doc ||= false
+        c.set_db_doc(params[:doc], params[:data],append_to_doc)
+        ''
+      end
+      
+      get "/:client_id", \
+                      :deprecated_route => {:verb => :post, :url => ['/api/get_client_params', '/api/client/get_client_params']} do
+        Client.load(params[:client_id],{:source_name => '*'}).to_array.to_json
+      end
+      
+      get "/:client_id/sources/:source_id/docnames", \
+                      :deprecated_route => {:verb => :post, :url => ['/api/list_client_docs', '/api/client/list_client_docs']} do
+        result = ""
+        Rhoconnect::Stats::Record.update('clientdocs') do
+          c = Client.load(params[:client_id],{:source_name => params[:source_id]})
+          res = {}
+          Client.valid_doctypes.each do |doc|
+            db_key = c.docname(doc)
+            res.merge!(doc => db_key)
+          end
+          result = res.to_json
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/dynamic_adapter_controller.rb

@@ -0,0 +1,93 @@
+module Rhoconnect
+  module Controller  
+    class DynamicAdapterController < Rhoconnect::Controller::Base
+      set_default :admin_required, false
+      set_default :login_required, true
+      set_default :source_required, true
+      set_default :client_required, true
+
+      register Rhoconnect::EndPoint
+
+      # QUERY
+      get "/:source_name", :rc_handler => :query do
+        @model.query(params[:query])
+      end
+      
+      # CUD
+      post "/:source_name", :rc_handler => :cud do
+        operation = params[:operation]
+        @model.send operation.to_sym, params["#{operation}_object".to_sym]
+      end
+
+      put "/:source_name/:id", :rc_handler => :update do
+        @model.update(params[:update_object])
+      end
+
+      delete "/:source_name/:id", :rc_handler => :delete do
+        @model.delete(params[:delete_object])
+      end
+      
+      # push objects
+      post "/:source_id/push_objects", \
+              { :rc_handler => :push_objects,
+                :admin_required => true, 
+                :login_required => false, 
+                :source_required => false,
+                :client_required => false,
+                :deprecated_route => {:verb => :post, :url => ['/api/push_objects', '/api/source/push_objects']}
+              } do
+        @model.push_objects(params)
+      end
+      
+      # push_deletes
+      post "/:source_id/push_deletes", \
+            { :rc_handler => :push_deletes,
+              :admin_required => true, 
+              :login_required => false,
+              :source_required => false, 
+              :client_required => false,
+              :deprecated_route => {:verb => :post, :url => ['/api/push_deletes', '/api/source/push_deletes']}
+            } do
+        @model.push_deletes(params)
+      end
+      
+      # fast insert
+      post "/:source_id/fast_insert", \
+            { :admin_required => true, 
+              :login_required => false, 
+              :source_required => false,
+              :client_required => false,
+              :deprecated_route => {:verb => :post, :url => ['/api/fast_insert', '/api/source/fast_insert']}
+            } do
+        do_fast_insert
+      end
+      
+      # fast update
+      post "/:source_id/fast_update", \
+            { :admin_required => true, 
+              :login_required => false, 
+              :source_required => false,
+              :client_required => false,
+              :deprecated_route => {:verb => :post, :url => ['/api/fast_update', '/api/source/fast_update']}
+            } do
+        do_fast_update
+      end
+      
+      # fast object delete
+      post "/:source_id/fast_delete", \
+              { :admin_required => true, 
+                :login_required => false, 
+                :source_required => false,
+                :client_required => false,
+                :deprecated_route => {:verb => :post, :url => ['/api/fast_delete', '/api/source/fast_delete']}
+              } do
+        do_fast_delete
+      end
+      
+      private
+      def self.rest_path
+        "/app/#{Rhoconnect::API_VERSION}"
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/js_base.rb

@@ -0,0 +1,124 @@
+module Rhoconnect
+  module Controller
+    module JsBaseHelpers
+      def query_finish(return_value)
+        @model.result = return_value
+      end
+    end
+
+    class JsBase < Rhoconnect::Controller::Base
+
+      # Add helpers for deprecated routes
+      Rhoconnect::DefaultServer.helpers Rhoconnect::Controller::JsBaseHelpers
+
+      helpers Rhoconnect::Controller::JsBaseHelpers
+
+      # source name is available inherently from controller
+      before do
+        params[:source_name] = self.class._rest_name
+        params[:source_id] = self.class._rest_name
+      end
+
+      def self.register_routes(json)
+        Rhoconnect::Model::JsBase.register_models(json['models'])
+        json['result'].each do |key,val|
+          controller_name = "#{key}Controller"
+          next if Object.const_defined?(controller_name)
+          if controller_name == 'ApplicationController'
+            klass = Object.const_set(controller_name, Class.new(Rhoconnect::Controller::JsAppBase))
+          else
+            klass = Object.const_set(controller_name, Class.new(Rhoconnect::Controller::JsBase))
+          end
+          Rhoconnect.add_to_url_map(klass)
+          process_defaults(klass,val['defaults'])
+          process_routes(klass,val['routes'])
+        end
+      end
+
+      private
+
+      def self.process_defaults(klass,defaults)
+        defaults.each do |default|
+          default.each do |key,val|
+            klass.send(:set_default,key,val)
+          end
+        end
+      end
+
+      def self.process_routes(klass,routes)
+        routes.each do |r|
+          opts = {}
+          s_route = r.split('_rjs_')
+          verb = s_route[0]
+          action = s_route[2]
+          opts = hshify(s_route[3]) if s_route[3]
+          block = js_block(r)
+          case opts[:rc_handler]
+          when 'query'
+            block = js_block(r,:query_finish)
+          end
+          klass.send(verb,action,opts,&block)
+        end
+      end
+
+      def self.hshify(str)
+        result = JSON.parse(str, :symbolize_names => true)
+        # result = str.split(",").inject({}) do |res,element|
+        #   items = element.split(":")
+        #   res[items[0].to_sym] = items[1]
+        #   res
+        # end
+        result
+      end
+
+      def self.js_block(key,finish_block=nil)
+        Proc.new do
+          json = {
+             :url   => key,
+             :args  => params,
+             :model => under_score(params[:source_name]),
+             :route => 'request'
+          }
+          return_value = NodeChannel.publish_channel_and_wait(json,@model)
+          if finish_block
+            self.send(finish_block, return_value)
+          else
+            return_value
+          end
+        end
+      end
+
+      def self._prefix
+        "app/#{Rhoconnect::API_VERSION}"
+      end
+
+    end
+    class JsAppBase < Rhoconnect::Controller::JsBase
+      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
+end

data/lib/rhoconnect/controller/read_state_controller.rb

@@ -0,0 +1,22 @@
+module Rhoconnect
+  module Controller  
+    class ReadStateController < Rhoconnect::Controller::APIBase
+      set_default :admin_required, true
+      set_default :login_required, false
+      set_default :source_required, false
+      set_default :client_required, false
+
+      register Rhoconnect::EndPoint
+      
+      put "/users/:user_name/sources/:source_name", \
+                  :deprecated_route => {:verb => :post, :url => ['/api/set_refresh_time', '/api/source/set_refresh_time']} do
+        source = Source.load(params[:source_name],
+          {:app_id => APP_NAME, :user_id => params[:user_name]})
+        source.poll_interval = params[:poll_interval] if params[:poll_interval]
+        params[:refresh_time] ||= 0
+        source.read_state.refresh_time = Time.now.to_i + params[:refresh_time].to_i
+        ''
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/source_adapter_base.rb

@@ -0,0 +1,14 @@
+module Rhoconnect
+  module Controller
+    class SourceAdapterBase < Rhoconnect::Controller::Base
+      # create SourceAdapterController class for every source
+      def self.register_controller(source_name)
+        return if Object.const_defined?("#{source_name}Controller")
+        # klass will be added automatically to the URL map
+        klass = Object.const_set("#{source_name}Controller", Class.new(Rhoconnect::Controller::SourceAdapterBase))
+        klass.register Rhoconnect::EndPoint
+        klass.register Rhoconnect::Handler::Sync
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/sources_controller.rb

@@ -0,0 +1,44 @@
+module Rhoconnect
+  module Controller  
+    class SourcesController < Rhoconnect::Controller::APIBase
+      set_default :admin_required, true
+      set_default :login_required, false
+      set_default :source_required, false
+      set_default :client_required, false
+
+      register Rhoconnect::EndPoint
+      
+      # get source's params
+      get "/:source_id", \
+                  :deprecated_route => {:verb => :post, :url => ['/api/get_source_params', '/api/source/get_source_params']} do
+        Source.load(params[:source_id],{:app_id => APP_NAME,:user_id => '*'}).to_array.to_json
+      end
+      
+      # get all sources with particular partition type
+      get "/type/:partition_type", \
+                  :deprecated_route => {:verb => :post, :url => ['/api/list_sources', '/api/source/list_sources']}  do
+        sources = App.load(APP_NAME).sources
+        if params['partition_type'].nil? or params['partition_type'] == 'all'
+          sources.to_json 
+        else
+          res = []
+          sources.each do |name|
+            s = Source.load(name,{:app_id => APP_NAME,:user_id => '*'})
+            if s and s.partition_type and s.partition_type == params['partition_type'].to_sym
+              res << name 
+            end
+          end  
+          res.to_json
+        end  
+      end
+      
+      # update source's params
+      put "/:source_id" do
+        source = Source.load(params[:source_id],
+          {:app_id => APP_NAME, :user_id => '*'})
+        source.update_fields(params[:data])
+        ''
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/store_controller.rb

@@ -0,0 +1,25 @@
+module Rhoconnect
+  module Controller  
+    class StoreController < Rhoconnect::Controller::APIBase
+      set_default :admin_required, true
+      set_default :login_required, false
+      set_default :source_required, false
+      set_default :client_required, false
+
+      register Rhoconnect::EndPoint
+      
+      get "/:doc", \
+                :deprecated_route => {:verb => :post, :url => ['/api/get_db_doc', '/api/source/get_db_doc']} do
+        Store.get_db_doc(params[:doc])
+      end
+      
+      post "/:doc", \
+                  :deprecated_route => {:verb => :post, :url => ['/api/set_db_doc', '/api/source/set_db_doc'] } do
+        append_to_doc = params[:append]
+        append_to_doc ||= false
+        Store.set_db_doc(params[:doc],params[:data],append_to_doc)
+        ''
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/system_controller.rb

@@ -0,0 +1,67 @@
+module Rhoconnect
+  module Controller 
+    class SystemController < Rhoconnect::Controller::APIBase
+      set_default :admin_required, true
+      set_default :login_required, false
+      set_default :source_required, false
+      set_default :client_required, false
+
+      register Rhoconnect::EndPoint
+     
+      get "/appserver", \
+                :deprecated_route => {:verb => :post, :url => ['/api/get_adapter', '/api/source/get_adapter']} do
+        {:adapter_url => Rhoconnect.appserver}.to_json
+      end
+     
+      post "/appserver", \
+                :deprecated_route => {:verb => :post, :url => ['/api/save_adapter', '/api/source/save_adapter']} do
+        Rhoconnect.appserver = params['adapter_url'] || params[:attributes]['adapter_url']
+      end
+     
+      get "/license", \
+                 :deprecated_route => {:verb => :post, :url => ['/api/get_license_info', '/api/admin/get_license_info']} do
+        {:rhoconnect_version => Rhoconnect.license.rhoconnect_version, 
+         :licensee => Rhoconnect.license.licensee, 
+         :seats => Rhoconnect.license.seats, 
+         :issued => Rhoconnect.license.issued,
+         :available => Rhoconnect.license.available }.to_json
+      end
+     
+      post "/login", :rc_handler => :admin_authenticate, :admin_required => false, :deprecated_route => {:verb => :post, :url => ['/login', '/api/admin/login']} do
+        user = User.authenticate(params[:login], params[:password])
+      end
+
+      post "/reset", :deprecated_route => {:verb => :post, :url => ['/api/reset', '/api/admin/reset']} do
+        keep_token = current_user.token.value
+        Store.flush_all
+        Rhoconnect.bootstrap(Rhoconnect.base_directory)
+        # restoring previous token value after flushdb
+        current_user.token = keep_token
+        "DB reset"
+      end
+     
+      get "/stats", \
+                      :deprecated_route => {:verb => :post, :url => ['/api/stats', '/api/admin/stats']} do
+        if Rhoconnect.stats == true
+          names = params[:names]
+          if names
+            Rhoconnect::Stats::Record.keys(names).to_json
+          else
+            metric = params[:metric]
+            rtype = Rhoconnect::Stats::Record.rtype(metric)
+            if rtype == 'zset'
+              # returns [] if no results
+              Rhoconnect::Stats::Record.range(metric,params[:start],params[:finish]).to_json 
+            elsif rtype == 'string'
+              Rhoconnect::Stats::Record.get_value(metric) || ''
+            else
+              raise ApiException.new(404, "Unknown metric")
+            end
+          end
+        else
+          raise ApiException.new(500, "Stats not enabled")
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/controller/users_controller.rb

@@ -0,0 +1,99 @@
+module Rhoconnect
+  module Controller  
+    class UsersController < Rhoconnect::Controller::APIBase
+      set_default :admin_required, true
+      set_default :login_required, false
+      set_default :source_required, false
+      set_default :client_required, false
+
+      register Rhoconnect::EndPoint
+      
+      # show users
+      get "/", :admin_required => true, :deprecated_route => {:verb => :post, :url => ['/api/list_users', '/api/user/list_users']} do
+        current_app.users.members.to_json
+      end
+      
+      # show user
+      get "/:user_id" do
+        User.load(params[:user_id]).to_array.to_json
+      end
+      
+      # create user
+      post "/", :deprecated_route => { :url => "/api/create_user", :verb => :post } do
+        app = current_app
+        u = User.create({:login => params[:attributes][:login]})
+        u.password = params[:attributes]['password']
+        app.users << u.login
+        "User created"
+      end
+      
+      # update user
+      put "/:user_id", :deprecated_route => {:verb => :post, :url => ["/api/update_user", '/api/user/update_user']} do
+        User.load(params[:user_id]).update(params[:attributes])
+        "User updated"
+      end
+      
+      # delete user
+      delete "/:user_id", :deprecated_route => {:verb => :post, :url => ['/api/delete_user', '/api/user/delete_user']} do
+        app = current_app
+        User.load(params[:user_id]).delete
+        app.users.delete(params[:user_id])
+        s_params = {:app_id => APP_NAME,:user_id => params[:user_id]}
+        app.sources.each{ |source|
+          Source.load(source, s_params).flush_store_data
+        }
+        "User deleted"
+      end
+      
+      # get user's clients
+      get "/:user_id/clients", :admin_required => true, \
+                    :deprecated_route => {:verb => :post, :url => ['/api/list_clients', '/api/client/list_clients']} do
+        User.load(params[:user_id]).clients.members.to_json
+      end
+      
+      # delete user's client
+      delete "/:user_id/clients/:client_id", :admin_required => true, \
+                :deprecated_route => {:verb => :post, :url => ['/api/delete_client', '/api/client/delete_client']} do
+        Client.load(params[:client_id],{:source_name => '*'}).delete
+        User.load(params[:user_id]).clients.delete(params[:client_id])
+        "Client deleted"
+      end
+      
+      # get user's docnames
+      get "/:user_id/sources/:source_id/docnames", :admin_required => true, \
+                :deprecated_route => {:verb => :post, :url => ['/api/list_source_docs', '/api/source/list_source_docs']} do
+        res = {}
+        s = Source.load(params[:source_id], {:app_id => APP_NAME,:user_id => params[:user_id]})
+        [:md,:md_size,:md_copy,:errors].each do |doc|
+          db_key = s.docname(doc)
+          res.merge!(doc => db_key)
+        end
+        res.to_json
+      end
+      
+      # get user's DB document
+      get "/:user_id/sources/:source_id/docs/:doc", :admin_required => true do
+        s = Source.load(params[:source_id], {:app_id => APP_NAME,:user_id => params[:user_id]})
+        db_key = s.docname(params[:doc])
+        Store.get_db_doc(db_key)
+      end
+      
+      # set user's DB document
+      post "/:user_id/sources/:source_id/docs/:doc", :admin_required => true do
+        throw :halt, [500, "Unknown user '#{params[:user_id]}'"] unless User.is_exist?(params[:user_id])
+      
+        s = Source.load(params[:source_id], {:app_id => APP_NAME,:user_id => params[:user_id]})
+        db_key = s.docname(params[:doc])
+        append_to_doc = params[:append]
+        append_to_doc ||= false
+        Store.set_db_doc(db_key,params[:data],append_to_doc)
+        ''
+      end
+      
+      # ping user's client
+      post "/ping", :admin_required => true, :deprecated_route => {:verb => :post, :url => ['/api/ping', '/api/client/ping']} do
+        User.ping(params)
+      end
+    end
+  end
+end

data/lib/rhoconnect/db_adapter.rb

@@ -9,9 +9,7 @@ class DBAdapter
   def get_connection(dbfile)
     if defined?(JRUBY_VERSION) # JRuby
       require 'dbi'
-      require 'dbd/Jdbc'
-      require 'jdbc/sqlite3'
-      
+
       db = DBI.connect("DBI:Jdbc:SQLite:#{dbfile}", nil, nil, 'driver' => 'org.sqlite.JDBC')
       class << db
         # jdbc/sqlite3 has no Database#execute_batch method