-
Notifications
You must be signed in to change notification settings - Fork 3
/
gen.go
137 lines (100 loc) · 2.9 KB
/
gen.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
// Package gen is the package that contains the generation logic.
package gen
import (
"github.com/aiven/aiven-go-client"
"golang.org/x/net/context"
"golang.org/x/sync/errgroup"
"github.com/aiven/go-api-schemas/internal/convert"
"github.com/aiven/go-api-schemas/internal/pkg/types"
"github.com/aiven/go-api-schemas/internal/pkg/util"
)
const (
// generating is a part of the message that is printed when the generation process starts.
generating = "generating %s"
)
// logger is a pointer to the logger.
var logger *util.Logger
// env is a map of environment variables.
var env util.EnvMap
// client is a pointer to the Aiven client.
var client *aiven.Client
// result is the result of the generation process.
var result types.GenerationResult
// serviceTypes generates the service types.
func serviceTypes() error {
defer util.MeasureExecutionTime(logger)()
logger.Info.Printf(generating, "service types")
r, err := client.Projects.ServiceTypes(env[util.EnvAivenProjectName])
if err != nil {
return err
}
out := make(map[string]types.UserConfigSchema, len(r))
for k, v := range r {
cv, err := convert.UserConfigSchema(v.UserConfigSchema)
if err != nil {
return err
}
out[k] = *cv
}
result[types.KeyServiceTypes] = out
return nil
}
// integrationTypes generates the integration types.
func integrationTypes() error {
defer util.MeasureExecutionTime(logger)()
logger.Info.Printf(generating, "integration types")
r, err := client.Projects.IntegrationTypes(env[util.EnvAivenProjectName])
if err != nil {
return err
}
out := make(map[string]types.UserConfigSchema, len(r))
for _, v := range r {
cv, err := convert.UserConfigSchema(v.UserConfigSchema)
if err != nil {
return err
}
out[v.IntegrationType] = *cv
}
result[types.KeyIntegrationTypes] = out
return nil
}
// integrationEndpointTypes generates the integration endpoint types.
func integrationEndpointTypes() error {
defer util.MeasureExecutionTime(logger)()
logger.Info.Printf(generating, "integration endpoint types")
r, err := client.Projects.IntegrationEndpointTypes(env[util.EnvAivenProjectName])
if err != nil {
return err
}
out := make(map[string]types.UserConfigSchema, len(r))
for _, v := range r {
cv, err := convert.UserConfigSchema(v.UserConfigSchema)
if err != nil {
return err
}
out[v.EndpointType] = *cv
}
result[types.KeyIntegrationEndpointTypes] = out
return nil
}
// setup sets up the generation process.
func setup(l *util.Logger, e util.EnvMap, c *aiven.Client) {
logger = l
env = e
client = c
result = types.GenerationResult{}
}
// Run executes the generation process.
func Run(
ctx context.Context,
logger *util.Logger,
env util.EnvMap,
client *aiven.Client,
) (types.GenerationResult, error) {
setup(logger, env, client)
errs, _ := errgroup.WithContext(ctx)
errs.Go(serviceTypes)
errs.Go(integrationTypes)
errs.Go(integrationEndpointTypes)
return result, errs.Wait()
}