/
main.go
147 lines (125 loc) · 4.31 KB
/
main.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
package main
import (
"flag"
"fmt"
"os"
"os/signal"
reaperaws "github.com/mozilla-services/reaper/aws"
reaperevents "github.com/mozilla-services/reaper/events"
"github.com/mozilla-services/reaper/reaper"
log "github.com/mozilla-services/reaper/reaperlog"
)
var (
config reaper.Config
eventReporters []reaperevents.EventReporter
)
func init() {
configFile := flag.String("config", "", "path to config file")
withoutCloudformationResources := flag.Bool("withoutCloudformationResources", false, "disables dependency checking for Cloudformations (which is slow!)")
useMozlog := flag.Bool("useMozlog", true, "set to false to disable mozlog output")
flag.Parse()
if *useMozlog {
log.EnableMozlog()
}
// if no config file -> exit with error
if *configFile == "" {
log.Error("Config file is a required Argument. Specify with -config='filename'")
os.Exit(1)
}
// if config file path specified, attempt to load it
if c, err := reaper.LoadConfig(*configFile); err == nil {
// catches panics loading config
defer func() {
if r := recover(); r != nil {
log.Error("Invalid config ", r)
os.Exit(1)
}
}()
config = *c
log.Info(fmt.Sprintf("Configuration loaded from %s", *configFile))
} else {
// config not successfully loaded -> exit with error
log.Error("toml", err)
os.Exit(1)
}
// if log file path specified, attempt to load it
if config.LogFile != "" {
log.AddLogFile(config.LogFile)
}
// if DatadogStatistics EventReporter is enabled
if config.Events.DatadogStatistics.Enabled {
log.Info("DatadogStatistics EventReporter enabled.")
eventReporters = append(eventReporters, reaperevents.NewDatadogStatistics(&config.Events.DatadogStatistics))
}
// if DatadogEvents EventReporter is enabled
if config.Events.DatadogEvents.Enabled {
log.Info("DatadogEvents EventReporter enabled.")
eventReporters = append(eventReporters, reaperevents.NewDatadogEvents(&config.Events.DatadogEvents))
}
// if Email EventReporter is enabled
if config.Events.Email.Enabled {
log.Info("Email EventReporter enabled.")
eventReporters = append(eventReporters, reaperevents.NewMailer(&config.Events.Email))
// these methods have pointer receivers
log.Debug("SMTP Config: %s", &config.Events.Email)
log.Debug("SMTP From: %s", &config.Events.Email.From)
}
// if Tagger EventReporter is enabled
if config.Events.Tagger.Enabled {
log.Info("Tagger EventReporter enabled.")
eventReporters = append(eventReporters, reaperevents.NewTagger(&config.Events.Tagger))
}
// if Reaper EventReporter is enabled
if config.Events.Reaper.Enabled {
log.Info("Reaper EventReporter enabled.")
eventReporters = append(eventReporters, reaperevents.NewReaperEvent(&config.Events.Reaper))
}
// if WhitelistTag is not set
if config.WhitelistTag == "" {
log.Error("WhitelistTag is empty, exiting")
os.Exit(1)
} else {
log.Info("Using WhitelistTag '%s'", config.WhitelistTag)
}
if *withoutCloudformationResources {
config.AWS.WithoutCloudformationResources = true
}
}
func main() {
// config and events are vars in the reaper package
// they NEED to be set before a reaper.Reaper can be initialized
reaper.SetConfig(&config)
reaperevents.SetEvents(&eventReporters)
if config.DryRun {
log.Info("Dry run mode enabled, no events will be triggered. Enable Extras in Notifications for per-event DryRun notifications.")
reaperevents.SetDryRun(config.DryRun)
}
// Ready() NEEDS to be called after BOTH SetConfig() and SetEvents()
// it uses those values to set individual EventReporter config values
// and to init the Reapables map
reaper.Ready()
// sets the config variable in Reaper's AWS package
// this also NEEDS to be set before a Reaper can be started
reaperaws.SetConfig(&config.AWS)
// single instance of reaper
reapRunner := reaper.NewReaper()
// Run the reaper process
reapRunner.Start()
// run the HTTP server
api := reaper.NewHTTPApi(config.HTTP)
if err := api.Serve(); err != nil {
log.Error(err.Error())
} else {
// HTTP server successfully started
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, os.Kill)
// waiting for an Interrupt or Kill signal
// this channel blocks until it receives one
sig := <-c
log.Info("Got signal %s, stopping services", sig.String())
log.Info("Stopping HTTP")
api.Stop()
log.Info("Stopping reaper runner")
reapRunner.Stop()
}
}