. "github.com/onsi/gomega"
)
var _ = Describe("ByRoutingKey", func() {
Describe("RoutesByRoutingKeyFromDesireds", func() {
It("should build a map of routes", func() {
abcRoutes := cfroutes.CFRoutes{
{Hostnames: []string{"foo.com", "bar.com"}, Port: 8080, RouteServiceUrl: "https://something.creative"},
{Hostnames: []string{"foo.example.com"}, Port: 9090},
}
defRoutes := cfroutes.CFRoutes{
{Hostnames: []string{"baz.com"}, Port: 8080},
}
routes := routing_table.RoutesByRoutingKeyFromSchedulingInfos([]*models.DesiredLRPSchedulingInfo{
{DesiredLRPKey: models.NewDesiredLRPKey("abc", "tests", "abc-guid"), Routes: abcRoutes.RoutingInfo()},
{DesiredLRPKey: models.NewDesiredLRPKey("def", "tests", "def-guid"), Routes: defRoutes.RoutingInfo()},
})
Expect(routes).To(HaveLen(3))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 8080}].Hostnames).To(Equal([]string{"foo.com", "bar.com"}))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 8080}].LogGuid).To(Equal("abc-guid"))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 8080}].RouteServiceUrl).To(Equal("https://something.creative"))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 9090}].Hostnames).To(Equal([]string{"foo.example.com"}))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "abc", ContainerPort: 9090}].LogGuid).To(Equal("abc-guid"))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "def", ContainerPort: 8080}].Hostnames).To(Equal([]string{"baz.com"}))
Expect(routes[routing_table.RoutingKey{ProcessGuid: "def", ContainerPort: 8080}].LogGuid).To(Equal("def-guid"))
})
staleChan <-chan []cc_messages.CCDesiredAppFingerprint
missingChan <-chan []cc_messages.CCDesiredAppFingerprint
deletedChan <-chan []string
errorsChan <-chan error
logger *lagertest.TestLogger
differ bulk.AppDiffer
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
existingSchedulingInfo = &models.DesiredLRPSchedulingInfo{
DesiredLRPKey: models.NewDesiredLRPKey("process-guid", "domain", "log-guid"),
Instances: 1,
Annotation: "some-etag-1",
}
existingAppFingerprint = cc_messages.CCDesiredAppFingerprint{
ProcessGuid: existingSchedulingInfo.ProcessGuid,
ETag: existingSchedulingInfo.Annotation,
}
desiredChan = make(chan []cc_messages.CCDesiredAppFingerprint, 1)
cancelChan = make(chan struct{})
})
JustBeforeEach(func() {
existingSchedulingInfoMap = map[string]*models.DesiredLRPSchedulingInfo{
syncDuration = 900900
pollingInterval = 500 * time.Millisecond
clock = fakeclock.NewFakeClock(time.Now())
fingerprintsToFetch = []cc_messages.CCDesiredAppFingerprint{
{ProcessGuid: "current-process-guid", ETag: "current-etag"},
{ProcessGuid: "stale-process-guid", ETag: "new-etag"},
{ProcessGuid: "docker-process-guid", ETag: "new-etag"},
{ProcessGuid: "new-process-guid", ETag: "new-etag"},
}
staleRouteMessage := json.RawMessage([]byte(`{ "some-route-key": "some-route-value" }`))
existingSchedulingInfos = []*models.DesiredLRPSchedulingInfo{
{
DesiredLRPKey: models.NewDesiredLRPKey("current-process-guid", "domain", "log-guid"),
Annotation: "current-etag"},
{
DesiredLRPKey: models.NewDesiredLRPKey("stale-process-guid", "domain", "log-guid"),
Annotation: "stale-etag",
Routes: models.Routes{
"router-route-data": &staleRouteMessage,
},
},
{
DesiredLRPKey: models.NewDesiredLRPKey("docker-process-guid", "domain", "log-guid"),
Annotation: "docker-etag",
Routes: models.Routes{
"router-route-data": &staleRouteMessage,
},
},
It("sends a 'synced routes' metric", func() {
Eventually(func() uint64 {
return fakeMetricSender.GetCounter("RoutesSynced")
}, 2).Should(BeEquivalentTo(2))
})
})
Context("Begin & End events", func() {
currentTag := &models.ModificationTag{Epoch: "abc", Index: 1}
hostname1 := "foo.example.com"
hostname2 := "bar.example.com"
endpoint1 := routing_table.Endpoint{InstanceGuid: "ig-1", Host: "1.1.1.1", Port: 11, ContainerPort: 8080, Evacuating: false, ModificationTag: currentTag}
endpoint2 := routing_table.Endpoint{InstanceGuid: "ig-2", Host: "2.2.2.2", Port: 22, ContainerPort: 8080, Evacuating: false, ModificationTag: currentTag}
schedulingInfo1 := &models.DesiredLRPSchedulingInfo{
DesiredLRPKey: models.NewDesiredLRPKey("pg-1", "tests", "lg1"),
Routes: cfroutes.CFRoutes{
cfroutes.CFRoute{
Hostnames: []string{hostname1},
Port: 8080,
RouteServiceUrl: "https://rs.example.com",
},
}.RoutingInfo(),
}
schedulingInfo2 := &models.DesiredLRPSchedulingInfo{
DesiredLRPKey: models.NewDesiredLRPKey("pg-2", "tests", "lg2"),
Routes: cfroutes.CFRoutes{
cfroutes.CFRoute{
Hostnames: []string{hostname2},
Port: 8080,
func newValidLRPKey() models.DesiredLRPKey {
return models.NewDesiredLRPKey("some-guid", "domain", "log-guid")
}
var _ = Describe("DesiredLRPKey", func() {
const guid = "valid-guid"
const domain = "valid-domain"
const log = "valid-log-guid"
DescribeTable("Validation",
func(key models.DesiredLRPKey, expectedErr string) {
err := key.Validate()
if expectedErr == "" {
Expect(err).NotTo(HaveOccurred())
} else {
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring(expectedErr))
}
},
Entry("valid key", models.NewDesiredLRPKey(guid, domain, log), ""),
Entry("blank process guid", models.NewDesiredLRPKey("", domain, log), "process_guid"),
Entry("blank domain", models.NewDesiredLRPKey(guid, "", log), "domain"),
Entry("blank log guid is valid", models.NewDesiredLRPKey(guid, domain, ""), ""),
)
Context("process_guid only contains `A-Z`, `a-z`, `0-9`, `-`, and `_`", func() {
validGuids := []string{"a", "A", "0", "-", "_", "-aaaa", "_-aaa", "09a87aaa-_aASKDn"}
for _, validGuid := range validGuids {
func(validGuid string) {
It(fmt.Sprintf("'%s' is a valid process_guid", validGuid), func() {
key := models.NewDesiredLRPKey(validGuid, domain, log)
err := key.Validate()
Expect(err).NotTo(HaveOccurred())
})
}(validGuid)
}
//what follows is fake data to distinguish between
//the "sync" and "emit" codepaths
dummyEndpoint := routing_table.Endpoint{InstanceGuid: "instance-guid-1", Host: "1.1.1.1", Port: 11, ContainerPort: 1111}
dummyMessage := routing_table.RegistryMessageFor(dummyEndpoint, routing_table.Routes{Hostnames: []string{"foo.com", "bar.com"}, LogGuid: logGuid})
syncMessages = routing_table.MessagesToEmit{
RegistrationMessages: []routing_table.RegistryMessage{dummyMessage},
}
dummyEndpoint = routing_table.Endpoint{InstanceGuid: "instance-guid-2", Host: "2.2.2.2", Port: 22, ContainerPort: 2222}
dummyMessage = routing_table.RegistryMessageFor(dummyEndpoint, routing_table.Routes{Hostnames: []string{"baz.com"}, LogGuid: logGuid})
messagesToEmit = routing_table.MessagesToEmit{
RegistrationMessages: []routing_table.RegistryMessage{dummyMessage},
}
schedulingInfoResponse = &models.DesiredLRPSchedulingInfo{
DesiredLRPKey: models.NewDesiredLRPKey(processGuid, "domain", logGuid),
Routes: cfroutes.CFRoutes{{Hostnames: []string{"route-1", "route-2"}, Port: containerPort}}.RoutingInfo(),
}
actualResponses = []*models.ActualLRPGroup{
{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey(processGuid, 1, "domain"),
ActualLRPInstanceKey: models.NewActualLRPInstanceKey(instanceGuid, "cell-id"),
ActualLRPNetInfo: models.NewActualLRPNetInfo(lrpHost, models.NewPortMapping(1234, containerPort)),
State: models.ActualLRPStateRunning,
},
},
{
Instance: &models.ActualLRP{
ActualLRPKey: models.NewActualLRPKey("", 1, ""),