Files
dokku/plugins/registry/subcommands.go
T
Jose Diaz-Gonzalez 624eea1959 feat: add registry:auth-status to read back login state
There was no way to ask whether Dokku was already logged in to a registry with a given credential, so tooling converging a declared state onto a server had to re-run `registry:login` on every pass purely to discover that nothing needed to change. The new `registry:auth-status` command compares a supplied credential against the stored one and reports the result through its exit code alone, distinguishing a server with no credential from one whose credential differs, and from one whose secret a docker credential helper or an identity token puts out of reach. An `auth-servers` triad on `registry:report` exposes which servers have credentials without emitting any part of one.
2026-09-19 19:19:57 -04:00

229 lines
6.0 KiB
Go

package registry
import (
"bytes"
"errors"
"fmt"
"io"
"os"
"strings"
"github.com/dokku/dokku/plugins/common"
)
// readPasswordFromStdin reads a registry password from stdin
func readPasswordFromStdin() (string, error) {
stdin, err := io.ReadAll(os.Stdin)
if err != nil {
return "", err
}
return strings.TrimSpace(string(stdin)), nil
}
// CommandAuthStatus reports whether the stored registry credential matches the
// requested state, communicating the result via the exit code alone
func CommandAuthStatus(appName string, server string, username string, password string, passwordStdin bool) error {
if passwordStdin {
if username == "" {
return InvalidAuthStatusArguments("Missing username argument")
}
stdin, err := readPasswordFromStdin()
if err != nil {
return InvalidAuthStatusArguments(err.Error())
}
password = stdin
}
if server == "" {
return InvalidAuthStatusArguments("Missing server argument")
}
if username != "" && password == "" {
return InvalidAuthStatusArguments("Missing password argument")
}
if username == "" && password != "" {
return InvalidAuthStatusArguments("Missing username argument")
}
configPath := GetGlobalRegistryConfigPath()
if appName != "" {
if err := common.VerifyAppName(appName); err != nil {
// a missing app carries its own exit code, while an invalid name is
// a malformed call and must not be reported as a missing credential
if _, ok := err.(common.ErrWithExitCode); ok {
return err
}
return InvalidAuthStatusArguments(err.Error())
}
configPath = GetAppRegistryConfigPath(appName)
}
contents, err := os.ReadFile(configPath)
if err != nil && !os.IsNotExist(err) {
return &common.ExitCodeError{
Code: authStatusUnknown,
Message: fmt.Sprintf("Unable to read the docker config: %s", err.Error()),
}
}
code, message := checkAuthStatus(authStatusInput{
ConfigBytes: contents,
Server: server,
Username: username,
Password: password,
})
if code == authStatusMatch {
return nil
}
return &common.ExitCodeError{Code: code, Message: message}
}
// InvalidAuthStatusArguments reports a registry:auth-status call that could not be checked
func InvalidAuthStatusArguments(message string) error {
return &common.ExitCodeError{Code: authStatusInvalidArguments, Message: message}
}
// CommandLogin logs a user into the specified server
func CommandLogin(appName string, server string, username string, password string, passwordStdin bool) error {
if passwordStdin {
stdin, err := readPasswordFromStdin()
if err != nil {
return err
}
password = stdin
}
if server == "" {
return errors.New("Missing server argument")
}
if username == "" {
return errors.New("Missing username argument")
}
if password == "" {
return errors.New("Missing password argument")
}
server = normalizeRegistryServer(server)
buffer := bytes.Buffer{}
buffer.Write([]byte(password + "\n"))
env := map[string]string{}
if appName != "" {
if err := common.VerifyAppName(appName); err != nil {
return err
}
configDir := GetAppRegistryConfigDir(appName)
if err := os.MkdirAll(configDir, 0700); err != nil {
return fmt.Errorf("Unable to create registry config directory: %w", err)
}
env["DOCKER_CONFIG"] = GetAppRegistryConfigDir(appName)
}
result, err := common.CallExecCommand(common.ExecCommandInput{
Command: common.DockerBin(),
Args: []string{"login", "--username", username, "--password-stdin", server},
Env: env,
Stdin: &buffer,
})
if err != nil {
return fmt.Errorf("Unable to run docker login: %w", err)
}
if result.ExitCode != 0 {
return fmt.Errorf("Unable to run docker login: %s", result.StderrContents())
}
if appName != "" {
common.LogWarn(fmt.Sprintf("Login Succeeded for %s", appName))
} else {
common.LogWarn("Login Succeeded for global registry")
}
// todo: change the signature of the trigger to include the app name
_, err = common.CallPlugnTrigger(common.PlugnTriggerInput{
Trigger: "post-registry-login",
Args: []string{server, username},
StreamStdio: true,
Env: map[string]string{
"DOCKER_REGISTRY_PASS": password,
},
})
if err != nil {
return err
}
return nil
}
// CommandLogout logs a user out from the specified server
func CommandLogout(appName string, server string) error {
if server == "" {
return errors.New("Missing server argument")
}
// docker only erases the exact auths key it is given, and stores Docker Hub
// under the index server address rather than the hostname logged in with, so
// a logout for docker.io has to name that address to remove anything
server = dockerAuthKey(server)
env := map[string]string{}
if appName != "" {
if err := common.VerifyAppName(appName); err != nil {
return err
}
configDir := GetAppRegistryConfigDir(appName)
if !common.DirectoryExists(configDir) {
return fmt.Errorf("No registry credentials found for app %s", appName)
}
env["DOCKER_CONFIG"] = GetAppRegistryConfigDir(appName)
}
result, err := common.CallExecCommand(common.ExecCommandInput{
Command: common.DockerBin(),
Args: []string{"logout", server},
Env: env,
})
if err != nil {
return fmt.Errorf("Unable to run docker logout: %w", err)
}
if result.ExitCode != 0 {
return fmt.Errorf("Unable to run docker logout: %s", result.StderrContents())
}
return nil
}
// CommandReport displays a registry report for one or more apps
func CommandReport(appName string, format string, infoFlag string) error {
if len(appName) == 0 {
apps, err := common.DokkuApps()
if err != nil {
if errors.Is(err, common.NoAppsExist) {
common.LogWarn(err.Error())
return nil
}
return err
}
for _, appName := range apps {
if err := ReportSingleApp(appName, format, infoFlag); err != nil {
return err
}
}
return nil
}
return ReportSingleApp(appName, format, infoFlag)
}
// CommandSet set or clear a registry property for an app
func CommandSet(appName string, property string, value string) error {
common.CommandPropertySet("registry", appName, property, value, DefaultProperties, GlobalProperties)
return nil
}