vcs 0.2.148 → 0.3.0

data/ruby_ex/session/hookable.rb

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

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

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