librex 0.0.68 → 0.0.70

data/lib/rex/job_container.rb

@@ -8,90 +8,90 @@ module Rex
 ###
 class Job
 
-	#
-	# Creates an individual job instance and initializes it with the supplied
-	# parameters.
-	#
-	def initialize(container, jid, name, ctx, run_proc, clean_proc)
-		self.container  = container
-		self.jid        = jid
-		self.name       = name
-		self.run_proc   = run_proc
-		self.clean_proc = clean_proc
-		self.ctx        = ctx
-		self.start_time = nil
-	end
-
-	#
-	# Runs the job in the context of its own thread if the async flag is false.
-	# Otherwise, the job is run inline.
-	#
-	def start(async = false)
-		self.start_time = Time.now
-		if (async)
-			self.job_thread = Rex::ThreadFactory.spawn("JobID(#{jid})-#{name}", false) {
-				# Deschedule our thread momentarily
-				::IO.select(nil, nil, nil, 0.01)
-
-				begin
-					run_proc.call(ctx)
-				ensure
-					clean_proc.call(ctx)
-					container.remove_job(self)
-				end
-			}
-		else
-			begin
-				run_proc.call(ctx)
-			rescue ::Exception
-				container.stop_job(jid)
-				raise $!
-			end
-		end
-	end
-
-	#
-	# Stops the job if it's currently running and calls its cleanup procedure
-	#
-	def stop
-		if (self.job_thread)
-			self.job_thread.kill
-			self.job_thread = nil
-		end
-
-		clean_proc.call(ctx) if (clean_proc)
-	end
-
-	#
-	# The name of the job.
-	#
-	attr_reader :name
-
-	#
-	# The job identifier as assigned by the job container.
-	#
-	attr_reader :jid
-
-	#
-	# The time at which this job was started.
-	#
-	attr_reader :start_time
-
-	#
-	# Some job context.
-	#
-	attr_reader :ctx
+  #
+  # Creates an individual job instance and initializes it with the supplied
+  # parameters.
+  #
+  def initialize(container, jid, name, ctx, run_proc, clean_proc)
+    self.container  = container
+    self.jid        = jid
+    self.name       = name
+    self.run_proc   = run_proc
+    self.clean_proc = clean_proc
+    self.ctx        = ctx
+    self.start_time = nil
+  end
+
+  #
+  # Runs the job in the context of its own thread if the async flag is false.
+  # Otherwise, the job is run inline.
+  #
+  def start(async = false)
+    self.start_time = Time.now
+    if (async)
+      self.job_thread = Rex::ThreadFactory.spawn("JobID(#{jid})-#{name}", false) {
+        # Deschedule our thread momentarily
+        ::IO.select(nil, nil, nil, 0.01)
+
+        begin
+          run_proc.call(ctx)
+        ensure
+          clean_proc.call(ctx)
+          container.remove_job(self)
+        end
+      }
+    else
+      begin
+        run_proc.call(ctx)
+      rescue ::Exception
+        container.stop_job(jid)
+        raise $!
+      end
+    end
+  end
+
+  #
+  # Stops the job if it's currently running and calls its cleanup procedure
+  #
+  def stop
+    if (self.job_thread)
+      self.job_thread.kill
+      self.job_thread = nil
+    end
+
+    clean_proc.call(ctx) if (clean_proc)
+  end
+
+  #
+  # The name of the job.
+  #
+  attr_reader :name
+
+  #
+  # The job identifier as assigned by the job container.
+  #
+  attr_reader :jid
+
+  #
+  # The time at which this job was started.
+  #
+  attr_reader :start_time
+
+  #
+  # Some job context.
+  #
+  attr_reader :ctx
 
 protected
 
