vcs 0.1 → 0.2.148

data/ruby_ex/session/hookable.rb

@@ -0,0 +1,26 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: hookable.rb 53 2004-12-02 22:24:03Z ertai $
+
+
+require 'drb'
+
+
+module Session
+
+  module Hookable
+    include DRb::DRbUndumped
+
+    def hook(sid, profile, request, *args)
+      meth = "hook_#{request}"
+      if protected_methods.include?(meth)
+        send(meth.to_sym, sid, profile, *args)
+      end
+    end
+
+  end # module Hook
+
+end # module Session

data/ruby_ex/session/profile.rb

@@ -0,0 +1,110 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: profile.rb 70 2004-12-07 17:44:50Z polrop $
+
+
+require 'drb'
+
+require 'const_regexp'
+
+
+module Session
+
+  class Profile
+
+    attr_reader :data
+
+    def initialize(usrname, usrdesc, uri, dispatcher, *hooks)
+      @data = usrdesc.dup
+      @data[:usrname] = usrname
+      @data[:login_time] = Time.now
+      @data[:last_request_time] = Time.now
+      @data[:uri] = uri
+      uri_chunks = Profile.parse_uri(uri)
+      @data[:protocol], @data[:hostname], @data[:port] = *uri_chunks
+      @data[:hooks] = hooks
+      @data[:nb_requests] = 0
+      @data[:dispatcher] = dispatcher
+    end
+
+    def Profile.parse_uri(uri)
+      return $1, $2, $3.to_i if uri =~ ConstRegexp::DRB_URI
+    end
+
+    def _dump(depth)
+      data = {}
+      @data.each do |key, val|
+        begin
+          data[key] = Marshal.dump(val)
+        rescue TypeError
+          data[key] = Marshal.dump(DRbObject.new(val))
+        end
+      end
+      Marshal.dump([self.class, data])
+    end
+
+    def self._load(data)
+      klass, data = Marshal.load(data)
+      obj = klass.new(data[:usrname],
+                      {},
+                      data[:uri],
+                      nil,
+                      nil)
+      data.each do |attr, value|
+        obj[attr] = Marshal.load(value)
+      end
+      obj
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def to_hash
+      @data.dup
+    end
+
+    def each
+      @data.each { |k, v| yield(k, v) }
+    end
+
+    def allowed_request?(request)
+      return true if @data[:admin]
+      @data[:allowed_requests].include?(request)
+    end
+
+    def add_request(request)
+      unless @data[:allowed_requests].include?(request)
+        @data[:allowed_requests] << request
+      end
+    end
+
+    def allowed_hook?(hook)
+      return true if @data[:admin]
+      @data[:allowed_hooks].include?(hook)
+    end
+
+    def add_client(uri, client_class, *args)
+      @data[:dispatcher].add(uri,
+                             @data[:usrname],
+                             @data[:passwd],
+                             client_class,
+                             *args)
+    end
+
+    def del_client(uri)
+      @data[:dispatcher].del(uri)
+    end
+
+  end # class Profile
+
+end # class Session
+
+

data/ruby_ex/session/server.rb

