func subscribeToEvents(logger lager.Logger, bbsClient bbs.Client, subscriptionChan chan<- events.EventSource) {
logger.Info("subscribing-to-events")
eventSource, err := bbsClient.SubscribeToEvents()
if err != nil {
logger.Error("failed-subscribing-to-events", err)
subscriptionChan <- nil
} else {
logger.Info("subscribed-to-events")
subscriptionChan <- eventSource
}
}
func getTasksByState(client bbs.Client, state models.Task_State) []*models.Task {
tasks, err := client.Tasks()
Expect(err).NotTo(HaveOccurred())
filteredTasks := make([]*models.Task, 0)
for _, task := range tasks {
if task.State == state {
filteredTasks = append(filteredTasks, task)
}
}
return filteredTasks
}
func Fetch(bbsClient bbs.Client, w io.Writer) error {
desiredLRPs, err := bbsClient.DesiredLRPs(models.DesiredLRPFilter{})
if err != nil {
return err
}
actualLRPGroups, err := bbsClient.ActualLRPGroups(models.ActualLRPFilter{})
if err != nil {
return err
}
tasks, err := bbsClient.Tasks()
if err != nil {
return err
}
domains, err := bbsClient.Domains()
if err != nil {
return err
}
dump := veritas_models.StoreDump{
Domains: domains,
LRPS: veritas_models.VeritasLRPS{},
Tasks: veritas_models.VeritasTasks{},
}
for _, desired := range desiredLRPs {
dump.LRPS.Get(desired.ProcessGuid).DesiredLRP = desired
}
for _, actualLRPGroup := range actualLRPGroups {
actual, _ := actualLRPGroup.Resolve()
lrp := dump.LRPS.Get(actual.ProcessGuid)
index := strconv.Itoa(int(actual.Index))
lrp.ActualLRPGroupsByIndex[index] = actualLRPGroup
}
for _, task := range tasks {
dump.Tasks[task.Domain] = append(dump.Tasks[task.Domain], task)
}
encoder := json.NewEncoder(w)
return encoder.Encode(dump)
}
func SetDomain(bbsClient bbs.Client, domain string, ttl time.Duration) error {
say.Println(0, say.Green("Setting Domain %s with TTL %ds", domain, int(ttl.Seconds())))
return bbsClient.UpsertDomain(domain, ttl)
}
import (
"os"
"path"
"github.com/cloudfoundry-incubator/bbs"
"github.com/cloudfoundry-incubator/bbs/cmd/bbs/testrunner"
"github.com/tedsuo/ifrit/ginkgomon"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Secure", func() {
var (
client bbs.Client
err error
basePath string
)
BeforeEach(func() {
basePath = path.Join(os.Getenv("GOPATH"), "src", "github.com", "cloudfoundry-incubator", "bbs", "cmd", "bbs", "fixtures")
bbsURL.Scheme = "https"
})
JustBeforeEach(func() {
client = bbs.NewClient(bbsURL.String())
bbsRunner = testrunner.New(bbsBinPath, bbsArgs)
bbsProcess = ginkgomon.Invoke(bbsRunner)
})
AfterEach(func() {
exitDuration = 4 * time.Second
convergeRepeatInterval = 500 * time.Millisecond
taskKickInterval = convergeRepeatInterval
expireCompletedTaskDuration = 3 * convergeRepeatInterval
expirePendingTaskDuration = 30 * time.Minute
)
var (
binPaths BinPaths
etcdRunner *etcdstorerunner.ETCDClusterRunner
bbsArgs bbsrunner.Args
bbsProcess ifrit.Process
bbsClient bbs.Client
convergerConfig *convergerrunner.Config
convergerProcess ifrit.Process
runner *ginkgomon.Runner
consulRunner *consulrunner.ClusterRunner
consulSession *consuladapter.Session
etcdClient storeadapter.StoreAdapter
logger lager.Logger
)
SynchronizedBeforeSuite(func() []byte {
convergerBinPath, err := Build("github.com/cloudfoundry-incubator/converger/cmd/converger", "-race")
Expect(err).NotTo(HaveOccurred())
bbsBinPath, err := Build("github.com/cloudfoundry-incubator/bbs/cmd/bbs", "-race")
Expect(err).NotTo(HaveOccurred())
bytes, err := json.Marshal(BinPaths{