/
opts.go
executable file
·154 lines (130 loc) · 4.92 KB
/
opts.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
package cmd
import (
"os"
"time"
"github.com/go-playground/validator"
crd "github.com/nerdalize/nerd/crd/pkg/client/clientset/versioned"
"github.com/nerdalize/nerd/pkg/kubeconfig"
"github.com/nerdalize/nerd/pkg/populator"
transfer "github.com/nerdalize/nerd/pkg/transfer"
"github.com/nerdalize/nerd/pkg/transfer/archiver"
"github.com/nerdalize/nerd/pkg/transfer/store"
"github.com/nerdalize/nerd/svc"
"github.com/pkg/errors"
apiext "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/tools/clientcmd"
)
//ConfOpts are the options related to config file and the way output is handled.
type ConfOpts struct {
ConfigFile func(string) `long:"config-file" default:"" default-mask:"" env:"NERD_CONFIG_FILE" description:"Location of config file"`
SessionFile func(string) `long:"session-file" default:"" default-mask:"" env:"NERD_SESSION_FILE" description:"Location of session file"`
}
//TransferOpts hold CLI options for configuring data transfer
type TransferOpts struct {
S3Bucket string `long:"s3-bucket" description:"S3 Bucket name that will be used for dataset storage" default:"nlz-datasets-dev"`
AWSRegion string `long:"aws-region" description:"AWS region used for dataset storage"`
S3AccessKey string `long:"s3-access-key" description:"access key used for auth with the storage backend"`
S3SecretKey string `long:"s3-secret-key" description:"secret key for auth with the storage backend"`
S3SessionToken string `long:"s3-session-token" description:"temporary auth token for the storage backend"`
S3Prefix string `long:"s3-prefix" description:"store this dataset under a specific prefix"`
}
//TransferManager creates a transfermanager using the command line options
func (opts TransferOpts) TransferManager(kube *svc.Kube) (mgr transfer.Manager, sto *transferstore.StoreOptions, sta *transferarchiver.ArchiverOptions, err error) {
if mgr, err = transfer.NewKubeManager(
kube,
); err != nil {
return nil, nil, nil, errors.Wrap(err, "failed to setup transfer manager")
}
sto = &transferstore.StoreOptions{
Type: transferstore.StoreTypeS3,
S3StoreBucket: opts.S3Bucket,
S3StoreAWSRegion: opts.AWSRegion,
S3StoreAccessKey: opts.S3AccessKey,
S3StoreSecretKey: opts.S3SecretKey,
S3SessionToken: opts.S3SessionToken,
S3StorePrefix: opts.S3Prefix,
}
sta = &transferarchiver.ArchiverOptions{
Type: transferarchiver.ArchiverTypeTar,
}
return mgr, sto, sta, nil
}
//KubeOpts can be used to create a Kubernetes service
type KubeOpts struct {
KubeConfig string `long:"kubeconfig" description:"file at which Nerd will look for Kubernetes credentials" env:"KUBECONFIG" default-mask:"~/.kube/config"`
Timeout time.Duration `long:"timeout" description:"duration for which Nerd will wait for Kubernetes" default-mask:"10s" default:"10s" required:"true"`
}
//Deps exposes dependencies
type Deps struct {
val svc.Validator
kube kubernetes.Interface
crd crd.Interface
apiext apiext.Interface
logs svc.Logger
ns string
}
//NewDeps uses options to setup dependencies
func NewDeps(logs svc.Logger, kopts KubeOpts) (*Deps, error) {
kubeConfig, err := kubeconfig.GetPath(kopts.KubeConfig)
if err != nil {
return nil, errors.Wrap(err, "failed to get kube config file path")
}
kcfg, err := clientcmd.BuildConfigFromFlags("", kubeConfig)
if err != nil {
if os.IsNotExist(err) {
return nil, ErrNotLoggedIn
}
return nil, errors.Wrap(err, "failed to build Kubernetes config from provided kube config path")
}
d := &Deps{
logs: logs,
}
d.apiext, err = apiext.NewForConfig(kcfg)
if err != nil {
return nil, errors.Wrap(err, "failed to create Kuberntes configuration")
}
d.crd, err = crd.NewForConfig(kcfg)
if err != nil {
return nil, errors.Wrap(err, "failed to create Kubernetes configuration")
}
d.kube, err = kubernetes.NewForConfig(kcfg)
if err != nil {
return nil, errors.Wrap(err, "failed to create Kubernetes configuration")
}
if !populator.NerdContext(kubeConfig) {
return nil, ErrNamespaceNotSet
}
d.ns, err = populator.Namespace(kubeConfig)
if err != nil || d.ns == "" {
return nil, ErrNamespaceNotSet
}
val := validator.New()
val.RegisterValidation("is-abs-path", svc.ValidateAbsPath)
d.val = val
return d, nil
}
//Kube provides the kubernetes dependency.
func (deps *Deps) Kube() kubernetes.Interface {
return deps.kube
}
//Validator provides the Validator dependency.
func (deps *Deps) Validator() svc.Validator {
return deps.val
}
//Logger provides the Logger dependency.
func (deps *Deps) Logger() svc.Logger {
return deps.logs
}
//Namespace provides the namespace dependency.
func (deps *Deps) Namespace() string {
return deps.ns
}
//Crd provides the custom resource definition API.
func (deps *Deps) Crd() crd.Interface {
return deps.crd
}
//APIExt provides the extensions api to create a custom resource definition.
func (deps *Deps) APIExt() apiext.Interface {
return deps.apiext
}