package command import ( "fmt" "io" "os" "path/filepath" "github.com/docker/cli/cli/config/configfile" "github.com/docker/cli/cli/context/docker" "github.com/docker/cli/cli/context/kubernetes" "github.com/docker/cli/cli/context/store" cliflags "github.com/docker/cli/cli/flags" "github.com/docker/docker/pkg/homedir" "github.com/pkg/errors" ) const ( // DefaultContextName is the name reserved for the default context (config & env based) DefaultContextName = "default" ) // DefaultContext contains the default context data for all enpoints type DefaultContext struct { Meta store.Metadata TLS store.ContextTLSData } // DefaultContextResolver is a function which resolves the default context base on the configuration and the env variables type DefaultContextResolver func() (*DefaultContext, error) // ContextStoreWithDefault implements the store.Store interface with a support for the default context type ContextStoreWithDefault struct { store.Store Resolver DefaultContextResolver } // resolveDefaultContext creates a Metadata for the current CLI invocation parameters func resolveDefaultContext(opts *cliflags.CommonOptions, config *configfile.ConfigFile, stderr io.Writer) (*DefaultContext, error) { stackOrchestrator, err := GetStackOrchestrator("", "", config.StackOrchestrator, stderr) if err != nil { return nil, err } contextTLSData := store.ContextTLSData{ Endpoints: make(map[string]store.EndpointTLSData), } contextMetadata := store.Metadata{ Endpoints: make(map[string]interface{}), Metadata: DockerContext{ Description: "", StackOrchestrator: stackOrchestrator, }, Name: DefaultContextName, } dockerEP, err := resolveDefaultDockerEndpoint(opts) if err != nil { return nil, err } contextMetadata.Endpoints[docker.DockerEndpoint] = dockerEP.EndpointMeta if dockerEP.TLSData != nil { contextTLSData.Endpoints[docker.DockerEndpoint] = *dockerEP.TLSData.ToStoreTLSData() } // Default context uses env-based kubeconfig for Kubernetes endpoint configuration kubeconfig := os.Getenv("KUBECONFIG") if kubeconfig == "" { kubeconfig = filepath.Join(homedir.Get(), ".kube/config") } kubeEP, err := kubernetes.FromKubeConfig(kubeconfig, "", "") if (stackOrchestrator == OrchestratorKubernetes || stackOrchestrator == OrchestratorAll) && err != nil { return nil, errors.Wrapf(err, "default orchestrator is %s but kubernetes endpoint could not be found", stackOrchestrator) } if err == nil { contextMetadata.Endpoints[kubernetes.KubernetesEndpoint] = kubeEP.EndpointMeta if kubeEP.TLSData != nil { contextTLSData.Endpoints[kubernetes.KubernetesEndpoint] = *kubeEP.TLSData.ToStoreTLSData() } } return &DefaultContext{Meta: contextMetadata, TLS: contextTLSData}, nil } // List implements store.Store's List func (s *ContextStoreWithDefault) List() ([]store.Metadata, error) { contextList, err := s.Store.List() if err != nil { return nil, err } defaultContext, err := s.Resolver() if err != nil { return nil, err } return append(contextList, defaultContext.Meta), nil } // CreateOrUpdate is not allowed for the default context and fails func (s *ContextStoreWithDefault) CreateOrUpdate(meta store.Metadata) error { if meta.Name == DefaultContextName { return errors.New("default context cannot be created nor updated") } return s.Store.CreateOrUpdate(meta) } // Remove is not allowed for the default context and fails func (s *ContextStoreWithDefault) Remove(name string) error { if name == DefaultContextName { return errors.New("default context cannot be removed") } return s.Store.Remove(name) } // GetMetadata implements store.Store's GetMetadata func (s *ContextStoreWithDefault) GetMetadata(name string) (store.Metadata, error) { if name == DefaultContextName { defaultContext, err := s.Resolver() if err != nil { return store.Metadata{}, err } return defaultContext.Meta, nil } return s.Store.GetMetadata(name) } // ResetTLSMaterial is not implemented for default context and fails func (s *ContextStoreWithDefault) ResetTLSMaterial(name string, data *store.ContextTLSData) error { if name == DefaultContextName { return errors.New("The default context store does not support ResetTLSMaterial") } return s.Store.ResetTLSMaterial(name, data) } // ResetEndpointTLSMaterial is not implemented for default context and fails func (s *ContextStoreWithDefault) ResetEndpointTLSMaterial(contextName string, endpointName string, data *store.EndpointTLSData) error { if contextName == DefaultContextName { return errors.New("The default context store does not support ResetEndpointTLSMaterial") } return s.Store.ResetEndpointTLSMaterial(contextName, endpointName, data) } // ListTLSFiles implements store.Store's ListTLSFiles func (s *ContextStoreWithDefault) ListTLSFiles(name string) (map[string]store.EndpointFiles, error) { if name == DefaultContextName { defaultContext, err := s.Resolver() if err != nil { return nil, err } tlsfiles := make(map[string]store.EndpointFiles) for epName, epTLSData := range defaultContext.TLS.Endpoints { var files store.EndpointFiles for filename := range epTLSData.Files { files = append(files, filename) } tlsfiles[epName] = files } return tlsfiles, nil } return s.Store.ListTLSFiles(name) } // GetTLSData implements store.Store's GetTLSData func (s *ContextStoreWithDefault) GetTLSData(contextName, endpointName, fileName string) ([]byte, error) { if contextName == DefaultContextName { defaultContext, err := s.Resolver() if err != nil { return nil, err } if defaultContext.TLS.Endpoints[endpointName].Files[fileName] == nil { return nil, &noDefaultTLSDataError{endpointName: endpointName, fileName: fileName} } return defaultContext.TLS.Endpoints[endpointName].Files[fileName], nil } return s.Store.GetTLSData(contextName, endpointName, fileName) } type noDefaultTLSDataError struct { endpointName string fileName string } func (e *noDefaultTLSDataError) Error() string { return fmt.Sprintf("tls data for %s/%s/%s does not exist", DefaultContextName, e.endpointName, e.fileName) } // NotFound satisfies interface github.com/docker/docker/errdefs.ErrNotFound func (e *noDefaultTLSDataError) NotFound() {} // IsTLSDataDoesNotExist satisfies github.com/docker/cli/cli/context/store.tlsDataDoesNotExist func (e *noDefaultTLSDataError) IsTLSDataDoesNotExist() {} // GetStorageInfo implements store.Store's GetStorageInfo func (s *ContextStoreWithDefault) GetStorageInfo(contextName string) store.StorageInfo { if contextName == DefaultContextName { return store.StorageInfo{MetadataPath: "", TLSPath: ""} } return s.Store.GetStorageInfo(contextName) }