return null;
        }

        final File parentFile = uploadFile.getParentFile();
        if (!parentFile.exists() && !parentFile.mkdirs()) {
            logger.warn("Could not create directory: {}", parentFile.getAbsolutePath());
        }

        try {

You must first [build MinIO](#install-from-source) and ensure the `minio` binary exists in the project root.

The following command builds the Docker image using the default `Dockerfile` in the root project directory with the repository and image tag `myminio:minio`

```sh
docker build -t myminio:minio .
```

Use `docker image ls` to confirm the image exists in your local repository.
You can run the server using standard Docker invocation:

        if ((flags & SmbFile.O_CREAT) == SmbFile.O_CREAT) {
            // create it if necessary
            if ((flags & SmbFile.O_EXCL) == SmbFile.O_EXCL) {
                // fail if already exists
                openFunction = OPEN_FN_CREATE | OPEN_FN_FAIL_IF_EXISTS;
            } else {
                openFunction = OPEN_FN_CREATE | OPEN_FN_OPEN;
            }
        } else {

	mc admin cluster iam export old-minio
	set +x

	mc admin service stop old-minio
}

import_iam_content_in_new_minio() {
	echo "Importing IAM content in new minio instance."
	# Assume current minio binary exists.
	MINIO_CI_CD=1 ./minio server /tmp/data/{1...4} &
	sleep 5

	set -x
	mc alias set new-minio http://localhost:9000 minioadmin minioadmin
	echo "BEFORE IMPORT mappings:"
	mc ready new-minio

}

// MAC is a non-functional stub.
func (s StubKMS) MAC(_ context.Context, m *MACRequest) ([]byte, error) {
	return m.Message, nil
}

// containsKeyName returns true if the given key name exists in the stub KMS.
func (s *StubKMS) containsKeyName(keyName string) bool {
	return slices.Contains(s.KeyNames, keyName)

        try {
            JarOutputStream(BufferedOutputStream(FileOutputStream(jarFile))).use { jarOutputStream ->
                if (manifestFile.exists()) {
                    jarOutputStream.addJarEntry(JarFile.MANIFEST_NAME, manifestFile)
                }
                val visited = linkedSetOf<ClassDetails>()

        doFirst {
            val moduleBaseDir = localRepository.get().dir("org/gradle/${baseName.get()}").asFile
            if (moduleBaseDir.exists()) {
                // Make sure artifacts do not pile up locally
                moduleBaseDir.deleteRecursively()
            }
        }

        doLast {

     * @return the path to the JAR file
     * @throws ThemeException if the JAR file does not exist
     */
    protected Path getJarFile(final Artifact artifact) {
        final Path jarPath = ResourceUtil.getPluginPath(artifact.getFileName());
        if (!Files.exists(jarPath)) {
            throw new ThemeException(artifact.getFileName() + " does not exist.");
        }
        return jarPath;
    }

    public boolean isMerged() {
        return merged;
    }

    protected abstract void merge(Metadata recessive);

    static Metadata read(Path metadataPath) throws RepositoryException {
        if (!Files.exists(metadataPath)) {
            return new Metadata();
        }

        try (InputStream input = Files.newInputStream(metadataPath)) {
            return new Metadata(new MetadataStaxReader().read(input, false));

REM Causes the JVM to dump its heap on OutOfMemory.
REM set FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -XX:+HeapDumpOnOutOfMemoryError
REM The path to the heap dump location, note directory must exists and have enough
REM space for a full heap dump.
REM FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -XX:HeapDumpPath=%FESS_HOME%/logs/heapdump.hprof

REM Disables explicit GC
set FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -XX:+DisableExplicitGC