-	attr_writer   :name #:nodoc:
-	attr_writer   :jid #:nodoc:
-	attr_accessor :job_thread #:nodoc:
-	attr_accessor :container #:nodoc:
-	attr_accessor :run_proc #:nodoc:
-	attr_accessor :clean_proc #:nodoc:
-	attr_writer   :ctx #:nodoc:
-	attr_writer   :start_time #:nodoc:
+  attr_writer   :name #:nodoc:
+  attr_writer   :jid #:nodoc:
+  attr_accessor :job_thread #:nodoc:
+  attr_accessor :container #:nodoc:
+  attr_accessor :run_proc #:nodoc:
+  attr_accessor :clean_proc #:nodoc:
+  attr_writer   :ctx #:nodoc:
+  attr_writer   :start_time #:nodoc:
 
 end
 
@@ -105,94 +105,94 @@ end
 ###
 class JobContainer < Hash
 
-	def initialize
-		self.job_id_pool = 0
-	end
-
-	#
-	# Adds an already running task as a symbolic job to the container.
-	#
-	def add_job(name, ctx, run_proc, clean_proc)
-		real_name = name
-		count     = 0
-		jid       = job_id_pool
-
-		self.job_id_pool += 1
-
-		# If we were not supplied with a job name, pick one from the hat
-		if (real_name == nil)
-			real_name = '#' + jid.to_s
-		end
-
-		# Find a unique job name
-		while (j = self[real_name])
-			real_name  = name + " #{count}"
-			count     += 1
-		end
-
-		j = Job.new(self, jid, real_name, ctx, run_proc, clean_proc)
-
-		self[jid.to_s] = j
-	end
-
-	#
-	# Starts a job using the supplied name and run/clean procedures.
-	#
-	def start_job(name, ctx, run_proc, clean_proc = nil)
-		j = add_job(name, ctx, run_proc, clean_proc)
-		j.start
-
-		j.jid
-	end
-
-	#
-	# Starts a background job that doesn't call the cleanup routine or run
-	# the run_proc in its own thread.  Rather, the run_proc is called
-	# immediately and the clean_proc is never called until the job is removed
-	# from the job container.
-	#
-	def start_bg_job(name, ctx, run_proc, clean_proc = nil, async = true)
-		j = add_job(name, ctx, run_proc, clean_proc)
-		j.start(async)
-
-		j.jid
-	end
-
-	#
-	# Stops the job with the supplied name and forces it to cleanup.  Stopping
-	# the job also leads to its removal.
-	#
-	def stop_job(jid)
-		if (j = self[jid.to_s])
-			j.stop
-
-			remove_job(j)
-		end
-	end
-
-	#
-	# Removes a job that was previously running.  This is typically called when
-	# a job completes its task.
-	#
-	def remove_job(inst)
-		self.delete(inst.jid.to_s)
-	end
-
-	#
-	# Overrides the builtin 'each' operator to avoid the following exception on Ruby 1.9.2+
-	#    "can't add a new key into hash during iteration"
-	#
-	def each(&block)
-		list = []
-		self.keys.sort.each do |sidx|
-			list << [sidx, self[sidx]]
-		end
-		list.each(&block)
-	end
-	
+  def initialize
+    self.job_id_pool = 0
+  end
+
+  #
+  # Adds an already running task as a symbolic job to the container.
+  #
+  def add_job(name, ctx, run_proc, clean_proc)
+    real_name = name
+    count     = 0
+    jid       = job_id_pool
+
+    self.job_id_pool += 1
+
+    # If we were not supplied with a job name, pick one from the hat
+    if (real_name == nil)
+      real_name = '#' + jid.to_s
+    end
+
+    # Find a unique job name
+    while (j = self[real_name])
+      real_name  = name + " #{count}"
+      count     += 1
+    end
+
+    j = Job.new(self, jid, real_name, ctx, run_proc, clean_proc)
+
+    self[jid.to_s] = j
+  end
+
+  #
+  # Starts a job using the supplied name and run/clean procedures.
+  #
+  def start_job(name, ctx, run_proc, clean_proc = nil)
+    j = add_job(name, ctx, run_proc, clean_proc)
+    j.start
+
+    j.jid
+  end
+
+  #
+  # Starts a background job that doesn't call the cleanup routine or run
+  # the run_proc in its own thread.  Rather, the run_proc is called
+  # immediately and the clean_proc is never called until the job is removed
+  # from the job container.
+  #
+  def start_bg_job(name, ctx, run_proc, clean_proc = nil, async = true)
+    j = add_job(name, ctx, run_proc, clean_proc)
+    j.start(async)
+
+    j.jid
+  end
+
+  #
+  # Stops the job with the supplied name and forces it to cleanup.  Stopping
+  # the job also leads to its removal.
+  #
+  def stop_job(jid)
+    if (j = self[jid.to_s])
+      j.stop
+
+      remove_job(j)
+    end
+  end
+
+  #
+  # Removes a job that was previously running.  This is typically called when
+  # a job completes its task.
+  #
+  def remove_job(inst)
+    self.delete(inst.jid.to_s)
+  end
+
+  #
+  # Overrides the builtin 'each' operator to avoid the following exception on Ruby 1.9.2+
+  #    "can't add a new key into hash during iteration"
+  #
+  def each(&block)
+    list = []
+    self.keys.sort.each do |sidx|
+      list << [sidx, self[sidx]]
+    end
+    list.each(&block)
+  end
+
 protected
 
