func newDesiredLRP(guid string) (*models.DesiredLRP, error) {
myRouterJSON := json.RawMessage(`[{"hostnames":["dora.bosh-lite.com"],"port":8080}]`)
myRouterJSON2 := json.RawMessage(`{"container_port":2222,"host_fingerprint":"44:00:2b:21:19:1a:42:ab:54:2f:c3:9d:97:d6:c8:0f","private_key":"-----BEGIN RSA PRIVATE KEY-----\nMIICXQIBAAKBgQCu4BiQh96+AvbYHDxRhfK9Scsl5diUkb/LIbe7Hx7DZg8iTxvr\nkw+de3i1TZG3wH02bdReBnCXrN/u59q0qqsz8ge71BFqnSF0dJaSmXhWizN0NQEy\n5u4WyqM4WJTzUGFnofJxnwFArHBT6QEtDjqCJxyggjuBrF60x3HtSfp4gQIDAQAB\nAoGBAJp/SbSHFXbxz3tmlrO/j5FEHMJCqnG3wqaIB3a+K8Od60j4c0ZRCr6rUx16\nhn69BOKNbc4UCm02QjEjjcmH7u/jLflvKLR/EeEXpGpAd7i3b5bqNn98PP+KwnbS\nPxbot37KErdwLnlF8QYFZMeqHiXQG8nO1nqroiX+fVUDtipBAkEAx8nDxLet6ObJ\nWzdR/8dSQ5qeCqXlfX9PFN6JHtw/OBZjRP5jc2cfGXAAB2h7w5XBy0tak1+76v+Y\nTrdq/rqAdQJBAOAT7W0FpLAZEJusY4sXkhZJvGO0e9MaOdYx53Z2m2gUgxLuowkS\nOmKn/Oj+jqr8r1FAhnTYBDY3k5lzM9p41l0CQEXQ9j6qSXXYIIllvZv6lX7Wa2Ah\nNR8z+/i5A4XrRZReDnavxyUu5ilHgFsWYhmpHb3jKVXS4KJwi1MGubcmiXkCQQDH\nWrNG5Vhpm0MdXLeLDcNYtO04P2BSpeiC2g81Y7xLUsRyWYEPFvp+vznRCHhhQ0Gu\npht5ZJ4KplNYmBev7QW5AkA2PuQ8n7APgIhi8xBwlZW3jufnSHT8dP6JUCgvvon1\nDvUM22k/ZWRo0mUB4BdGctIqRFiGwB8Hd0WSl7gSb5oF\n-----END RSA PRIVATE KEY-----\n"}`)
modTag := models.NewModificationTag("epoch", 0)
desiredLRP := &models.DesiredLRP{
ProcessGuid: guid,
Domain: "benchmark-bbs",
RootFs: "some:rootfs",
Instances: 1,
EnvironmentVariables: []*models.EnvironmentVariable{{Name: "FOO", Value: "bar"}},
Setup: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}),
Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}),
StartTimeoutMs: 15000,
Monitor: models.WrapAction(models.EmitProgressFor(
models.Timeout(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"}))),
10*time.Second,
),
"start-message",
"success-message",
"failure-message",
)),
DiskMb: 512,
MemoryMb: 1024,
CpuWeight: 42,
Routes: &models.Routes{"my-router": &myRouterJSON,
"diego-ssh": &myRouterJSON2},
LogSource: "some-log-source",
LogGuid: "some-log-guid",
MetricsGuid: "some-metrics-guid",
Annotation: "some-annotation",
EgressRules: []*models.SecurityGroupRule{{
Protocol: models.TCPProtocol,
Destinations: []string{"1.1.1.1/32", "2.2.2.2/32"},
PortRange: &models.PortRange{Start: 10, End: 16000},
}},
ModificationTag: &modTag,
}
err := desiredLRP.Validate()
if err != nil {
return nil, err
}
return desiredLRP, nil
}
func NewValidTaskDefinition() *models.TaskDefinition {
return &models.TaskDefinition{
RootFs: "docker:///docker.com/docker",
EnvironmentVariables: []*models.EnvironmentVariable{
{
Name: "FOO",
Value: "BAR",
},
},
CachedDependencies: []*models.CachedDependency{
{Name: "app bits", From: "blobstore.com/bits/app-bits", To: "/usr/local/app", CacheKey: "cache-key", LogSource: "log-source"},
{Name: "app bits with checksum", From: "blobstore.com/bits/app-bits-checksum", To: "/usr/local/app-checksum", CacheKey: "cache-key", LogSource: "log-source", ChecksumAlgorithm: "md5", ChecksumValue: "checksum-value"},
},
Action: models.WrapAction(&models.RunAction{
User: "******",
Path: "echo",
Args: []string{"hello world"},
ResourceLimits: &models.ResourceLimits{},
}),
MemoryMb: 256,
DiskMb: 1024,
MaxPids: 1024,
CpuWeight: 42,
Privileged: true,
LogGuid: "123",
LogSource: "APP",
MetricsGuid: "456",
ResultFile: "some-file.txt",
EgressRules: []*models.SecurityGroupRule{
{
Protocol: "tcp",
Destinations: []string{"0.0.0.0/0"},
PortRange: &models.PortRange{
Start: 1,
End: 1024,
},
Log: true,
},
{
Protocol: "udp",
Destinations: []string{"8.8.0.0/16"},
Ports: []uint32{53},
},
},
Annotation: `[{"anything": "you want!"}]... dude`,
Network: &models.Network{
Properties: map[string]string{
"some-key": "some-value",
"some-other-key": "some-other-value",
},
},
LegacyDownloadUser: "******",
TrustedSystemCertificatesPath: "/etc/somepath",
VolumeMounts: []*models.VolumeMount{
{
Driver: "my-driver",
ContainerDir: "/mnt/mypath",
Mode: "r",
Shared: &models.SharedDevice{
VolumeId: "my-volume",
MountConfig: `{"foo":"bar"}`,
},
},
},
PlacementTags: []string{"red-tag", "blue-tag", "one-tag", "two-tag"},
}
}
func NewValidDesiredLRP(guid string) *models.DesiredLRP {
myRouterJSON := json.RawMessage(`{"foo":"bar"}`)
modTag := models.NewModificationTag("epoch", 0)
desiredLRP := &models.DesiredLRP{
ProcessGuid: guid,
Domain: "some-domain",
RootFs: "some:rootfs",
Instances: 1,
EnvironmentVariables: []*models.EnvironmentVariable{{Name: "FOO", Value: "bar"}},
CachedDependencies: []*models.CachedDependency{
{Name: "app bits", From: "blobstore.com/bits/app-bits", To: "/usr/local/app", CacheKey: "cache-key", LogSource: "log-source"},
{Name: "app bits with checksum", From: "blobstore.com/bits/app-bits-checksum", To: "/usr/local/app-checksum", CacheKey: "cache-key", LogSource: "log-source", ChecksumAlgorithm: "md5", ChecksumValue: "checksum-value"},
},
Setup: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}),
Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}),
StartTimeoutMs: 15000,
Monitor: models.WrapAction(models.EmitProgressFor(
models.Timeout(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"}))),
10*time.Second,
),
"start-message",
"success-message",
"failure-message",
)),
DiskMb: 512,
MemoryMb: 1024,
CpuWeight: 42,
MaxPids: 1024,
Routes: &models.Routes{"my-router": &myRouterJSON},
LogSource: "some-log-source",
LogGuid: "some-log-guid",
MetricsGuid: "some-metrics-guid",
Annotation: "some-annotation",
Network: &models.Network{
Properties: map[string]string{
"some-key": "some-value",
"some-other-key": "some-other-value",
},
},
EgressRules: []*models.SecurityGroupRule{{
Protocol: models.TCPProtocol,
Destinations: []string{"1.1.1.1/32", "2.2.2.2/32"},
PortRange: &models.PortRange{Start: 10, End: 16000},
}},
ModificationTag: &modTag,
LegacyDownloadUser: "******",
TrustedSystemCertificatesPath: "/etc/somepath",
PlacementTags: []string{"red-tag", "blue-tag"},
VolumeMounts: []*models.VolumeMount{
{
Driver: "my-driver",
ContainerDir: "/mnt/mypath",
Mode: "r",
Shared: &models.SharedDevice{
VolumeId: "my-volume",
MountConfig: `{"foo":"bar"}`,
},
},
},
}
err := desiredLRP.Validate()
Expect(err).NotTo(HaveOccurred())
return desiredLRP
}
func NewValidAction() *models.Action {
return models.WrapAction(&models.RunAction{Path: "ls", User: "******"})
}
BeforeEach(func() {
fakeRawEventSource = new(eventfakes.FakeRawEventSource)
eventSource = events.NewEventSource(fakeRawEventSource)
})
Describe("Next", func() {
Describe("Desired LRP events", func() {
var desiredLRP *models.DesiredLRP
BeforeEach(func() {
desiredLRP = &models.DesiredLRP{
ProcessGuid: "some-guid",
Domain: "some-domain",
RootFs: "some-rootfs",
Action: models.WrapAction(&models.RunAction{
Path: "true",
User: "******",
}),
}
})
Context("when receiving a DesiredLRPCreatedEvent", func() {
var expectedEvent *models.DesiredLRPCreatedEvent
BeforeEach(func() {
expectedEvent = models.NewDesiredLRPCreatedEvent(desiredLRP)
payload, err := proto.Marshal(expectedEvent)
Expect(err).NotTo(HaveOccurred())
payload = []byte(base64.StdEncoding.EncodeToString(payload))
fakeRawEventSource.NextReturns(
sse.Event{
It("returns a not implemented error", func() {
Expect(migration.Down(logger)).To(HaveOccurred())
})
})
Describe("Up", func() {
var (
task *models.Task
migrationErr error
)
Describe("Task Migration", func() {
BeforeEach(func() {
task = model_helpers.NewValidTask("task-guid-1")
task.Action = models.WrapAction(&models.TimeoutAction{Action: model_helpers.NewValidAction(),
DeprecatedTimeoutNs: 5 * int64(time.Second),
})
})
JustBeforeEach(func() {
taskData, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, task)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(etcddb.TaskSchemaPath(task), taskData, 0)
Expect(err).NotTo(HaveOccurred())
migration.SetStoreClient(storeClient)
migration.SetCryptor(cryptor)
migration.SetClock(fakeClock)
migrationErr = migration.Up(logger)
})
err := response.Unmarshal(responseRecorder.Body.Bytes())
Expect(err).NotTo(HaveOccurred())
Expect(response.Error).To(BeNil())
Expect(response.DesiredLrps).To(HaveLen(2))
Expect(response.DesiredLrps[0]).To(Equal(desiredLRP1.VersionDownTo(format.V1)))
Expect(response.DesiredLrps[1]).To(Equal(desiredLRP2.VersionDownTo(format.V1)))
})
})
Context("and the desired LRPs have actions with timeout not timeout_ms", func() {
BeforeEach(func() {
desiredLRP1.Setup = &models.Action{
TimeoutAction: &models.TimeoutAction{
Action: models.WrapAction(&models.UploadAction{
From: "web_location",
}),
TimeoutMs: 10000,
},
}
desiredLRP1.Action = &models.Action{
TimeoutAction: &models.TimeoutAction{
Action: models.WrapAction(&models.UploadAction{
From: "web_location",
}),
TimeoutMs: 20000,
},
}
desiredLRP1.Monitor = &models.Action{
TimeoutAction: &models.TimeoutAction{
Action: models.WrapAction(&models.UploadAction{
"max_pids": 256
}`
task = models.Task{
TaskDefinition: &models.TaskDefinition{
RootFs: "docker:///docker.com/docker",
EnvironmentVariables: []*models.EnvironmentVariable{
{
Name: "ENV_VAR_NAME",
Value: "an environmment value",
},
},
Action: models.WrapAction(&models.DownloadAction{
From: "old_location",
To: "new_location",
CacheKey: "the-cache-key",
User: "******",
ChecksumAlgorithm: "md5",
ChecksumValue: "some value",
}),
MemoryMb: 256,
DiskMb: 1024,
MaxPids: 256,
CpuWeight: 42,
Privileged: true,
LogGuid: "123",
LogSource: "APP",
MetricsGuid: "456",
ResultFile: "some-file.txt",
EgressRules: []*models.SecurityGroupRule{
{
func (t crashTest) Test() {
Context(t.Name, func() {
var (
crashErr error
shouldRestart bool
actualLRPKey *models.ActualLRPKey
instanceKey *models.ActualLRPInstanceKey
initialTimestamp int64
initialModificationIndex uint32
beforeActualGroup, afterActualGroup *models.ActualLRPGroup
)
BeforeEach(func() {
actualLRP := t.LRP()
actualLRPKey = &actualLRP.ActualLRPKey
instanceKey = &actualLRP.ActualLRPInstanceKey
initialTimestamp = actualLRP.Since
initialModificationIndex = actualLRP.ModificationTag.Index
desiredLRP := models.DesiredLRP{
ProcessGuid: actualLRPKey.ProcessGuid,
Domain: actualLRPKey.Domain,
Instances: actualLRPKey.Index + 1,
RootFs: "foo:bar",
Action: models.WrapAction(&models.RunAction{Path: "true", User: "******"}),
}
etcdHelper.SetRawDesiredLRP(&desiredLRP)
etcdHelper.SetRawActualLRP(&actualLRP)
})
JustBeforeEach(func() {
clock.Increment(600)
beforeActualGroup, afterActualGroup, shouldRestart, crashErr = etcdDB.CrashActualLRP(logger, actualLRPKey, instanceKey, "crashed")
})
if t.Result.ReturnedErr == nil {
It("does not return an error", func() {
Expect(crashErr).NotTo(HaveOccurred())
})
} else {
It(fmt.Sprintf("returned error should be '%s'", t.Result.ReturnedErr.Error()), func() {
Expect(crashErr).To(Equal(t.Result.ReturnedErr))
})
}
It(fmt.Sprintf("has crash count %d", t.Result.CrashCount), func() {
actualLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(actualLRP.CrashCount).To(Equal(t.Result.CrashCount))
})
It(fmt.Sprintf("has crash reason %s", t.Result.CrashReason), func() {
actualLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(actualLRP.CrashReason).To(Equal(t.Result.CrashReason))
})
if t.Result.ShouldUpdate {
It("updates the Since", func() {
actualLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(actualLRP.Since).To(Equal(clock.Now().UnixNano()))
})
It("updates the ModificationIndex", func() {
actualLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(actualLRP.ModificationTag.Index).To(Equal(initialModificationIndex + 1))
})
It("returns the existing and new actual lrp", func() {
actualLRP := t.LRP()
actualLRP.Since = 0
beforeActualGroup.Instance.Since = 0
Expect(beforeActualGroup).To(Equal(&models.ActualLRPGroup{Instance: &actualLRP}))
newLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(afterActualGroup.Instance).To(Equal(newLRP))
})
} else {
It("does not update the Since", func() {
actualLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(actualLRP.Since).To(Equal(initialTimestamp))
})
It("does not update the ModificationIndex", func() {
actualLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(actualLRP.ModificationTag.Index).To(Equal(initialModificationIndex))
})
}
It(fmt.Sprintf("CAS to %s", t.Result.State), func() {
actualLRP, err := etcdHelper.GetInstanceActualLRP(actualLRPKey)
Expect(err).NotTo(HaveOccurred())
Expect(actualLRP.State).To(Equal(t.Result.State))
})
if t.Result.Auction {
It("starts an auction", func() {
Expect(shouldRestart).To(BeTrue())
})
} else {
It("does not start an auction", func() {
Expect(shouldRestart).To(BeFalse())
})
}
Context("when crashing a different instance key", func() {
var beforeActualGroup *models.ActualLRPGroup
BeforeEach(func() {
var err error
beforeActualGroup, err = etcdDB.ActualLRPGroupByProcessGuidAndIndex(logger, actualLRPKey.ProcessGuid, actualLRPKey.Index)
Expect(err).NotTo(HaveOccurred())
instanceKey.InstanceGuid = "another-guid"
})
It("does not crash", func() {
Expect(crashErr).To(Equal(models.ErrActualLRPCannotBeCrashed))
afterActualGroup, err := etcdDB.ActualLRPGroupByProcessGuidAndIndex(logger, actualLRPKey.ProcessGuid, actualLRPKey.Index)
Expect(err).NotTo(HaveOccurred())
Expect(afterActualGroup).To(Equal(beforeActualGroup))
})
})
})
}
Eventually(eventChannel).Should(BeClosed())
})
Describe("Desired LRPs", func() {
BeforeEach(func() {
routeMessage := json.RawMessage([]byte(`[{"port":8080,"hostnames":["original-route"]}]`))
routes := &models.Routes{"cf-router": &routeMessage}
desiredLRP = &models.DesiredLRP{
ProcessGuid: "some-guid",
Domain: "some-domain",
RootFs: "some:rootfs",
Routes: routes,
Action: models.WrapAction(&models.RunAction{
User: "******",
Dir: "/tmp",
Path: "true",
LogSource: "logs",
}),
}
})
It("receives events", func() {
By("creating a DesiredLRP")
err := client.DesireLRP(logger, desiredLRP)
Expect(err).NotTo(HaveOccurred())
desiredLRP, err := client.DesiredLRPByProcessGuid(logger, desiredLRP.ProcessGuid)
Expect(err).NotTo(HaveOccurred())
var event models.Event
Eventually(eventChannel).Should(Receive(&event))
"router": &rawMessage,
}
expectedSchedulingInfo.ModificationTag.Increment()
schedulingInfo.ApplyUpdate(update)
Expect(schedulingInfo).To(Equal(expectedSchedulingInfo))
})
})
Describe("Version Down To", func() {
Context("V1", func() {
BeforeEach(func() {
desiredLRP.Setup = models.WrapAction(models.Timeout(
&models.RunAction{
Path: "/the/path",
User: "******",
},
10*time.Millisecond,
))
desiredLRP.Action = models.WrapAction(models.Timeout(
&models.RunAction{
Path: "/the/path",
User: "******",
},
20*time.Millisecond,
))
desiredLRP.Monitor = models.WrapAction(models.Timeout(
&models.RunAction{
Path: "/the/path",
User: "******",
},
itSerializesAndDeserializes := func(actionPayload string, action *models.Action) {
itSerializes(actionPayload, action)
itDeserializes(actionPayload, action)
}
Describe("WrapAction", func() {
It("wraps an action into *Action", func() {
action := &models.DownloadAction{
Artifact: "mouse",
From: "web_location",
To: "local_location",
CacheKey: "elephant",
User: "******",
}
wrapped := models.WrapAction(action)
Expect(wrapped).NotTo(BeNil())
Expect(wrapped.GetValue()).To(Equal(action))
})
It("does not wrap nil", func() {
wrapped := models.WrapAction(nil)
Expect(wrapped).To(BeNil())
})
})
Describe("Nil Actions", func() {
It("Action -> JSON for a Nil action", func() {
var action *models.Action = nil
By("marshalling to JSON", func() {
json, err := json.Marshal(action)