func NewValidActualLRP(guid string, index int32) *models.ActualLRP {
actualLRP := &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(guid, index, "some-domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey("some-guid", "some-cell"),
ActualLRPNetInfo: models.NewActualLRPNetInfo("some-address", models.NewPortMapping(2222, 4444)),
CrashCount: 33,
CrashReason: "badness",
State: models.ActualLRPStateRunning,
Since: 1138,
ModificationTag: models.ModificationTag{
Epoch: "some-epoch",
Index: 999,
},
}
err := actualLRP.Validate()
Expect(err).NotTo(HaveOccurred())
return actualLRP
}
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 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 (lo *lrpOperation) Execute() {
defer GinkgoRecover()
defer atomic.AddInt32(lo.globalCount, 1)
var err error
randomNum := rand.Float64() * 100.0
// divided by 2 because the start following the claim cause two writes.
isClaiming := randomNum < (lo.percentWrites / 2)
actualLRP := lo.actualLRP
lo.b.Time("start actual LRP", func() {
netInfo := models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(61999, 8080))
lo.semaphore <- struct{}{}
err = bbsClient.StartActualLRP(logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &netInfo)
<-lo.semaphore
Expect(err).NotTo(HaveOccurred())
if actualLRP.State == models.ActualLRPStateClaimed {
defer atomic.AddInt32(lo.globalClaimCount, 1)
}
}, reporter.ReporterInfo{
MetricName: RepStartActualLRP,
})
if isClaiming {
lo.b.Time("claim actual LRP", func() {
index := int(actualLRP.ActualLRPKey.Index)
lo.semaphore <- struct{}{}
err = bbsClient.ClaimActualLRP(logger, actualLRP.ActualLRPKey.ProcessGuid, index, &actualLRP.ActualLRPInstanceKey)
<-lo.semaphore
Expect(err).NotTo(HaveOccurred())
defer atomic.AddInt32(lo.globalClaimCount, 1)
}, reporter.ReporterInfo{
MetricName: RepClaimActualLRP,
})
}
}
netInfo models.ActualLRPNetInfo
requestBody interface{}
)
BeforeEach(func() {
key = models.NewActualLRPKey(
processGuid,
index,
"domain-0",
)
instanceKey = models.NewActualLRPInstanceKey(
"instance-guid-0",
"cell-id-0",
)
netInfo = models.NewActualLRPNetInfo("1.1.1.1", models.NewPortMapping(10, 20))
requestBody = &models.StartActualLRPRequest{
ActualLrpKey: &key,
ActualLrpInstanceKey: &instanceKey,
ActualLrpNetInfo: &netInfo,
}
actualLRP = models.ActualLRP{
ActualLRPKey: key,
State: models.ActualLRPStateUnclaimed,
Since: 1138,
}
afterActualLRP = models.ActualLRP{
ActualLRPKey: key,
ActualLRPInstanceKey: instanceKey,
evacuatingLRP *models.ActualLRP
otherDomainLRP *models.ActualLRP
otherCellIdLRP *models.ActualLRP
baseLRPKey models.ActualLRPKey
baseLRPInstanceKey models.ActualLRPInstanceKey
otherLRPInstanceKey models.ActualLRPInstanceKey
netInfo models.ActualLRPNetInfo
)
BeforeEach(func() {
baseLRPKey = models.NewActualLRPKey(baseProcessGuid, baseIndex, baseDomain)
baseLRPInstanceKey = models.NewActualLRPInstanceKey(baseInstanceGuid, cellID)
otherLRPInstanceKey = models.NewActualLRPInstanceKey(otherInstanceGuid, otherCellID)
netInfo = models.NewActualLRPNetInfo("127.0.0.1", models.NewPortMapping(8080, 80))
baseLRP = &models.ActualLRP{
ActualLRPKey: baseLRPKey,
ActualLRPInstanceKey: baseLRPInstanceKey,
ActualLRPNetInfo: netInfo,
State: models.ActualLRPStateRunning,
Since: clock.Now().UnixNano(),
}
evacuatingLRP = &models.ActualLRP{
ActualLRPKey: baseLRPKey,
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(evacuatingInstanceGuid, cellID),
ActualLRPNetInfo: netInfo,
State: models.ActualLRPStateRunning,
Since: clock.Now().UnixNano() - 1000,
})
})
})
})
})
Describe("ActualLRP", func() {
var lrp models.ActualLRP
var lrpKey models.ActualLRPKey
var instanceKey models.ActualLRPInstanceKey
var netInfo models.ActualLRPNetInfo
BeforeEach(func() {
lrpKey = models.NewActualLRPKey("some-guid", 2, "some-domain")
instanceKey = models.NewActualLRPInstanceKey("some-instance-guid", "some-cell-id")
netInfo = models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(5678, 8080), models.NewPortMapping(1234, 8081))
lrp = models.ActualLRP{
ActualLRPKey: lrpKey,
ActualLRPInstanceKey: instanceKey,
ActualLRPNetInfo: netInfo,
CrashCount: 1,
State: models.ActualLRPStateRunning,
Since: 1138,
ModificationTag: models.ModificationTag{
Epoch: "some-guid",
Index: 50,
},
}
})
func (g *DesiredLRPGenerator) Generate(logger lager.Logger, numReps, count int) (int, map[string]int, error) {
logger = logger.Session("generate-desired-lrp", lager.Data{"count": count})
start := time.Now()
var wg sync.WaitGroup
desiredErrCh := make(chan *stampedError, count)
actualErrCh := make(chan *stampedError, count)
actualStartErrCh := make(chan *stampedError, count)
logger.Info("queing-started")
for i := 0; i < count; i++ {
wg.Add(1)
id := fmt.Sprintf("BENCHMARK-BBS-GUID-%06d", i)
g.workPool.Submit(func() {
defer wg.Done()
desired, err := newDesiredLRP(id)
if err != nil {
desiredErrCh <- newStampedError(err, id, "")
return
}
desiredErrCh <- newStampedError(g.bbsClient.DesireLRP(logger, desired), id, "")
cellID := fmt.Sprintf("cell-%d", rand.Intn(numReps))
actualLRPInstanceKey := &models.ActualLRPInstanceKey{InstanceGuid: desired.ProcessGuid + "-i", CellId: cellID}
actualErrCh <- newStampedError(
g.bbsClient.ClaimActualLRP(
logger,
desired.ProcessGuid,
0,
actualLRPInstanceKey,
),
id,
cellID,
)
netInfo := models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(61999, 8080))
actualStartErrCh <- newStampedError(
g.bbsClient.StartActualLRP(logger, &models.ActualLRPKey{Domain: desired.Domain, ProcessGuid: desired.ProcessGuid, Index: 0}, actualLRPInstanceKey, &netInfo),
id,
cellID,
)
})
if i%10000 == 0 {
logger.Info("queing-progress", lager.Data{"current": i, "total": count})
}
}
logger.Info("queing-complete", lager.Data{"duration": time.Since(start)})
go func() {
wg.Wait()
close(desiredErrCh)
close(actualErrCh)
close(actualStartErrCh)
}()
return g.processResults(logger, desiredErrCh, actualErrCh, actualStartErrCh, numReps)
}
Expect(desiredLRPRemovedEvent.DesiredLrp.ProcessGuid).To(Equal(desiredLRP.ProcessGuid))
})
})
Describe("Actual LRPs", func() {
const (
processGuid = "some-process-guid"
domain = "some-domain"
noExpirationTTL = 0
)
BeforeEach(func() {
key = models.NewActualLRPKey(processGuid, 0, domain)
instanceKey = models.NewActualLRPInstanceKey("instance-guid", "cell-id")
newInstanceKey = models.NewActualLRPInstanceKey("other-instance-guid", "other-cell-id")
netInfo = models.NewActualLRPNetInfo("1.1.1.1")
desiredLRP = &models.DesiredLRP{
ProcessGuid: processGuid,
Domain: domain,
RootFs: "some:rootfs",
Instances: 1,
Action: models.WrapAction(&models.RunAction{
Path: "true",
User: "******",
}),
}
})
It("receives events", func() {
By("creating a ActualLRP")
Expect(err).NotTo(HaveOccurred())
processGuid = "desired-with-restartable-crashed-actuals" + "-" + domain
desiredLRPWithRestartableCrashedActuals := model_helpers.NewValidDesiredLRP(processGuid)
desiredLRPWithRestartableCrashedActuals.Domain = domain
desiredLRPWithRestartableCrashedActuals.Instances = 2
err = sqlDB.DesireLRP(logger, desiredLRPWithRestartableCrashedActuals)
Expect(err).NotTo(HaveOccurred())
for i := int32(0); i < 2; i++ {
crashedActualLRPKey := models.NewActualLRPKey(processGuid, i, domain)
_, err = sqlDB.CreateUnclaimedActualLRP(logger, &crashedActualLRPKey)
Expect(err).NotTo(HaveOccurred())
instanceGuid = "restartable-crashed-actual" + "-" + domain
_, _, err = sqlDB.ClaimActualLRP(logger, processGuid, i, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"})
Expect(err).NotTo(HaveOccurred())
actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", models.NewPortMapping(2222, 4444))
_, _, err = sqlDB.StartActualLRP(logger, &crashedActualLRPKey, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}, &actualLRPNetInfo)
Expect(err).NotTo(HaveOccurred())
_, _, _, err = sqlDB.CrashActualLRP(logger, &crashedActualLRPKey, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}, "because it failed")
Expect(err).NotTo(HaveOccurred())
queryStr = `
UPDATE actual_lrps
SET state = ?
WHERE process_guid = ? AND instance_index = ? AND evacuating = ?
`
if test_helpers.UsePostgres() {
queryStr = test_helpers.ReplaceQuestionMarks(queryStr)
}
_, err = db.Exec(queryStr, models.ActualLRPStateCrashed, processGuid, i, false)
Expect(err).NotTo(HaveOccurred())
queryStr = `UPDATE actual_lrps SET evacuating = ? WHERE process_guid = ?`