func (this *Server) SetPlusServicers(plusServicers int) {
this.Lock()
defer this.Unlock()
// Stop the current set of servicers
close(this.plusDone)
logging.Infop("SetPlusServicers - waiting for current plusServicers to finish")
this.plusWg.Wait()
// Set plus servicer count and recreate plus servicers
atomic.StoreInt64(&this.plusServicers, int64(plusServicers))
logging.Infop("SetPlusServicers - starting new plusServicers")
// Start new set of servicers
this.plusDone = make(chan bool)
go this.PlusServe()
}
func (this *HttpEndpoint) ListenTLS() error {
// create tls configuration
tlsCert, err := tls.LoadX509KeyPair(this.certFile, this.keyFile)
if err != nil {
return err
}
ln, err := net.Listen("tcp", this.httpsAddr)
if err == nil {
cfg := &tls.Config{
Certificates: []tls.Certificate{tlsCert},
ClientAuth: tls.NoClientCert,
MinVersion: tls.VersionTLS10,
CipherSuites: []uint16{tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
tls.TLS_RSA_WITH_AES_128_CBC_SHA,
tls.TLS_RSA_WITH_AES_256_CBC_SHA,
tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256},
}
tls_ln := tls.NewListener(ln, cfg)
this.listenerTLS = tls_ln
go http.Serve(tls_ln, this.mux)
logging.Infop("HttpEndpoint: ListenTLS", logging.Pair{"Address", ln.Addr()})
}
return err
}
func TestStub(t *testing.T) {
logger := NewLogger(os.Stdout, logging.DEBUG, false)
logging.SetLogger(logger)
logger.Infof("This is a message from %s", "test")
logging.Infof("This is a message from %s", "test")
logger.Infop("This is a message from ", logging.Pair{"name", "test"}, logging.Pair{"Queue Size", 10}, logging.Pair{"Debug Mode", false})
logging.Infop("This is a message from ", logging.Pair{"name", "test"})
logger.Infom("This is a message from ", logging.Map{"name": "test", "Queue Size": 10, "Debug Mode": false})
logging.Infom("This is a message from ", logging.Map{"name": "test"})
logger.Requestf(logging.WARN, "This is a Request from %s", "test")
logging.Requestf(logging.INFO, "This is a Request from %s", "test")
logger.Requestp(logging.DEBUG, "This is a Request from ", logging.Pair{"name", "test"})
logging.Requestp(logging.ERROR, "This is a Request from ", logging.Pair{"name", "test"})
logger.SetLevel(logging.WARN)
fmt.Printf("Log level is %s\n", logger.Level())
logger.Requestf(logging.WARN, "This is a Request from %s", "test")
logging.Requestf(logging.INFO, "This is a Request from %s", "test")
logger.Requestp(logging.DEBUG, "This is a Request from ", logging.Pair{"name", "test"})
logging.Requestp(logging.ERROR, "This is a Request from ", logging.Pair{"name", "test"})
logger.Warnf("This is a message from %s", "test")
logging.Infof("This is a message from %s", "test")
logger.Debugp("This is a message from ", logging.Pair{"name", "test"})
logging.Errorp("This is a message from ", logging.Pair{"name", "test"})
fmt.Printf("Changing to json formatter\n")
logger.entryFormatter = &jsonFormatter{}
logger.SetLevel(logging.DEBUG)
logger.Infof("This is a message from %s", "test")
logging.Infof("This is a message from %s", "test")
logger.Infop("This is a message from ", logging.Pair{"name", "test"}, logging.Pair{"Queue Size", 10}, logging.Pair{"Debug Mode", false})
logging.Infop("This is a message from ", logging.Pair{"name", "test"})
logger.Infom("This is a message from ", logging.Map{"name": "test", "Queue Size": 10, "Debug Mode": false})
logging.Infom("This is a message from ", logging.Map{"name": "test"})
logger.Requestf(logging.WARN, "This is a Request from %s", "test")
logging.Requestf(logging.INFO, "This is a Request from %s", "test")
logger.Requestp(logging.DEBUG, "This is a Request from ", logging.Pair{"name", "test"})
logging.Requestp(logging.ERROR, "This is a Request from ", logging.Pair{"name", "test"})
}
func (this *HttpEndpoint) closeListener(l net.Listener) error {
var err error
if l != nil {
err = l.Close()
logging.Infop("HttpEndpoint: close listener ", logging.Pair{"Address", l.Addr()}, logging.Pair{"err", err})
}
return err
}
func (this *HttpEndpoint) Listen() error {
ln, err := net.Listen("tcp", this.httpAddr)
if err == nil {
this.listener = ln
go http.Serve(ln, this.mux)
logging.Infop("HttpEndpoint: Listen", logging.Pair{"Address", ln.Addr()})
}
return err
}
func pollStdin() {
reader := bufio.NewReader(os.Stdin)
logging.Infop("pollEOF: About to start stdin polling")
for {
ch, err := reader.ReadByte()
if err == io.EOF {
logging.Infop("Received EOF; Exiting...")
os.Exit(0)
}
if err != nil {
logging.Errorp("Unexpected error polling stdin",
logging.Pair{"error", err})
os.Exit(1)
}
if ch == '\n' || ch == '\r' {
logging.Infop("Received EOL; Exiting...")
// TODO: "graceful" shutdown should be placed here
os.Exit(0)
}
}
}
func TestRequestDefaults(t *testing.T) {
statement := "select 1"
logging.Infop("message", logging.Pair{"statement", statement})
doUrlRequest(t, map[string]string{
"statement": statement,
})
if test_server.request().State() != server.COMPLETED {
t.Errorf("Expected request state: %v, actual: %v\n", server.COMPLETED, test_server.request().State())
}
if test_server.request().Statement() != statement {
t.Errorf("Expected request statement: %v, actual: %v\n", statement, test_server.request().Statement())
}
}
// signalCatcher blocks until a signal is recieved and then takes appropriate action
func signalCatcher(server *server.Server, endpoint *http.HttpEndpoint) {
sig_chan := make(chan os.Signal, 4)
signal.Notify(sig_chan, os.Interrupt, syscall.SIGTERM)
var s os.Signal
select {
case s = <-sig_chan:
}
if server.CpuProfile() != "" {
logging.Infop("Stopping CPU profile")
pprof.StopCPUProfile()
}
if server.MemProfile() != "" {
f, err := os.Create(server.MemProfile())
if err != nil {
logging.Errorp("Cannot create memory profile file", logging.Pair{"error", err})
} else {
logging.Infop("Writing Memory profile")
pprof.WriteHeapProfile(f)
f.Close()
}
}
if s == os.Interrupt {
// Interrupt (ctrl-C) => Immediate (ungraceful) exit
logging.Infop("Shutting down immediately")
os.Exit(0)
}
logging.Infop("Attempting graceful exit")
// Stop accepting new requests
err := endpoint.Close()
if err != nil {
logging.Errorp("error closing http listener", logging.Pair{"err", err})
}
err = endpoint.CloseTLS()
if err != nil {
logging.Errorp("error closing https listener", logging.Pair{"err", err})
}
}
func (this *Fetch) UnmarshalJSON(body []byte) error {
var _unmarshalled struct {
_ string `json:"#operator"`
Proj string `json:"projection"`
Names string `json:"namespace"`
Keys string `json:"keyspace"`
As string `json:"as"`
}
var proj_expr expression.Path
err := json.Unmarshal(body, &_unmarshalled)
if err != nil {
return err
}
if _unmarshalled.Proj != "" {
expr, err := parser.Parse(_unmarshalled.Proj)
logging.Infop("Fetch", logging.Pair{"_unmarshalled.Proj", _unmarshalled.Proj},
logging.Pair{"err", err},
logging.Pair{"expr", expr},
)
if err != nil {
return err
}
_proj_expr, is_path := expr.(expression.Path)
if !is_path {
return fmt.Errorf("Fetch.UnmarshalJSON: cannot resolve path expression from %s", _unmarshalled.Proj)
}
proj_expr = _proj_expr
}
this.term = algebra.NewKeyspaceTerm(_unmarshalled.Names, _unmarshalled.Keys,
proj_expr, _unmarshalled.As, nil, nil)
this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys)
return err
}
func main() {
HideConsole(true)
defer HideConsole(false)
// useful for getting list of go-routines
go go_http.ListenAndServe("localhost:6060", nil)
flag.Parse()
if *LOGGER != "" {
logger, _ := log_resolver.NewLogger(*LOGGER)
if logger == nil {
fmt.Printf("Invalid logger: %s\n", *LOGGER)
os.Exit(1)
}
logging.SetLogger(logger)
}
if *DEBUG {
logging.SetLevel(logging.DEBUG)
} else {
level := logging.INFO
if *LOG_LEVEL != "" {
lvl, ok := logging.ParseLevel(*LOG_LEVEL)
if ok {
level = lvl
}
}
logging.SetLevel(level)
}
datastore, err := resolver.NewDatastore(*DATASTORE)
if err != nil {
logging.Errorp(err.Error())
os.Exit(1)
}
datastore_package.SetDatastore(datastore)
configstore, err := config_resolver.NewConfigstore(*CONFIGSTORE)
if err != nil {
logging.Errorp("Could not connect to configstore",
logging.Pair{"error", err},
)
}
acctstore, err := acct_resolver.NewAcctstore(*ACCTSTORE)
if err != nil {
logging.Errorp("Could not connect to acctstore",
logging.Pair{"error", err},
)
} else {
// Create the metrics we are interested in
accounting.RegisterMetrics(acctstore)
// Make metrics available
acctstore.MetricReporter().Start(1, 1)
}
channel := make(server.RequestChannel, *REQUEST_CAP)
plusChannel := make(server.RequestChannel, *REQUEST_CAP)
sys, err := system.NewDatastore(datastore)
if err != nil {
logging.Errorp(err.Error())
os.Exit(1)
}
server, err := server.NewServer(datastore, sys, configstore, acctstore, *NAMESPACE,
*READONLY, channel, plusChannel, *SERVICERS, *PLUS_SERVICERS,
*MAX_PARALLELISM, *TIMEOUT, *SIGNATURE, *METRICS, *ENTERPRISE)
if err != nil {
logging.Errorp(err.Error())
os.Exit(1)
}
datastore_package.SetSystemstore(server.Systemstore())
server.SetCpuProfile(*CPU_PROFILE)
server.SetKeepAlive(*KEEP_ALIVE_LENGTH)
server.SetMemProfile(*MEM_PROFILE)
server.SetPipelineCap(*PIPELINE_CAP)
server.SetPipelineBatch(*PIPELINE_BATCH)
server.SetRequestSizeCap(*REQUEST_SIZE_CAP)
server.SetScanCap(*SCAN_CAP)
if server.Enterprise() && os.Getenv("GOMAXPROCS") == "" {
runtime.GOMAXPROCS(runtime.NumCPU())
}
if !server.Enterprise() {
var numCPU int
if os.Getenv("GOMAXPROCS") == "" {
numCPU = runtime.NumCPU()
} else {
numCPU = runtime.GOMAXPROCS(0)
}
// Use at most 4 cpus in non-enterprise mode
runtime.GOMAXPROCS(util.MinInt(numCPU, 4))
}
go server.Serve()
go server.PlusServe()
logging.Infop("cbq-engine started",
logging.Pair{"version", util.VERSION},
logging.Pair{"datastore", *DATASTORE},
logging.Pair{"max-concurrency", runtime.GOMAXPROCS(0)},
logging.Pair{"loglevel", logging.LogLevel().String()},
logging.Pair{"servicers", server.Servicers()},
logging.Pair{"plus-servicers", server.PlusServicers()},
logging.Pair{"pipeline-cap", server.PipelineCap()},
logging.Pair{"pipeline-batch", *PIPELINE_BATCH},
logging.Pair{"request-cap", *REQUEST_CAP},
logging.Pair{"request-size-cap", server.RequestSizeCap()},
logging.Pair{"timeout", server.Timeout()},
)
// Create http endpoint
endpoint := http.NewServiceEndpoint(server, *STATIC_PATH, *METRICS,
*HTTP_ADDR, *HTTPS_ADDR, *CERT_FILE, *KEY_FILE)
er := endpoint.Listen()
if er != nil {
logging.Errorp("cbq-engine exiting with error",
logging.Pair{"error", er},
logging.Pair{"HTTP_ADDR", *HTTP_ADDR},
)
os.Exit(1)
}
if server.Enterprise() && *CERT_FILE != "" && *KEY_FILE != "" {
er := endpoint.ListenTLS()
if er != nil {
logging.Errorp("cbq-engine exiting with error",
logging.Pair{"error", er},
logging.Pair{"HTTPS_ADDR", *HTTPS_ADDR},
)
os.Exit(1)
}
}
signalCatcher(server, endpoint)
}