; Log file management
         (*logcount* (string->number (get-metadata "current-logfile" "0")))
         (set-logcount! (lambda (newcount)
                         (set! *logcount* newcount)))
         (*log* (file-open (string-append logdir "/log" (number->string *logcount*))
                  (bitwise-ior open/creat open/rdwr open/append) (bitwise-ior perm/irusr perm/iwusr)))

         ;; FIXME: GC this hash. Keep an LRU list and a maximum size,
         ;; and zap the least recently used one to make room. Perhaps
         ;; a fixed-size vector of FDs with a wrapping pointer moving
         ;; through it, and the hash maps from indexes to vector
         ;; indices, would do the trick.
         (*logfiles* (make-hash-table)) ; hash of file number to FD
         (get-log (lambda (index)
            (if (hash-table-exists? *logfiles* index)
               (hash-table-ref *logfiles* index)
               (begin
                 (let ((fd (file-open (string-append logdir "/log" (number->string index)) open/rdonly perm/irwxu)))
                   (set! (hash-table-ref *logfiles* index) fd)
                   fd)))))

         ; Basic configurables
         (block-size (string->number (get-metadata "block-size" "1048576")))
         (writable? (not (string=? "0" (get-metadata "writable" "1"))))
         (check-writable (lambda ()
                           (unless writable?
                                   (error "This archive is write protected"))))

                       (let* ((log-file-name (string-append logdir "/log" (number->string log-number))))
                         (if (file-exists? log-file-name)
                          (begin
                            ((backend-log!) 'info (sprintf "Reading ~a" log-file-name))
                            (with-input-from-file log-file-name
                              (lambda ()
                                (let loop-over-entries ()
                                  (let* ((entry (handle-exceptions
                                                 exn
                                                 (begin
                                                   ((backend-log!) 'error (sprintf "Exception reading header ~S in ~S at ~S" (describe-exception exn) log-file-name (file-position (current-input-port))))
                                                   #!eof)
                                                 (read)))
                                         (posn (file-position (current-input-port))))
                                    (if (eof-object? entry)
                                        (loop-over-logs (+ log-number 1))
                                        (begin
                                          (match entry
                                                 (('block key type length)
                                                  (handle-exceptions
                                                   exn
                                                   ((backend-log!) 'error (sprintf "Exception updating block ~S: ~S in ~S at ~S" entry (describe-exception exn) log-file-name (file-position (current-input-port))))
                                                   (set-block-data! key type log-number posn length))
                                                  (set-file-position! (current-input-port) length seek/cur))
                                                 (('tag tag key)
                                                  (handle-exceptions
                                                   exn
                                                   ((backend-log!) 'error (sprintf "Exception updating tag ~S: ~S in ~S at ~S" entry (describe-exception exn) log-file-name (file-position (current-input-port))))
                                                   (set-tag! tag key)))
                                                 (else
						  ;; FIXME: This happens when a log header is corrupted.
						  ;; Rather than just trying to read again, which will produce a stream of errors
						  ;; until we re-synchronise, we should go into a loop that looks for a likely log
						  ;; entry.
                                                  ((backend-log!) 'error (sprintf "Unknown log entry ~S in ~S at ~S" entry log-file-name (file-position (current-input-port))))))
                                          (loop-over-entries)))))))))
                         (void)))
                     (flush!)
                     (void))))

      (make-storage
         block-size

(module
 ugarit-api
 (open-vault ;; Note: Mutates job configuration from the conf file
  vault-close!
  vault-fork-tag!

  ;; Re-exports from ugarit-core
  vault?
  vault-global-directory-rules
  vault-admin!
  vault-exists? vault-get

  make-job
  job?
  job-blocks-stored
  job-bytes-stored
  job-blocks-skipped
  job-bytes-skipped

         storage-close!

         backend-log!

         export-storage! ; Export a storage via stdin/stdout
         export-storage-error!
         import-storage ; Create a storage from a command line

         describe-exception ; Doesn't really belong here...
         )

(import scheme)
(import chicken)

(use extras)
(use ports)