ttk 0.1.576

data/ruby_ex/session/administrable.rb

@@ -0,0 +1,120 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: administrable.rb 67 2004-12-07 01:00:10Z polrop $
+
+
+require 'session/server'
+
+
+module Session
+
+  module Administrable
+
+    #
+    # Sessions-oriented requests
+    #
+    protected
+    def request_sessions(sid, profile)
+      @mutex.synchronize { @sessions }
+    end
+
+    protected
+    def request_kick(sid, profile, sid_to_kick)
+      prof = nil
+      @mutex.synchronize do
+        prof = get_profile(sid_to_kick).dup
+        if prof[:admin]
+          raise(Session::PermissionError,
+                "`#{sid_to_kick}' - cannot kick an admin session")
+        end
+      end
+      request(sid_to_kick, :logout)
+    end
+
+    protected
+    def request_add_usr(sid, profile, usrname, usrdesc)
+      @mutex.synchronize do
+        check_usrname(usrname)
+        check_usrdesc(usrdesc)
+        if @usrdb[usrname].nil?
+          @usrdb[usrname] = usrdesc
+        else
+          raise(Session::UserError, "`#{usrname}' - user already registered")
+        end
+        usrdesc
+      end
+    end
+
+    protected
+    def request_del_usr(sid, profile, usrname)
+      @mutex.synchronize do
+        usrdesc = get_usr_desc(usrname)
+        if usrdesc[:admin]
+          raise(Session::UserError, "`#{usrname}' - cannot delete admin user")
+        end
+        @usrdb.delete(usrname)
+      end
+    end
+
+    protected
+    def request_get_usr_desc(sid, profile, usrname)
+      @mutex.synchronize { get_usr_desc(check_usrname(usrname)) }
+    end
+
+    protected
+    def request_set_usr_desc(sid, profile, usrname, usrdesc)
+      @mutex.synchronize do
+        check_usrdesc(usrdesc)
+        get_usr_desc(usrname)
+        @usrdb[usrname] = usrdesc
+      end
+    end
+
+    protected
+    def request_set_usrdb(sid, profile, usrdb)
+      @mutex.synchronize { @usrdb = check_usrdb(usrdb) }
+    end
+
+    protected
+    def request_get_usrdb(sid, profile)
+      @mutex.synchronize { @usrdb }
+    end
+
+    protected
+    def request_set_max_usr(sid, profile, max_usr)
+      @mutex.synchronize { @max_usr = check_max_usr(max_usr) }
+    end
+
+    protected
+    def request_get_max_usr(sid, profile)
+      @mutex.synchronize { @max_usr }
+    end
+
+    protected
+    def request_set_wipeout_delay(sid, profile, wipeout_delay)
+      @mutex.synchronize { @wipeout_delay = check_wipeout_delay(wipeout_delay) }
+    end
+
+    protected
+    def request_get_wipeout_delay(sid, profile)
+      @mutex.synchronize { @wipeout_delay }
+    end
+
+    #
+    # Methods
+    #
+    protected
+    def get_usr_desc(usrname)
+      usrdesc = @usrdb[usrname]
+      if usrdesc.nil?
+        raise(Session::UserError, "`#{usrname}' - not a registered user")
+      end
+      usrdesc
+    end
+
+  end # module Administrable
+
+end # module Session

data/ruby_ex/session/client.rb

