forked from JamesClonk/backman
-
Notifications
You must be signed in to change notification settings - Fork 19
/
service.go
190 lines (168 loc) · 5.32 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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
package service
import (
"fmt"
"math/rand"
"sync"
"time"
cfenv "github.com/cloudfoundry-community/go-cfenv"
"github.com/swisscom/backman/config"
"github.com/swisscom/backman/log"
"github.com/swisscom/backman/s3"
"github.com/swisscom/backman/service/mysql"
"github.com/swisscom/backman/service/postgres"
"github.com/swisscom/backman/service/redis"
"github.com/swisscom/backman/service/util"
"github.com/swisscom/backman/state"
)
var (
service *Service
once sync.Once
)
// Service is used interact with services and dump/restore backups
type Service struct {
App *cfenv.App
S3 *s3.Client
Services []util.Service
}
func init() {
rand.Seed(time.Now().UTC().UnixNano())
}
func new(app *cfenv.App, s3 *s3.Client) *Service {
return &Service{
App: app,
S3: s3,
}
}
func Get() *Service {
once.Do(func() {
app, err := cfenv.Current()
if err != nil {
log.Fatalf("%v", err)
}
s3 := s3.New(app)
service = new(app, s3)
service.parseServices()
})
return service
}
func (s *Service) parseServices() {
s.Services = make([]util.Service, 0)
for _, services := range s.App.Services {
for _, service := range services {
// exclude S3 storage service, don't try to parse it as a service for backups
if service.Name == config.Get().S3.ServiceName ||
(service.Label == config.Get().S3.ServiceLabel && service.Label != "user-provided") {
continue
}
// if it is an unrecognized type/label or user-provided service
// then try to figure out if it can be identified as a supported service type
if !util.IsValidServiceType(service.Label) || service.Label == "user-provided" {
// can it be identified as a custom postgres binding?
if postgres.IsPostgresBinding(&service) {
service.Label = "postgres"
} else if mysql.IsMySQLBinding(&service) { // or a mysql binding?
service.Label = "mysql"
} else if redis.IsRedisBinding(&service) { // or a redis binding?
service.Label = "redis"
} else {
// try to guess it via service tags as a last resort
var identified bool
for _, tag := range service.Tags {
if util.IsValidServiceType(tag) {
identified = true
service.Label = tag
break
}
}
if !identified {
log.Errorf("unsupported service type [%s]: could not identify [%s]", service.Label, service.Name)
continue // cannot handle this service binding
}
}
}
// read timeout for service
timeout := config.Get().Services[service.Name].Timeout
if timeout.Seconds() <= 1 {
timeout.Duration = 1 * time.Hour // default
}
// read crontab schedule for service
schedule := config.Get().Services[service.Name].Schedule
if len(schedule) == 0 {
// create a random schedule for daily backup as a fallback
schedule = fmt.Sprintf("%d %d %d * * *", rand.Intn(59), rand.Intn(59), rand.Intn(23))
}
// read retention days & files, with defaults as fallback
retentionDays := config.Get().Services[service.Name].Retention.Days
retentionFiles := config.Get().Services[service.Name].Retention.Files
if retentionDays <= 0 {
retentionDays = 31 // default
}
if retentionFiles <= 0 {
retentionFiles = 100 // default
}
newService := util.Service{
Name: service.Name,
Label: service.Label,
Plan: service.Plan,
Tags: service.Tags,
Timeout: timeout.Duration,
Schedule: schedule,
Retention: util.Retention{
Days: retentionDays,
Files: retentionFiles,
},
DirectS3: config.Get().Services[service.Name].DirectS3,
DisableColumnStatistics: config.Get().Services[service.Name].DisableColumnStatistics,
LogStdErr: config.Get().Services[service.Name].LogStdErr,
ForceImport: config.Get().Services[service.Name].ForceImport,
LocalBackupPath: config.Get().Services[service.Name].LocalBackupPath,
IgnoreTables: config.Get().Services[service.Name].IgnoreTables,
BackupOptions: config.Get().Services[service.Name].BackupOptions,
RestoreOptions: config.Get().Services[service.Name].RestoreOptions,
}
s.Services = append(s.Services, newService)
}
}
// setup service metrics
for _, service := range s.Services {
// init prometheus state metrics to 0
state.BackupInit(service)
state.RestoreInit(service)
// init backup files state & metrics in background
go func(label, name string) {
_, _ = s.GetBackups(label, name)
}(service.Label, service.Name)
}
log.Debugf("services loaded: %+v", s.Services)
}
func (s *Service) GetServices(serviceType, serviceName string) []util.Service {
services := make([]util.Service, 0)
if len(serviceName) > 0 {
// list only a specific service binding
for _, service := range s.Services {
if service.Name == serviceName {
services = append(services, service)
break
}
}
} else if len(serviceType) > 0 {
// list services only for a specific service type
for _, service := range s.Services {
if service.Label == serviceType {
services = append(services, service)
}
}
} else {
// list all services
return s.Services
}
return services
}
func (s *Service) GetService(serviceType, serviceName string) util.Service {
for _, service := range s.Services {
if service.Name == serviceName && service.Label == serviceType {
return service
}
}
return util.Service{}
}