/**
     * Returns the number of byte written since {@link #start(long)} was called.
     */
    public long getBytesWritten() {
        return countingOutputStream.getCount();
    }

    /**
     * Finishes writing, flushing and resetting any buffered state
     */
    public void done() throws IOException {
        countingOutputStream.flush();
        countingOutputStream = null;
    }

     *
     * @param failure Can be null, in which case this method does nothing.
     */
    void failed(@Nullable Throwable failure);

    /**
     * Finishes the build operation which should only be done once.
     */
    void setResult(@Nullable Object result);

    /**
     * Record a status or outcome for given build operation.
     *

    }

    /**
     * Returns the number of bytes read since {@link #start(long)} was called.
     */
    public long getBytesRead() {
        return countingInputStream.getCount();
    }

    /**
     * Finishes reading, resetting any buffered state.
     */
    public void done() {
        countingInputStream = null;
    }

    private static class ResettableBufferedInputStream extends BufferedInputStream {

    /**
     * Updates the VFS and the watchers before the build finishes.
     *
     * For example, this removes everything from the root which can't be kept after the current build finished.
     * This is anything which is not within a watchable hierarchy or in a cache directory.
     *

			if (verbose) {
				printf("attempting external signal test\n");
			}

			fprintf(stderr, "OK\n");
			fflush(stderr);

			// The program should be interrupted before
			// this sleep finishes. We use select rather
			// than sleep because in older versions of
			// glibc the sleep function does some signal
			// fiddling to handle SIGCHLD.  If this
			// program is fiddling signals just when the

     * The copy operation happens only once. Sets the Jansi-related system property.
     *
     * This hackery is to prevent Jansi from creating a shared lib in a tmp dir which is deleted when
     * the Java process finishes. To avoid performance impacts caused by Jansi's default behavior the
     * library is proactively extracted into a known directory and reused by subsequent invocations.
     *

Double-click **tutorial > app > build > build**.

image::tutorial/intellij-idea-build.png[]

Once the build finishes, make sure it is successful in the IntelliJ console:
[source,text]
----
BUILD SUCCESSFUL in 966ms
7 actionable tasks: 7 executed
3:18:24 AM: Execution finished 'build'.
----

== Step 6. Running Tasks in the Terminal
Run the following command in your terminal:
[source,text]
----

                doLast {
                    submitWorkItem("workTask")
                }
            }

            // Wait for dependent task, to ensure that work task finishes first
            slowTask.doLast {
                ${blockingHttpServer.callFromBuild("slowTask2")}
            }

            project(':childProject') {
                task dependsOnWorkTask(type: MultipleWorkItemTask) {

Because this code is executed before the application **starts** taking requests, and right after it **finishes** handling requests, it covers the whole application **lifespan** (the word "lifespan" will be important in a second 😉).

- will send all the existing payloads (that it has in its cache) to the ztunnel using AddWorkload message.
- the ztunnel will send an ack for each payload (which the CNI will wait for before sending the next one).
- when the CNI finishes sending the content of its current cache, a SnapshotSent message will be sent.
- the ztunnel will then remove any entries from its cache that were not sent up to this point (as these entries do not exist in the CNI