File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby19/lib64/ruby/1.9.1

opt / alt / ruby19 / lib64 / ruby / 1.9.1 /

?? ..
?? English.rb(5.59 KB)
?? abbrev.rb(2.57 KB)
?? base64.rb(2.63 KB)
?? benchmark.rb(18 KB)
?? cgi
?? cgi.rb(9.3 KB)
?? cmath.rb(7.22 KB)
?? complex.rb(380 B)
?? csv.rb(82.66 KB)
?? date
?? date.rb(946 B)
?? debug.rb(23.23 KB)
?? delegate.rb(9.74 KB)
?? digest
?? digest.rb(2.24 KB)
?? dl
?? dl.rb(176 B)
?? drb
?? drb.rb(19 B)
?? e2mmap.rb(3.8 KB)
?? erb.rb(25.72 KB)
?? expect.rb(1.33 KB)
?? fiddle
?? fiddle.rb(928 B)
?? fileutils.rb(45.32 KB)
?? find.rb(2.03 KB)
?? forwardable.rb(7.64 KB)
?? getoptlong.rb(15.38 KB)
?? gserver.rb(8.83 KB)
?? ipaddr.rb(24.92 KB)
?? irb
?? irb.rb(8.34 KB)
?? json
?? json.rb(1.74 KB)
?? kconv.rb(5.74 KB)
?? logger.rb(20.85 KB)
?? mathn.rb(6.52 KB)
?? matrix
?? matrix.rb(47.65 KB)
?? mkmf.rb(68.9 KB)
?? monitor.rb(6.94 KB)
?? mutex_m.rb(1.61 KB)
?? net
?? observer.rb(5.69 KB)
?? open-uri.rb(25.84 KB)
?? open3.rb(20.64 KB)
?? openssl
?? openssl.rb(547 B)
?? optparse
?? optparse.rb(51.13 KB)
?? ostruct.rb(6.49 KB)
?? pathname.rb(14.21 KB)
?? pp.rb(13.31 KB)
?? prettyprint.rb(9.63 KB)
?? prime.rb(13.98 KB)
?? profile.rb(205 B)
?? profiler.rb(1.59 KB)
?? pstore.rb(15.81 KB)
?? psych
?? psych.rb(9.82 KB)
?? racc
?? rake
?? rake.rb(2.02 KB)
?? rational.rb(308 B)
?? rbconfig
?? rdoc
?? rdoc.rb(4.29 KB)
?? resolv-replace.rb(1.74 KB)
?? resolv.rb(59.91 KB)
?? rexml
?? rinda
?? ripper
?? ripper.rb(91 B)
?? rss
?? rss.rb(2.84 KB)
?? rubygems
?? rubygems.rb(34.13 KB)
?? scanf.rb(23.53 KB)
?? securerandom.rb(8.46 KB)
?? set.rb(29.91 KB)
?? shell
?? shell.rb(5.9 KB)
?? shellwords.rb(3.88 KB)
?? singleton.rb(4.02 KB)
?? socket.rb(23.22 KB)
?? syck
?? syck.rb(13.91 KB)
?? sync.rb(6.87 KB)
?? tempfile.rb(10.42 KB)
?? test
?? thread.rb(6.59 KB)
?? thwait.rb(3.38 KB)
?? time.rb(17.03 KB)
?? timeout.rb(3.26 KB)
?? tmpdir.rb(3.72 KB)
?? tracer.rb(6.63 KB)
?? tsort.rb(6.79 KB)
?? ubygems.rb(268 B)
?? un.rb(8.32 KB)
?? uri
?? uri.rb(3.07 KB)
?? weakref.rb(2.29 KB)
?? webrick
?? webrick.rb(6.8 KB)
?? x86_64-linux
?? xmlrpc
?? yaml
?? yaml.rb(2.58 KB)

Editing: sync.rb

