func forwardSignals(signals <-chan os.Signal, process ifrit.Process) {
exit := process.Wait()
for {
select {
case sig := <-signals:
process.Signal(sig)
case <-exit:
return
}
}
}
func waitUntilReady(process ifrit.Process, logger lager.Logger) error {
//we could not find a reliable way for ifrit to report that all processes
//were ready without error, so we opted to simply report as ready if no errors
//were thrown within a timeout
ready := time.After(5 * time.Second)
select {
case <-ready:
logger.Info("All child processes are ready")
return nil
case err := <-process.Wait():
if err == nil {
//sometimes process will exit early, but will return a nil error
err = errors.New("Child process exited before becoming ready")
}
return err
}
}
func waitForEvents(
member Member,
process ifrit.Process,
entrance entranceEventChannel,
exit exitEventChannel,
) {
select {
case <-process.Ready():
entrance <- EntranceEvent{
Member: member,
Process: process,
}
exit <- ExitEvent{
Member: member,
Err: <-process.Wait(),
}
case err := <-process.Wait():
entrance <- EntranceEvent{
Member: member,
Process: process,
}
exit <- ExitEvent{
Member: member,
Err: err,
}
}
}
attempt3Factory = new(fakes.FakeStepFactory)
attempt3Step = new(fakes.FakeStep)
attempt3Factory.UsingReturns(attempt3Step)
stepFactory = Retry{attempt1Factory, attempt2Factory, attempt3Factory}
step = stepFactory.Using(nil, nil)
})
Context("when attempt 1 succeeds", func() {
BeforeEach(func() {
attempt1Step.ResultStub = successResult(true)
})
Describe("Run", func() {
var process ifrit.Process
JustBeforeEach(func() {
process = ifrit.Invoke(step)
})
It("returns nil having only run the first attempt", func() {
Expect(<-process.Wait()).ToNot(HaveOccurred())
Expect(attempt1Step.RunCallCount()).To(Equal(1))
Expect(attempt2Step.RunCallCount()).To(Equal(0))
Expect(attempt3Step.RunCallCount()).To(Equal(0))
})
Describe("Result", func() {
It("delegates to attempt 1", func() {
"github.com/pivotal-golang/clock/fakeclock"
"github.com/cloudfoundry-incubator/converger/converger_process"
)
const aBit = 100 * time.Millisecond
var _ = Describe("ConvergerProcess", func() {
var (
fakeBBSServiceClient *fake_bbs.FakeServiceClient
fakeBBSClient *fake_bbs.FakeClient
logger *lagertest.TestLogger
fakeClock *fakeclock.FakeClock
convergeRepeatInterval time.Duration
kickTaskDuration time.Duration
expirePendingTaskDuration time.Duration
expireCompletedTaskDuration time.Duration
process ifrit.Process
waitEvents chan<- models.CellEvent
waitErrs chan<- error
)
BeforeEach(func() {
fakeBBSServiceClient = new(fake_bbs.FakeServiceClient)
fakeBBSClient = new(fake_bbs.FakeClient)
logger = lagertest.NewTestLogger("test")
fakeClock = fakeclock.NewFakeClock(time.Now())
convergeRepeatInterval = 1 * time.Second
"code.cloudfoundry.org/lager/lagertest"
"github.com/nats-io/nats"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/tedsuo/ifrit"
)
var _ = Describe("Subscriber", func() {
var (
sub *mbus.Subscriber
subOpts *mbus.SubscriberOpts
process ifrit.Process
registry *fakes.FakeRegistryInterface
natsRunner *test_util.NATSRunner
natsPort uint16
natsClient *nats.Conn
startMsgChan chan struct{}
logger lager.Logger
)
BeforeEach(func() {
natsPort = test_util.NextAvailPort()
natsRunner = test_util.NewNATSRunner(int(natsPort))
natsRunner.Start()
natsClient = natsRunner.MessageBus
registry = new(fakes.FakeRegistryInterface)
fakeWorkerClient = new(wfakes.FakeClient)
factory = NewGardenFactory(fakeWorkerClient, fakeTracker, func() string { return "" })
stdoutBuf = gbytes.NewBuffer()
stderrBuf = gbytes.NewBuffer()
})
Describe("DependentGet", func() {
var (
getDelegate *fakes.FakeGetDelegate
resourceConfig atc.ResourceConfig
params atc.Params
version atc.Version
tags []string
inStep *fakes.FakeStep
repo *SourceRepository
step Step
process ifrit.Process
)
BeforeEach(func() {
getDelegate = new(fakes.FakeGetDelegate)
getDelegate.StdoutReturns(stdoutBuf)
getDelegate.StderrReturns(stderrBuf)
resourceConfig = atc.ResourceConfig{
Name: "some-resource",
Type: "some-resource-type",
handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
startedRequestChan <- struct{}{}
<-finishRequestChan
w.Write([]byte("yo"))
})
)
BeforeEach(func() {
startedRequestChan = make(chan struct{}, 1)
finishRequestChan = make(chan struct{}, 1)
port := 8000 + GinkgoParallelNode()
address = fmt.Sprintf("127.0.0.1:%d", port)
})
Describe("Invoke", func() {
var process ifrit.Process
var socketPath string
Context("when the server is started with a different net Protocol.", func() {
var tmpdir string
BeforeEach(func() {
unixHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("yo"))
})
var err error
tmpdir, err = ioutil.TempDir(os.TempDir(), "ifrit-server-test")
Ω(err).ShouldNot(HaveOccurred())
socketPath = path.Join(tmpdir, "ifrit.sock")
Ω(err).ShouldNot(HaveOccurred())
"github.com/concourse/atc"
. "github.com/concourse/atc/resource"
"github.com/concourse/atc/resource/fakes"
)
var _ = Describe("Resource Out", func() {
var (
source atc.Source
params atc.Params
fakeArtifactSource *fakes.FakeArtifactSource
outScriptStdout string
outScriptStderr string
outScriptExitStatus int
runOutError error
outScriptProcess *gfakes.FakeProcess
versionedSource VersionedSource
outProcess ifrit.Process
ioConfig IOConfig
stdoutBuf *gbytes.Buffer
stderrBuf *gbytes.Buffer
)
BeforeEach(func() {
source = atc.Source{"some": "source"}
params = atc.Params{"some": "params"}
fakeArtifactSource = new(fakes.FakeArtifactSource)
"github.com/tedsuo/ifrit"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
)
// a bit of grace time for eventuallys
const aBit = 50 * time.Millisecond
var _ = Describe("PeriodicMetronNotifier", func() {
var (
sender *fake.FakeMetricSender
etcdOptions etcd.ETCDOptions
reportInterval time.Duration
fakeClock *fakeclock.FakeClock
pmn ifrit.Process
)
BeforeEach(func() {
reportInterval = 100 * time.Millisecond
fakeClock = fakeclock.NewFakeClock(time.Unix(123, 456))
sender = fake.NewFakeMetricSender()
dropsonde_metrics.Initialize(sender, nil)
})
JustBeforeEach(func() {
"fmt"
"os"
"time"
. "github.com/cloudfoundry/gunk/diegonats"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager/lagertest"
"github.com/tedsuo/ifrit"
)
var _ = Describe("Starting the NatsClientRunner process", func() {
var natsClient NATSClient
var natsClientRunner ifrit.Runner
var natsClientProcess ifrit.Process
BeforeEach(func() {
natsAddress := fmt.Sprintf("127.0.0.1:%d", natsPort)
natsClient = NewClient()
natsClientRunner = NewClientRunner(natsAddress, "nats", "nats", lagertest.NewTestLogger("test"), natsClient)
})
AfterEach(func() {
stopNATS()
if natsClientProcess != nil {
natsClientProcess.Signal(os.Interrupt)
Eventually(natsClientProcess.Wait(), 5).Should(Receive())
}
})
"syscall"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/fake_runner"
"github.com/tedsuo/ifrit/grouper"
)
var _ = Describe("dynamicGroup", func() {
var (
client grouper.DynamicClient
pool grouper.DynamicGroup
poolProcess ifrit.Process
childRunner1 *fake_runner.TestRunner
childRunner2 *fake_runner.TestRunner
childRunner3 *fake_runner.TestRunner
)
BeforeEach(func() {
childRunner1 = fake_runner.NewTestRunner()
childRunner2 = fake_runner.NewTestRunner()
childRunner3 = fake_runner.NewTestRunner()
})
AfterEach(func() {
childRunner1.EnsureExit()
childRunner2.EnsureExit()
childRunner3.EnsureExit()
})
"code.cloudfoundry.org/lager"
"code.cloudfoundry.org/lager/lagertest"
"github.com/nats-io/nats"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/tedsuo/ifrit"
)
var _ = Describe("Router", func() {
var (
logger lager.Logger
natsRunner *test_util.NATSRunner
config *cfg.Config
p proxy.Proxy
mbusClient *nats.Conn
registry *rregistry.RouteRegistry
varz vvarz.Varz
rtr *router.Router
subscriber ifrit.Process
natsPort uint16
healthCheck int32
)
testAndVerifyRouterStopsNoDrain := func(signals chan os.Signal, closeChannel chan struct{}, sigs ...os.Signal) {
app := common.NewTestApp([]route.Uri{"drain.vcap.me"}, config.Port, mbusClient, nil, "")
blocker := make(chan bool)
resultCh := make(chan bool, 2)
app.AddHandler("/", func(w http.ResponseWriter, r *http.Request) {
blocker <- true
_, err := ioutil.ReadAll(r.Body)
func Kill(process ifrit.Process, intervals ...interface{}) {
if process != nil {
process.Signal(os.Kill)
Eventually(process.Wait(), intervals...).Should(Receive(), "killed ginkgomon process failed to exit in time")
}
}
func Interrupt(process ifrit.Process, intervals ...interface{}) {
process.Signal(os.Interrupt)
Eventually(process.Wait(), intervals...).Should(Receive(), "interrupted ginkgomon process failed to exit in time")
}
factory = NewGardenFactory(fakeWorkerClient, fakeTracker, func() string {
return "a-random-guid"
})
stdoutBuf = gbytes.NewBuffer()
stderrBuf = gbytes.NewBuffer()
})
Describe("Task", func() {
var (
taskDelegate *fakes.FakeTaskDelegate
privileged Privileged
tags []string
configSource *fakes.FakeTaskConfigSource
inStep *fakes.FakeStep
repo *SourceRepository
step Step
process ifrit.Process
)
BeforeEach(func() {
taskDelegate = new(fakes.FakeTaskDelegate)
taskDelegate.StdoutReturns(stdoutBuf)
taskDelegate.StderrReturns(stderrBuf)
privileged = false
tags = []string{"step", "tags"}
configSource = new(fakes.FakeTaskConfigSource)
Eventually(fakeCC.StagingResponses).Should(HaveLen(1))
Expect(fakeCC.StagingResponses()[0]).To(Equal(
cc_messages.StagingResponseForCC{
Error: &cc_messages.StagingError{
Id: cc_messages.NO_COMPATIBLE_CELL,
Message: "found no compatible cell",
},
}))
Expect(fakeCC.StagingGuids()[0]).To(Equal(stagingGuid))
})
})
Context("when posting a staging response fails repeatedly", func() {
var converger ifrit.Process
const convergeRepeatInterval = time.Second
// Choose duration factors so that:
// a) the resolving task will be rescheduled for completion before being expired
// b) the above will only happen once before the task is expired
// Thus, the total number of expected resolution attempts is 2:
// a) once immediately after the task completes
// b) once as a result of convergence
const expireFactor = 11
const kickFactor = 7
const expectedResolutionAttempts = 2
BeforeEach(func() {
converger = ginkgomon.Invoke(componentMaker.Converger(
"-convergeRepeatInterval", convergeRepeatInterval.String(),
"github.com/apcera/nats"
"github.com/cloudfoundry-incubator/natbeat"
"github.com/cloudfoundry/gunk/diegonats"
"github.com/pivotal-golang/lager"
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/ginkgomon"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Heartbeater", func() {
var fakeNatsClient *diegonats.FakeNATSClient
var heartbeater *natbeat.Heartbeater
var heartbeaterProcess ifrit.Process
var registrations chan natbeat.RegistryMessage
var initialRegisterInterval = 100 * time.Millisecond
var expectedRegistryMsg = natbeat.RegistryMessage{
URIs: []string{"foo.bar.com", "example.com"},
Host: "1.2.3.4",
Port: 4567,
App: "my-awesome-app",
PrivateInstanceId: "deadbeef-c0ffee",
}
BeforeEach(func() {
logger := lager.NewLogger("test")
fakeNatsClient = diegonats.NewFakeClient()
heartbeater = natbeat.New(fakeNatsClient, expectedRegistryMsg, initialRegisterInterval, logger)
registrations = make(chan natbeat.RegistryMessage, 1)
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
"github.com/pivotal-golang/operationq"
"github.com/pivotal-golang/operationq/fake_operationq"
"github.com/tedsuo/ifrit"
)
var _ = Describe("Bulker", func() {
var (
sender *fake.FakeMetricSender
logger *lagertest.TestLogger
pollInterval time.Duration
evacuationPollInterval time.Duration
fakeClock *fakeclock.FakeClock
fakeGenerator *fake_generator.FakeGenerator
fakeQueue *fake_operationq.FakeQueue
evacuatable evacuation_context.Evacuatable
evacuationNotifier evacuation_context.EvacuationNotifier
bulker *harmonizer.Bulker
process ifrit.Process
)
BeforeEach(func() {
sender = fake.NewFakeMetricSender()
metrics.Initialize(sender, nil)
logger = lagertest.NewTestLogger("test")
pollInterval = 30 * time.Second
evacuationPollInterval = 10 * time.Second
. "github.com/onsi/gomega"
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/ginkgomon"
)
var _ = Describe("Migration Manager", func() {
var (
manager ifrit.Runner
migrationProcess ifrit.Process
logger *lagertest.TestLogger
fakeETCDDB *dbfakes.FakeDB
etcdStoreClient etcd.StoreClient
fakeSQLDB *dbfakes.FakeDB
rawSQLDB *sql.DB
migrations []migration.Migration
migrationsDone chan struct{}
dbVersion *models.Version
fakeMigration *migrationfakes.FakeMigration
cryptor encryption.Cryptor
)
BeforeEach(func() {
migrationsDone = make(chan struct{})
dbVersion = &models.Version{}
func init() {
sender = metrics_fakes.NewFakeMetricSender()
metrics.Initialize(sender, nil)
}
var _ = Describe("RouteFetcher", func() {
var (
cfg *config.Config
uaaClient *testUaaClient.FakeClient
registry *testRegistry.FakeRegistryInterface
fetcher *RouteFetcher
logger lager.Logger
client *fake_routing_api.FakeClient
token *schema.Token
response []db.Route
process ifrit.Process
eventChannel chan routing_api.Event
errorChannel chan error
clock *fakeclock.FakeClock
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
cfg = config.DefaultConfig()
cfg.PruneStaleDropletsInterval = 2 * time.Second
retryInterval := 0
"github.com/concourse/atc/exec/fakes"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/tedsuo/ifrit"
)
var _ = Describe("Timeout Step", func() {
var (
fakeStepFactoryStep *fakes.FakeStepFactory
runStep *fakes.FakeStep
timeout StepFactory
step Step
startStep chan error
process ifrit.Process
timeoutDuration atc.Duration
)
BeforeEach(func() {
startStep = make(chan error, 1)
fakeStepFactoryStep = new(fakes.FakeStepFactory)
runStep = new(fakes.FakeStep)
fakeStepFactoryStep.UsingReturns(runStep)
})
"time"
"github.com/cloudfoundry-incubator/switchboard/health"
"github.com/pivotal-golang/lager/lagertest"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/tedsuo/ifrit"
)
var _ = Describe("HealthRunner", func() {
var (
healthPort int
logger *lagertest.TestLogger
healthRunner health.Runner
healthProcess ifrit.Process
startupTimeout = 5 * time.Second
)
BeforeEach(func() {
healthPort = 10000 + GinkgoParallelNode()
logger = lagertest.NewTestLogger("HealthRunner Test")
healthRunner = health.NewRunner(uint(healthPort), logger)
healthProcess = ifrit.Invoke(healthRunner)
isReady := healthProcess.Ready()
Eventually(isReady, startupTimeout).Should(BeClosed(), "Error starting Health Runner")
})
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/contraband/checkin/db/postgresrunner"
"github.com/tedsuo/ifrit"
)
func TestDB(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "DB Suite")
}
var postgresRunner postgresrunner.Runner
var dbProcess ifrit.Process
var _ = BeforeSuite(func() {
postgresRunner = postgresrunner.Runner{
Port: 5433 + GinkgoParallelNode(),
}
dbProcess = ifrit.Invoke(postgresRunner)
postgresRunner.CreateTestDB()
})
var _ = AfterSuite(func() {
dbProcess.Signal(os.Interrupt)
Eventually(dbProcess.Wait(), 10*time.Second).Should(Receive())
})
var repResources = rep.Resources{
MemoryMB: 100.0,
DiskMB: 100.0,
Containers: 100,
}
var timeout time.Duration
var workers int
var svgReport *visualization.SVGReport
var reports []*visualization.Report
var reportName string
var disableSVGReport bool
var sessionsToTerminate []*gexec.Session
var runnerProcess ifrit.Process
var runnerDelegate *auctionRunnerDelegate
var workPool *workpool.WorkPool
var runner auctiontypes.AuctionRunner
var logger lager.Logger
func init() {
flag.StringVar(&communicationMode, "communicationMode", "inprocess", "one of inprocess or http")
flag.DurationVar(&timeout, "timeout", time.Second, "timeout when waiting for responses from remote calls")
flag.IntVar(&workers, "workers", 500, "number of concurrent communication worker pools")
flag.BoolVar(&disableSVGReport, "disableSVGReport", false, "disable displaying SVG reports of the simulation runs")
flag.StringVar(&reportName, "reportName", "report", "report name")
}
func TestAuction(t *testing.T) {
"github.com/concourse/atc"
. "github.com/concourse/atc/resource"
)
var _ = Describe("Resource In", func() {
var (
source atc.Source
params atc.Params
version atc.Version
inScriptStdout string
inScriptStderr string
inScriptExitStatus int
runInError error
inScriptProcess *gfakes.FakeProcess
versionedSource VersionedSource
inProcess ifrit.Process
ioConfig IOConfig
stdoutBuf *gbytes.Buffer
stderrBuf *gbytes.Buffer
)
BeforeEach(func() {
source = atc.Source{"some": "source"}
version = atc.Version{"some": "version"}
params = atc.Params{"some": "params"}
factory = NewGardenFactory(fakeWorkerClient, fakeTracker)
stdoutBuf = gbytes.NewBuffer()
stderrBuf = gbytes.NewBuffer()
})
Describe("Put", func() {
var (
putDelegate *fakes.FakePutDelegate
resourceConfig atc.ResourceConfig
params atc.Params
tags []string
resourceTypes atc.ResourceTypes
inStep *fakes.FakeStep
repo *SourceRepository
fakeSource *fakes.FakeArtifactSource
fakeOtherSource *fakes.FakeArtifactSource
fakeMountedSource *fakes.FakeArtifactSource
step Step
process ifrit.Process
)
BeforeEach(func() {
putDelegate = new(fakes.FakePutDelegate)
putDelegate.StdoutReturns(stdoutBuf)
putDelegate.StderrReturns(stderrBuf)
resourceConfig = atc.ResourceConfig{
package restart_test
import (
"os"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/fake_runner"
"github.com/tedsuo/ifrit/restart"
)
var _ = Describe("Restart", func() {
var testRunner *fake_runner.TestRunner
var restarter restart.Restarter
var process ifrit.Process
BeforeEach(func() {
testRunner = fake_runner.NewTestRunner()
restarter = restart.Restarter{
Runner: testRunner,
Load: func(runner ifrit.Runner, err error) ifrit.Runner {
return nil
},
}
})
JustBeforeEach(func() {
process = ifrit.Background(restarter)
})
"github.com/cloudfoundry-incubator/bbs"
"github.com/cloudfoundry-incubator/bbs/models"
"github.com/cloudfoundry-incubator/locket"
"github.com/cloudfoundry-incubator/runtime-schema/cc_messages"
)
var _ = Describe("Syncing desired state with CC", func() {
const interruptTimeout = 5 * time.Second
var (
fakeCC *ghttp.Server
process ifrit.Process
domainTTL time.Duration
bulkerLockName = "nsync_bulker_lock"
pollingInterval time.Duration
heartbeatInterval time.Duration
logger lager.Logger
)
startBulker := func(check bool) ifrit.Process {
runner := ginkgomon.New(ginkgomon.Config{
Name: "nsync-bulker",
AnsiColorCode: "97m",
StartCheck: "nsync.bulker.started",
Command: exec.Command(
bulkerPath,
"-ccBaseURL", fakeCC.URL(),
"github.com/tedsuo/ifrit"
)
var _ = Describe("Helpers", func() {
Describe("RouteRegister", func() {
var (
routeRegister *helpers.RouteRegister
database *fake_db.FakeDB
route models.Route
logger *lagertest.TestLogger
timeChan chan time.Time
ticker *time.Ticker
)
var process ifrit.Process
BeforeEach(func() {
route = models.Route{
Route: "i dont care",
Port: 3000,
IP: "i dont care even more",
TTL: 120,
LogGuid: "i care a little bit more now",
}
database = &fake_db.FakeDB{}
logger = lagertest.NewTestLogger("event-handler-test")
timeChan = make(chan time.Time)
ticker = &time.Ticker{C: timeChan}
