<project>
  <groupId>snapshot-test</groupId>
  <artifactId>maven-test-snapshot-resolving</artifactId>
  <packaging>jar</packaging>
  <repositories>
    <repository>
      <id>central</id>
      <name>Fake Maven Central Repository</name>
      <url>file://dummy</url>
    </repository>
  </repositories>
  <dependencies>
    <dependency>
      <groupId>snapshot-test</groupId>
      <artifactId>maven-snapshot-a</artifactId>

Just keep in mind that when you read "server" in general, it could refer to one of those two things.

When referring to the remote machine, it's common to call it **server**, but also **machine**, **VM** (virtual machine), **node**. Those all refer to some type of remote machine, normally running Linux, where you run programs.

 * defined precisely.</p>
 *
 * <p>{@link org.apache.maven.api.Artifact} instances are the pointed artifacts in the repository.
 * They are created when <dfn>resolving</dfn> an {@code ArtifactCoordinates}. Resolving is the process
 * that selects a particular version and downloads the artifact in the local repository.
 * There are two sub-interfaces, {@link org.apache.maven.api.DownloadedArtifact} which is used when

- Kube-controller-manager: the dynamic resource controller steps in when a pod got created such that the scheduler ignores it (i.e. spec.nodeName is set) and then takes care of triggering delayed resource claim allocation and/or reserving a claim for the pod. ([#118209](https://github.com/kubernetes/kubernetes/pull/118209), [@pohly](https://github.com/pohly)) [SIG API Machinery, Apps, Auth, Node and Testing]

  // `SummarizeValue` to resolving this handle and formatting the tensor.
  //
  // For example some tensor handles may represent distributed values, in which
  // case placement information is lost when resolving the handle.
  //
  // If false, a caller might implement pretty-printing by resolving and
  // iterating over the resulting tensor. This may still be viable if resolving

    /**
     * Get the model based on the path when resolving the parent based on relativePath.
     *
     * @param from    the requiring model
     * @param pomFile the path to the pomFile
     * @return the model, otherwise {@code null}
     */
    Model getRawModel(Path from, Path pomFile);

    /**
     * Get the model from the reactor based on the groupId and artifactId when resolving reactor dependencies.
     *

# Lifespan Events

You can define logic (code) that should be executed before the application **starts up**. This means that this code will be executed **once**, **before** the application **starts receiving requests**.

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.

[Transport]'s limit on 1xx informational responses received
in response to a request has changed.
It previously aborted a request and returned an error after
receiving more than 5 1xx responses.
It now returns an error if the total size of all 1xx responses
exceeds the [Transport.MaxResponseHeaderBytes] configuration setting.

In addition, when a request has a
[net/http/httptrace.ClientTrace.Got1xxResponse]

 *
 * <p>Each {@code Artifact} instance is basically an exact pointer to a file in a Maven repository.
 * {@code Artifact} instances are created when <dfn>resolving</dfn> {@link ArtifactCoordinates} instances.
 * Resolving is the process that selects a {@linkplain #getVersion() particular version}
 * and downloads the artifact in the local repository.  This operation returns a {@link DownloadedArtifact}.
 * </p>
 *

// - plugins with a dependency the same as the core but different versions, make it fail then fix it

  /*
 *
 * h2. Concerns for the plugin manager
 *
 * h3. resolving the dependencies of a plugin - these could be resolved remotely at runtime or, -
 * they could be resolved from a local repository - I think we need a simple dependency model here