-	attr_accessor :job_id_pool # :nodoc:
+  attr_accessor :job_id_pool # :nodoc:
 
 end
 

data/lib/rex/logging.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/constants' # for LEV_'s

data/lib/rex/logging/log_dispatcher.rb

@@ -14,105 +14,105 @@ module Logging
 ###
 class LogDispatcher
 
-	#
-	# Creates the global log dispatcher instance and initializes it for use.
-	#
-	def initialize()
-		self.log_sinks      = {}
-		self.log_levels     = {}
-		self.log_sinks_lock = Mutex.new
-	end
-
-	#
-	# Returns the sink that is associated with the supplied source.
-	#
-	def [](src)
-		sink = nil
-
-		log_sinks_lock.synchronize {
-			sink = log_sinks[src]
-		}
-
-		return sink
-	end
-
-	#
-	# Calls the source association routie.
-	#
-	def []=(src, sink)
-		store(src, sink)
-	end
-
-	#
-	# Associates the supplied source with the supplied sink.  If a log level
-	# has already been defined for the source, the level argument is ignored.
-	# Use set_log_level to alter it.
-	#
-	def store(src, sink, level = 0)
-		log_sinks_lock.synchronize {
-			if (log_sinks[src] == nil)
-				log_sinks[src] = sink
-
-				set_log_level(src, level) if (log_levels[src] == nil)
-			else
-				raise(
-					RuntimeError,
-					"The supplied log source #{src} is already registered.",
-					caller)
-			end
-		}
-	end
-
-	#
-	# Removes a source association if one exists.
-	#
-	def delete(src)
-		sink = nil
-
-		log_sinks_lock.synchronize {
-			sink = log_sinks[src]
-
-			log_sinks.delete(src)
-		}
-
-		if (sink)
-			sink.cleanup
-
-			return true
-		end
-
-		return false
-	end
-
-	#
-	# Performs the actual log operation against the supplied source
-	#
-	def log(sev, src, level, msg, from)
-		log_sinks_lock.synchronize {
-			if ((sink = log_sinks[src]))
-				next if (log_levels[src] and level > log_levels[src])
-
-				sink.log(sev, src, level, msg, from)
-			end
-		}
-	end
-
-	#
-	# This method sets the log level threshold for a given source.
-	#
-	def set_level(src, level)
-		log_levels[src] = level.to_i
-	end
-
-	#
-	# This method returns the log level threshold of a given source.
-	#
-	def get_level(src)
-		log_levels[src]
-	end
-
-	attr_accessor :log_sinks, :log_sinks_lock # :nodoc:
-	attr_accessor :log_levels # :nodoc:
+  #
+  # Creates the global log dispatcher instance and initializes it for use.
+  #
+  def initialize()
+    self.log_sinks      = {}
+    self.log_levels     = {}
+    self.log_sinks_lock = Mutex.new
+  end
+
+  #
+  # Returns the sink that is associated with the supplied source.
+  #
+  def [](src)
+    sink = nil
+
+    log_sinks_lock.synchronize {
+      sink = log_sinks[src]
+    }
+
+    return sink
+  end
+
+  #
+  # Calls the source association routie.
+  #
+  def []=(src, sink)
+    store(src, sink)
+  end
+
+  #
+  # Associates the supplied source with the supplied sink.  If a log level
+  # has already been defined for the source, the level argument is ignored.
+  # Use set_log_level to alter it.
+  #
+  def store(src, sink, level = 0)
+    log_sinks_lock.synchronize {
+      if (log_sinks[src] == nil)
+        log_sinks[src] = sink
+
+        set_log_level(src, level) if (log_levels[src] == nil)
+      else
+        raise(
+          RuntimeError,
+          "The supplied log source #{src} is already registered.",
+          caller)
+      end
+    }
+  end
+
+  #
+  # Removes a source association if one exists.
+  #
+  def delete(src)
+    sink = nil
+
+    log_sinks_lock.synchronize {
+      sink = log_sinks[src]
+
+      log_sinks.delete(src)
+    }
+
+    if (sink)
+      sink.cleanup
+
+      return true
+    end
+
+    return false
+  end
+
+  #
+  # Performs the actual log operation against the supplied source
+  #
+  def log(sev, src, level, msg, from)
+    log_sinks_lock.synchronize {
+      if ((sink = log_sinks[src]))
+        next if (log_levels[src] and level > log_levels[src])
+
+        sink.log(sev, src, level, msg, from)
+      end
+    }
+  end
+
+  #
+  # This method sets the log level threshold for a given source.
+  #
+  def set_level(src, level)
+    log_levels[src] = level.to_i
+  end
+
+  #
+  # This method returns the log level threshold of a given source.
+  #
+  def get_level(src)
+    log_levels[src]
+  end
+
+  attr_accessor :log_sinks, :log_sinks_lock # :nodoc:
+  attr_accessor :log_levels # :nodoc:
 end
 
 end
