func (db *ETCDDB) UnclaimActualLRP(logger lager.Logger, key *models.ActualLRPKey) (*models.ActualLRPGroup, *models.ActualLRPGroup, error) {
actualLRP, modifiedIndex, err := db.rawActualLRPByProcessGuidAndIndex(logger, key.ProcessGuid, key.Index)
bbsErr := models.ConvertError(err)
if bbsErr != nil {
return nil, nil, bbsErr
}
beforeActualLRP := *actualLRP
if actualLRP.State == models.ActualLRPStateUnclaimed {
logger.Debug("already-unclaimed")
return nil, nil, models.ErrActualLRPCannotBeUnclaimed
}
actualLRP.State = models.ActualLRPStateUnclaimed
actualLRP.ActualLRPKey = *key
actualLRP.ActualLRPInstanceKey = models.ActualLRPInstanceKey{}
actualLRP.ActualLRPNetInfo = models.EmptyActualLRPNetInfo()
actualLRP.Since = db.clock.Now().UnixNano()
actualLRP.ModificationTag.Increment()
data, err := db.serializeModel(logger, actualLRP)
if err != nil {
return nil, nil, err
}
_, err = db.client.CompareAndSwap(ActualLRPSchemaPath(key.ProcessGuid, key.Index), data, 0, modifiedIndex)
if err != nil {
logger.Error("failed-compare-and-swap", err)
return nil, nil, ErrorFromEtcdError(logger, err)
}
return &models.ActualLRPGroup{Instance: &beforeActualLRP}, &models.ActualLRPGroup{Instance: actualLRP}, nil
}
func (db *ETCDDB) CrashActualLRP(logger lager.Logger, key *models.ActualLRPKey, instanceKey *models.ActualLRPInstanceKey, errorMessage string) (*models.ActualLRPGroup, *models.ActualLRPGroup, bool, error) {
logger = logger.WithData(lager.Data{"actual_lrp_key": key, "actual_lrp_instance_key": instanceKey})
logger.Info("starting")
lrp, prevIndex, err := db.rawActualLRPByProcessGuidAndIndex(logger, key.ProcessGuid, key.Index)
if err != nil {
logger.Error("failed-to-get-actual-lrp", err)
return nil, nil, false, err
}
beforeActualLRP := *lrp
latestChangeTime := time.Duration(db.clock.Now().UnixNano() - lrp.Since)
var newCrashCount int32
if latestChangeTime > models.CrashResetTimeout && lrp.State == models.ActualLRPStateRunning {
newCrashCount = 1
} else {
newCrashCount = lrp.CrashCount + 1
}
logger.Debug("retrieved-lrp")
if !lrp.AllowsTransitionTo(key, instanceKey, models.ActualLRPStateCrashed) {
logger.Error("failed-to-transition-to-crashed", nil, lager.Data{"from_state": lrp.State, "same_instance_key": lrp.ActualLRPInstanceKey.Equal(instanceKey)})
return nil, nil, false, models.ErrActualLRPCannotBeCrashed
}
lrp.State = models.ActualLRPStateCrashed
lrp.Since = db.clock.Now().UnixNano()
lrp.CrashCount = newCrashCount
lrp.ActualLRPInstanceKey = models.ActualLRPInstanceKey{}
lrp.ActualLRPNetInfo = models.EmptyActualLRPNetInfo()
lrp.ModificationTag.Increment()
lrp.CrashReason = errorMessage
var immediateRestart bool
if lrp.ShouldRestartImmediately(models.NewDefaultRestartCalculator()) {
lrp.State = models.ActualLRPStateUnclaimed
immediateRestart = true
}
lrpData, serializeErr := db.serializeModel(logger, lrp)
if serializeErr != nil {
return nil, nil, false, serializeErr
}
_, err = db.client.CompareAndSwap(ActualLRPSchemaPath(key.ProcessGuid, key.Index), lrpData, 0, prevIndex)
if err != nil {
logger.Error("failed", err)
return nil, nil, false, models.ErrActualLRPCannotBeCrashed
}
logger.Info("succeeded")
return &models.ActualLRPGroup{Instance: &beforeActualLRP}, &models.ActualLRPGroup{Instance: lrp}, immediateRestart, nil
}
func (db *ETCDDB) unclaimActualLRPWithIndex(
logger lager.Logger,
lrp *models.ActualLRP,
storeIndex uint64,
actualLRPKey *models.ActualLRPKey,
actualLRPInstanceKey *models.ActualLRPInstanceKey,
) (change stateChange, err error) {
logger = logger.Session("unclaim-actual-lrp-with-index")
defer func() {
logger.Debug("complete", lager.Data{"stateChange": change, "error": err})
}()
if !lrp.ActualLRPKey.Equal(actualLRPKey) {
logger.Error("failed-actual-lrp-key-differs", models.ErrActualLRPCannotBeUnclaimed)
return stateDidNotChange, models.ErrActualLRPCannotBeUnclaimed
}
if lrp.State == models.ActualLRPStateUnclaimed {
logger.Info("already-unclaimed")
return stateDidNotChange, nil
}
if !lrp.ActualLRPInstanceKey.Equal(actualLRPInstanceKey) {
logger.Error("failed-actual-lrp-instance-key-differs", models.ErrActualLRPCannotBeUnclaimed)
return stateDidNotChange, models.ErrActualLRPCannotBeUnclaimed
}
lrp.Since = db.clock.Now().UnixNano()
lrp.State = models.ActualLRPStateUnclaimed
lrp.ActualLRPInstanceKey = models.ActualLRPInstanceKey{}
lrp.ActualLRPNetInfo = models.EmptyActualLRPNetInfo()
lrp.ModificationTag.Increment()
err = lrp.Validate()
if err != nil {
logger.Error("failed-to-validate-unclaimed-lrp", err)
return stateDidNotChange, models.NewError(models.Error_InvalidRecord, err.Error())
}
lrpData, serialErr := db.serializeModel(logger, lrp)
if serialErr != nil {
logger.Error("failed-to-marshal-unclaimed-lrp", serialErr)
return stateDidNotChange, serialErr
}
_, err = db.client.CompareAndSwap(ActualLRPSchemaPath(actualLRPKey.ProcessGuid, actualLRPKey.Index), lrpData, 0, storeIndex)
if err != nil {
logger.Error("failed-to-compare-and-swap", err)
return stateDidNotChange, models.ErrActualLRPCannotBeUnclaimed
}
logger.Debug("changed-to-unclaimed")
return stateDidChange, nil
}
Expect(actualLRPInstanceKey.Validate()).To(ConsistOf(models.ErrInvalidField{"cell_id"}))
})
})
Context("when only the cell id is specified", func() {
It("returns a validation error", func() {
actualLRPInstanceKey = models.NewActualLRPInstanceKey("", "cell-id")
Expect(actualLRPInstanceKey.Validate()).To(ConsistOf(models.ErrInvalidField{"instance_guid"}))
})
})
})
Describe("ActualLRPNetInfo", func() {
Describe("EmptyActualLRPNetInfo", func() {
It("returns a net info with an empty address and non-nil empty PortMapping slice", func() {
netInfo := models.EmptyActualLRPNetInfo()
Expect(netInfo.GetAddress()).To(BeEmpty())
Expect(netInfo.GetPorts()).NotTo(BeNil())
Expect(netInfo.GetPorts()).To(HaveLen(0))
})
})
})
})
Describe("ActualLRPGroup", func() {
Describe("Resolve", func() {
var (
instanceLRP *models.ActualLRP
evacuatingLRP *models.ActualLRP
func (db *ETCDDB) CrashActualLRP(logger lager.Logger, request *models.CrashActualLRPRequest) *models.Error {
key := request.ActualLrpKey
instanceKey := request.ActualLrpInstanceKey
errorMessage := request.ErrorMessage
logger.Info("starting")
lrp, prevIndex, bbsErr := db.rawActuaLLRPByProcessGuidAndIndex(logger, key.ProcessGuid, key.Index)
if bbsErr != nil {
logger.Error("failed-to-get-actual-lrp", bbsErr)
return bbsErr
}
latestChangeTime := time.Duration(db.clock.Now().UnixNano() - lrp.Since)
var newCrashCount int32
if latestChangeTime > models.CrashResetTimeout && lrp.State == models.ActualLRPStateRunning {
newCrashCount = 1
} else {
newCrashCount = lrp.CrashCount + 1
}
logger.Debug("retrieved-lrp")
if !lrp.AllowsTransitionTo(key, instanceKey, models.ActualLRPStateCrashed) {
err := fmt.Errorf("cannot transition crashed lrp from state %s to state %s", lrp.State, models.ActualLRPStateCrashed)
logger.Error("failed-to-transition-actual", err)
return models.ErrActualLRPCannotBeCrashed
}
if lrp.State == models.ActualLRPStateUnclaimed || lrp.State == models.ActualLRPStateCrashed ||
((lrp.State == models.ActualLRPStateClaimed || lrp.State == models.ActualLRPStateRunning) &&
!lrp.ActualLRPInstanceKey.Equal(instanceKey)) {
return models.ErrActualLRPCannotBeCrashed
}
lrp.State = models.ActualLRPStateCrashed
lrp.Since = db.clock.Now().UnixNano()
lrp.CrashCount = newCrashCount
lrp.ActualLRPInstanceKey = models.ActualLRPInstanceKey{}
lrp.ActualLRPNetInfo = models.EmptyActualLRPNetInfo()
lrp.ModificationTag.Increment()
lrp.CrashReason = errorMessage
var immediateRestart bool
if lrp.ShouldRestartImmediately(models.NewDefaultRestartCalculator()) {
lrp.State = models.ActualLRPStateUnclaimed
immediateRestart = true
}
lrpRawJSON, err := json.Marshal(lrp)
if err != nil {
return models.ErrSerializeJSON
}
_, err = db.client.CompareAndSwap(ActualLRPSchemaPath(key.ProcessGuid, key.Index), string(lrpRawJSON), 0, "", prevIndex)
if err != nil {
logger.Error("failed", err)
return models.ErrActualLRPCannotBeCrashed
}
if immediateRestart {
auctionErr := db.requestLRPAuctionForLRPKey(logger, key)
if err != nil {
return auctionErr
}
}
logger.Info("succeeded")
return nil
}
index int32 = 0
lrpKey = models.NewActualLRPKey(desiredLRP.ProcessGuid, index, desiredLRP.Domain)
alphaInstanceKey = models.NewActualLRPInstanceKey(alphaInstanceGuid, alphaCellID)
betaInstanceKey = models.NewActualLRPInstanceKey(betaInstanceGuid, betaCellID)
omegaInstanceKey = models.NewActualLRPInstanceKey(omegaInstanceGuid, omegaCellID)
emptyInstanceKey = models.ActualLRPInstanceKey{}
alphaPorts = models.NewPortMapping(9872, 2349)
alphaNetInfo = models.NewActualLRPNetInfo(alphaAddress, alphaPorts)
betaPorts = models.NewPortMapping(9868, 2353)
betaNetInfo = models.NewActualLRPNetInfo(betaAddress, betaPorts)
omegaPorts = models.NewPortMapping(9876, 2345)
omegaNetInfo = models.NewActualLRPNetInfo(omegaAddress, omegaPorts)
emptyNetInfo = models.EmptyActualLRPNetInfo()
)
type testable interface {
Test()
}
type evacuationTest struct {
Name string
Subject func() (bool, error)
InstanceLRP lrpSetupFunc
EvacuatingLRP lrpSetupFunc
Result testResult
}
func lrp(state string, instanceKey models.ActualLRPInstanceKey, netInfo models.ActualLRPNetInfo, placementError string) lrpSetupFunc {
func (db *ETCDDB) CrashActualLRP(logger lager.Logger, key *models.ActualLRPKey, instanceKey *models.ActualLRPInstanceKey, errorMessage string) error {
logger = logger.Session("crash-actual-lrp", lager.Data{"actual_lrp_key": key, "actual_lrp_instance_key": instanceKey})
logger.Info("starting")
lrp, prevIndex, err := db.rawActuaLLRPByProcessGuidAndIndex(logger, key.ProcessGuid, key.Index)
if err != nil {
logger.Error("failed-to-get-actual-lrp", err)
return err
}
latestChangeTime := time.Duration(db.clock.Now().UnixNano() - lrp.Since)
var newCrashCount int32
if latestChangeTime > models.CrashResetTimeout && lrp.State == models.ActualLRPStateRunning {
newCrashCount = 1
} else {
newCrashCount = lrp.CrashCount + 1
}
logger.Debug("retrieved-lrp")
if !lrp.AllowsTransitionTo(key, instanceKey, models.ActualLRPStateCrashed) {
err := fmt.Errorf("cannot transition crashed lrp from state %s to state %s", lrp.State, models.ActualLRPStateCrashed)
logger.Error("failed-to-transition-actual", err)
return models.ErrActualLRPCannotBeCrashed
}
if lrp.State == models.ActualLRPStateUnclaimed || lrp.State == models.ActualLRPStateCrashed ||
((lrp.State == models.ActualLRPStateClaimed || lrp.State == models.ActualLRPStateRunning) &&
!lrp.ActualLRPInstanceKey.Equal(instanceKey)) {
logger.Debug("cannot-be-crashed", lager.Data{"state": lrp.State, "same-instance-key": lrp.ActualLRPInstanceKey.Equal(instanceKey)})
return models.ErrActualLRPCannotBeCrashed
}
lrp.State = models.ActualLRPStateCrashed
lrp.Since = db.clock.Now().UnixNano()
lrp.CrashCount = newCrashCount
lrp.ActualLRPInstanceKey = models.ActualLRPInstanceKey{}
lrp.ActualLRPNetInfo = models.EmptyActualLRPNetInfo()
lrp.ModificationTag.Increment()
lrp.CrashReason = errorMessage
var immediateRestart bool
if lrp.ShouldRestartImmediately(models.NewDefaultRestartCalculator()) {
lrp.State = models.ActualLRPStateUnclaimed
immediateRestart = true
}
lrpData, serializeErr := db.serializeModel(logger, lrp)
if serializeErr != nil {
return serializeErr
}
_, err = db.client.CompareAndSwap(ActualLRPSchemaPath(key.ProcessGuid, key.Index), lrpData, 0, prevIndex)
if err != nil {
logger.Error("failed", err)
return models.ErrActualLRPCannotBeCrashed
}
if immediateRestart {
auctionErr := db.requestLRPAuctionForLRPKey(logger, key)
if auctionErr != nil {
return auctionErr
}
}
logger.Info("succeeded")
return nil
}