fail2ban.server.jailthread module
*********************************

class fail2ban.server.jailthread.JailThread

   Bases: "threading.Thread"

   Abstract class for threading elements in Fail2Ban.

   Attributes:
      "daemon"
         A boolean value indicating whether this thread is a daemon
         thread.

      "ident"
         Thread identifier of this thread or None if it has not been
         started.

      "name"
         A string used for identification purposes only.

      "status"
         Abstract - Should provide status information.

      **active** : bool
         Control the state of the thread.

      **idle** : bool
         Control the idle state of the thread.

      **sleeptime** : int
         The time the thread sleeps for in the loop.

   -[ Methods ]-

   +------------+--------------------------------------------------------------------------------------------+
   | "isAlive"  | Return whether the thread is alive.                                                        |
   | (self)     |                                                                                            |
   +------------+--------------------------------------------------------------------------------------------+
   | "is_alive  | Return whether the thread is alive.                                                        |
   | "(self)    |                                                                                            |
   +------------+--------------------------------------------------------------------------------------------+
   | "join"(se  | Wait until the thread terminates.                                                          |
   | lf[,       |                                                                                            |
   | timeout])  |                                                                                            |
   +------------+--------------------------------------------------------------------------------------------+
   | "run"(sel  | Abstract - Called when thread starts, thread stops when returns.                           |
   | f)         |                                                                                            |
   +------------+--------------------------------------------------------------------------------------------+
   | "start"(s  | Sets active flag and starts thread.                                                        |
   | elf)       |                                                                                            |
   +------------+--------------------------------------------------------------------------------------------+
   | "status"(  | Abstract - Should provide status information.                                              |
   | self[,     |                                                                                            |
   | flavor])   |                                                                                            |
   +------------+--------------------------------------------------------------------------------------------+
   | "stop"(se  | Sets *active* property to False, to flag run method to return.                             |
   | lf)        |                                                                                            |
   +------------+--------------------------------------------------------------------------------------------+

   +---------------+------------+
   | **getName**   |            |
   +---------------+------------+
   | **isDaemon**  |            |
   +---------------+------------+
   | **setDaemon** |            |
   +---------------+------------+
   | **setName**   |            |
   +---------------+------------+

   property daemon

      A boolean value indicating whether this thread is a daemon
      thread.

      This must be set before start() is called, otherwise
      RuntimeError is raised. Its initial value is inherited from the
      creating thread; the main thread is not a daemon thread and
      therefore all threads created in the main thread default to
      daemon = False.

      The entire Python program exits when only daemon threads are
      left.

   getName(self)

   property ident

      Thread identifier of this thread or None if it has not been
      started.

      This is a nonzero integer. See the get_ident() function. Thread
      identifiers may be recycled when a thread exits and another
      thread is created. The identifier is available even after the
      thread has exited.

   isAlive(self)

      Return whether the thread is alive.

      This method is deprecated, use is_alive() instead.

   isDaemon(self)

   is_alive(self)

      Return whether the thread is alive.

      This method returns True just before the run() method starts
      until just after the run() method terminates. The module
      function enumerate() returns a list of all alive threads.

   join(self, timeout=None)

      Wait until the thread terminates.

      This blocks the calling thread until the thread whose join()
      method is called terminates -- either normally or through an
      unhandled exception or until the optional timeout occurs.

      When the timeout argument is present and not None, it should be
      a floating point number specifying a timeout for the operation
      in seconds (or fractions thereof). As join() always returns
      None, you must call is_alive() after join() to decide whether a
      timeout happened -- if the thread is still alive, the join()
      call timed out.

      When the timeout argument is not present or None, the operation
      will block until the thread terminates.

      A thread can be join()ed many times.

      join() raises a RuntimeError if an attempt is made to join the
      current thread as that would cause a deadlock. It is also an
      error to join() a thread before it has been started and attempts
      to do so raises the same exception.

   property name

      A string used for identification purposes only.

      It has no semantics. Multiple threads may be given the same
      name. The initial name is set by the constructor.

   abstract run(self)

      Abstract - Called when thread starts, thread stops when returns.

   setDaemon(self, daemonic)

   setName(self, name)

   start(self)

      Sets active flag and starts thread.

   abstract status(self, flavor='basic')

      Abstract - Should provide status information.

   stop(self)

      Sets *active* property to False, to flag run method to return.
