// The main function of the system is responsable for deploying all system components that
// are enabled. For now we have the REST server and the scan system
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
logPath := filepath.Join(
config.ShelterConfig.BasePath,
config.ShelterConfig.LogFilename,
)
if err := log.SetOutput(logPath); err != nil {
log.Println(err)
return
}
defer log.Close()
if config.ShelterConfig.RESTServer.Enabled {
var err error
restListeners, err = rest.Listen()
if err != nil {
log.Println("Error while aquiring interfaces for REST server. Details:", err)
os.Exit(ErrListeningRESTInterfaces)
}
if err := rest.Start(restListeners); err != nil {
log.Println("Error starting the REST server. Details:", err)
os.Exit(ErrStartingRESTServer)
}
log.Info("REST server started")
}
if config.ShelterConfig.WebClient.Enabled {
var err error
clientListeners, err = client.Listen()
if err != nil {
log.Println("Error while aquiring interfaces for Client server. Details:", err)
os.Exit(ErrListeningClientInterfaces)
}
if err := client.Start(clientListeners); err != nil {
log.Println("Error starting the Client server. Details:", err)
os.Exit(ErrStartingWebClient)
}
log.Info("Web client started")
}
if config.ShelterConfig.Scan.Enabled {
// Attention: Cannot use timezone abbreviations
// http://stackoverflow.com/questions/25368415/golang-timezone-parsing
scanTime, err := time.Parse("15:04:05 -0700", config.ShelterConfig.Scan.Time)
if err != nil {
log.Println("Scan time not in a valid format. Details:", err)
os.Exit(ErrScanTimeFormat)
}
scanTime = scanTime.UTC()
now := time.Now().UTC()
nextExecution := time.Date(
now.Year(),
now.Month(),
now.Day(),
scanTime.Hour(),
scanTime.Minute(),
scanTime.Second(),
scanTime.Nanosecond(),
scanTime.Location(),
)
scheduler.Register(scheduler.Job{
Type: scheduler.JobTypeScan,
NextExecution: nextExecution,
Interval: time.Duration(config.ShelterConfig.Scan.IntervalHours) * time.Hour,
Task: scan.ScanDomains,
})
// Must be called after registering in scheduler, because we retrieve the next execution time
// from it
if err := model.InitializeCurrentScan(); err != nil {
log.Println("Current scan information got an error while initializing. Details:", err)
os.Exit(ErrCurrentScanInitialize)
}
}
if config.ShelterConfig.Notification.Enabled {
if err := notification.LoadTemplates(); err != nil {
log.Println("Error loading notification templates. Details:", err)
os.Exit(ErrNotificationTemplates)
}
// Attention: Cannot use timezone abbreviations
// http://stackoverflow.com/questions/25368415/golang-timezone-parsing
notificationTime, err := time.Parse("15:04:05 -0700", config.ShelterConfig.Scan.Time)
if err != nil {
log.Println("Scan time not in a valid format. Details:", err)
os.Exit(ErrScanTimeFormat)
}
notificationTime = notificationTime.UTC()
now := time.Now().UTC()
nextExecution := time.Date(
now.Year(),
now.Month(),
now.Day(),
notificationTime.Hour(),
notificationTime.Minute(),
notificationTime.Second(),
notificationTime.Nanosecond(),
notificationTime.Location(),
)
scheduler.Register(scheduler.Job{
Type: scheduler.JobTypeNotification,
NextExecution: nextExecution,
Interval: time.Duration(config.ShelterConfig.Notification.IntervalHours) * time.Hour,
Task: notification.Notify,
})
}
scheduler.Start()
select {}
}
func simpleNotification(domainDAO dao.DomainDAO, templateName string,
messageChannel chan *mail.Message, errorChannel chan error) {
generateAndSaveDomain("example.com.br.", domainDAO, templateName)
notification.TemplateExtension = ""
if err := notification.LoadTemplates(); err != nil {
utils.Fatalln("Error loading templates", err)
}
notification.Notify()
timeout := make(chan bool, 1)
go func() {
time.Sleep(5 * time.Second)
timeout <- true
}()
select {
case message := <-messageChannel:
if message.Header.Get("From") != "*****@*****.**" {
utils.Fatalln(fmt.Sprintf("E-mail from header is different. Expected "+
"[email protected] but found %s", message.Header.Get("From")), nil)
}
if message.Header.Get("To") != "*****@*****.**" {
utils.Fatalln("E-mail to header is different", nil)
}
if message.Header.Get("Subject") != "=?UTF-8?B?TWlzY29uZmlndXJhdGlvbiBvbiBkb21haW4gZXhhbXBsZS5jb20uYnIu?=" {
utils.Fatalln("E-mail subject header is different", nil)
}
body, err := ioutil.ReadAll(message.Body)
if err != nil {
utils.Fatalln("Error reading e-mail body", err)
}
expectedBody := "Dear Sir/Madam,\r\n" +
"\r\n" +
"During our periodically domain verification, a configuration problem was detected with the\r\n" +
"domain example.com.br..\r\n" +
"\r\n" +
" * Nameserver ns1.example.com.br. got an internal error while receiving the DNS request.\r\n" +
" Please check the DNS server log to detect and solve the problem.\r\n" +
"\r\n" +
"Best regards,\r\n" +
"LACTLD\r\n" +
".\r\n"
if string(body) != expectedBody {
utils.Fatalln(fmt.Sprintf("E-mail body is different from what we expected. "+
"Expected [%s], but found [%s]", expectedBody, body), nil)
}
case err := <-errorChannel:
utils.Fatalln("Error receiving message", err)
case <-timeout:
utils.Fatalln("No mail sent", nil)
}
if err := domainDAO.RemoveByFQDN("example.com.br."); err != nil {
utils.Fatalln("Error removing domain", err)
}
}