@@ -131,49 +131,49 @@ end
 ExceptionCallStack = "__EXCEPTCALLSTACK__"
 
 def dlog(msg, src = 'core', level = 0, from = caller)
-	$dispatcher.log(LOG_DEBUG, src, level, msg, from)
+  $dispatcher.log(LOG_DEBUG, src, level, msg, from)
 end
 
 def elog(msg, src = 'core', level = 0, from = caller)
-	$dispatcher.log(LOG_ERROR, src, level, msg, from)
+  $dispatcher.log(LOG_ERROR, src, level, msg, from)
 end
 
 def wlog(msg, src = 'core', level = 0, from = caller)
-	$dispatcher.log(LOG_WARN, src, level, msg, from)
+  $dispatcher.log(LOG_WARN, src, level, msg, from)
 end
 
 def ilog(msg, src = 'core', level = 0, from = caller)
-	$dispatcher.log(LOG_INFO, src, level, msg, from)
+  $dispatcher.log(LOG_INFO, src, level, msg, from)
 end
 
 def rlog(msg, src = 'core', level = 0, from = caller)
-	if (msg == ExceptionCallStack)
-		msg = "\nCall stack:\n" + $@.join("\n") + "\n"
-	end
+  if (msg == ExceptionCallStack)
+    msg = "\nCall stack:\n" + $@.join("\n") + "\n"
+  end
 
-	$dispatcher.log(LOG_RAW, src, level, msg, from)
+  $dispatcher.log(LOG_RAW, src, level, msg, from)
 end
 
 def log_source_registered?(src)
-	($dispatcher[src] != nil)
+  ($dispatcher[src] != nil)
 end
 
 def register_log_source(src, sink, level = nil)
-	$dispatcher[src] = sink
+  $dispatcher[src] = sink
 
-	set_log_level(src, level) if (level)
+  set_log_level(src, level) if (level)
 end
 
 def deregister_log_source(src)
-	$dispatcher.delete(src)
+  $dispatcher.delete(src)
 end
 
 def set_log_level(src, level)
-	$dispatcher.set_level(src, level)
+  $dispatcher.set_level(src, level)
 end
 
 def get_log_level(src)
-	$dispatcher.get_level(src)
+  $dispatcher.get_level(src)
 end
 
 # Creates the global log dispatcher