-
Notifications
You must be signed in to change notification settings - Fork 3
/
service.go
153 lines (129 loc) · 4.11 KB
/
service.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
// Package service implements business logic to create Kubernetes resources
// against the Kubernetes API.
package service
import (
"context"
"sync"
infrastructurev1alpha3 "github.com/giantswarm/apiextensions/v3/pkg/apis/infrastructure/v1alpha3"
releasev1alpha1 "github.com/giantswarm/apiextensions/v3/pkg/apis/release/v1alpha1"
"github.com/giantswarm/k8sclient/v5/pkg/k8sclient"
"github.com/giantswarm/k8sclient/v5/pkg/k8srestconfig"
"github.com/giantswarm/microendpoint/service/version"
"github.com/giantswarm/microerror"
"github.com/giantswarm/micrologger"
"github.com/spf13/viper"
"k8s.io/client-go/rest"
apiv1alpha3 "sigs.k8s.io/cluster-api/api/v1alpha3"
"github.com/giantswarm/aws-collector/client/aws"
"github.com/giantswarm/aws-collector/flag"
"github.com/giantswarm/aws-collector/pkg/project"
"github.com/giantswarm/aws-collector/service/collector"
)
// Config represents the configuration used to create a new service.
type Config struct {
Logger micrologger.Logger
Flag *flag.Flag
Viper *viper.Viper
}
type Service struct {
Version *version.Service
bootOnce sync.Once
operatorCollector *collector.Set
}
// New creates a new configured service object.
func New(config Config) (*Service, error) {
// Settings.
if config.Flag == nil {
return nil, microerror.Maskf(invalidConfigError, "config.Flag must not be empty")
}
if config.Viper == nil {
return nil, microerror.Maskf(invalidConfigError, "config.Viper must not be empty")
}
// Dependencies.
if config.Logger == nil {
return nil, microerror.Maskf(invalidConfigError, "logger must not be empty")
}
var err error
var restConfig *rest.Config
{
c := k8srestconfig.Config{
Logger: config.Logger,
Address: config.Viper.GetString(config.Flag.Service.Kubernetes.Address),
InCluster: config.Viper.GetBool(config.Flag.Service.Kubernetes.InCluster),
KubeConfig: config.Viper.GetString(config.Flag.Service.Kubernetes.KubeConfig),
TLS: k8srestconfig.ConfigTLS{
CAFile: config.Viper.GetString(config.Flag.Service.Kubernetes.TLS.CAFile),
CrtFile: config.Viper.GetString(config.Flag.Service.Kubernetes.TLS.CrtFile),
KeyFile: config.Viper.GetString(config.Flag.Service.Kubernetes.TLS.KeyFile),
},
}
restConfig, err = k8srestconfig.New(c)
if err != nil {
return nil, microerror.Mask(err)
}
}
var k8sClient *k8sclient.Clients
{
c := k8sclient.ClientsConfig{
SchemeBuilder: k8sclient.SchemeBuilder{
apiv1alpha3.AddToScheme,
infrastructurev1alpha3.AddToScheme,
releasev1alpha1.AddToScheme,
},
Logger: config.Logger,
RestConfig: restConfig,
}
k8sClient, err = k8sclient.NewClients(c)
if err != nil {
return nil, microerror.Mask(err)
}
}
var awsConfig aws.Config
{
awsConfig = aws.Config{
AccessKeyID: config.Viper.GetString(config.Flag.Service.AWS.HostAccessKey.ID),
AccessKeySecret: config.Viper.GetString(config.Flag.Service.AWS.HostAccessKey.Secret),
Region: config.Viper.GetString(config.Flag.Service.AWS.Region),
SessionToken: config.Viper.GetString(config.Flag.Service.AWS.HostAccessKey.Session),
}
}
var operatorCollector *collector.Set
{
c := collector.SetConfig{
Clients: k8sClient,
Logger: config.Logger,
AWSConfig: awsConfig,
InstallationName: config.Viper.GetString(config.Flag.Service.Installation.Name),
TrustedAdvisorEnabled: config.Viper.GetBool(config.Flag.Service.AWS.TrustedAdvisor.Enabled),
}
operatorCollector, err = collector.NewSet(c)
if err != nil {
return nil, microerror.Mask(err)
}
}
var versionService *version.Service
{
c := version.Config{
Description: project.Description(),
GitCommit: project.GitSHA(),
Name: project.Name(),
Source: project.Source(),
Version: project.Version(),
}
versionService, err = version.New(c)
if err != nil {
return nil, microerror.Mask(err)
}
}
s := &Service{
Version: versionService,
bootOnce: sync.Once{},
operatorCollector: operatorCollector,
}
return s, nil
}
func (s *Service) Boot(ctx context.Context) {
s.bootOnce.Do(func() {
go s.operatorCollector.Boot(ctx) // nolint: errcheck
})
}