# AGPLv3 Compliance

We have designed MinIO as an Open Source software for the Open Source software community. This requires applications to consider whether their usage of MinIO is in compliance with the GNU AGPLv3 [license](https://github.com/minio/minio/blob/master/LICENSE).

import org.apache.maven.building.StringSource;

/**
 * Wraps an ordinary {@link CharSequence} as a model source.
 *
 *
 * @deprecated instead use {@link StringSource}
 */
@Deprecated
public class StringModelSource extends StringSource implements ModelSource {

    /**
     * Creates a new model source backed by the specified string.
     *
     * @param pom The POM's string representation, may be empty or {@code null}.

        return new CommonsCliEncryptOptions(Options.SOURCE_CLI, cliManager, cliManager.parse(args));
    }

    protected CommonsCliEncryptOptions(String source, CLIManager cliManager, CommandLine commandLine) {
        super(source, cliManager, commandLine);
    }

    @Override
    public Optional<Boolean> force() {
        if (commandLine.hasOption(CLIManager.FORCE)) {

For example, each process has different supported JVMs and a different set of services available for dependency injection.
While a lot of Gradle source code runs only in the Gradle daemon, not all of it does so.
When working on some source code it is important to be aware of the runtimes in which it will run, so that you don't break these constraints.

            ArtifactMetadataSource source,
            ArtifactFilter filter,
            List<ResolutionListener> listeners) {
        return collect(
                artifacts,
                originatingArtifact,
                managedVersions,
                localRepository,
                remoteRepositories,
                source,
                filter,
                listeners,

package dsync

import (
	"math/rand"
	"sync"
)

// lockedRandSource provides protected rand source, implements rand.Source interface.
type lockedRandSource struct {
	lk  sync.Mutex
	src rand.Source
}

// Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
func (r *lockedRandSource) Int63() (n int64) {
	r.lk.Lock()
	n = r.src.Int63()

public abstract class UserManual {
    /**
     * The root of the user manual documentation.  This is the source of the adoc files.
     */
    public abstract DirectoryProperty getRoot();

    /**
     * Source of snippets that can be inserted into the user manual
     */
    public abstract DirectoryProperty getSnippets();

    /**
     * Source of samples that can be inserted into the user manual
     *
     */

                }
            }
        }

        private void mergePluginContainerPlugins(PluginContainer target, PluginContainer source) {
            List<Plugin> src = source.getPlugins();
            if (!src.isEmpty()) {
                List<Plugin> tgt = target.getPlugins();

                Map<Object, Plugin> managedPlugins = new LinkedHashMap<>(src.size() * 2);

    /**
     * Install an artifact from a particular file.
     *
     * @param source the file to install
     * @param artifact the artifact definition
     * @param localRepository the local repository to install into
     * @throws ArtifactInstallationException if an error occurred installing the artifact
     */
    void install(File source, Artifact artifact, ArtifactRepository localRepository)

        WARNING //
    }

    /**
     * Gets the hint about the source of the problem. While the syntax of this hint is unspecified and depends on the
     * creator of the problem, the general expectation is that the hint provides sufficient information to the user to
     * track the problem back to its origin. A concrete example for such a source hint can be the file path or URL from
     * which the settings were read.
     *