func (t *ETCDHelper) SetRawEvacuatingActualLRP(lrp *models.ActualLRP, ttlInSeconds uint64) {
value, err := t.serializer.Marshal(t.logger, t.format, lrp)
Expect(err).NotTo(HaveOccurred())
key := etcddb.EvacuatingActualLRPSchemaPath(lrp.GetProcessGuid(), lrp.GetIndex())
_, err = t.client.Set(key, value, ttlInSeconds)
Expect(err).NotTo(HaveOccurred())
}
func (db *ETCDDB) EvacuateActualLRP(
logger lager.Logger,
lrpKey *models.ActualLRPKey,
instanceKey *models.ActualLRPInstanceKey,
netInfo *models.ActualLRPNetInfo,
ttl uint64,
) (*models.ActualLRPGroup, error) {
logger = logger.Session("evacuate-actual-lrp", lager.Data{"process_guid": lrpKey.ProcessGuid, "index": lrpKey.Index})
logger.Debug("starting")
defer logger.Debug("complete")
node, err := db.fetchRaw(logger, EvacuatingActualLRPSchemaPath(lrpKey.ProcessGuid, lrpKey.Index))
bbsErr := models.ConvertError(err)
if bbsErr != nil {
if bbsErr.Type == models.Error_ResourceNotFound {
return db.createEvacuatingActualLRP(logger, lrpKey, instanceKey, netInfo, ttl)
}
return nil, bbsErr
}
lrp := models.ActualLRP{}
err = db.deserializeModel(logger, node, &lrp)
if err != nil {
return nil, err
}
if lrp.ActualLRPKey.Equal(lrpKey) &&
lrp.ActualLRPInstanceKey.Equal(instanceKey) &&
reflect.DeepEqual(lrp.ActualLRPNetInfo, *netInfo) {
return &models.ActualLRPGroup{Evacuating: &lrp}, nil
}
lrp.ActualLRPNetInfo = *netInfo
lrp.ActualLRPKey = *lrpKey
lrp.ActualLRPInstanceKey = *instanceKey
lrp.Since = db.clock.Now().UnixNano()
lrp.ModificationTag.Increment()
data, err := db.serializeModel(logger, &lrp)
if err != nil {
logger.Error("failed-serializing", err)
return nil, err
}
_, err = db.client.CompareAndSwap(EvacuatingActualLRPSchemaPath(lrp.ProcessGuid, lrp.Index), data, ttl, node.ModifiedIndex)
if err != nil {
return nil, ErrorFromEtcdError(logger, err)
}
return &models.ActualLRPGroup{Evacuating: &lrp}, nil
}
func prettyPrint(encrypted []byte, key string, label string) {
var decrypted, err = decrypt(encrypted, key, label)
if err != nil {
return
}
var model1 models.DesiredLRPRunInfo
err = model1.Unmarshal(decrypted)
if err != nil {
// NOP
} else {
pretty.Println(model1)
return
}
var model2 models.DesiredLRPSchedulingInfo
err = model2.Unmarshal(decrypted)
if err != nil {
// NOP
} else {
pretty.Println(model2)
return
}
var model3 models.ActualLRP
err = model3.Unmarshal(decrypted)
if err != nil {
// NOP
} else {
pretty.Println(model3)
return
}
var model4 models.Task
err = model4.Unmarshal(decrypted)
if err != nil {
// NOP
} else {
pretty.Println(model4)
return
}
var model5 models.DesiredLRP
err = model5.Unmarshal(decrypted)
if err != nil {
log.Println("Unknown data type: ", string(decrypted))
} else {
pretty.Println(model5)
return
}
}
func lrpForState(state string, timeInState time.Duration) models.ActualLRP {
var actualLRPKey = models.NewActualLRPKey("some-process-guid", 1, "tests")
var instanceKey = models.NewActualLRPInstanceKey("some-instance-guid", "some-cell")
lrp := models.ActualLRP{
ActualLRPKey: actualLRPKey,
State: state,
Since: clock.Now().Add(-timeInState).UnixNano(),
}
switch state {
case models.ActualLRPStateUnclaimed:
case models.ActualLRPStateCrashed:
lrp.CrashReason = "crashed"
case models.ActualLRPStateClaimed:
lrp.ActualLRPInstanceKey = instanceKey
case models.ActualLRPStateRunning:
lrp.ActualLRPInstanceKey = instanceKey
lrp.ActualLRPNetInfo = models.NewActualLRPNetInfo("1.2.3.4", &models.PortMapping{ContainerPort: 1234, HostPort: 5678})
}
return lrp
}
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
}
func itValidatesPresenceOfPlacementError(lrp *models.ActualLRP) {
Context("when placement error is set", func() {
BeforeEach(func() {
lrp.PlacementError = "insufficient capacity"
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
Context("when placement error is not set", func() {
BeforeEach(func() {
lrp.PlacementError = ""
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
func itValidatesAbsenceOfPlacementError(lrp *models.ActualLRP) {
Context("when placement error is set", func() {
BeforeEach(func() {
lrp.PlacementError = "insufficient capacity"
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("placement error"))
})
})
Context("when placement error is not set", func() {
BeforeEach(func() {
lrp.PlacementError = ""
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
func itValidatesAbsenceOfTheInstanceKey(lrp *models.ActualLRP) {
Context("when the instance key is set", func() {
BeforeEach(func() {
lrp.ActualLRPInstanceKey = models.NewActualLRPInstanceKey("some-instance", "some-cell")
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("instance key"))
})
})
Context("when the instance key is not set", func() {
BeforeEach(func() {
lrp.ActualLRPInstanceKey = models.ActualLRPInstanceKey{}
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
func itValidatesAbsenceOfNetInfo(lrp *models.ActualLRP) {
Context("when net info is set", func() {
BeforeEach(func() {
lrp.ActualLRPNetInfo = models.NewActualLRPNetInfo("1.2.3.4")
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("net info"))
})
})
Context("when net info is not set", func() {
BeforeEach(func() {
lrp.ActualLRPNetInfo = models.ActualLRPNetInfo{}
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
func itValidatesPresenceOfTheLRPKey(lrp *models.ActualLRP) {
Context("when the lrp key is set", func() {
BeforeEach(func() {
lrp.ActualLRPKey = models.NewActualLRPKey("some-guid", 1, "domain")
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
Context("when the lrp key is not set", func() {
BeforeEach(func() {
lrp.ActualLRPKey = models.ActualLRPKey{}
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("process_guid"))
})
})
}
func ActualLRPProtoToResponse(actualLRP models.ActualLRP, evacuating bool) receptor.ActualLRPResponse {
return receptor.ActualLRPResponse{
ProcessGuid: actualLRP.GetProcessGuid(),
InstanceGuid: actualLRP.GetInstanceGuid(),
CellID: actualLRP.GetCellId(),
Domain: actualLRP.GetDomain(),
Index: int(actualLRP.GetIndex()),
Address: actualLRP.GetAddress(),
Ports: PortMappingFromProto(actualLRP.GetPorts()),
State: actualLRPProtoStateToResponseState(actualLRP.GetState()),
PlacementError: actualLRP.GetPlacementError(),
Since: actualLRP.GetSince(),
CrashCount: int(actualLRP.GetCrashCount()),
CrashReason: actualLRP.GetCrashReason(),
Evacuating: evacuating,
ModificationTag: actualLRPProtoModificationTagToResponseModificationTag(actualLRP.GetModificationTag()),
}
}
processGuid,
1,
"domain-0",
),
State: models.ActualLRPStateUnclaimed,
Since: 1138,
}
})
JustBeforeEach(func() {
request := newTestRequest(requestBody)
handler.RemoveActualLRP(responseRecorder, request)
})
Context("when removing the actual lrp in the DB succeeds", func() {
var removedActualLRP models.ActualLRP
BeforeEach(func() {
removedActualLRP = actualLRP
removedActualLRP.ActualLRPInstanceKey = instanceKey
fakeActualLRPDB.RemoveActualLRPReturns(nil)
})
It("removes the actual lrp by process guid and index", func() {
Expect(responseRecorder.Code).To(Equal(http.StatusOK))
Expect(fakeActualLRPDB.RemoveActualLRPCallCount()).To(Equal(1))
_, actualProcessGuid, idx := fakeActualLRPDB.RemoveActualLRPArgsForCall(0)
Expect(actualProcessGuid).To(Equal(processGuid))
Expect(idx).To(BeEquivalentTo(index))
})
oldmodels "github.com/cloudfoundry-incubator/runtime-schema/models"
"github.com/gogo/protobuf/proto"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager"
)
var _ = Describe("Actual LRP Handlers", func() {
var (
logger lager.Logger
fakeLegacyBBS *fake_legacy_bbs.FakeReceptorBBS
fakeBBS *fake_bbs.FakeClient
responseRecorder *httptest.ResponseRecorder
handler *handlers.ActualLRPHandler
oldActualLRP1 oldmodels.ActualLRP
oldActualLRP2 oldmodels.ActualLRP
oldEvacuatingLRP2 oldmodels.ActualLRP
actualLRP1 models.ActualLRP
actualLRP2 models.ActualLRP
evacuatingLRP2 models.ActualLRP
)
BeforeEach(func() {
fakeLegacyBBS = new(fake_legacy_bbs.FakeReceptorBBS)
fakeBBS = new(fake_bbs.FakeClient)
logger = lager.NewLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
responseRecorder = httptest.NewRecorder()
handler = handlers.NewActualLRPHandler(fakeBBS, fakeLegacyBBS, logger)
})
It("errors", func() {
_, err := etcdDB.ActualLRPGroupByProcessGuidAndIndex(logger, "some-other-guid", 0)
Expect(err).To(HaveOccurred())
})
})
})
Describe("ClaimActualLRP", func() {
var (
actualLRP *models.ActualLRP
claimedActualLRP *models.ActualLRP
claimErr *models.Error
lrpKey models.ActualLRPKey
instanceKey models.ActualLRPInstanceKey
processGuid string
index int32
domain string
)
JustBeforeEach(func() {
request := &models.ClaimActualLRPRequest{
ProcessGuid: processGuid,
Index: index,
ActualLrpInstanceKey: &instanceKey,
}
claimedActualLRP, claimErr = etcdDB.ClaimActualLRP(logger, request)
})
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
group models.ActualLRPGroup
resolvedLRP *models.ActualLRP
evacuating bool
)
BeforeEach(func() {
lrpKey := models.NewActualLRPKey("process-guid", 1, "domain")
instanceLRP = &models.ActualLRP{
ActualLRPKey: lrpKey,
Since: 1138,
}
evacuatingLRP = &models.ActualLRP{
ActualLRPKey: lrpKey,
Since: 3417,
}
Expect(*actualLRP).To(Equal(expectedActualLRP))
fetchedActualLRPGroup, err := client.ActualLRPGroupByProcessGuidAndIndex(unclaimedProcessGuid, unclaimedIndex)
Expect(err).NotTo(HaveOccurred())
fetchedActualLRP, evacuating := fetchedActualLRPGroup.Resolve()
Expect(evacuating).To(BeFalse())
Expect(*fetchedActualLRP).To(Equal(expectedActualLRP))
})
})
Describe("POST /v1/actual_lrps/start", func() {
var (
actualLRP *models.ActualLRP
instanceKey models.ActualLRPInstanceKey
startErr error
)
JustBeforeEach(func() {
instanceKey = models.ActualLRPInstanceKey{
CellId: "my-cell-id",
InstanceGuid: "my-instance-guid",
}
actualLRP, startErr = client.StartActualLRP(&unclaimedLRPKey, &instanceKey, &netInfo)
})
It("starts the actual_lrp", func() {
Expect(startErr).NotTo(HaveOccurred())
expectedActualLRP := *unclaimedLRP
var response models.RemoveEvacuatingActualLRPResponse
err := response.Unmarshal(responseRecorder.Body.Bytes())
Expect(err).NotTo(HaveOccurred())
Expect(response.Error).NotTo(BeNil())
Expect(response.Error).To(Equal(models.ErrResourceNotFound))
})
})
})
Describe("EvacuateClaimedActualLRP", func() {
var (
request *http.Request
requestBody *models.EvacuateClaimedActualLRPRequest
actual *models.ActualLRP
afterActual *models.ActualLRP
desiredLRP *models.DesiredLRP
)
BeforeEach(func() {
desiredLRP = model_helpers.NewValidDesiredLRP("the-guid")
fakeDesiredLRPDB.DesiredLRPByProcessGuidReturns(desiredLRP, nil)
actual = model_helpers.NewValidActualLRP("process-guid", 1)
requestBody = &models.EvacuateClaimedActualLRPRequest{
ActualLrpKey: &actual.ActualLRPKey,
ActualLrpInstanceKey: &actual.ActualLRPInstanceKey,
}
afterActual = model_helpers.NewValidActualLRP("process-guid", 1)
afterActual.State = models.ActualLRPStateUnclaimed
package serialization_test
import (
"github.com/cloudfoundry-incubator/bbs/models"
"github.com/cloudfoundry-incubator/receptor"
"github.com/cloudfoundry-incubator/receptor/serialization"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("ActualLRP Serialization", func() {
Describe("ActualLRPProtoToResponse", func() {
var actualLRP *models.ActualLRP
BeforeEach(func() {
actualLRP = &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(
"process-guid-0",
3,
"some-domain",
),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(
"instance-guid-0",
"cell-id-0",
),
ActualLRPNetInfo: models.NewActualLRPNetInfo(
"address-0",
models.NewPortMapping(9876, 2345),
),
State: models.ActualLRPStateRunning,
func (db *ETCDDB) gatherAndOptionallyPruneActualLRPs(logger lager.Logger, guids map[string]struct{}, doPrune bool, lmc *LRPMetricCounter) (map[string]map[int32]*models.ActualLRP, error) {
response, modelErr := db.fetchRecursiveRaw(logger, ActualLRPSchemaRoot)
if modelErr == models.ErrResourceNotFound {
logger.Info("actual-lrp-schema-root-not-found")
return map[string]map[int32]*models.ActualLRP{}, nil
}
if modelErr != nil {
return nil, modelErr
}
actuals := map[string]map[int32]*models.ActualLRP{}
var guidKeysToDelete, indexKeysToDelete []string
var actualsToDelete []string
var guidsLock, actualsLock, guidKeysToDeleteLock, indexKeysToDeleteLock,
crashingDesiredsLock, actualsToDeleteLock sync.Mutex
logger.Debug("walking-actual-lrp-tree")
works := []func(){}
crashingDesireds := map[string]struct{}{}
for _, guidGroup := range response.Nodes {
guidGroup := guidGroup
works = append(works, func() {
guidGroupWillBeEmpty := true
for _, indexGroup := range guidGroup.Nodes {
indexGroupWillBeEmpty := true
for _, actualNode := range indexGroup.Nodes {
actual := new(models.ActualLRP)
err := db.deserializeModel(logger, actualNode, actual)
if err != nil {
actualsToDeleteLock.Lock()
actualsToDelete = append(actualsToDelete, actualNode.Key)
actualsToDeleteLock.Unlock()
continue
}
err = actual.Validate()
if err != nil {
actualsToDeleteLock.Lock()
actualsToDelete = append(actualsToDelete, actualNode.Key)
actualsToDeleteLock.Unlock()
continue
}
indexGroupWillBeEmpty = false
guidGroupWillBeEmpty = false
switch actual.State {
case models.ActualLRPStateUnclaimed:
atomic.AddInt32(&lmc.unclaimedLRPs, 1)
case models.ActualLRPStateClaimed:
atomic.AddInt32(&lmc.claimedLRPs, 1)
case models.ActualLRPStateRunning:
atomic.AddInt32(&lmc.runningLRPs, 1)
case models.ActualLRPStateCrashed:
crashingDesiredsLock.Lock()
crashingDesireds[actual.ProcessGuid] = struct{}{}
crashingDesiredsLock.Unlock()
atomic.AddInt32(&lmc.crashedActualLRPs, 1)
}
guidsLock.Lock()
guids[actual.ProcessGuid] = struct{}{}
guidsLock.Unlock()
if path.Base(actualNode.Key) == ActualLRPInstanceKey {
actualsLock.Lock()
if actuals[actual.ProcessGuid] == nil {
actuals[actual.ProcessGuid] = map[int32]*models.ActualLRP{}
}
actuals[actual.ProcessGuid][actual.Index] = actual
actualsLock.Unlock()
}
}
if indexGroupWillBeEmpty {
indexKeysToDeleteLock.Lock()
indexKeysToDelete = append(indexKeysToDelete, indexGroup.Key)
indexKeysToDeleteLock.Unlock()
}
}
if guidGroupWillBeEmpty {
guidKeysToDeleteLock.Lock()
guidKeysToDelete = append(guidKeysToDelete, guidGroup.Key)
guidKeysToDeleteLock.Unlock()
}
})
}
logger.Debug("done-walking-actual-lrp-tree")
throttler, err := workpool.NewThrottler(db.convergenceWorkersSize, works)
if err != nil {
logger.Error("failed-to-create-throttler", err)
}
throttler.Work()
if doPrune {
logger.Info("deleting-invalid-actual-lrps", lager.Data{"num_lrps": len(actualsToDelete)})
db.batchDeleteNodes(actualsToDelete, logger)
actualLRPsDeleted.Add(uint64(len(actualsToDelete)))
logger.Info("deleting-empty-actual-indices", lager.Data{"num_indices": len(indexKeysToDelete)})
err = db.deleteLeaves(logger, indexKeysToDelete)
if err != nil {
logger.Error("failed-deleting-empty-actual-indices", err, lager.Data{"num_indices": len(indexKeysToDelete)})
} else {
logger.Info("succeeded-deleting-empty-actual-indices", lager.Data{"num_indices": len(indexKeysToDelete)})
}
logger.Info("deleting-empty-actual-guids", lager.Data{"num_guids": len(guidKeysToDelete)})
err = db.deleteLeaves(logger, guidKeysToDelete)
if err != nil {
logger.Error("failed-deleting-empty-actual-guids", err, lager.Data{"num_guids": len(guidKeysToDelete)})
} else {
logger.Info("succeeded-deleting-empty-actual-guids", lager.Data{"num_guids": len(guidKeysToDelete)})
}
}
lmc.crashingDesiredLRPs = int32(len(crashingDesireds))
return actuals, nil
}
func (db *SQLDB) EvacuateActualLRP(
logger lager.Logger,
lrpKey *models.ActualLRPKey,
instanceKey *models.ActualLRPInstanceKey,
netInfo *models.ActualLRPNetInfo,
ttl uint64,
) (*models.ActualLRPGroup, error) {
logger = logger.Session("evacuate-lrp-sqldb", lager.Data{"lrp_key": lrpKey, "instance_key": instanceKey, "net_info": netInfo})
logger.Debug("starting")
defer logger.Debug("complete")
var actualLRP *models.ActualLRP
err := db.transact(logger, func(logger lager.Logger, tx *sql.Tx) error {
var err error
processGuid := lrpKey.ProcessGuid
index := lrpKey.Index
actualLRP, err = db.fetchActualLRPForUpdate(logger, processGuid, index, true, tx)
if err == models.ErrResourceNotFound {
logger.Debug("creating-evacuating-lrp")
actualLRP, err = db.createEvacuatingActualLRP(logger, lrpKey, instanceKey, netInfo, ttl, tx)
return err
}
if err != nil {
logger.Error("failed-locking-lrp", err)
return err
}
if actualLRP.ActualLRPKey.Equal(lrpKey) &&
actualLRP.ActualLRPInstanceKey.Equal(instanceKey) &&
reflect.DeepEqual(actualLRP.ActualLRPNetInfo, *netInfo) {
logger.Debug("evacuating-lrp-already-exists")
return nil
}
now := db.clock.Now().UnixNano()
actualLRP.ModificationTag.Increment()
actualLRP.ActualLRPKey = *lrpKey
actualLRP.ActualLRPInstanceKey = *instanceKey
actualLRP.Since = now
actualLRP.ActualLRPNetInfo = *netInfo
netInfoData, err := db.serializeModel(logger, netInfo)
if err != nil {
logger.Error("failed-serializing-net-info", err)
return err
}
_, err = db.update(logger, tx, "actual_lrps",
SQLAttributes{
"domain": actualLRP.Domain,
"instance_guid": actualLRP.InstanceGuid,
"cell_id": actualLRP.CellId,
"net_info": netInfoData,
"state": actualLRP.State,
"since": actualLRP.Since,
"modification_tag_index": actualLRP.ModificationTag.Index,
},
"process_guid = ? AND instance_index = ? AND evacuating = ?",
actualLRP.ProcessGuid, actualLRP.Index, true,
)
if err != nil {
logger.Error("failed-update-evacuating-lrp", err)
return db.convertSQLError(err)
}
return nil
})
return &models.ActualLRPGroup{Evacuating: actualLRP}, err
}
"strconv"
"github.com/cloudfoundry-incubator/bbs/db/fakes"
"github.com/cloudfoundry-incubator/bbs/handlers"
"github.com/cloudfoundry-incubator/bbs/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager"
)
var _ = Describe("ActualLRP Handlers", func() {
var (
logger lager.Logger
fakeActualLRPDB *fakes.FakeActualLRPDB
responseRecorder *httptest.ResponseRecorder
handler *handlers.ActualLRPHandler
actualLRP1 models.ActualLRP
actualLRP2 models.ActualLRP
evacuatingLRP2 models.ActualLRP
)
BeforeEach(func() {
fakeActualLRPDB = new(fakes.FakeActualLRPDB)
logger = lager.NewLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
responseRecorder = httptest.NewRecorder()
handler = handlers.NewActualLRPHandler(logger, fakeActualLRPDB)
})
Describe("ActualLRPGroups", func() {
var request *http.Request
"github.com/cloudfoundry-incubator/bbs/cmd/bbs/testrunner"
"github.com/cloudfoundry-incubator/bbs/models"
"github.com/cloudfoundry-incubator/bbs/models/test/model_helpers"
"github.com/tedsuo/ifrit/ginkgomon"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Evacuation API", func() {
BeforeEach(func() {
bbsRunner = testrunner.New(bbsBinPath, bbsArgs)
bbsProcess = ginkgomon.Invoke(bbsRunner)
})
var actual *models.ActualLRP
BeforeEach(func() {
actual = model_helpers.NewValidActualLRP("some-process-guid", 1)
actual.State = models.ActualLRPStateRunning
desiredLRP := model_helpers.NewValidDesiredLRP(actual.ProcessGuid)
desiredLRP.Instances = 2
err := client.DesireLRP(logger, desiredLRP)
Expect(err).NotTo(HaveOccurred())
err = client.ClaimActualLRP(logger, actual.ProcessGuid, 1, &actual.ActualLRPInstanceKey)
Expect(err).NotTo(HaveOccurred())
})
Describe("RemoveEvacuatingActualLRP", func() {
It("removes the evacuating actual_lrp", func() {
_, err := client.EvacuateClaimedActualLRP(logger, &actual.ActualLRPKey, &actual.ActualLRPInstanceKey)
import (
"errors"
"github.com/cloudfoundry-incubator/bbs/db/etcd"
"github.com/cloudfoundry-incubator/bbs/models"
"github.com/cloudfoundry-incubator/bbs/models/test/model_helpers"
etcderrors "github.com/coreos/go-etcd/etcd"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Evacuation", func() {
Describe("EvacuateActualLRP", func() {
var (
actualLRP *models.ActualLRP
index int32
guid string
ttl uint64
)
BeforeEach(func() {
guid = "the-guid"
index = 1
ttl = 60
actualLRP = model_helpers.NewValidActualLRP(guid, index)
etcdHelper.SetRawEvacuatingActualLRP(actualLRP, ttl)
node, err := storeClient.Get(etcd.EvacuatingActualLRPSchemaPath(guid, index), false, false)
fakeStoreClient.GetReturns(node, err)
})