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)
	}
}
Beispiel #2
0
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
}
Beispiel #3
0
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")
	}
}
Beispiel #4
0
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)
}