func main() {
flag.Parse()
config := common.DefaultConfig()
if *runtimePath != "" {
config.Runner.PreserveFiles = true
} else {
var err error
if *runtimePath, err = ioutil.TempDir("", "runner"); err != nil {
panic(err)
}
defer os.RemoveAll(*runtimePath)
}
config.Logging.File = "stderr"
if *verbose {
config.Logging.Level = "debug"
}
config.Runner.RuntimePath = *runtimePath
config.Tracing.Enabled = false
ctx, err := common.NewContext(&config)
if err != nil {
panic(err)
}
inputManager := common.NewInputManager(ctx)
results, err := runner.RunHostBenchmark(
ctx,
inputManager,
&minijail,
&ioLock,
)
if err != nil {
panic(err)
}
encoded, err := json.MarshalIndent(results, "", " ")
if err != nil {
panic(err)
}
os.Stdout.Write(encoded)
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
flag.Parse()
if err := loadContext(); err != nil {
panic(err)
}
ctx := globalContext.Load().(*common.Context)
expvar.Publish("config", &globalContext.Load().(*common.Context).Config)
inputManager = common.NewInputManager(ctx)
inputPath := path.Join(ctx.Config.Runner.RuntimePath, "input")
go inputManager.PreloadInputs(
inputPath,
runner.NewRunnerCachedInputFactory(inputPath),
&ioLock,
)
transport := &http.Transport{
Dial: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
if !*insecure {
cert, err := ioutil.ReadFile(ctx.Config.TLS.CertFile)
if err != nil {
panic(err)
}
certPool := x509.NewCertPool()
certPool.AppendCertsFromPEM(cert)
keyPair, err := tls.LoadX509KeyPair(
ctx.Config.TLS.CertFile,
ctx.Config.TLS.KeyFile,
)
transport.TLSClientConfig = &tls.Config{
Certificates: []tls.Certificate{keyPair},
RootCAs: certPool,
ClientAuth: tls.RequireAndVerifyClientCert,
}
if err != nil {
panic(err)
}
if err := http2.ConfigureTransport(transport); err != nil {
panic(err)
}
}
client := &http.Client{Transport: transport}
baseURL, err := url.Parse(ctx.Config.Runner.GraderURL)
if err != nil {
panic(err)
}
setupMetrics(ctx)
ctx.Log.Info("omegaUp runner ready to serve")
go func() {
for {
results, err := runner.RunHostBenchmark(
ctx,
inputManager,
&minijail,
&ioLock,
)
if err != nil {
ctx.Log.Error("Failed to run benchmark", "err", err)
} else {
ctx.Log.Info("Benchmark successful", "results", results)
}
gaugesUpdate(results)
time.Sleep(time.Duration(1) * time.Minute)
}
}()
var sleepTime float32 = 1
for {
if err := processRun(ctx, client, baseURL); err != nil {
if err, ok := err.(net.Error); ok && err.Timeout() {
// Timeouts are expected. Just retry.
sleepTime = 1
continue
}
ctx.Log.Error("error grading run", "err", err)
// Randomized exponential backoff.
time.Sleep(time.Duration(rand.Float32()*sleepTime) * time.Second)
if sleepTime < 64 {
sleepTime *= 2
}
} else {
sleepTime = 1
}
}
}