@@ -0,0 +1,153 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: client.rb 67 2004-12-07 01:00:10Z polrop $
+
+
+require 'drb'
+
+require 'session/const'
+require 'session/hookable'
+require 'session/profile'
+require 'const_regexp'
+
+
+module Session
+
+  class Client
+    include Hookable
+
+    #
+    # Constants
+    #
+    URI = 'druby://localhost:42000'
+    USRNAME = 'guest'
+    PASSWD = 'guest'.crypt(Const::SALT_KEY)
+
+    #
+    # Attributs
+    #
+    attr_reader :sid, :uri, :protocol, :hostname, :port, :usrname, :passwd,
+                :local_uri, :force_login
+
+    #
+    # Constructor
+    #
+    def initialize(uri=URI,
+                   usrname=USRNAME,
+                   passwd=PASSWD,
+                   force_login=false,
+                   *hooks)
+      unless force_login.is_a?(TrueClass) or force_login.is_a?(FalseClass)
+        raise(ArgumentError, 'force_login must be a boolean')
+      end
+      hooks.each do |hook|
+        unless hook.respond_to?(:hook)
+          raise(ArgumentError, 'hookable object must respond to hook')
+        end
+      end
+      self.uri = uri
+      @usrname = usrname
+      @passwd = passwd
+      @force_login = force_login
+      @hooks = hooks
+      @srv = nil
+      @sid = nil
+      @online = false
+      @local_nb_requests = 0
+      @online_mutex = Mutex.new
+      @local_logout_mutex = Mutex.new
+      login if @force_login
+    end
+
+    #
+    # Methods
+    #
+    def uri=(uri)
+      @uri = uri
+      @protocol, @hostname, @port = Profile.parse_uri(uri)
+    end
+
+    def online?
+      @online_mutex.synchronize { @online }
+    end
+
+    def login
+      @online_mutex.synchronize do
+        return true if @online
+        start_service
+        begin
+          @sid = @srv_front.login(@usrname, @passwd, DRb.uri, self, *@hooks)
+        rescue Exception
+          stop_service
+          raise
+        end
+        @online = true
+        @local_nb_requests = 0
+      end
+    end
+
+    def logout
+      @online_mutex.synchronize do
+        return true unless @online
+        @srv_front.request(@sid, :logout)
+        local_logout
+        true
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      request(meth, *args, &block)
+    end
+
+    def request(meth, *args, &block)
+      login
+      @online_mutex.synchronize { @local_nb_requests += 1 }
+      result = @srv_front.request(@sid, meth, *args, &block)
+      @online_mutex.synchronize { @local_nb_requests -= 1 }
+      result
+    end
+
+    # sid equal @sid when I'm loging out.
+    protected
+    def hook_logout(sid, profile)
+      local_logout if sid == @sid
+    end
+
+    # sid equal nil when I'm loging in.
+    protected
+    def hook_login(sid, profile)
+    end
+
+    protected
+    def local_logout
+      @local_logout_mutex.synchronize do
+        @online = false
+        @sid = nil
+        @local_nb_requests = 0
+      end
+    end
+
+    protected
+    def start_service
+      stop_service unless @srv.nil?
+      @srv = DRb.start_service
+      @srv_front = DRbObject.new(nil, @uri)
+      @local_uri = @srv.uri
+    end
+
+    protected
+    def stop_service
+      @srv.stop_service
+      @srv_front = nil
+      @local_uri = nil
+      @srv = nil
+    end
+
+  end # Client
+
+end # module Session
+
+

data/ruby_ex/session/const.rb

@@ -0,0 +1,18 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: const.rb 64 2004-12-06 13:28:14Z polrop $
+
+
+module Session
+
+  module Const
+
+    SALT_KEY = 'ab'
+
+  end # module Const
+
+end # module Session
+

data/ruby_ex/session/dispatcher.rb

