[model] release username may be configured with env var. Resolves #256

2026-03-10 08:31:24 +00:00 · 2021-07-03 22:00:44 +02:00
parent f4de1a94c8
commit 416ffd9530
16 changed files with 212 additions and 78 deletions
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/AbstractRepositoryTap.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/AbstractRepositoryTap.java
@@ -41,6 +41,7 @@ public abstract class AbstractRepositoryTap implements RepositoryTap {
        this.basename = basename;
    }

+    @Override
    public String getBasename() {
        return basename;
    }
@@ -69,6 +70,12 @@ public abstract class AbstractRepositoryTap implements RepositoryTap {
        return basename;
    }

+    @Override
+    public String getResolvedUsername(GitService service) {
+        return Env.resolve(Env.toVar(basename + "_"
+            + service.getServiceName()) + "_USERNAME", username);
+    }
+
    @Override
    public String getResolvedToken(GitService service) {
        return Env.resolve(Env.toVar(basename + "_"
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/GitService.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/GitService.java
@@ -419,6 +419,10 @@ public abstract class GitService implements Releaser, CommitAuthorAware, OwnerAw
        return Env.resolve(Env.toVar(getServiceName()) + "_TOKEN", token);
    }

+    public String getResolvedUsername() {
+        return Env.resolve(Env.toVar(getServiceName()) + "_USERNAME", username);
+    }
+
    public String getUsername() {
        return username;
    }
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/Registry.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/Registry.java
@@ -52,6 +52,10 @@ public class Registry implements Domain, Comparable<Registry> {
        return Env.resolve("DOCKER_" + Env.toVar(serverName) + "_PASSWORD", password);
    }

+    public String getResolvedUsername() {
+        return Env.resolve("DOCKER_" + Env.toVar(serverName) + "_USERNAME", username);
+    }
+
    public String getServer() {
        return server;
    }
@@ -98,7 +102,7 @@ public class Registry implements Domain, Comparable<Registry> {
        map.put("server", server);
        map.put("serverName", serverName);
        map.put("repositoryName", repositoryName);
-        map.put("username", username);
+        map.put("username", getResolvedUsername());
        map.put("password", isNotBlank(password) ? HIDE : UNSET);
        return map;
    }
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/RepositoryTap.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/RepositoryTap.java
@@ -22,18 +22,16 @@ package org.jreleaser.model;
 * @since 0.1.0
 */
 public interface RepositoryTap extends Domain, OwnerAware {
+    String getBasename();
+
    String getCanonicalRepoName();

    String getResolvedName();

+    String getResolvedUsername(GitService service);
+
    String getResolvedToken(GitService service);

-    @Override
-    String getOwner();
-
-    @Override
-    void setOwner(String owner);
-
    String getName();

    void setName(String name);
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/BrewValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/BrewValidator.java
@@ -21,8 +21,11 @@ import org.jreleaser.model.Artifact;
 import org.jreleaser.model.Brew;
 import org.jreleaser.model.Cask;
 import org.jreleaser.model.Distribution;
+import org.jreleaser.model.GitService;
+import org.jreleaser.model.HomebrewTap;
 import org.jreleaser.model.JReleaserContext;
 import org.jreleaser.model.JReleaserModel;
+import org.jreleaser.util.Env;
 import org.jreleaser.util.Errors;

 import java.util.ArrayList;
@@ -50,7 +53,8 @@ public abstract class BrewValidator extends Validator {
            tool.setActive(parentTool.getActive());
        }
        if (!tool.resolveEnabled(context.getModel().getProject(), distribution)) return;
-        if (!model.getRelease().getGitService().isReleaseSupported()) {
+        GitService service = model.getRelease().getGitService();
+        if (!service.isReleaseSupported()) {
            tool.disable();
            return;
        }
@@ -58,7 +62,8 @@ public abstract class BrewValidator extends Validator {
        context.getLogger().debug("distribution.{}.brew", distribution.getName());

        validateCommitAuthor(tool, parentTool);
-        validateOwner(tool.getTap(), parentTool.getTap());
+        HomebrewTap tap = tool.getTap();
+        validateOwner(tap, parentTool.getTap());
        validateTemplate(context, distribution, tool, parentTool, errors);
        mergeExtraProperties(tool, parentTool);

@@ -70,16 +75,30 @@ public abstract class BrewValidator extends Validator {
            tool.setFormulaName(distribution.getName());
        }

-        if (isBlank(tool.getTap().getName())) {
-            tool.getTap().setName(parentTool.getTap().getName());
+        if (isBlank(tap.getName())) {
+            tap.setName(parentTool.getTap().getName());
        }
-        if (isBlank(tool.getTap().getUsername())) {
-            tool.getTap().setUsername(parentTool.getTap().getUsername());
+        if (isBlank(tap.getUsername())) {
+            tap.setUsername(parentTool.getTap().getUsername());
        }
-        if (isBlank(tool.getTap().getToken())) {
-            tool.getTap().setToken(parentTool.getTap().getToken());
+        if (isBlank(tap.getToken())) {
+            tap.setToken(parentTool.getTap().getToken());
        }

+        tap.setUsername(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(tap.getBasename() + "_" + service.getServiceName()) + "_USERNAME",
+                "distribution." + distribution.getName() + "brew.tap.username",
+                tap.getUsername(),
+                service.getResolvedUsername()));
+
+        tap.setToken(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(tap.getBasename() + "_" + service.getServiceName()) + "_TOKEN",
+                "distribution." + distribution.getName() + "brew.tap.token",
+                tap.getToken(),
+                service.getResolvedToken()));
+
        validateCask(context, distribution, tool, errors);
        if (!tool.getCask().isEnabled()) {
            validateArtifactPlatforms(context, distribution, tool, errors);
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/ChocolateyValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/ChocolateyValidator.java
@@ -18,9 +18,12 @@
 package org.jreleaser.model.validation;

 import org.jreleaser.model.Chocolatey;
+import org.jreleaser.model.ChocolateyBucket;
 import org.jreleaser.model.Distribution;
+import org.jreleaser.model.GitService;
 import org.jreleaser.model.JReleaserContext;
 import org.jreleaser.model.JReleaserModel;
+import org.jreleaser.util.Env;
 import org.jreleaser.util.Errors;

 import static org.jreleaser.model.validation.DistributionsValidator.validateArtifactPlatforms;
@@ -41,7 +44,8 @@ public abstract class ChocolateyValidator extends Validator {
            tool.setActive(parentTool.getActive());
        }
        if (!tool.resolveEnabled(context.getModel().getProject(), distribution)) return;
-        if (!model.getRelease().getGitService().isReleaseSupported()) {
+        GitService service = model.getRelease().getGitService();
+        if (!service.isReleaseSupported()) {
            tool.disable();
            return;
        }
@@ -49,28 +53,43 @@ public abstract class ChocolateyValidator extends Validator {
        context.getLogger().debug("distribution.{}.chocolatey", distribution.getName());

        validateCommitAuthor(tool, parentTool);
-        validateOwner(tool.getBucket(), parentTool.getBucket());
+        ChocolateyBucket bucket = tool.getBucket();
+        validateOwner(bucket, parentTool.getBucket());
        validateTemplate(context, distribution, tool, parentTool, errors);
        mergeExtraProperties(tool, parentTool);

        if (isBlank(tool.getUsername())) {
-            tool.setUsername(model.getRelease().getGitService().getOwner());
+            tool.setUsername(service.getOwner());
        }
        if (!tool.isRemoteBuildSet() && parentTool.isRemoteBuildSet()) {
            tool.setRemoteBuild(parentTool.isRemoteBuild());
        }

-        if (isBlank(tool.getBucket().getName())) {
-            tool.getBucket().setName("chocolatey-bucket");
+        if (isBlank(bucket.getName())) {
+            bucket.setName("chocolatey-bucket");
        }
-        tool.getBucket().setBasename("chocolatey-bucket");
-        if (isBlank(tool.getBucket().getUsername())) {
-            tool.getBucket().setUsername(parentTool.getBucket().getUsername());
+        bucket.setBasename("chocolatey-bucket");
+        if (isBlank(bucket.getUsername())) {
+            bucket.setUsername(parentTool.getBucket().getUsername());
        }
-        if (isBlank(tool.getBucket().getToken())) {
-            tool.getBucket().setToken(parentTool.getBucket().getToken());
+        if (isBlank(bucket.getToken())) {
+            bucket.setToken(parentTool.getBucket().getToken());
        }

+        bucket.setUsername(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(bucket.getBasename() + "_" + service.getServiceName()) + "_USERNAME",
+                "distribution." + distribution.getName() + "chocolatey.bucket.username",
+                bucket.getUsername(),
+                service.getResolvedUsername()));
+
+        bucket.setToken(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(bucket.getBasename() + "_" + service.getServiceName()) + "_TOKEN",
+                "distribution." + distribution.getName() + "chocolatey.bucket.token",
+                bucket.getToken(),
+                service.getResolvedToken()));
+
        validateArtifactPlatforms(context, distribution, tool, errors);
    }
 }
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/DockerValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/DockerValidator.java
@@ -22,6 +22,7 @@ import org.jreleaser.model.Distribution;
 import org.jreleaser.model.Docker;
 import org.jreleaser.model.DockerConfiguration;
 import org.jreleaser.model.DockerSpec;
+import org.jreleaser.model.GitService;
 import org.jreleaser.model.JReleaserContext;
 import org.jreleaser.model.JReleaserModel;
 import org.jreleaser.model.Registry;
@@ -261,22 +262,29 @@ public abstract class DockerValidator extends Validator {
        }

        for (Registry registry : registries) {
-            if (isBlank(registry.getUsername())) {
-                registry.setUsername(model.getRelease().getGitService().getUsername());
-            }
+            GitService service = model.getRelease().getGitService();
+            String serverName = registry.getServerName();
+
+            registry.setUsername(
+                checkProperty(context.getModel().getEnvironment(),
+                    "DOCKER_" + Env.toVar(serverName) + "_USERNAME",
+                    "registry." + Env.toVar(serverName) + ".username",
+                    registry.getUsername(),
+                    service.getResolvedUsername()));
+
            if (isBlank(registry.getRepositoryName())) {
-                registry.setRepositoryName(model.getRelease().getGitService().getOwner());
+                registry.setRepositoryName(service.getOwner());
            }

            if (isBlank(registry.getUsername())) {
                errors.configuration(element +
-                    ".registry." + registry.getServerName() + ".username must not be blank");
+                    ".registry." + serverName + ".username must not be blank");
            }

            registry.setPassword(
                checkProperty(context.getModel().getEnvironment(),
-                    "DOCKER_" + Env.toVar(registry.getServerName()) + "_PASSWORD",
-                    "registry." + Env.toVar(registry.getServerName()) + ".password",
+                    "DOCKER_" + Env.toVar(serverName) + "_PASSWORD",
+                    "registry." + Env.toVar(serverName) + ".password",
                    registry.getPassword(),
                    errors,
                    context.isDryrun()));
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/GitServiceValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/GitServiceValidator.java
@@ -64,9 +64,13 @@ public abstract class GitServiceValidator extends Validator {
        if (isBlank(service.getName())) {
            service.setName(project.getName());
        }
-        if (isBlank(service.getUsername())) {
-            service.setUsername(service.getOwner());
-        }
+
+        service.setUsername(
+            checkProperty(context.getModel().getEnvironment(),
+                service.getServiceName().toUpperCase() + "_USERNAME",
+                service.getServiceName() + ".username",
+                service.getUsername(),
+                service.getOwner()));

        service.setToken(
            checkProperty(context.getModel().getEnvironment(),
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/JbangValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/JbangValidator.java
@@ -18,9 +18,12 @@
 package org.jreleaser.model.validation;

 import org.jreleaser.model.Distribution;
+import org.jreleaser.model.GitService;
 import org.jreleaser.model.JReleaserContext;
 import org.jreleaser.model.JReleaserModel;
 import org.jreleaser.model.Jbang;
+import org.jreleaser.model.JbangCatalog;
+import org.jreleaser.util.Env;
 import org.jreleaser.util.Errors;

 import java.util.List;
@@ -46,7 +49,8 @@ public abstract class JbangValidator extends Validator {
            tool.setActive(parentTool.getActive());
        }
        if (!tool.resolveEnabled(context.getModel().getProject(), distribution)) return;
-        if (!model.getRelease().getGitService().isReleaseSupported()) {
+        GitService service = model.getRelease().getGitService();
+        if (!service.isReleaseSupported()) {
            tool.disable();
            return;
        }
@@ -54,23 +58,38 @@ public abstract class JbangValidator extends Validator {
        context.getLogger().debug("distribution.{}.jbang", distribution.getName());

        validateCommitAuthor(tool, parentTool);
-        validateOwner(tool.getCatalog(), parentTool.getCatalog());
+        JbangCatalog catalog = tool.getCatalog();
+        validateOwner(catalog, parentTool.getCatalog());
        validateTemplate(context, distribution, tool, parentTool, errors);
        mergeExtraProperties(tool, parentTool);

        if (isBlank(tool.getAlias())) {
            tool.setAlias(distribution.getExecutable());
        }
-        if (isBlank(tool.getCatalog().getName())) {
-            tool.getCatalog().setName(parentTool.getCatalog().getName());
+        if (isBlank(catalog.getName())) {
+            catalog.setName(parentTool.getCatalog().getName());
        }
-        if (isBlank(tool.getCatalog().getUsername())) {
-            tool.getCatalog().setUsername(parentTool.getCatalog().getUsername());
+        if (isBlank(catalog.getUsername())) {
+            catalog.setUsername(parentTool.getCatalog().getUsername());
        }
-        if (isBlank(tool.getCatalog().getToken())) {
-            tool.getCatalog().setToken(parentTool.getCatalog().getToken());
+        if (isBlank(catalog.getToken())) {
+            catalog.setToken(parentTool.getCatalog().getToken());
        }

+        catalog.setUsername(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(catalog.getBasename() + "_" + service.getServiceName()) + "_USERNAME",
+                "distribution." + distribution.getName() + "jbang.catalog.username",
+                catalog.getUsername(),
+                service.getResolvedUsername()));
+
+        catalog.setToken(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(catalog.getBasename() + "_" + service.getServiceName()) + "_TOKEN",
+                "distribution." + distribution.getName() + "jbang.catalog.token",
+                catalog.getToken(),
+                service.getResolvedToken()));
+
        if (model.getProject().getExtraProperties().containsKey(KEY_REVERSE_REPO_HOST) &&
            !parentTool.getExtraProperties().containsKey(KEY_REVERSE_REPO_HOST)) {
            parentTool.getExtraProperties().put(KEY_REVERSE_REPO_HOST,
@@ -87,7 +106,7 @@ public abstract class JbangValidator extends Validator {
            tool.getExtraProperties().put(KEY_REVERSE_REPO_HOST,
                distribution.getExtraProperties().get(KEY_REVERSE_REPO_HOST));
        }
-        if (isBlank(model.getRelease().getGitService().getReverseRepoHost()) &&
+        if (isBlank(service.getReverseRepoHost()) &&
            !tool.getExtraProperties().containsKey(KEY_REVERSE_REPO_HOST)) {
            errors.configuration("distribution." + distribution.getName() +
                ".jbang must define an extra property named '" +
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/PackagersValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/PackagersValidator.java
@@ -18,10 +18,13 @@
 package org.jreleaser.model.validation;

 import org.jreleaser.model.AbstractRepositoryTool;
+import org.jreleaser.model.GitService;
 import org.jreleaser.model.JReleaserContext;
 import org.jreleaser.model.JReleaserModel;
 import org.jreleaser.model.OwnerAware;
 import org.jreleaser.model.Packagers;
+import org.jreleaser.model.RepositoryTap;
+import org.jreleaser.util.Env;
 import org.jreleaser.util.Errors;

 import static org.jreleaser.util.StringUtils.isBlank;
@@ -79,10 +82,25 @@ public abstract class PackagersValidator extends Validator {

    private static void validatePackager(JReleaserContext context,
                                         AbstractRepositoryTool tool,
-                                         OwnerAware ownerAware,
+                                         RepositoryTap tap,
                                         Errors errors) {
        tool.resolveEnabled(context.getModel().getProject());
-        validateCommitAuthor(tool, context.getModel().getRelease().getGitService());
-        validateOwner(ownerAware, context.getModel().getRelease().getGitService());
+        GitService service = context.getModel().getRelease().getGitService();
+        validateCommitAuthor(tool, service);
+        validateOwner(tap, service);
+
+        tap.setUsername(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(tap.getBasename() + "_" + service.getServiceName()) + "_USERNAME",
+                "<empty>",
+                tap.getUsername(),
+                service.getResolvedUsername()));
+
+        tap.setToken(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(tap.getBasename() + "_" + service.getServiceName()) + "_TOKEN",
+                "<empty>",
+                tap.getToken(),
+                service.getResolvedToken()));
    }
 }
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/ScoopValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/ScoopValidator.java
@@ -18,9 +18,12 @@
 package org.jreleaser.model.validation;

 import org.jreleaser.model.Distribution;
+import org.jreleaser.model.GitService;
 import org.jreleaser.model.JReleaserContext;
 import org.jreleaser.model.JReleaserModel;
 import org.jreleaser.model.Scoop;
+import org.jreleaser.model.ScoopBucket;
+import org.jreleaser.util.Env;
 import org.jreleaser.util.Errors;

 import static org.jreleaser.model.validation.DistributionsValidator.validateArtifactPlatforms;
@@ -41,7 +44,8 @@ public abstract class ScoopValidator extends Validator {
            tool.setActive(parentTool.getActive());
        }
        if (!tool.resolveEnabled(context.getModel().getProject(), distribution)) return;
-        if (!model.getRelease().getGitService().isReleaseSupported()) {
+        GitService service = model.getRelease().getGitService();
+        if (!service.isReleaseSupported()) {
            tool.disable();
            return;
        }
@@ -49,35 +53,50 @@ public abstract class ScoopValidator extends Validator {
        context.getLogger().debug("distribution.{}.scoop", distribution.getName());

        validateCommitAuthor(tool, parentTool);
-        validateOwner(tool.getBucket(), parentTool.getBucket());
+        ScoopBucket bucket = tool.getBucket();
+        validateOwner(bucket, parentTool.getBucket());
        validateTemplate(context, distribution, tool, parentTool, errors);
        mergeExtraProperties(tool, parentTool);

        if (isBlank(tool.getCheckverUrl())) {
            tool.setCheckverUrl(parentTool.getCheckverUrl());
            if (isBlank(tool.getCheckverUrl())) {
-                tool.setCheckverUrl(model.getRelease().getGitService().getLatestReleaseUrl());
+                tool.setCheckverUrl(service.getLatestReleaseUrl());
            }
        }
        if (isBlank(tool.getAutoupdateUrl())) {
            tool.setAutoupdateUrl(parentTool.getAutoupdateUrl());
            if (isBlank(tool.getAutoupdateUrl())) {
-                tool.setAutoupdateUrl(model.getRelease().getGitService().getDownloadUrl());
+                tool.setAutoupdateUrl(service.getDownloadUrl());
            }
        }

-        if (isBlank(tool.getBucket().getName())) {
-            tool.getBucket().setName(parentTool.getBucket().getName());
+        if (isBlank(bucket.getName())) {
+            bucket.setName(parentTool.getBucket().getName());
        }
-        tool.getBucket().setBasename(parentTool.getBucket().getBasename());
+        bucket.setBasename(parentTool.getBucket().getBasename());

-        if (isBlank(tool.getBucket().getUsername())) {
-            tool.getBucket().setUsername(parentTool.getBucket().getUsername());
+        if (isBlank(bucket.getUsername())) {
+            bucket.setUsername(parentTool.getBucket().getUsername());
        }
-        if (isBlank(tool.getBucket().getToken())) {
-            tool.getBucket().setToken(parentTool.getBucket().getToken());
+        if (isBlank(bucket.getToken())) {
+            bucket.setToken(parentTool.getBucket().getToken());
        }

+        bucket.setUsername(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(bucket.getBasename() + "_" + service.getServiceName()) + "_USERNAME",
+                "distribution." + distribution.getName() + "scoop.bucket.username",
+                bucket.getUsername(),
+                service.getResolvedUsername()));
+
+        bucket.setToken(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(bucket.getBasename() + "_" + service.getServiceName()) + "_TOKEN",
+                "distribution." + distribution.getName() + "scoop.bucket.token",
+                bucket.getToken(),
+                service.getResolvedToken()));
+
        validateArtifactPlatforms(context, distribution, tool, errors);
    }
 }
--- a/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/SnapValidator.java
+++ b/core/jreleaser-model/src/main/java/org/jreleaser/model/validation/SnapValidator.java
@@ -18,11 +18,14 @@
 package org.jreleaser.model.validation;

 import org.jreleaser.model.Distribution;
+import org.jreleaser.model.GitService;
 import org.jreleaser.model.JReleaserContext;
 import org.jreleaser.model.JReleaserModel;
 import org.jreleaser.model.Plug;
 import org.jreleaser.model.Slot;
 import org.jreleaser.model.Snap;
+import org.jreleaser.model.SnapTap;
+import org.jreleaser.util.Env;
 import org.jreleaser.util.Errors;

 import java.util.ArrayList;
@@ -49,7 +52,8 @@ public abstract class SnapValidator extends Validator {
            tool.setActive(parentTool.getActive());
        }
        if (!tool.resolveEnabled(context.getModel().getProject(), distribution)) return;
-        if (!model.getRelease().getGitService().isReleaseSupported()) {
+        GitService service = model.getRelease().getGitService();
+        if (!service.isReleaseSupported()) {
            tool.disable();
            return;
        }
@@ -57,7 +61,8 @@ public abstract class SnapValidator extends Validator {
        context.getLogger().debug("distribution.{}.snap", distribution.getName());

        validateCommitAuthor(tool, parentTool);
-        validateOwner(tool.getSnap(), parentTool.getSnap());
+        SnapTap snap = tool.getSnap();
+        validateOwner(snap, parentTool.getSnap());
        validateTemplate(context, distribution, tool, parentTool, errors);
        mergeExtraProperties(tool, parentTool);
        mergeSnapPlugs(tool, parentTool);
@@ -94,17 +99,31 @@ public abstract class SnapValidator extends Validator {
            }
        }

-        if (isBlank(tool.getSnap().getName())) {
-            tool.getSnap().setName(distribution.getName() + "-snap");
+        if (isBlank(snap.getName())) {
+            snap.setName(distribution.getName() + "-snap");
        }
-        tool.getSnap().setBasename(distribution.getName() + "-snap");
-        if (isBlank(tool.getSnap().getUsername())) {
-            tool.getSnap().setUsername(parentTool.getSnap().getUsername());
+        snap.setBasename(distribution.getName() + "-snap");
+        if (isBlank(snap.getUsername())) {
+            snap.setUsername(parentTool.getSnap().getUsername());
        }
-        if (isBlank(tool.getSnap().getToken())) {
-            tool.getSnap().setToken(parentTool.getSnap().getToken());
+        if (isBlank(snap.getToken())) {
+            snap.setToken(parentTool.getSnap().getToken());
        }

+        snap.setUsername(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(snap.getBasename() + "_" + service.getServiceName()) + "_USERNAME",
+                "distribution." + distribution.getName() + "snap.snap.username",
+                snap.getUsername(),
+                service.getResolvedUsername()));
+
+        snap.setToken(
+            checkProperty(context.getModel().getEnvironment(),
+                Env.toVar(snap.getBasename() + "_" + service.getServiceName()) + "_TOKEN",
+                "distribution." + distribution.getName() + "snap.snap.token",
+                snap.getToken(),
+                service.getResolvedToken()));
+
        validateArtifactPlatforms(context, distribution, tool, errors);
    }

--- a/core/jreleaser-tools/src/main/java/org/jreleaser/tools/AbstractRepositoryToolProcessor.java
+++ b/core/jreleaser-tools/src/main/java/org/jreleaser/tools/AbstractRepositoryToolProcessor.java
@@ -125,16 +125,12 @@ abstract class AbstractRepositoryToolProcessor<T extends RepositoryTool> extends
    }

    protected String resolveGitUsername(GitService gitService) {
-        if (isNotBlank(tool.getRepositoryTap().getUsername())) {
-            return tool.getRepositoryTap().getUsername();
-        }
-        return gitService.getUsername();
+        String username = tool.getRepositoryTap().getResolvedUsername(gitService);
+        return isNotBlank(username) ? username : gitService.getResolvedUsername();
    }

    protected String resolveGitToken(GitService gitService) {
-        if (isNotBlank(tool.getRepositoryTap().getResolvedToken(gitService))) {
-            return tool.getRepositoryTap().getResolvedToken(gitService);
-        }
-        return gitService.getResolvedToken();
+        String token = tool.getRepositoryTap().getResolvedToken(gitService);
+        return isNotBlank(token) ? token : gitService.getResolvedToken();
    }
 }
--- a/core/jreleaser-tools/src/main/java/org/jreleaser/tools/DockerToolProcessor.java
+++ b/core/jreleaser-tools/src/main/java/org/jreleaser/tools/DockerToolProcessor.java
@@ -262,7 +262,7 @@ public class DockerToolProcessor extends AbstractToolProcessor<Docker> {
            cmd.add(registry.getServer());
        }
        cmd.add("-u");
-        cmd.add(registry.getUsername());
+        cmd.add(registry.getResolvedUsername());
        cmd.add("-p");
        cmd.add(registry.getResolvedPassword());

--- a/sdks/genericgit-java-sdk/src/main/java/org/jreleaser/sdk/generic/git/GenericGitReleaser.java
+++ b/sdks/genericgit-java-sdk/src/main/java/org/jreleaser/sdk/generic/git/GenericGitReleaser.java
@@ -81,7 +81,7 @@ public class GenericGitReleaser implements Releaser {
            context.getLogger().debug("pushing tag to remote, dryrun = {}", context.isDryrun());

            UsernamePasswordCredentialsProvider credentialsProvider = new UsernamePasswordCredentialsProvider(
-                context.getModel().getRelease().getGitService().getUsername(),
+                context.getModel().getRelease().getGitService().getResolvedUsername(),
                context.getModel().getRelease().getGitService().getResolvedToken());

            gitSdk.open().push()
--- a/sdks/github-java-sdk/src/main/java/org/jreleaser/sdk/github/GithubReleaser.java
+++ b/sdks/github-java-sdk/src/main/java/org/jreleaser/sdk/github/GithubReleaser.java
@@ -57,7 +57,7 @@ public class GithubReleaser implements Releaser {
            String changelog = context.getChangelog();

            Github api = new Github(context.getLogger(),
-                github.getUsername(),
+                github.getResolvedUsername(),
                github.getResolvedToken(),
                github.getConnectTimeout(),
                github.getReadTimeout());