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 {

            throw new SettingsBuildingException(convert(e.getProblems()));
        }
    }

    private org.apache.maven.api.services.Source toSource(File file, Source source) {
        if (file != null && file.exists()) {
            return org.apache.maven.api.services.Source.fromPath(file.toPath());
        } else if (source instanceof FileSource fs) {
            return org.apache.maven.api.services.Source.fromPath(fs.getPath());

		}

		// Do not send sensitive creds.
		if _, ok := sensitive[key]; ok || strings.Contains(strings.ToLower(key), "password") || strings.HasSuffix(strings.ToLower(key), "key") {
			props.MinioEnvVars[key] = "*** EXISTS, REDACTED ***"
			continue
		}
		props.MinioEnvVars[key] = value
	}

	objLayer := newObjectLayerFn()
	if objLayer != nil {
		storageInfo := objLayer.LocalStorageInfo(GlobalContext, metrics)

    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isErrorSqlContinue: (NotRequired - Default false)
    #  Does it continue the task when error SQL exists?
    #
    #; isErrorSqlContinue = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o sqlFileEncoding: (NotRequired - Default 'UTF-8')

    /** metadata URI */
    protected String uri;

    /** is metadata found anywhere */
    protected boolean resolved = false;

    /** does the actual artifact for this metadata exists */
    protected boolean artifactExists = false;
    /** artifact URI */
    protected String artifactUri;

    /** error message  */
    private String error;

                }
            }
        }
        return plugins.values();
    }

    private PluginInfo extractPluginInfo(Artifact artifact) {
        // sanity: jar, no classifier and file exists
        if (artifact != null
                && "jar".equals(artifact.getExtension())
                && "".equals(artifact.getClassifier())
                && artifact.getPath() != null) {

FESS_JAVA_OPTS="$FESS_JAVA_OPTS -Dlog4j.skipJansi=true"

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

# Disables explicit GC
FESS_JAVA_OPTS="$FESS_JAVA_OPTS -XX:+DisableExplicitGC"

    }

    private Profile newExistsProfile(String filePath) {
        ActivationFile activationFile =
                ActivationFile.newBuilder().exists(filePath).build();
        return newProfile(activationFile);
    }

    private Profile newMissingProfile(String filePath) {
        ActivationFile activationFile =

	return r
}

// SetTags - sets key/val to ReqInfo.tags
func (r *ReqInfo) SetTags(key, val string) *ReqInfo {
	if r == nil {
		return nil
	}
	r.Lock()
	defer r.Unlock()
	// Search of tag key already exists in tags
	var updated bool
	for _, tag := range r.tags {
		if tag.Key == key {
			tag.Val = val
			updated = true
			break
		}
	}
	if !updated {
		// Append to the end of tags list

	if s3Error := checkRequestAuthType(ctx, r, policy.GetBucketVersioningAction, bucket, ""); s3Error != ErrNone {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL)
		return
	}

	// Check if bucket exists.
	if _, err := objectAPI.GetBucketInfo(ctx, bucket, BucketOptions{}); err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	config, err := globalBucketVersioningSys.Get(bucket)