cleanup:
        System.setProperty("user.dir", originalDir.absolutePath)
        env.setProcessDir(originalDir)
    }

    def "can get pid of current process"() {
        expect:
        env.pid != null
        env.maybeGetPid() == env.pid
    }

            import ${ProcessEnvironment.name}
            import ${Time.name}
            import ${Timer.name}

            def pid = gradle.services.get(ProcessEnvironment).maybeGetPid()
            def timer = Time.startTimer()

            def listener = new TraceListener(pid: pid, timer: timer)
            def manager = gradle.services.get(BuildOperationListenerManager)
            manager.addListener(listener)

    # if not running, start it up here, usually something like "daemon $exec"
    daemon --user $FESS_USER --pidfile="$pidfile" $exec -d
    retval=$?
    pid=`ps aux | grep "^${FESS_USER}" | grep "${PROC_NAME}" | sed 's/[\t ]\+/\t/g' | cut -f2`
    if [ -n "$pid" ]; then
        echo $pid > "$pidfile"
    fi
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "

        expect:
        def connection = connector.maybeConnect({it.pid < 12} as ExplainingSpec)
        connection && connection.connection.num < 12
    }

    def "maybeConnect() returns null when no daemon matches spec"() {
        given:
        startIdleDaemon()
        startIdleDaemon()

        expect:
        connector.maybeConnect({it.pid == 12} as DummyExplainingSpec) == null
    }

[19499] [INFO] Listening at: http://0.0.0.0:80 (19499)
[19499] [INFO] Using worker: uvicorn.workers.UvicornWorker
[19511] [INFO] Booting worker with pid: 19511
[19513] [INFO] Booting worker with pid: 19513
[19514] [INFO] Booting worker with pid: 19514
[19515] [INFO] Booting worker with pid: 19515
[19511] [INFO] Started server process [19511]
[19511] [INFO] Waiting for application startup.
[19511] [INFO] Application startup complete.

            throw new IllegalStateException("unable to parse DefaultDaemonContext from source: [${daemonLog.file.absolutePath}].")
        }
        if (this.context?.pid == null) {
            println "PID in daemon log ($daemonLog.file.absolutePath) is null."
            println "daemon.log exists: ${daemonLog.file.exists()}"

            def logText = daemonLog.text

        lockFileAccess.close();
    }

    public void writeLockInfo(int port, long lockId, String pid, String operation) throws IOException {
        LockInfo lockInfo = new LockInfo();
        lockInfo.port = port;
        lockInfo.lockId = lockId;
        lockInfo.pid = pid;
        lockInfo.operation = operation;
        lockInfoAccess.writeLockInfo(lockFileAccess, lockInfo);
    }

	processIOReadBytesMD              = NewCounterMD(processIOReadBytes, "Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes")
	processIOWCharBytesMD             = NewCounterMD(processIOWCharBytes, "Total bytes written by the process to the underlying storage system including page cache, /proc/[pid]/io wchar")

		next  *_Plink // known to be 4(ptr)
		last  *_Plink
		first *_Plink
		pid   uint32
		what  uint32
	}
	cyclefreq uint64 // cycle clock frequency if there is one, 0 otherwise
	kcycles   int64  // cycles spent in kernel
	pcycles   int64  // cycles spent in process (kernel + user)
	pid       uint32 // might as well put the pid here
	clock     uint32
	// top of stack is here
}

const (

	SYS_SCHED_SETPARAM         = 327 // { int sched_setparam (pid_t pid, const struct sched_param *param); }
	SYS_SCHED_GETPARAM         = 328 // { int sched_getparam (pid_t pid, struct sched_param *param); }
	SYS_SCHED_SETSCHEDULER     = 329 // { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
	SYS_SCHED_GETSCHEDULER     = 330 // { int sched_getscheduler (pid_t pid); }
	SYS_SCHED_YIELD            = 331 // { int sched_yield (void); }