vendor/github.com/docker/swarmkit/template/getter.go

   1 package template
   2
   3 import (
   4         "github.com/docker/swarmkit/agent/exec"
   5         "github.com/docker/swarmkit/api"
   6         "github.com/pkg/errors"
   7 )
   8
   9 type templatedSecretGetter struct {
  10         dependencies exec.DependencyGetter
  11         t            *api.Task
  12 }
  13
  14 // NewTemplatedSecretGetter returns a SecretGetter that evaluates templates.
  15 func NewTemplatedSecretGetter(dependencies exec.DependencyGetter, t *api.Task) exec.SecretGetter {
  16         return templatedSecretGetter{dependencies: dependencies, t: t}
  17 }
  18
  19 func (t templatedSecretGetter) Get(secretID string) (*api.Secret, error) {
  20         if t.dependencies == nil {
  21                 return nil, errors.New("no secret provider available")
  22         }
  23
  24         secrets := t.dependencies.Secrets()
  25         if secrets == nil {
  26                 return nil, errors.New("no secret provider available")
  27         }
  28
  29         secret, err := secrets.Get(secretID)
  30         if err != nil {
  31                 return secret, err
  32         }
  33
  34         newSpec, err := ExpandSecretSpec(secret, t.t, t.dependencies)
  35         if err != nil {
  36                 return secret, errors.Wrapf(err, "failed to expand templated secret %s", secretID)
  37         }
  38
  39         secretCopy := *secret
  40         secretCopy.Spec = *newSpec
  41         return &secretCopy, nil
  42 }
  43
  44 type templatedConfigGetter struct {
  45         dependencies exec.DependencyGetter
  46         t            *api.Task
  47 }
  48
  49 // NewTemplatedConfigGetter returns a ConfigGetter that evaluates templates.
  50 func NewTemplatedConfigGetter(dependencies exec.DependencyGetter, t *api.Task) exec.ConfigGetter {
  51         return templatedConfigGetter{dependencies: dependencies, t: t}
  52 }
  53
  54 func (t templatedConfigGetter) Get(configID string) (*api.Config, error) {
  55         if t.dependencies == nil {
  56                 return nil, errors.New("no config provider available")
  57         }
  58
  59         configs := t.dependencies.Configs()
  60         if configs == nil {
  61                 return nil, errors.New("no config provider available")
  62         }
  63
  64         config, err := configs.Get(configID)
  65         if err != nil {
  66                 return config, err
  67         }
  68
  69         newSpec, err := ExpandConfigSpec(config, t.t, t.dependencies)
  70         if err != nil {
  71                 return config, errors.Wrapf(err, "failed to expand templated config %s", configID)
  72         }
  73
  74         configCopy := *config
  75         configCopy.Spec = *newSpec
  76         return &configCopy, nil
  77 }
  78
  79 type templatedDependencyGetter struct {
  80         secrets exec.SecretGetter
  81         configs exec.ConfigGetter
  82 }
  83
  84 // NewTemplatedDependencyGetter returns a DependencyGetter that evaluates templates.
  85 func NewTemplatedDependencyGetter(dependencies exec.DependencyGetter, t *api.Task) exec.DependencyGetter {
  86         return templatedDependencyGetter{
  87                 secrets: NewTemplatedSecretGetter(dependencies, t),
  88                 configs: NewTemplatedConfigGetter(dependencies, t),
  89         }
  90 }
  91
  92 func (t templatedDependencyGetter) Secrets() exec.SecretGetter {
  93         return t.secrets
  94 }
  95
  96 func (t templatedDependencyGetter) Configs() exec.ConfigGetter {
  97         return t.configs
  98 }