anchor.diff:    (leases :accessor leases-of :initform nil)
     (statuses :accessor statuses-of :initform nil))
   
  +(defclass lease ()
  +  ((nick :accessor nick-of :initarg :nick)
  +   (env :accessor env-of :initarg :env)
  +   (activity :accessor activity-of :initarg :activity)
  +   (expires :accessor expires-of :initarg :expires)
  +   (timer :accessor timer-of :initarg :timer)))
  +
   (defmethod initialize-module ((module env-module) config)
     (load-env-data module))
  +
  +(defmethod deinitialize-module ((module env-module))
  +  (dolist (lease (leases-of module))
  +    (when (timer-of lease)
  +      (iolib:remove-timer *event-base* (timer-of lease)))))
   
   (defun save-env-data (module)
     (with-open-file (ouf (orcabot-path "data/pss-envs.lisp")
  
positive.code:              for match-el on matching
               for match = (car match-el)
               do
               (format str "~a (~@[~a/~]~a)" (first match)
                       (third match)
                       (describe-duration (- (fourth match) (get-universal-time))))
               (unless (eq match-el end)
                 (format str ", "))))
          (format nil "~a~@[(~a)~] is currently free" env-name status))))
  
  (defun remove-all-env-leases (module env-name)
    (setf (leases-of module) (remove env-name (leases-of module) :test #'string-equal :key #'second)))
  
  (defun remove-env-lease (module env-name nick)
    (setf (leases-of module) (remove-if (lambda (lease)
                                    (and (string-equal (second lease) env-name)
                                         (string-equal (first lease) nick)))
                                  (leases-of module))))
  
  (defun create-lease (module env-name nick time-str activity)
  
negative.code:                        :if-does-not-exist nil)
      (when inf
        (setf (environments-of module) (read inf nil nil))
        (setf (leases-of module)
              (loop for lease-data in (read inf nil)
                 collect (make-instance 'lease
                                        :nick (first lease-data)
                                        :env (second lease-data)
                                        :activity (third lease-data)
                                        :expires (fourth lease-data))))
        (setf (statuses-of module) (read inf nil nil))
        ;; instantiate timers
        (let ((now (get-universal-time)))
          (dolist (lease (leases-of module))
            (instantiate-lease-timer module lease now))))))
  
  (defun expire-env-leases (module)
    (let ((now (get-universal-time)))
      (setf (leases-of module) (delete-if (lambda (lease)
                                      (<= (expires-of lease) now))
                                    (leases-of module)))))
  
  (defun parse-expire-time (str)
  