#
#   sync.rb - 2 phase lock with counter
#       $Release Version: 1.0$
#       $Revision: 32281 $
#       by Keiju ISHITSUKA(keiju@ishitsuka.com)
#
# --
#  Sync_m, Synchronizer_m
#  Usage:
#   obj.extend(Sync_m)
#   or
#   class Foo
#       include Sync_m
#       :
#   end
#
#   Sync_m#sync_mode
#   Sync_m#sync_locked?, locked?
#   Sync_m#sync_shared?, shared?
#   Sync_m#sync_exclusive?, sync_exclusive?
#   Sync_m#sync_try_lock, try_lock
#   Sync_m#sync_lock, lock
#   Sync_m#sync_unlock, unlock
#
#  Sync, Synchronizer:
#  Usage:
#   sync = Sync.new
#
#   Sync#mode
#   Sync#locked?
#   Sync#shared?
#   Sync#exclusive?
#   Sync#try_lock(mode) -- mode = :EX, :SH, :UN
#   Sync#lock(mode)     -- mode = :EX, :SH, :UN
#   Sync#unlock
#   Sync#synchronize(mode) {...}
#
#

unless defined? Thread
  raise "Thread not available for this ruby interpreter"
end

##
# A module that provides a two-phase lock with a counter.

module Sync_m
  RCS_ID='-$Id: sync.rb 32281 2011-06-29 03:09:34Z drbrain $-'

# lock mode
  UN = :UN
  SH = :SH
  EX = :EX

# exceptions
  class Err < StandardError
    def Err.Fail(*opt)
      fail self, sprintf(self::Message, *opt)
    end

class UnknownLocker < Err
      Message = "Thread(%s) not locked."
      def UnknownLocker.Fail(th)
        super(th.inspect)
      end
    end

class LockModeFailer < Err
      Message = "Unknown lock mode(%s)"
      def LockModeFailer.Fail(mode)
        if mode.id2name
          mode = id2name
        end
        super(mode)
      end
    end
  end

def Sync_m.define_aliases(cl)
    cl.module_eval %q{
      alias locked? sync_locked?
      alias shared? sync_shared?
      alias exclusive? sync_exclusive?
      alias lock sync_lock
      alias unlock sync_unlock
      alias try_lock sync_try_lock
      alias synchronize sync_synchronize
    }
  end

def Sync_m.append_features(cl)
    super
    # do nothing for Modules
    # make aliases for Classes.
    define_aliases(cl) unless cl.instance_of?(Module)
    self
  end

def Sync_m.extend_object(obj)
    super
    obj.sync_extend
  end

def sync_extend
    unless (defined? locked? and
            defined? shared? and
            defined? exclusive? and
            defined? lock and
            defined? unlock and
            defined? try_lock and
            defined? synchronize)
      Sync_m.define_aliases(singleton_class)
    end
    sync_initialize
  end

# accessing
  def sync_locked?
    sync_mode != UN
  end

def sync_shared?
    sync_mode == SH
  end

def sync_exclusive?
    sync_mode == EX
  end

# locking methods.
  def sync_try_lock(mode = EX)
    return unlock if mode == UN
    @sync_mutex.synchronize do
      sync_try_lock_sub(mode)
    end
  end

def sync_lock(m = EX)
    return unlock if m == UN

while true
      @sync_mutex.synchronize do
        if sync_try_lock_sub(m)
          return self
        else
          if sync_sh_locker[Thread.current]
            sync_upgrade_waiting.push [Thread.current, sync_sh_locker[Thread.current]]
            sync_sh_locker.delete(Thread.current)
          else
            sync_waiting.push Thread.current
          end
          @sync_mutex.sleep
        end
      end
    end
    self
  end

def sync_unlock(m = EX)
    wakeup_threads = []
    @sync_mutex.synchronize do
      if sync_mode == UN
        Err::UnknownLocker.Fail(Thread.current)
      end