@@ -0,0 +1,184 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: dispatcher.rb 186 2005-04-03 00:07:45Z ertai $
+
+
+require 'drb'
+
+require 'session/client'
+
+
+module Session
+
+  class Dispatcher
+    include DRb::DRbUndumped
+
+    #
+    # Constants
+    #
+    MAX_JOBS = 5
+    MAX_JOBS_LIMIT = 100
+    SRVDB = {
+      'druby://localhost:42000' => {
+        :usrname => 'guest',
+        :passwd => 'guest'.crypt(Const::SALT_KEY)
+      }
+    }
+    BASE_CLIENT_CLASS = Client
+
+    #
+    # Attributes
+    #
+    attr_reader :max_jobs
+
+    #
+    # Constructor
+    #
+    def initialize(srvdb=SRVDB,
+                   max_jobs=MAX_JOBS,
+                   client_class=BASE_CLIENT_CLASS,
+                   *args)
+      unless 1 <= max_jobs && max_jobs <= MAX_JOBS_LIMIT
+        raise(ArgumentError,
+              "`#{max_jobs}' - too big max jobs (must be <= #{MAX_JOBS_LIMIT})")
+      end
+      @max_jobs = max_jobs
+      @srvdb = {}
+      srvdb.each do |uri, srv|
+        add(uri, srv[:usrname], srv[:passwd], client_class, *args)
+      end
+    end
+
+    def dispatch(clts, request, *args, &block)
+      mutex = Mutex.new
+      threads = []
+      nb_threads = [ clts.size, @max_jobs].min
+      clts_q = clts.dup
+      result = {}
+      nb_threads.times do
+        threads << Thread.new do
+          loop do
+            clt = mutex.synchronize { clts_q.shift }
+            break if clt.nil?
+            res = request(clt, request, *args, &block)
+            mutex.synchronize { result.update(res) }
+          end
+        end
+      end
+      threads.each { |thread| thread.join }
+      result
+    end
+
+    alias update dispatch
+
+    def select(&comp)
+      clts = []
+      each_client { |uri, clt| clts << clt if comp[clt] }
+      clts
+    end
+
+    def select_all
+      select { |clt| true }
+    end
+
+    def select_by(attr, value)
+      select { |clt| test_client_attribut(clt, attr, value) }
+    end
+
+    def multi_select_by(hash, init_val=true, &bool_fun)
+      select do |clt|
+        ret = init_val
+        hash.each do |k, v|
+          ret = bool_fun[ret, test_client_attribut(clt, k, v)]
+        end
+        ret
+      end
+    end
+
+    def and_multi_select_by(hash)
+      select do |clt|
+        ret = true
+        hash.each do |k, v|
+          ret = (ret and test_client_attribut(clt, k, v))
+        end
+        ret
+      end
+    end
+
+    def or_multi_select_by(hash)
+      select do |clt|
+        ret = false
+        hash.each { |k, v| ret = (ret or test_client_attribut(clt, k, v)) }
+        ret
+      end
+    end
+
+    def dispatch_all(request, *args, &block)
+      dispatch(select_all, request, *args, &block)
+    end
+
+    def method_missing(request, *args, &block)
+      dispatch_all(request, *args, &block)
+    end
+
+    # overload me
+    def choose(clients)
+      raise(NotImplementedError, "`choose' - not implemented at this level")
+    end
+
+    def choose_and_select(&block)
+      choose(select(&block))
+    end
+
+    def each
+      @srvdb.each { |uri, desc| yield(uri, desc) }
+    end
+
+    def each_client
+      @srvdb.each { |uri, desc| yield(uri, desc[:client]) }
+    end
+
+    def [](uri)
+      @srvdb[uri]
+    end
+
+    def add(uri, usrname, passwd, client_class, *args)
+      return nil if @srvdb[uri]
+      @srvdb[uri] = {
+        :usrname => usrname,
+        :passwd => passwd,
+        :client => client_class.new(uri, usrname, passwd, *args)
+      }
+    end
+
+    def del(uri)
+      @srvdb.delete(uri)
+    end
+
+    def request(clt, request, *args, &block)
+      res = nil
+      begin
+        res = clt.send(request, *args, &block)
+      rescue Exception => err
+        res = err
+      end
+      { clt.uri => res }
+    end
+
+    protected
+    def test_client_attribut(clt, attr, value)
+      if value.is_a? Regexp
+        clt.send(attr).to_s =~ value
+      else
+        clt.send(attr) == value
+      end
+    end
+
+  end # module Dispatcher
+
+end # module Session
+
+