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.
229 lines
6.0 KiB
Go
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
|
|
}
|