示例#1
0
func main() {
	backend := backend.Backend{Implementation: "memory", Address: ""}
	flag.Var(&backend, "backend", "impl[:address] of the storage backend")
	bootstrap := flag.Bool("bootstrap", true, "Create initial work specs")
	nsName := flag.String("namespace", "", "Coordinate namespace name")
	flag.Parse()

	coordinateRoot, err := backend.Coordinate()
	if err != nil {
		panic(err)
	}

	namespace, err := coordinateRoot.Namespace(*nsName)
	if err != nil {
		panic(err)
	}

	if *bootstrap {
		err = createWorkSpecs(namespace)
		if err != nil {
			panic(err)
		}
	}

	tasks := map[string]func(context.Context, []coordinate.Attempt){
		"generator": runGenerator,
		"runner":    runRunner,
	}

	worker := worker.Worker{
		Namespace: namespace,
		Tasks:     tasks,
	}
	worker.Run(context.Background())
}
示例#2
0
func main() {
	backend := backend.Backend{Implementation: "memory"}
	app := cli.NewApp()
	app.Usage = "benchmark the Coordinate job queue system"
	app.Flags = []cli.Flag{
		cli.GenericFlag{
			Name:  "backend",
			Value: &backend,
			Usage: "impl:[address] of Coordinate backend",
		},
		cli.StringFlag{
			Name:  "namespace",
			Usage: "Coordinate namespace name",
		},
		cli.IntFlag{
			Name:  "concurrency",
			Value: runtime.NumCPU(),
			Usage: "run this many jobs in parallel",
		},
	}
	app.Commands = []cli.Command{
		addUnits,
		doWork,
		clear,
	}
	app.Before = func(c *cli.Context) (err error) {
		bench.Coordinate, err = backend.Coordinate()
		if err != nil {
			return
		}

		bench.Namespace, err = bench.Coordinate.Namespace(c.String("namespace"))
		if err != nil {
			return
		}

		bench.WorkSpec, err = bench.Namespace.SetWorkSpec(map[string]interface{}{
			"name": "spec",
		})
		if err != nil {
			return
		}

		bench.Concurrency = c.Int("concurrency")

		return
	}
	app.RunAndExitOnError()
}
示例#3
0
func main() {
	var err error

	cborRPCBind := flag.String("cborrpc", ":5932",
		"[ip]:port for CBOR-RPC interface")
	httpBind := flag.String("http", ":5980",
		"[ip]:port for HTTP REST interface")
	backend := backend.Backend{Implementation: "memory", Address: ""}
	flag.Var(&backend, "backend", "impl[:address] of the storage backend")
	config := flag.String("config", "", "global configuration YAML file")
	logRequests := flag.Bool("log-requests", false, "log all requests")
	flag.Parse()

	var gConfig map[string]interface{}
	if *config != "" {
		gConfig, err = loadConfigYaml(*config)
		if err != nil {
			logrus.WithFields(logrus.Fields{
				"err": err,
			}).Fatal("Could not load YAML configuration")
			return
		}
	}

	coordinate, err := backend.Coordinate()
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"err": err,
		}).Fatal("Could not create Coordinate backend")
		return
	}
	coordinate = cache.New(coordinate)

	var reqLogger *logrus.Logger
	if *logRequests {
		stdlog := logrus.StandardLogger()
		reqLogger = &logrus.Logger{
			Out:       stdlog.Out,
			Formatter: stdlog.Formatter,
			Hooks:     stdlog.Hooks,
			Level:     logrus.DebugLevel,
		}
	}

	go ServeCBORRPC(coordinate, gConfig, "tcp", *cborRPCBind, reqLogger)
	go ServeHTTP(coordinate, *httpBind)
	select {}
}