func main() { flag.Parse() //make the out dir logger.Component = "SIMULATOR" if outDir == "" { logger.Fatal("out.dir.unspecified") } err := os.MkdirAll(outDir, 0777) if err != nil { logger.Fatal("out.dir.creation.failed", err) } //set up logging outputFile, err := os.Create(filepath.Join(outDir, "simulator.log")) if err != nil { logger.Fatal("failed.to.create.simulator.log", err) } logger.Writer = io.MultiWriter(os.Stdout, outputFile) cleanup.Register(func() { outputFile.Sync() }) //compile the executor logger.Info("compiling.executor") output, err := exec.Command("go", "install", "github.com/cloudfoundry-incubator/simulator/game_executor").CombinedOutput() if err != nil { logger.Fatal("failed.to.compile.executor", string(output)) } //write info to the output dir writeInfo() //start etcd logger.Info("starting.etcd", etcdNodes) etcd = etcdstorerunner.NewETCDClusterRunner(4001, etcdNodes) etcd.Start() //set up the bbs pool := workerpool.NewWorkerPool(50) etcdAdapter = etcdstoreadapter.NewETCDStoreAdapter(etcd.NodeURLS(), pool) etcdAdapter.Connect() bbs = Bbs.New(etcdAdapter, timeprovider.NewTimeProvider()) //monitor etcd monitorETCD() //start executors startExecutors() cleanup.Register(func() { logger.Info("stopping.etcd", etcdNodes) etcd.Stop() }) //run the simulator runSimulation() cleanup.Exit(0) }
func main() { flag.Parse() datadogApiKey := os.Getenv("DATADOG_API_KEY") datadogAppKey := os.Getenv("DATADOG_APP_KEY") var datadogClient *datadog.Client if datadogApiKey != "" { datadogClient = datadog.NewClient(datadogApiKey, datadogAppKey) } store := etcdstoreadapter.NewETCDStoreAdapter( strings.Split(*etcdMachines, ","), workerpool.NewWorkerPool(50), ) err := store.Connect() if err != nil { log.Fatalln("failed to connect to store:", err) } if *emitStates { // logging mode etcd_logger.EmitRunOnceStates(datadogClient, store, strings.Split(*etcdMachines, ",")) } else { // stampede mode runOnce := &models.RunOnce{ Actions: []models.ExecutorAction{ { models.RunAction{ Script: *script, Timeout: *timeout, }, }, }, Stack: *stack, MemoryMB: *memoryMB, DiskMB: *diskMB, } if *logGuid != "" { runOnce.Log = models.LogConfig{ Guid: *logGuid, SourceName: *logSourceName, } } stampede.RunonceStampede(bbs.New(store, timeprovider.NewTimeProvider()), datadogClient, runOnce, *runOnceCount) } }
func buildTimeProvider(l logger.Logger) timeprovider.TimeProvider { if os.Getenv("HM9000_FAKE_TIME") == "" { return timeprovider.NewTimeProvider() } else { timestamp, err := strconv.Atoi(os.Getenv("HM9000_FAKE_TIME")) if err != nil { l.Error("Failed to load timestamp", err) os.Exit(1) } return &faketimeprovider.FakeTimeProvider{ TimeToProvide: time.Unix(int64(timestamp), 0), } } }
func main() { flag.Parse() cleanup.Register(func() { logger.Info("executor.shuttingdown") close(stop) tasks.Wait() logger.Info("executor.shutdown") }) logger.Component = fmt.Sprintf("EXECUTOR %s", *executorID) lock = &sync.Mutex{} currentMemory = *maxMemory etcdAdapter := etcdstoreadapter.NewETCDStoreAdapter( strings.Split(*etcdCluster, ","), workerpool.NewWorkerPool(10), ) err := etcdAdapter.Connect() if err != nil { logger.Fatal("etcd.connect.fatal", err) } tasks = &sync.WaitGroup{} stop = make(chan bool) bbs := Bbs.New(etcdAdapter, timeprovider.NewTimeProvider()) ready := make(chan bool, 1) err = maintainPresence(bbs, ready) if err != nil { logger.Fatal("executor.initializing-presence.failed", err) } go handleRunOnces(bbs) go convergeRunOnces(bbs) <-ready logger.Info("executor.up") select {} }
func main() { var err error runtime.GOMAXPROCS(runtime.NumCPU()) rand.Seed(time.Now().UnixNano()) flag.Parse() executorUUID, err := uuid.NewV4() if err != nil { log.Fatalln("could not generate guid:", err) } executorID = executorUUID.String() cleanup.Register(func() { once.Do(func() { logger.Info("shutting-down", map[string]interface{}{}) close(stop) tasks.Wait() logger.Info("shutdown", map[string]interface{}{}) }) }) natsClient := yagnats.NewClient() natsMembers := []yagnats.ConnectionProvider{} for _, addr := range strings.Split(*natsAddresses, ",") { natsMembers = append( natsMembers, &yagnats.ConnectionInfo{addr, *natsUsername, *natsPassword}, ) } natsInfo := &yagnats.ConnectionCluster{Members: natsMembers} err = logger.Connect(natsInfo) if err != nil { log.Fatalln("could not connect logger:", err) } err = natsClient.Connect(natsInfo) if err != nil { log.Fatalln("could not connect to nats:", err) } logger.Component = fmt.Sprintf("executor.%s", executorID) etcdAdapter := etcdstoreadapter.NewETCDStoreAdapter( strings.Split(*etcdCluster, ","), workerpool.NewWorkerPool(10), ) err = etcdAdapter.Connect() if err != nil { logger.Fatal("etcd.connect-failed", map[string]interface{}{ "error": err.Error(), }) } bbs := bbs.New(bbs.NewHurlerKicker(*hurlerAddress), etcdAdapter, timeprovider.NewTimeProvider()) ready := make(chan bool, 1) err = maintainPresence(bbs, ready) if err != nil { logger.Fatal("initializing-presence", map[string]interface{}{ "error": err.Error(), }) } err = registerHandler(etcdAdapter, *listenAddr, ready) if err != nil { logger.Fatal("initializing-route", map[string]interface{}{ "error": err.Error(), }) } go handleTasks(bbs, *listenAddr) go convergeTasks(bbs) <-ready <-ready logger.Info("up", map[string]interface{}{ "executor": executorID, }) select {} }
func (sinkManager *SinkManager) ensureRecentLogsSinkFor(appId string) { if sinkManager.sinks.DumpFor(appId) != nil { return } s := dump.NewDumpSink(appId, sinkManager.recentLogCount, sinkManager.logger, time.Hour, timeprovider.NewTimeProvider()) sinkManager.RegisterSink(s) }