artifact.isOptional());
        clone.setRelease(artifact.isRelease());
        clone.setResolvedVersion(artifact.getVersion());
        clone.setResolved(artifact.isResolved());
        clone.setFile(artifact.getFile());

        clone.setAvailableVersions(copyList(artifact.getAvailableVersions()));
        if (artifact.getVersion() != null) {

     * is queried frequently and exceptions would be rather costly to
     * throw on a regular basis here.
     *
     * @param host the hostname to resolve
     * @return the resolved NbtAddress or null if not found
     */

    public synchronized static NbtAddress getByName(final String host) {
        return getByName(new Name(host, 0x20, null));
    }

    <configuration>
      <![CDATA[
<dependencies>
  ...
</dependencies>
    ]]></configuration>
    <description>
      <![CDATA[
      This is a set of Artifact instances resolved from the set of dependencies for
      the current project.

      NOTE: This will likely contain much more than the direct dependencies of the
      current POM, since Maven uses transitive, or chained, dependency resolution.

     * @return the server connected to
     */
    public abstract String getServer();

    /**
     * Gets the server hostname resolved through DFS (Distributed File System)
     * @return the server resolved by DFS
     */
    public abstract String getServerWithDfs();

    /**
     * Gets the CIFS context used for transport operations
     * @return the transport context used

data class GitHubIssue(
    val number: Int,
    val title: String,
    @SerializedName("html_url") val htmlUrl: String
)


const val FIXED_ISSUES_INTRO = "The following issues were resolved:"


@DisableCachingByDefault(because = "Depends on GitHub API")
abstract class UpdateFixedIssuesInReleaseNotes : DefaultTask() {

    @get:Internal
    abstract val releaseNotes: RegularFileProperty

     *   <li>Parent directory references (..)</li>
     *   <li>Both file and directory targets</li>
     * </ul>
     *
     * @param relative path to resolve relative to this source
     * @return the resolved source, or null if resolution not possible
     * @throws NullPointerException if relative is null
     */
    @Nullable
    Source resolve(@Nonnull String relative);

    CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
    TF_Tensor* resolved = TFE_TensorHandleResolve(on_host, status);
    CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
    const float* resolved_data =
        static_cast<const float*>(TF_TensorData(resolved));
    EXPECT_EQ(0, memcmp(m_float, resolved_data, 4 * sizeof(float)));
    TF_DeleteTensor(resolved);

     * <p>
     * Initially, the SIDs within each ACE will not be resolved however when
     * <code>getType()</code>, <code>getDomainName()</code>, <code>getAccountName()</code>,
     * or <code>toString()</code> is called, the names will attempt to be
     * resolved. If the names cannot be resolved (e.g. due to temporary
     * network failure), the said methods will return default values (usually

                    new org.apache.maven.model.Plugin(plugin), dependencyFilter, repositories, repoSession);
            return result.getArtifactResults().stream()
                    .filter(ArtifactResult::isResolved)
                    .map(ArtifactResult::getArtifact)
                    .collect(Collectors.toList());
        } catch (PluginResolutionException | InterpolatorException e) {

points to the public IP address where each cluster might be accessible, this is unique for each cluster.

NOTE: `mybucket` only exists on one cluster either `cluster1` or `cluster2` this is random and
is decided by how `domain.com` gets resolved, if there is a round-robin DNS on `domain.com` then
it is randomized which cluster might provision the bucket.

### 3. Test your setup