func (ctx *serverContext) handlePush(w http.ResponseWriter, r *http.Request) (interface{}, error) { pushes, err := strconv.Atoi(r.FormValue("iterations")) if err != nil { pushes = 1 } concurrency := make([]int, 1) concurrency[0], err = strconv.Atoi(r.FormValue("concurrency")) if err != nil { concurrency[0] = 1 } rawConcurrencyStepTime, err := strconv.Atoi(r.FormValue("concurrency:timeBetweenSteps")) concurrencyStepTime := time.Duration(rawConcurrencyStepTime) * time.Second if err != nil { concurrencyStepTime = 60 * time.Second } interval, err := strconv.Atoi(r.FormValue("interval")) if err != nil { interval = 0 } stop, err := strconv.Atoi(r.FormValue("stop")) if err != nil { stop = 0 } workload := r.FormValue("workload") if workload == "" { workload = "cf:push" } workloadContext := context.New() workloadContext.PutString("app", r.FormValue("cfApp")) workloadContext.PutString("app:manifest", r.FormValue("cfManifest")) workloads.PopulateRestContext(r.FormValue("cfTarget"), r.FormValue("cfUsername"), r.FormValue("cfPassword"), r.FormValue("cfSpace"), workloadContext) experiment, _ := ctx.lab.Run( NewRunnableExperiment( NewExperimentConfiguration( pushes, concurrency, concurrencyStepTime, interval, stop, ctx.worker, workload)), workloadContext) return ctx.router.Get("experiment").URL("name", experiment) }
func slaveLoop(conn redis.Conn, delegate Worker, handle string) { var redisMsg redisMessage logger := logs.NewLogger("redis.slave") logger.Info("Started slave") for { reply, err := redis.Strings(conn.Do("BLPOP", "stop-"+handle, "tasks", 0)) if len(reply) == 0 { panic("Empty task, usually means connection lost, shutting down") } if reply[0] == "stop-"+handle { conn.Do("RPUSH", "stopped-"+handle, true) break } if err == nil { redisMsg.WorkloadContext = context.New() json.Unmarshal([]byte(reply[1]), &redisMsg) go func(experiment string, replyTo string, workloadCtx context.Context) { result := delegate.Time(experiment, workloadCtx) var encoded []byte encoded, err = json.Marshal(result) logger.Debug("Completed slave task, replying") conn.Do("RPUSH", replyTo, string(encoded)) }(redisMsg.Workload, redisMsg.Reply, redisMsg.WorkloadContext) } if err != nil { logger.Warnf("ERROR: slave encountered error: %v", err) } } }
) var workloadContext context.Context var _ = Describe("Server", func() { var ( lab *DummyLab workloadContext context.Context ) BeforeEach(func() { experiments := []*DummyExperiment{&DummyExperiment{"a"}, &DummyExperiment{"b"}, &DummyExperiment{"c"}} lab = &DummyLab{} lab.experiments = experiments http.DefaultServeMux = http.NewServeMux() workloadContext = context.New() }) JustBeforeEach(func() { ServeWithLab(lab) }) Describe("VCAP_APP_PORT", func() { var ( listen string flags config.Config ) BeforeEach(func() { flags = config.NewConfig() os.Clearenv()
package context_test import ( "github.com/cloudfoundry-incubator/pat/context" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) var _ = Describe("Context map", func() { var ( localContext context.Context ) JustBeforeEach(func() { localContext = context.New() }) Context("String values in context map", func() { It("uses a key to identify store fields", func() { localContext.PutString("key1", "abc") localContext.PutString("key2", "123") result, exists := localContext.GetString("key1") Ω(result).Should(Equal("abc")) Ω(exists).Should(Equal(true)) result, exists = localContext.GetString("key2") Ω(result).Should(Equal("123")) Ω(exists).Should(Equal(true)) })
. "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) var _ = Describe("RedisWorker", func() { var ( conn redis.Conn workloadCtx context.Context ) BeforeEach(func() { StartRedis("../redis/redis.conf") var err error conn, err = redis.Connect("", 63798, "p4ssw0rd") Ω(err).ShouldNot(HaveOccurred()) workloadCtx = context.New() }) AfterEach(func() { StopRedis() }) Describe("When a single experiment is provided", func() { Context("When no slaves are running", func() { It("Times out after a specified time", func() { worker := NewRedisWorkerWithTimeout(conn, 1) workloadCtx.PutInt("iterationIndex", 0) worker.AddWorkloadStep(workloads.Step("timesout", func() error { time.Sleep(10 * time.Second); return nil }, "")) result := make(chan error) go func() { result <- worker.Time("timesout", workloadCtx).Error
JustBeforeEach(func() { flags = config.NewConfig() InitCommandLineFlags(flags) flags.Parse(args) BlockExit = func() {} err = RunCommandLine() }) Describe("When rest parmaters are supplied", func() { var ( ctx context.Context ) BeforeEach(func() { ctx = context.New() args = []string{"-rest:target", "someTarget", "-rest:username", "someUser", "-rest:password", "hunter2", "-rest:space", "theFinalFrontier", } NewContext = func() context.Context { return ctx } }) It("configures the experiment with the parameter", func() { target, ok := ctx.GetString("rest:target") Ω(ok).To(BeTrue()) Ω(target).To(Equal("someTarget"))
for i, w := range testList { Ω(worker.Workloads[i].Name).Should(Equal(w.Name)) Ω(worker.Workloads[i].Description).Should(Equal(w.Description)) } Ω(worker.Workloads).Should(HaveLen(4)) }) Describe("#PopulateAppContext", func() { BeforeEach(func() { tmpDir := filepath.Join(os.TempDir(), "patTest") os.Chdir(tmpDir) }) It("inserts the app path and manifest path into the context", func() { ctx := context.New() PopulateAppContext("foo", "manifest.yml", ctx) appPath, ok := ctx.GetString("app") Ω(Expect(ok).To(BeTrue())) Ω(Expect(appPath).To(Equal("foo"))) manifestPath, ok := ctx.GetString("app:manifest") Ω(Expect(ok).To(BeTrue())) Ω(Expect(manifestPath).To(Equal("manifest.yml"))) }) It("inserts the app path and manifest path into the context", func() { ctx := context.New() if runtime.GOOS == "darwin" || runtime.GOOS == "linux" { PopulateAppContext("~/foo", "~/manifest.yml", ctx) usr, _ := user.Current()
package benchmarker import ( "time" "github.com/cloudfoundry-incubator/pat/context" . "github.com/cloudfoundry-incubator/pat/workloads" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) var _ = Describe("Benchmarker", func() { workloadCtx := context.New() Describe("#Time", func() { It("times an arbitrary function", func() { time, _ := Time(func() error { time.Sleep(2 * time.Second); return nil }) Ω(time.Seconds()).Should(BeNumerically("~", 2, 0.5)) }) }) Describe("TimedWithWorker", func() { It("sends the timing information retrieved from a worker to a channel", func() { ch := make(chan IterationResult) result := make(chan time.Duration) go func(result chan time.Duration) { defer close(ch) for t := range ch { result <- t.Duration }
} var LaboratoryFactory = func(store Store) (lab Laboratory) { lab = NewLaboratory(store) return } var BlockExit = func() { for { in := make([]byte, 1) os.Stdin.Read(in) if string(in) == "q" { return } } } var SilentExit = func(e <-chan int) { for _ = range e { } return } var PrintWorkload = func(workload workloads.WorkloadStep) { fmt.Printf("\x1b[1m%s\x1b[0m\n\t%s\n", workload.Name, workload.Description) } var NewContext = func() context.Context { return context.New() }