#include "pathlocks.hh"
#include "util.hh"

#include <cerrno>
#include <cstdlib>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


namespace nix {


int openLockFile(const Path & path, bool create)
{
    AutoCloseFD fd;

    fd = open(path.c_str(), O_RDWR | (create ? O_CREAT : 0), 0600);
    if (fd == -1 && (create || errno != ENOENT))
        throw SysError(format("opening lock file `%1%'") % path);

    closeOnExec(fd);

    return fd.borrow();
}


void deleteLockFile(const Path & path, int fd)
{
    /* Get rid of the lock file.  Have to be careful not to introduce
       races.  Write a (meaningless) token to the file to indicate to
       other processes waiting on this lock that the lock is stale
       (deleted). */
    unlink(path.c_str());
    writeFull(fd, "d");
    /* Note that the result of unlink() is ignored; removing the lock
       file is an optimisation, not a necessity. */
}


bool lockFile(int fd, LockType lockType, bool wait)
{
    struct flock lock;
    if (lockType == ltRead) lock.l_type = F_RDLCK;
    else if (lockType == ltWrite) lock.l_type = F_WRLCK;
    else if (lockType == ltNone) lock.l_type = F_UNLCK;
    else abort();
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0; /* entire file */

    if (wait) {
        while (fcntl(fd, F_SETLKW, &lock) != 0) {
            checkInterrupt();
            if (errno != EINTR)
                throw SysError(format("acquiring/releasing lock"));
        }
    } else {
        while (fcntl(fd, F_SETLK, &lock) != 0) {
            checkInterrupt();
            if (errno == EACCES || errno == EAGAIN) return false;
            if (errno != EINTR) 
                throw SysError(format("acquiring/releasing lock"));
        }
    }

    return true;
}


/* This enables us to check whether are not already holding a lock on
   a file ourselves.  POSIX locks (fcntl) suck in this respect: if we
   close a descriptor, the previous lock w;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2018, 2019, 2022 Ludovic Courtès &lt;ludo@gnu.org&gt;
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see &lt;http://www.gnu.org/licenses/&gt;.

(define-module (test-status)
  #:use-module (guix status)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-64)
  #:use-module (srfi srfi-71)
  #:use-module (rnrs bytevectors)
  #:use-module (rnrs io ports)
  #:use-module (ice-9 match))

(test-begin &quot;status&quot;)

(test-equal &quot;compute-status, no-op&quot;
  (build-status)
  (let ((port get-status (build-event-output-port compute-status)))
    (display &quot;foo\nbar\n\baz\n&quot; port)
    (get-status)))

(test-equal &quot;compute-status, builds + substitutes&quot;
  (list (build-status
         (building (list (build &quot;foo.drv&quot; &quot;x86_64-linux&quot;)))
         (downloading (list (download &quot;bar&quot; &quot;http://example.org/bar&quot;
                                      #:size 500
                                      #:start &apos;now))))
        (build-status
         (building (list (build &quot;foo.drv&quot; &quot;x86_64-linux&quot;)))
         (downloading (list (download &quot;bar&quot; &quot;http://example.org/bar&quot;
                                      #:size 500
                                      #:transferred 42
                                      #:start &apos;now))))
        (build-status
         (builds-completed (list (build &quot;foo.drv&quot; &quot;x86_64-linux&quot;)))
         (downloads-completed (list (download &quot;bar&quot; &quot;http://example.org/bar&quot;
                                              #:size 500
                                              #:transferred 500
                                              #:start &apos;now
                                              #:end &apos;now)))))
  (let ((port get-status
              (build-event-output-port (lambda (event status)
                                         (compute-status event status
                                                         #:current-time
                                                         (const &apos;now))))))
    (display &quot;@ build-started foo.drv - x86_64-linux \n&quot; port)
    (display &quot;@ substituter-started bar\n&quot; port)
    (display &quot;@ download-started bar http://example.org/bar 500\n&quot; port)
    (display &quot;various\nthings\nget\nwritten\n&quot; port)
    (let ((first (get-status)))
      (display &quot;@ download-progress bar http://example.org/bar 500 42\n&quot;
               port)
      (let ((second (get-status)))
        (display &quot;@ download-progress bar http://example.org/bar 500 84\n&quot;
                 port)
        (display &quot;@ build-succeeded foo.drv\n&quot; port)
        (display &quot;@ download-succeeded bar http://example.org/bar 500\n&quot; port)
        (display &q