@@ -0,0 +1,582 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: server.rb 186 2005-04-03 00:07:45Z ertai $
+
+
+require 'drb'
+
+require 'generate_id'
+require 'const_regexp'
+require 'drb/insecure_protected_methods'
+require 'session/profile'
+require 'session/dispatcher'
+require 'session/const'
+require 'session/error'
+require 'exception'
+
+
+module Session
+
+  class Server
+    include DRb::DRbUndumped
+
+    #
+    # Constants
+    #
+    MIN_USR = 1
+    MIN_WIPEOUT_DELAY = 2 # seconds
+    USRDB = {
+      'root' => {
+        :passwd => 'root'.crypt(Const::SALT_KEY),
+        :admin => true,
+        :allowed_requests => [],
+        :allowed_hooks => []
+      },
+      'admin' => {
+        :passwd => 'admin'.crypt(Const::SALT_KEY),
+        :admin => true,
+        :allowed_requests => [],
+        :allowed_hooks => []
+      },
+      'guest' => {
+        :passwd => 'guest'.crypt(Const::SALT_KEY),
+        :admin => false,
+        :allowed_requests => [
+          :profile, :help, :nb_requests, :ping
+        ],
+        :allowed_hooks => []
+      },
+      'anonymous' => {
+        :passwd => 'anonymous'.crypt(Const::SALT_KEY),
+        :admin => false,
+        :allowed_requests => [
+          :profile, :help, :nb_requests, :ping
+        ],
+        :allowed_hooks => []
+      }
+    }
+    MAX_USR = 10
+    WIPEOUT_DELAY = 60 # seconds
+    PROFILE_CLASS = Profile
+    MAX_DISPATCHER_JOBS = 1
+    OPTS = {
+      :usrdb => USRDB,
+      :max_usr => MAX_USR,
+      :wipeout_delay => WIPEOUT_DELAY,
+      :profile_class => PROFILE_CLASS,
+      :max_dispatcher_jobs => MAX_DISPATCHER_JOBS
+    }
+    REQUEST_REGEXP = /^request_/
+    REQUESTS_DESC = { #FIXME: write description for all the request
+      'logout' => 'disconnect from the server',
+      'help' => '[requests...] return all or several request descriptions',
+      'profile' => 'return the session profile'
+    }
+    USRNAME_REGEXP = /^[A-Za-z0-9_]+$/
+    PASSWD_REGEXP = ConstRegexp::CRYPTED_STRING
+    SID_REGEXP = /^[a-f0-9]{16}$/
+
+    #
+    # Constructor
+    #
+    def initialize(opts=OPTS)
+      @nb_requests = 0
+      @opts = opts
+      @mutex = Mutex.new
+      @usrdb = check_usrdb(opts[:usrdb])
+      @max_usr = check_max_usr(opts[:max_usr])
+      @wipeout_delay = check_wipeout_delay(opts[:wipeout_delay])
+      @profile_class = opts[:profile_class]
+      @max_dispatcher_jobs = opts[:max_dispatcher_jobs]
+      @sessions = {}
+      @thread = Thread.new do
+        loop do
+          sleep_time = MIN_WIPEOUT_DELAY
+          @mutex.synchronize { sleep_time = @wipeout_delay }
+          sleep(sleep_time)
+          wipeout
+        end
+      end
+      @detached = false
+    end
+
+    #
+    # Requests
+    #
+    def login(usrname, passwd, uri, *hooks)
+      sid = nil
+      profile = nil
+      @mutex.synchronize do
+        check_usrname(usrname)
+        check_passwd(passwd)
+        usr = authentification(usrname, passwd)
+        if usr.nil?
+          raise(AuthError, "#{usrname}:#{passwd} authentification failed")
+        end
+        hooks.each { |hook| check_hook(hook) }
+        usr_name, usr_desc = usr
+        dispatcher = Dispatcher.new({}, @max_dispatcher_jobs, Client)
+        profile = @profile_class.new(usr_name,
+                                     usr_desc,
+                                     uri,
+                                     dispatcher,
+                                     *hooks)
+        if @sessions.size >= @max_usr and (not profile[:admin])
+          raise(FullError, "server full")
+        end
+        sid = generate_id { |id| @sessions.has_key?(id) }
+        @sessions[sid] = profile
+      end
+      call_all_hooks(sid, profile, :login)
+      sid
+    end
+
+    def request(sid, request, *args, &block)
+      check_sid(sid)
+      profile = nil
+      req_name = nil
+      @mutex.synchronize do
+        profile = get_profile(sid)
+        req_name = check_request(request)
+        check_request_permission(profile, request)
+        @nb_requests += 1
+        profile[:nb_requests] += 1
+      end
+      ret = send(req_name.to_sym, sid, profile, *args, &block)
+      call_allowed_hooks(sid, profile, request, *args)
+      @mutex.synchronize do
+        profile[:last_request_time] = Time.now
+        @nb_requests -= 1
+        profile[:nb_requests] -= 1
+      end
+      ret
+    end
+
+    #
+    # Session-oriented requests
+    #
+    protected
+    def request_logout(sid, profile)
+      @mutex.synchronize { logout(sid, profile) }
+    end
+
+    protected
+    def request_ping(sid, profile, data)
+      data
+    end
+
+    protected
+    def request_help(sid, profile, *args)
+      res = {}
+      args_str = []
+      args.each { |arg| args_str << arg.to_s }
+      protected_methods.each do |meth|
+        meth_str = meth.to_s
+        next unless meth_str =~ REQUEST_REGEXP
+        m = meth_str.sub(REQUEST_REGEXP, '')
+        next if (not args_str.empty?) and (not args_str.include?(m))
+        if REQUESTS_DESC.has_key?(m)
+          res[m] = REQUESTS_DESC[m]
+        else
+          res[m] = 'no description available'
+        end
+      end
+      res
+    end
+
+    protected
+    def request_profile(sid, profile)
+      @mutex.synchronize { profile }
+    end
+
+    protected
+    def request_get_usr_profile(sid, profile, usrname)
+      @mutex.synchronize do
+        @sessions.values.each { |prof| return prof if usrname == prof[:usrname] }
+      end
+      raise(UserError, "`#{usrname}' - not logged user")
+    end
+
+    protected
+    def request_nb_requests(sid, profile)
+      @mutex.synchronize { profile[:nb_requests] }
+    end
+
+    protected
+    def request_total_nb_requests(sid, profile)
+      @mutex.synchronize { @nb_requests }
+    end
+
+    protected
+    def request_add_hook(sid, profile, *hooks)
+      @mutex.synchronize do
+        hooks.each do |hook|
+          check_hook(hook)
+          profile[:hooks] << hook
+        end
+      end
+      nil
+    end
+
+    protected
+    def request_del_hook(sid, profile, hook)
+      @mutex.synchronize { profile[:hooks].delete(hook) }
+    end
+
+    protected
+    def request_rsend(sid, profile, obj, meth, *args)
+      obj.send(meth, *args)
+    end
+
+    protected
+    def request_detach(sid, profile)
+      return if @detached
+      @detached = true
+      if pid = fork # father
+        exit
+      else # son
+        Dir.chdir('/')
+        Process.setsid
+        STDIN.close
+        STDOUT.close
+        STDERR.close
+      end
+    end
+
+    protected
+    def request_chdir(sid, profile, dir)
+      Dir.chdir(dir)
+    end
+
+    protected
+    def request_login_at(sid, profile, uri, *args)
+      @mutex.synchronize { profile.add_client(uri, Client, *args) }
+    end
+
+    protected
+    def request_request_at(sid, profile, uri, request, *args)
+      @mutex.synchronize { client_request(profile, uri, request, *args) }
+    end
+
+    protected
+    def request_logout_at(sid, profile, uri)
+      @mutex.synchronize { client_request(profile, uri, :logout, *args) }
+    end
+
+    protected
+    def request_start_sub_server(sid,
+                                 profile,
+                                 uri,
+                                 server_class=Server,
+                                 *args,
+                                 &block)
+      rd, wr = IO.pipe
+      if pid = fork # father
+        wr.close
+#         Process.detach(pid)
+        res_key, res_value = Marshal.load(rd)
+        rd.close
+        case res_key
+        when :uri
+          request(sid, :login_at, res_value, true)
+          return res_value
+        when :exc
+          Process.waitpid(-1)
+          raise(res_value)
+        else
+          raise(NameError, "`#{res_key}' - bad result key")
+        end
+      else # son
+        rd.close
+        begin
+          DRb.stop_service
+          srv = DRb.start_service(uri, server_class.new(*args))
+          block[srv] if block_given?
+          Marshal.dump([ :uri, srv.uri ], wr)
+          wr.close
+          srv.thread.join
+        rescue Exception => exc
+          data = exc
+          begin
+            Marshal.dump(exc)
+          rescue TypeError
+            data = exc.long_pp
+          end
+          Marshal.dump([ :exc, data ], wr)
+          wr.close
+          exit(1)
+        end
+        exit(0)
+      end
+    end
+
+    protected
+    def request_stop_sub_server(sid, profile, uri)
+      @mutex.synchronize { stop_sub_server(profile, uri) }
+    end
+
+    protected
+    def request_stop_all_sub_server(sid, profile)
+      @mutex.synchronize { stop_all_sub_server(profile) }
+    end
+
+    protected
+    def request_stop(sid, profile)
+      @sessions.dup.each { |id, prof| logout(id, prof) }
+      DRb.stop_service
+    end
+
+    protected
+    def request_pid(sid, profile)
+      Process.pid
+    end
+
+    #
+    # Methods
+    #
+    protected
+    def logout(sid, profile)
+      call_all_hooks(sid, profile, :logout)
+      stop_all_sub_server(profile)
+      @sessions.delete(sid)
+    end
+
+    protected
+    def get_profile(sid)
+      if @sessions[sid].nil?
+        raise(SessionError, "`#{sid}' - not an opened session")
+      end
+      @sessions[sid]
+    end
+
+    protected
+    def authentification(username, passwd)
+      @usrdb.each do |usr_name, usr_desc|
+        if usr_name == username and usr_desc[:passwd] == passwd
+          return usr_name, usr_desc
+        end
+      end
+      return nil
+    end
+
+    protected
+    def wipeout
+      dead = {}
+      @mutex.synchronize do
+        now = Time.now
+        @sessions.each do |sid, profile|
+          if (now - profile[:last_request_time]) > @wipeout_delay
+            dead[sid] = profile
+          end
+        end
+      end
+      dead.each { |sid, profile| request(sid, :logout) }
+      return dead
+    end
+
+    protected
+    def call_all_hooks(sid, profile, meth, *args)
+      hooks = []
+      unless @mutex.locked?
+        @mutex.synchronize do
+          @sessions.each { |id, prof| hooks += prof[:hooks] }
+        end
+      else
+        @sessions.each { |id, prof| hooks += prof[:hooks] }
+      end
+      hooks.each do |hook|
+        handle_dead_hook(hook, sid, profile, meth, *args)
+      end
+    end
+
+    protected
+    def call_allowed_hooks(sid, profile, request, *args)
+      hooks = []
+      @mutex.synchronize do
+        @sessions.each do |id, prof|
+          hooks += prof[:hooks] if prof.allowed_hook?(request)
+        end
+      end
+      hooks.each do |hook|
+        handle_dead_hook(hook, sid, profile, request, *args)
+      end
+    end
+
+    # overload me to handle every hook call
+    protected
+    def handle_dead_hook(hook, sid, profile, meth, *args)
+      nb_retry = 0
+      begin
+        call_hook(hook, sid.dup, profile.dup, meth, *args)
+      rescue DRb::DRbConnError
+        nb_retry += 1
+        retry if nb_retry <= 1
+      end
+    end
+
+    # overload me to handle every hook call
+    protected
+    def call_hook(hook, sid, profile, meth, *args)
+      hook.hook(sid, profile, meth, *args)
+    end
+
+    protected
+    def get_client_at(profile, uri)
+      clt = profile[:dispatcher].select_by(:uri, uri)
+      unless clt.nil? or clt.size == 1
+        raise(SessionError, "`#{uri}' - cannot opened a session at this uri")
+      end
+      clt.first
+    end
+
+    protected
+    def client_request(profile, uri, request, *args)
+      clt = get_client_at(profile, uri)
+      clt.send(request, *args)
+    end
+
+    protected
+    def stop_sub_server(profile, uri)
+      (client_request(profile, uri, :stop)) rescue DRb::DRbConnError
+      profile.del_client(uri)
+      Process.waitpid(-1)
+      $?
+    end
+
+    protected
+    def stop_all_sub_server(profile)
+      profile[:dispatcher].each do |uri, desc|
+        stop_sub_server(profile, uri)
+      end
+    end
+
+    protected
+    def check_sid(sid)
+      unless sid.is_a?(String) and sid =~ SID_REGEXP
+        raise(ParameterError, "`#{sid.inspect}' - bad session id format")
+      end
+      sid
+    end
+
+    protected
+    def check_usrdb(usrdb)
+      usrdb.each do |name, desc|
+        check_usrname(name)
+        check_usrdesc(desc)
+      end
+      usrdb
+    end
+
+    protected
+    def check_usrdesc(desc)
+      unless desc.is_a?(Hash) and desc.size >= 2
+        raise(ParameterError, "`#{desc.inspect}' - bad user description")
+      end
+      check_passwd(desc[:passwd])
+      check_admin(desc[:admin])
+      unless desc[:allowed_requests].nil?
+        check_allowed_requests(desc[:allowed_requests])
+      else
+        desc[:allowed_requests] = []
+      end
+      unless desc[:allowed_hooks].nil?
+        check_allowed_hooks(desc[:allowed_hooks])
+      else
+        desc[:allowed_hooks] = []
+      end
+    end
+
+    protected
+    def check_max_usr(max_usr)
+      unless max_usr.is_a?(Fixnum) and max_usr >= MIN_USR
+        raise(ParameterError, "`#{max_usr.inspect}' - bad max users number")
+      end
+      max_usr
+    end
+
+    protected
+    def check_wipeout_delay(wipeout_delay)
+      unless wipeout_delay.is_a?(Fixnum) and wipeout_delay >= MIN_WIPEOUT_DELAY
+        raise(ParameterError, "`#{wipeout_delay.inspect}' - bad wipeout delay")
+      end
+      @wipeout_delay = wipeout_delay
+    end
+
+    protected
+    def check_request(request)
+      unless request.is_a?(Symbol) and request.to_s =~ ConstRegexp::RB_METHOD
+        raise(ParameterError, "`#{request.inspect}' - bad request format")
+      end
+      req_name = 'request_' + request.to_s
+      unless self.respond_to?(req_name)
+        raise(RequestError, "`#{request.to_s}' - not a request")
+      end
+      req_name
+    end
+
+    protected
+    def check_request_permission(profile, request)
+      if (request != :logout) and (not profile.allowed_request?(request))
+        raise(PermissionError, "`#{request.to_s}' - request not allowed")
+      end
+      request
+    end
+
+    protected
+    def check_usrname(usrname)
+      unless usrname.is_a?(String) and usrname =~ USRNAME_REGEXP
+        raise(ParameterError, "`#{usrname.inspect}' - bad user name format")
+      end
+      usrname
+    end
+
+    protected
+    def check_passwd(passwd)
+      unless passwd.is_a?(String) and passwd =~ PASSWD_REGEXP
+        raise(ParameterError, "`#{passwd.inspect}' - bad password format")
+      end
+      passwd
+    end
+
+    protected
+    def check_allowed_requests(allowed_requests)
+      unless allowed_requests.is_a?(Array)
+        raise(ParameterError,
+              "`#{allowed_requests.inspect}' - bad allowed requests list format")
+      end
+      allowed_requests.each { |r| check_request(r) }
+      allowed_requests
+    end
+
+    protected
+    def check_allowed_hooks(allowed_hooks)
+      unless allowed_hooks.is_a?(Array)
+        raise(ParameterError,
+              "`#{allowed_hooks.inspect}' - bad allowed hooks list format")
+      end
+      allowed_hooks.each { |r| check_request(r) }
+      allowed_hooks
+    end
+
+    protected
+    def check_admin(admin)
+      unless admin.is_a?(TrueClass) or admin.is_a?(FalseClass)
+        raise(ParameterError, "`#{admin.inspect}' - bad admin flag")
+      end
+      admin
+    end
+
+    protected
+    def check_hook(hook)
+      unless hook.respond_to?(:hook)
+        raise(ParameterError, "`#{hook.inspect}' - do not respond to hook")
+      end
+      hook
+    end
+
+  end # class Server
+
+end # module Session