Merge "playground: adding missing README.md"
diff --git a/go/src/v.io/x/playground/compilerd/compile.go b/go/src/v.io/x/playground/compilerd/compile.go
index 2eeef40..0a37eca 100644
--- a/go/src/v.io/x/playground/compilerd/compile.go
+++ b/go/src/v.io/x/playground/compilerd/compile.go
@@ -13,7 +13,6 @@
import (
"flag"
- "log"
"net/http"
"time"
@@ -23,6 +22,7 @@
"v.io/x/playground/lib"
"v.io/x/playground/lib/event"
"v.io/x/playground/lib/hash"
+ "v.io/x/playground/lib/log"
)
var (
@@ -98,7 +98,7 @@
// The response is hard limited to 2*maxSize: maxSize for builder stdout,
// and another maxSize for compilerd error and status messages.
return event.NewResponseEventSink(lib.NewLimitedWriter(w, 2*(*maxSize), lib.DoOnce(func() {
- log.Println("Hard response size limit reached.")
+ log.Debugln("Hard response size limit reached.")
})), !wantDebug)
}
@@ -108,6 +108,8 @@
return
}
+ log.Debugln("Got valid compile request.")
+
// Hash the body and see if it's been cached. If so, return the cached
// response status and body.
// NOTE(sadovsky): In the client we may shift timestamps (based on current
@@ -117,6 +119,7 @@
if cachedResponseStruct, ok := cr.(cachedResponse); ok {
res := openResponse(cachedResponseStruct.Status)
event.Debug(res, "Sending cached response")
+ log.Debugln("Sending cached response.")
res.Write(cachedResponseStruct.Events...)
return
} else {
@@ -158,17 +161,19 @@
// If the client disconnects before job finishes, cancel the job.
// If job has already started, the job will finish and the results
// will be cached.
- log.Printf("Client disconnected. Cancelling job.")
+ log.Debugln("Client disconnected. Cancelling job.")
job.Cancel()
case result := <-resultChan:
if result.Success {
event.Debug(res, "Caching response")
+ log.Debugln("Caching response.")
cache.Add(requestBodyHash, cachedResponse{
Status: http.StatusOK,
Events: result.Events,
})
} else {
- event.Debug(res, "Internal errors encountered, not caching response")
+ event.Debug(res, "Internal errors encountered, not caching response.")
+ log.Warnln("Internal errors encountered, not caching response.")
}
return
}
diff --git a/go/src/v.io/x/playground/compilerd/jobqueue/jobqueue.go b/go/src/v.io/x/playground/compilerd/jobqueue/jobqueue.go
index e9df960..3b182d5 100644
--- a/go/src/v.io/x/playground/compilerd/jobqueue/jobqueue.go
+++ b/go/src/v.io/x/playground/compilerd/jobqueue/jobqueue.go
@@ -33,7 +33,6 @@
"bytes"
"fmt"
"io/ioutil"
- "log"
"os"
"os/exec"
"sync"
@@ -41,6 +40,7 @@
"v.io/x/playground/lib"
"v.io/x/playground/lib/event"
+ "v.io/x/playground/lib/log"
)
var (
@@ -99,7 +99,7 @@
func (j *Job) Cancel() {
j.mu.Lock()
defer j.mu.Unlock()
- log.Printf("Cancelling job %v.\n", j.id)
+ log.Debugf("Cancelling job %v.\n", j.id)
j.cancelled = true
}
@@ -125,6 +125,7 @@
var _ = Dispatcher((*dispatcherImpl)(nil))
func NewDispatcher(workers int, jobQueueCap int) Dispatcher {
+ log.Debugf("Creating new dispatcher with %v workers and %v queue capacity.\n", workers, jobQueueCap)
d := &dispatcherImpl{
jobQueue: make(chan *Job, jobQueueCap),
stopped: make(chan bool),
@@ -137,7 +138,7 @@
// start starts a given number of workers, then reads from the jobQueue and
// assigns jobs to free workers.
func (d *dispatcherImpl) start(num int) {
- log.Printf("Dispatcher starting %d workers.\n", num)
+ log.Debugf("Dispatcher starting.\n", num)
// Workers are published on the workerQueue when they are free.
workerQueue := make(chan *worker, num)
@@ -166,18 +167,18 @@
cancelled := job.cancelled
job.mu.Unlock()
if cancelled {
- log.Printf("Dispatcher encountered cancelled job %v, rejecting.\n", job.id)
+ log.Debugf("Dispatcher encountered cancelled job %v, rejecting.\n", job.id)
job.resultChan <- Result{
Success: false,
Events: nil,
}
workerQueue <- worker
} else {
- log.Printf("Dispatching job %v to worker %v.\n", job.id, worker.id)
+ log.Debugf("Dispatching job %v to worker %v.\n", job.id, worker.id)
d.wg.Add(1)
go func() {
job.resultChan <- worker.run(job)
- log.Printf("Job %v finished on worker %v.\n", job.id, worker.id)
+ log.Debugf("Job %v finished on worker %v.\n", job.id, worker.id)
d.wg.Done()
workerQueue <- worker
}()
@@ -186,19 +187,19 @@
}
}
- log.Printf("Dispatcher stopped.\n")
+ log.Debugf("Dispatcher stopped.\n")
// Dispatcher stopped, treat all remaining jobs as cancelled.
for {
select {
case job := <-d.jobQueue:
- log.Printf("Dispatcher is stopped, rejecting job %v.\n", job.id)
+ log.Debugf("Dispatcher is stopped, rejecting job %v.\n", job.id)
job.resultChan <- Result{
Success: false,
Events: nil,
}
default:
- log.Printf("Dispatcher job queue drained.\n")
+ log.Debugf("Dispatcher job queue drained.\n")
d.wg.Done()
return
}
@@ -213,7 +214,7 @@
// jobs, rather than rejecting them. Or, put logic in the client to retry
// cancelled jobs.
func (d *dispatcherImpl) Stop() {
- log.Printf("Stopping dispatcher.\n")
+ log.Debugf("Stopping dispatcher.\n")
d.stopped <- true
// Wait for workers to finish their current jobs.
@@ -282,7 +283,7 @@
// each other.
tmpDir, err := ioutil.TempDir("", "pg-builder-")
if err != nil {
- panic(fmt.Errorf("Error creating temp dir for builder: %v", err))
+ log.Panicf("Error creating temp dir for builder: %v\n", err)
} else {
cmd.Dir = tmpDir
}
@@ -320,7 +321,7 @@
userErrorCallback := func(err error) {
// A relay error can result from unparseable JSON caused by a builder bug
// or a malicious exploit inside Docker. Panicking could lead to a DoS.
- log.Println(j.id, "builder stdout relay error:", err)
+ log.Errorln(j.id, "builder stdout relay error:", err)
erroredOut = true
cmdKill()
}
@@ -376,7 +377,7 @@
// Log builder internal errors, if any.
// TODO(ivanpi): Prevent caching? Report to client if debug requested?
if errBuffer.Len() > 0 {
- log.Println(j.id, "builder stderr:", errBuffer.String())
+ log.Warnln(j.id, "builder stderr:", errBuffer.String())
}
event.Debug(j.res, "Response finished")
diff --git a/go/src/v.io/x/playground/compilerd/main.go b/go/src/v.io/x/playground/compilerd/main.go
index 5dd9b00..136f9d9 100644
--- a/go/src/v.io/x/playground/compilerd/main.go
+++ b/go/src/v.io/x/playground/compilerd/main.go
@@ -16,7 +16,6 @@
"flag"
"fmt"
"io"
- "log"
"math/rand"
"net/http"
"os"
@@ -27,6 +26,7 @@
"v.io/x/lib/dbutil"
"v.io/x/playground/compilerd/storage"
+ "v.io/x/playground/lib/log"
)
func init() {
@@ -75,10 +75,13 @@
}
func main() {
+ log.InitSyslogLoggers()
+
+ log.Debugf("Compilerd starting.\n")
flag.Parse()
if err := seedRNG(); err != nil {
- panic(err)
+ log.Panic(err)
}
c := newCompiler()
@@ -94,33 +97,45 @@
go waitForExit(c, time.Nanosecond*time.Duration(delayNs))
}
+ serveMux := http.NewServeMux()
+
if *sqlConf != "" {
+ log.Debugf("Using sql config %v\n", *sqlConf)
+
// Parse SQL configuration file and set up TLS.
dbConfig, err := dbutil.ActivateSqlConfigFromFile(*sqlConf)
if err != nil {
- log.Fatal(err)
+ log.Panic(err)
}
// Connect to storage backend.
if err := storage.Connect(dbConfig); err != nil {
- log.Fatal(err)
+ log.Panic(err)
}
// Add routes for storage.
- http.HandleFunc("/load", handlerLoad)
- http.HandleFunc("/save", handlerSave)
+ serveMux.HandleFunc("/load", handlerLoad)
+ serveMux.HandleFunc("/save", handlerSave)
} else {
+ log.Debugln("No sql config provided. Disabling /load and /save routes.")
+
// Return 501 Not Implemented for the /load and /save routes.
- http.HandleFunc("/load", handlerNotImplemented)
- http.HandleFunc("/save", handlerNotImplemented)
+ serveMux.HandleFunc("/load", handlerNotImplemented)
+ serveMux.HandleFunc("/save", handlerNotImplemented)
}
- http.HandleFunc("/compile", c.handlerCompile)
- http.HandleFunc("/healthz", handlerHealthz)
+ serveMux.HandleFunc("/compile", c.handlerCompile)
+ serveMux.HandleFunc("/healthz", handlerHealthz)
- log.Printf("Serving %s\n", *address)
- if err := http.ListenAndServe(*address, nil); err != nil {
- panic(err)
+ log.Debugf("Serving %s\n", *address)
+ s := http.Server{
+ Addr: *address,
+ Handler: serveMux,
+ ErrorLog: log.ErrorLogger,
+ }
+
+ if err := s.ListenAndServe(); err != nil {
+ log.Panic(err)
}
}
@@ -131,15 +146,15 @@
// Or if the time limit expires.
deadline := time.After(limit)
- log.Println("Exiting at", time.Now().Add(limit))
+ log.Debugln("Exiting at", time.Now().Add(limit))
Loop:
for {
select {
case <-deadline:
- log.Println("Deadline expired, exiting in at most", exitDelay)
+ log.Debugln("Deadline expired, exiting in at most", exitDelay)
break Loop
case <-term:
- log.Println("Got SIGTERM, exiting in at most", exitDelay)
+ log.Debugln("Got SIGTERM, exiting in at most", exitDelay)
break Loop
}
}
@@ -150,7 +165,7 @@
go func() {
select {
case <-time.After(exitDelay):
- fmt.Errorf("Dispatcher did not stop in %v, exiting.", exitDelay)
+ log.Warnf("Dispatcher did not stop in %v, exiting.", exitDelay)
os.Exit(1)
}
}()
@@ -165,7 +180,7 @@
// Close database connections.
if *sqlConf != "" {
if err := storage.Close(); err != nil {
- fmt.Errorf("storage.Close() failed: %v", err)
+ log.Errorf("storage.Close() failed: %v", err)
}
}
diff --git a/go/src/v.io/x/playground/compilerd/storage.go b/go/src/v.io/x/playground/compilerd/storage.go
index 5529625..52ab94c 100644
--- a/go/src/v.io/x/playground/compilerd/storage.go
+++ b/go/src/v.io/x/playground/compilerd/storage.go
@@ -15,10 +15,10 @@
import (
"encoding/json"
"fmt"
- "log"
"net/http"
"v.io/x/playground/compilerd/storage"
+ "v.io/x/playground/lib/log"
)
//////////////////////////////////////////
@@ -118,7 +118,7 @@
// Logs error internally and sends non-specific error response to client.
func storageInternalError(w http.ResponseWriter, v ...interface{}) {
if len(v) > 0 {
- log.Println(v...)
+ log.Errorln(v...)
}
storageError(w, http.StatusInternalServerError, "Internal error, please retry.")
}
diff --git a/go/src/v.io/x/playground/lib/log/log.go b/go/src/v.io/x/playground/lib/log/log.go
new file mode 100644
index 0000000..1b8dd08
--- /dev/null
+++ b/go/src/v.io/x/playground/lib/log/log.go
@@ -0,0 +1,116 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package log exports three diferent loggers: ErrorLogger, WarnLogger, and
+// DebugLogger, and convenience methods for logging messages to different
+// loggers depending on the level.
+//
+// By default, the loggers will only write to stdout. The default logger will
+// also be configured to print to stdout rather than stderr.
+//
+// Calling "InitSyslogLoggers", will create new loggers which will log to both
+// syslog and stdout, and also set the default logger to log to syslog and
+// stdout. The function will panic if syslog is unavailable.
+
+package log
+
+import (
+ "fmt"
+ "io"
+ "log"
+ "log/syslog"
+ "os"
+)
+
+func init() {
+ // By default, the loggers only log to stdout.
+ ErrorLogger = newLogger(os.Stdout)
+ WarnLogger = newLogger(os.Stdout)
+ DebugLogger = newLogger(os.Stdout)
+
+ // Default logger should also log to stdout.
+ log.SetOutput(os.Stdout)
+}
+
+// InitSyslogLoggers creates loggers that will log to syslog as well as stdout.
+// It will panic if syslog is unavailable.
+func InitSyslogLoggers() {
+ ErrorLogger = newLogger(newSyslogStdoutWriter(syslog.LOG_ERR))
+ WarnLogger = newLogger(newSyslogStdoutWriter(syslog.LOG_WARNING))
+ DebugLogger = newLogger(newSyslogStdoutWriter(syslog.LOG_DEBUG))
+
+ // Default logger should also log to syslog and stdout.
+ log.SetOutput(newSyslogStdoutWriter(syslog.LOG_DEBUG))
+}
+
+var (
+ ErrorLogger *log.Logger
+ WarnLogger *log.Logger
+ DebugLogger *log.Logger
+)
+
+// Debug functions use DebugLogger.
+func Debug(args ...interface{}) {
+ DebugLogger.Print(args...)
+}
+
+func Debugf(s string, args ...interface{}) {
+ DebugLogger.Printf(s, args...)
+}
+
+func Debugln(args ...interface{}) {
+ DebugLogger.Println(args...)
+}
+
+// Warn functions use WarnLogger.
+func Warn(args ...interface{}) {
+ WarnLogger.Print(args...)
+}
+
+func Warnf(s string, args ...interface{}) {
+ WarnLogger.Printf(s, args...)
+}
+
+func Warnln(args ...interface{}) {
+ WarnLogger.Println(args...)
+}
+
+// Error functions use ErrorLogger.
+func Error(args ...interface{}) {
+ ErrorLogger.Print(args...)
+}
+
+func Errorf(s string, args ...interface{}) {
+ ErrorLogger.Printf(s, args...)
+}
+
+func Errorln(args ...interface{}) {
+ ErrorLogger.Println(args...)
+}
+
+func Panic(args ...interface{}) {
+ ErrorLogger.Panic(args...)
+}
+
+func Panicf(s string, args ...interface{}) {
+ ErrorLogger.Panicf(s, args...)
+}
+
+func Panicln(args ...interface{}) {
+ ErrorLogger.Panicln(args...)
+}
+
+// Helper method to create a logger with given writer.
+func newLogger(w io.Writer) *log.Logger {
+ return log.New(w, "", log.LstdFlags)
+}
+
+// Helper method to create a writer that writes to syslog and stdout.
+func newSyslogStdoutWriter(level syslog.Priority) io.Writer {
+ if syslogWriter, err := syslog.New(level|syslog.LOG_USER, "playground"); err != nil {
+ panic(fmt.Errorf("Error connecting to syslog: %v", err))
+ } else {
+ return io.MultiWriter(io.MultiWriter(syslogWriter, os.Stdout))
+ }
+}
diff --git a/go/src/v.io/x/playground/lib/multi_writer.go b/go/src/v.io/x/playground/lib/multi_writer.go
index 015d64e..69f5cb7 100644
--- a/go/src/v.io/x/playground/lib/multi_writer.go
+++ b/go/src/v.io/x/playground/lib/multi_writer.go
@@ -12,6 +12,8 @@
import (
"io"
"sync"
+
+ "v.io/x/playground/lib/log"
)
// Initialize using NewMultiWriter.
@@ -32,7 +34,7 @@
t.mu.Lock()
defer t.mu.Unlock()
if t.wrote {
- panic("Tried to add writer after data has been written.")
+ log.Panic("Tried to add writer after data has been written.")
}
t.writers = append(t.writers, w)
return t