m = sync_mode if m == EX and sync_mode == SH

runnable = false
      case m
      when UN
        Err::UnknownLocker.Fail(Thread.current)

when EX
        if sync_ex_locker == Thread.current
          if (self.sync_ex_count = sync_ex_count - 1) == 0
            self.sync_ex_locker = nil
            if sync_sh_locker.include?(Thread.current)
              self.sync_mode = SH
            else
              self.sync_mode = UN
            end
            runnable = true
          end
        else
          Err::UnknownLocker.Fail(Thread.current)
        end

when SH
        if (count = sync_sh_locker[Thread.current]).nil?
          Err::UnknownLocker.Fail(Thread.current)
        else
          if (sync_sh_locker[Thread.current] = count - 1) == 0
            sync_sh_locker.delete(Thread.current)
            if sync_sh_locker.empty? and sync_ex_count == 0
              self.sync_mode = UN
              runnable = true
            end
          end
        end
      end

if runnable
        if sync_upgrade_waiting.size > 0
          th, count = sync_upgrade_waiting.shift
          sync_sh_locker[th] = count
          th.wakeup
          wakeup_threads.push th
        else
          wait = sync_waiting
          self.sync_waiting = []
          for th in wait
            th.wakeup
            wakeup_threads.push th
          end
        end
      end
    end
    for th in wakeup_threads
      th.run
    end
    self
  end

def sync_synchronize(mode = EX)
    sync_lock(mode)
    begin
      yield
    ensure
      sync_unlock
    end
  end

attr_accessor :sync_mode

attr_accessor :sync_waiting
  attr_accessor :sync_upgrade_waiting
  attr_accessor :sync_sh_locker
  attr_accessor :sync_ex_locker
  attr_accessor :sync_ex_count

def sync_inspect
    sync_iv = instance_variables.select{|iv| /^@sync_/ =~ iv.id2name}.collect{|iv| iv.id2name + '=' + instance_eval(iv.id2name).inspect}.join(",")
    print "<#{self.class}.extend Sync_m: #{inspect}, <Sync_m: #{sync_iv}>"
  end

private

def sync_initialize
    @sync_mode = UN
    @sync_waiting = []
    @sync_upgrade_waiting = []
    @sync_sh_locker = Hash.new
    @sync_ex_locker = nil
    @sync_ex_count = 0

@sync_mutex = Mutex.new
  end

def initialize(*args)
    super
    sync_initialize
  end

def sync_try_lock_sub(m)
    case m
    when SH
      case sync_mode
      when UN
        self.sync_mode = m
        sync_sh_locker[Thread.current] = 1
        ret = true
      when SH
        count = 0 unless count = sync_sh_locker[Thread.current]
        sync_sh_locker[Thread.current] = count + 1
        ret = true
      when EX
        # in EX mode, lock will upgrade to EX lock
        if sync_ex_locker == Thread.current
          self.sync_ex_count = sync_ex_count + 1
          ret = true
        else
          ret = false
        end
      end
    when EX
      if sync_mode == UN or
          sync_mode == SH && sync_sh_locker.size == 1 && sync_sh_locker.include?(Thread.current)
        self.sync_mode = m
        self.sync_ex_locker = Thread.current
        self.sync_ex_count = 1
        ret = true
      elsif sync_mode == EX && sync_ex_locker == Thread.current
        self.sync_ex_count = sync_ex_count + 1
        ret = true
      else
        ret = false
      end
    else
      Err::LockModeFailer.Fail mode
    end
    return ret
  end
end

##
# An alias for Sync_m from sync.rb

Synchronizer_m = Sync_m

##
# A class that providesa two-phase lock with a counter.  See Sync_m for
# details.

class Sync
  include Sync_m
end

##
# An alias for Sync from sync.rb.  See Sync_m for details.

Synchronizer = Sync

X7ROOT File Manager

Editing: sync.rb

Upload File

Create Folder