ttk 0.1.580 → 0.2.0

data/ruby_ex/session/administrable.rb

@@ -1,120 +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: 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

@@ -1,153 +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: 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

@@ -1,18 +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: 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

@@ -1,184 +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: 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
-
-