func (sender *Sender) stopMessageToSend(message models.PendingStopMessage) (models.StopMessage, bool) {
appKey := sender.store.AppKey(message.AppGuid, message.AppVersion)
app, found := sender.apps[appKey]
if !found {
sender.logger.Info("Skipping sending stop message: instance is no longer running", message.LogDescription())
return models.StopMessage{}, false
}
instanceToStop := app.InstanceWithGuid(message.InstanceGuid)
messageToSend := models.StopMessage{
AppGuid: message.AppGuid,
AppVersion: message.AppVersion,
InstanceGuid: message.InstanceGuid,
InstanceIndex: instanceToStop.InstanceIndex,
MessageId: message.MessageId,
}
if !app.IsDesired() {
sender.logger.Info("Sending stop message: instance is running, app is no longer desired", message.LogDescription(), app.LogDescription())
messageToSend.IsDuplicate = false
return messageToSend, true
}
if !app.IsIndexDesired(instanceToStop.InstanceIndex) {
sender.logger.Info("Sending stop message: index of instance to stop is beyond desired # of instances", message.LogDescription(), app.LogDescription())
messageToSend.IsDuplicate = false
return messageToSend, true
}
if instanceToStop.State == models.InstanceStateEvacuating {
sender.logger.Info("Sending stop message for evacuating app", message.LogDescription(), app.LogDescription())
messageToSend.IsDuplicate = true
return messageToSend, true
}
if len(app.StartingOrRunningInstancesAtIndex(instanceToStop.InstanceIndex)) > 1 {
sender.logger.Info("Sending stop message: instance is a duplicate running at a desired index", message.LogDescription(), app.LogDescription())
messageToSend.IsDuplicate = true
return messageToSend, true
}
sender.logger.Info("Skipping sending stop message: instance is running on a desired index (and there are no other instances running at that index)", message.LogDescription(), app.LogDescription())
return models.StopMessage{}, false
}
func (sender *Sender) sendStopMessage(stopMessage models.PendingStopMessage) {
messageToSend, shouldSend := sender.stopMessageToSend(stopMessage)
if shouldSend {
err := sender.messageBus.Publish(sender.conf.SenderNatsStopSubject, messageToSend.ToJSON())
if err != nil {
sender.logger.Error("Failed to send stop message", err, stopMessage.LogDescription())
sender.didSucceed = false
return
}
sender.sentStopMessages = append(sender.sentStopMessages, stopMessage)
if stopMessage.KeepAlive == 0 {
sender.queueStopMessageForDeletion(stopMessage, "sent stop message with no keep alive")
} else {
sender.markStopMessageSent(stopMessage)
}
} else {
sender.queueStopMessageForDeletion(stopMessage, "stop message that will not be sent")
}
}
func (a *appAnalyzer) appendStopMessageIfNotDuplicate(message models.PendingStopMessage, loggingMessage string, additionalDetails map[string]string) {
existingMessage, alreadyQueued := a.existingPendingStopMessages[message.StoreKey()]
if !alreadyQueued {
a.logger.Info(fmt.Sprintf("Enqueuing Stop Message: %s", loggingMessage), message.LogDescription(), additionalDetails)
a.stopMessages[message.StoreKey()] = message
} else {
a.logger.Info(fmt.Sprintf("Skipping Already Enqueued Stop Message: %s", loggingMessage), existingMessage.LogDescription(), additionalDetails)
}
}
func (sender *Sender) queueStopMessageForDeletion(stopMessage models.PendingStopMessage, reason string) {
sender.logger.Info(fmt.Sprintf("Deleting %s", reason), stopMessage.LogDescription())
sender.stopMessagesToDelete = append(sender.stopMessagesToDelete, stopMessage)
}
func (sender *Sender) markStopMessageSent(stopMessage models.PendingStopMessage) {
stopMessage.SentOn = sender.timeProvider.Time().Unix()
sender.stopMessagesToSave = append(sender.stopMessagesToSave, stopMessage)
}
"github.com/cloudfoundry/hm9000/models"
. "github.com/cloudfoundry/hm9000/store"
"github.com/cloudfoundry/hm9000/testhelpers/fakelogger"
"github.com/cloudfoundry/storeadapter"
"github.com/cloudfoundry/storeadapter/etcdstoreadapter"
"github.com/cloudfoundry/storeadapter/workerpool"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"time"
)
var _ = Describe("Storing PendingStopMessages", func() {
var (
store Store
storeAdapter storeadapter.StoreAdapter
conf *config.Config
message1 models.PendingStopMessage
message2 models.PendingStopMessage
message3 models.PendingStopMessage
)
BeforeEach(func() {
var err error
conf, err = config.DefaultConfig()
Ω(err).ShouldNot(HaveOccurred())
storeAdapter = etcdstoreadapter.NewETCDStoreAdapter(etcdRunner.NodeURLS(), workerpool.NewWorkerPool(conf.StoreMaxConcurrentRequests))
err = storeAdapter.Connect()
Ω(err).ShouldNot(HaveOccurred())
message1 = models.NewPendingStopMessage(time.Unix(100, 0), 10, 4, "ABC", "123", "XYZ", models.PendingStopMessageReasonInvalid)
message2 = models.NewPendingStopMessage(time.Unix(100, 0), 10, 4, "DEF", "456", "ALPHA", models.PendingStopMessageReasonInvalid)
message3 = models.NewPendingStopMessage(time.Unix(100, 0), 10, 4, "GHI", "789", "BETA", models.PendingStopMessageReasonInvalid)
func (sender *Sender) markStopMessageSent(stopMessage models.PendingStopMessage) {
stopMessage.SentOn = sender.currentTime.Unix()
sender.stopMessagesToSave = append(sender.stopMessagesToSave, stopMessage)
}
})
It("should neither delete the message nor send it", func() {
messages, _ := store.GetPendingStartMessages()
Ω(messages).Should(HaveLen(1))
Ω(messageBus.PublishedMessages).ShouldNot(HaveKey("hm9000.start"))
})
})
})
})
Context("when there are stop messages", func() {
var keepAliveTime int
var sentOn int64
var err error
var pendingMessage models.PendingStopMessage
var storeSetErrInjector *fakestoreadapter.FakeStoreAdapterErrorInjector
JustBeforeEach(func() {
store.SyncHeartbeats(app.Heartbeat(2))
pendingMessage = models.NewPendingStopMessage(time.Unix(100, 0), 30, keepAliveTime, app.AppGuid, app.AppVersion, app.InstanceAtIndex(0).InstanceGuid, models.PendingStopMessageReasonInvalid)
pendingMessage.SentOn = sentOn
store.SavePendingStopMessages(
pendingMessage,
)
storeAdapter.SetErrInjector = storeSetErrInjector
err = sender.Send()
})