// NewHTTPNotifier initializes a new HTTPNotifier func NewHTTPNotifier(URL string) (*HTTPNotifier, error) { if _, err := url.Parse(URL); err != nil { return nil, cerrors.NewBadRequestError("could not create a notifier with an invalid URL") } notifier := &HTTPNotifier{url: URL} health.RegisterHealthchecker("notifier", notifier.Healthcheck) return notifier, nil }
func init() { health.RegisterHealthchecker("database", Healthcheck) }
func init() { health.RegisterHealthchecker("updater", Healthcheck) }
// Run updates the vulnerability database at regular intervals. func Run(config *config.UpdaterConfig, st *utils.Stopper) { defer st.End() // Do not run the updater if there is no config or if the interval is 0. if config == nil || config.Interval == 0 { log.Infof("updater service is disabled.") return } // Register healthchecker. health.RegisterHealthchecker("updater", Healthcheck) whoAmI := uuid.New() log.Infof("updater service started. lock identifier: %s", whoAmI) for { // Set the next update time to (last update time + interval) or now if there // is no last update time stored in database (first update) or if an error // occurs. var nextUpdate time.Time var stop bool if lastUpdate := getLastUpdate(); !lastUpdate.IsZero() { nextUpdate = lastUpdate.Add(config.Interval) } else { nextUpdate = time.Now().UTC() } // If the next update timer is in the past, then try to update. if nextUpdate.Before(time.Now().UTC()) { // Attempt to get a lock on the the update. log.Debug("attempting to obtain update lock") hasLock, hasLockUntil := database.Lock(flagName, lockDuration, whoAmI) if hasLock { // Launch update in a new go routine. doneC := make(chan bool, 1) go func() { Update() doneC <- true }() for done := false; !done && !stop; { select { case <-doneC: done = true case <-time.After(refreshLockDuration): // Refresh the lock until the update is done. database.Lock(flagName, lockDuration, whoAmI) case <-st.Chan(): stop = true } } // Unlock the update. database.Unlock(flagName, whoAmI) if stop { break } continue } else { lockOwner, lockExpiration, err := database.LockInfo(flagName) if err != nil { log.Debug("update lock is already taken") nextUpdate = hasLockUntil } else { log.Debugf("update lock is already taken by %s until %v", lockOwner, lockExpiration) nextUpdate = lockExpiration } } } // Sleep, but remain stoppable until approximately the next update time. now := time.Now().UTC() waitUntil := nextUpdate.Add(time.Duration(rand.ExpFloat64()/0.5) * time.Second) log.Debugf("next update attempt scheduled for %v.", waitUntil) if !waitUntil.Before(now) { if !st.Sleep(waitUntil.Sub(time.Now())) { break } } } log.Info("updater service stopped") }
// Run starts the Notifier service. func Run(config *config.NotifierConfig, stopper *utils.Stopper) { defer stopper.End() // Configure registered notifiers. for notifierName, notifier := range notifiers { if configured, err := notifier.Configure(config); configured { log.Infof("notifier '%s' configured\n", notifierName) } else { delete(notifiers, notifierName) if err != nil { log.Errorf("could not configure notifier '%s': %s", notifierName, err) } } } // Do not run the updater if there is no notifier enabled. if len(notifiers) == 0 { log.Infof("notifier service is disabled") return } whoAmI := uuid.New() log.Infof("notifier service started. lock identifier: %s\n", whoAmI) // Register healthchecker. health.RegisterHealthchecker("notifier", Healthcheck) for running := true; running; { // Find task. // TODO(Quentin-M): Combine node and notification. node, notification := findTask(whoAmI, stopper) if node == "" && notification == nil { // Interrupted while finding a task, Clair is stopping. break } // Handle task. done := make(chan bool, 1) go func() { success, interrupted := handleTask(notification, stopper, config.Attempts) if success { database.MarkNotificationAsSent(node) } if interrupted { running = false } database.Unlock(node, whoAmI) done <- true }() // Refresh task lock until done. outer: for { select { case <-done: break outer case <-time.After(refreshLockDuration): database.Lock(node, lockDuration, whoAmI) } } } log.Info("notifier service stopped") }