anchor.diff:  
   ;;; Bindings for OpenStack Keystone identity API are defined here
   
  -;;; Helper functions
  +(defvar *service-catalog* nil
  +  "An alist map of service catalog endpoints, the value of which will
  +  be set when the OpenStack token object is initialized.")
  +
  +(defun get-public-url (service &key (endpoints *service-catalog*))
  +  "Retrieves a public URL of an OpenStack service endpoint from an
  +alist map of currently active endpoints."
  +  (alexandria:assoc-value
  +   (alexandria:assoc-value
  +    (alexandria:assoc-value endpoints service :test #'string=)
  +    "endpoints" :test #'string=)
  +   "public-url" :test #'string=))
  +
  +(defvar *openstack-token* nil
  +  "The default global OpenStack token object.")
   
   (defun parse-endpoints (service-catalog-jso)
  -  "Parses a JSON containing currently active service endpoints."
  +  "Parses a JSON containing currently active service endpoints into an
  +alist map."
     (mapcar
      #'(lambda (jso)
          (cons (st-json:getjso "name" jso)
  
positive.code:           (setf token-expiration-time
                  (local-time:parse-timestring (st-json:getjso "expires" token-jso))))))))
  
  (defun make-connection (keystone-hostname username password &optional tenant-name)
    "Creates and returns a new instant of the connection object."
    (let ((os-c (make-instance 'os-credential
                               :keystone-hostname keystone-hostname
                               :username username
                               :password password
                               :tenant-name tenant-name)))
      (make-instance 'connection :credential os-c)))
  
negative.code:                                       "password" (password ,os-c)))))))))
       ,@body))
  
  ;;; User's OpenStack credential payload object
  
  (defclass openstack-credential ()
    ((keystone-hostname :initarg :keystone-hostname
                        :reader keystone-hostname)
     (username :initarg :username
               :reader username)
     (password :initarg :password
               :reader password)
     (tenant-name :initarg :tenant-name
                  :initform nil
                  :accessor tenant-name))
    (:documentation "An OpenStack credential payload, with all the
  necessary information to authenticate a user.
  
  Requires a hostname of the Keystone identity service, a username, and
  a password. The tenant-name is an optional argument that will default
  to username if not provided."))
  
  (defun make-openstack-credential (hostname username password &optional tenant-name)
    "Makes and returns a new instant of OpenStack credential class."
    (make-instance 'openstack-credential
                   :keystone-hostname hostname
                   :username username
                   :password password
                   :tenant-name tenant-name))
  
  ;;; OpenStack authentication token object
  
  (defclass openstack-token ()
    ((credential :initarg :credential
                 :reader credential)
     (token :accessor token)
     (token-expiration-time :accessor token-expiration-time))
    (:documentation "An OpenStack token object containing an
  authentication token along with all the necessary information to
  reacquire the token once it expires.
  
  Only requires an instant of user credential payload, other slots will
  be initialized when we instantiate the object."))
  
  (defmethod initialize-instance :after ((token openstack-token) &key)
    "Uses an instant of user credential payload to authenticate and
  retrieve a token and its expiration time, then stores them into their
  respective slots.
  
  Also retrieves currently active service catalog endpoints, parses them
  into an alist map, and binds the alist map to the global special
  variable."
    (with-accessors ((os-c credential) (token token)
                     (token-expiration-time token-expiration-time)) token
      (with-keystone-response response (os-c)
        (let* ((access-jso (st-json:getjso "access" (st-json:read-json response)))
               (token-jso (st-json:getjso "token" access-jso))
               (service-catalog-jso (st-json:getjso "serviceCatalog" access-jso)))
          (setf token (st-json:getjso "id" token-jso))
          (setf token-expiration-time
                (local-time:parse-timestring (st-json:getjso "expires" token-jso)))
          (setf *service-catalog* (parse-endpoints service-catalog-jso))))))
  
  (defmethod token :before ((token openstack-token))
    "Before reading a value of the token's slot, check if it has already
  expired. If it does, then uses the credential payload to
  re-authenticate and reacquire the token."
    (with-accessors ((os-c credential) (token token)
                     (token-expiration-time token-expiration-time)) token
      (when (local-time:timestamp>= (local-time:now) token-expiration-time)
        (with-keystone-response response (os-c)
          (let ((token-jso (st-json:getjso
  