func (sq *SqlQuery) allowQueries(dbconfig *eproto.DBConfigs) {
sq.statemu.Lock()
v := sq.state.Get()
switch v {
case ABORT, SERVING:
sq.statemu.Unlock()
log.Info("Ignoring allowQueries request, current state: %v", v)
return
case INITIALIZING, SHUTTING_DOWN:
panic("unreachable")
}
// state is NOT_SERVING
sq.setState(INITIALIZING)
defer func() {
if x := recover(); x != nil {
log.Error("%s", x.(*TabletError).Message)
sq.setState(NOT_SERVING)
return
}
sq.setState(SERVING)
}()
sq.qe.Open(dbconfig)
sq.dbconfig = dbconfig
sq.sessionId = Rand()
log.Info("Session id: %d", sq.sessionId)
}
func (hh *httpHandler) ServeHTTP(c http.ResponseWriter, req *http.Request) {
conn := &httpConnectionBroker{c, req.Body}
codec := hh.cFactory(conn)
if err := rpc.ServeRequestWithContext(codec, &proto.Context{RemoteAddr: req.RemoteAddr}); err != nil {
log.Error("rpcwrap: %v", err)
}
}
func handleError(err *error, logStats *sqlQueryStats) {
if logStats != nil {
logStats.Send()
}
if x := recover(); x != nil {
terr, ok := x.(*TabletError)
if !ok {
log.Error("Uncaught panic:\n%v\n%s", x, tb.Stack(4))
*err = NewTabletError(FAIL, "%v: uncaught panic", x)
errorStats.Add("Panic", 1)
return
}
*err = terr
terr.RecordStats()
if terr.ErrorType == RETRY { // Retry errors are too spammy
return
}
log.Error("%s", terr.Message)
}
}
func (h *rpcHandler) ServeHTTP(c http.ResponseWriter, req *http.Request) {
conn, _, err := c.(http.Hijacker).Hijack()
if err != nil {
log.Error("rpc hijacking %s: %v", req.RemoteAddr, err)
return
}
io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n")
codec := h.cFactory(NewBufferedConnection(conn))
context := &proto.Context{RemoteAddr: req.RemoteAddr}
if h.useAuth {
if authenticated, err := auth.Authenticate(codec, context); !authenticated {
if err != nil {
log.Error("authentication erred at %s: %v", req.RemoteAddr, err)
}
codec.Close()
return
}
}
h.ServeCodecWithContext(codec, context)
}
func handleExecError(query *proto.Query, err *error, logStats *sqlQueryStats) {
if logStats != nil {
logStats.Send()
}
if x := recover(); x != nil {
terr, ok := x.(*TabletError)
if !ok {
log.Error("Uncaught panic for %v:\n%v\n%s", query, x, tb.Stack(4))
*err = NewTabletError(FAIL, "%v: uncaught panic for %v", x, query)
errorStats.Add("Panic", 1)
return
}
*err = terr
terr.RecordStats()
// suppress these errors in logs
// if terr.ErrorType == RETRY {
// return
// }
log.Error("%s: %v", terr.Message, query)
}
}
func killPredecessor(port string) {
resp, err := http.Get(fmt.Sprintf("http://localhost:%s%s", port, pidURL))
if err != nil {
if !strings.Contains(err.Error(), "connection refused") {
log.Error("unexpected error on port %v: %v, trying to start anyway", port, err)
}
return
}
num, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
log.Error("could not read pid: %vd, trying to start anyway", err)
return
}
pid, err := strconv.Atoi(string(num))
if err != nil {
log.Error("could not read pid: %vd, trying to start anyway", err)
return
}
err = syscall.Kill(pid, syscall.SIGUSR1)
if err != nil {
log.Error("error killing %v: %v, trying to start anyway", pid, err)
}
}
func (connection *RocksDbConnection) Gets(options *proto.DbReadOptions, keys [][]byte) ([][]byte, error) {
ro := ratgo.NewReadOptions()
defer ro.Close()
if options != nil {
ro.SetFillCache(options.FillCache)
ro.SetVerifyChecksums(options.VerifyChecksum)
if options.Snapshot != nil {
rocksdbSnapshot := options.Snapshot.Snapshot.(*ratgo.Snapshot)
ro.SetSnapshot(rocksdbSnapshot)
}
}
results, errors := connection.db.MultiGet(ro, keys)
for _, err := range errors {
if err != nil {
log.Error("Get Key:%v error, error", err)
return nil, err
}
}
return results, nil
}
func Init() {
mu.Lock()
defer mu.Unlock()
if inited {
log.Critical("servenv.Init called second time")
}
inited = true
// Once you run as root, you pretty much destroy the chances of a
// non-privileged user starting the program correctly.
if uid := os.Getuid(); uid == 0 {
log.Critical("servenv.Init: running this as root makes no sense")
}
runtime.MemProfileRate = *memProfileRate
gomaxprocs := os.Getenv("GOMAXPROCS")
if gomaxprocs == "" {
gomaxprocs = "1"
}
// We used to set this limit directly, but you pretty much have to
// use a root account to allow increasing a limit reliably. Dropping
// privileges is also tricky. The best strategy is to make a shell
// script set up the limits as root and switch users before starting
// the server.
fdLimit := &syscall.Rlimit{}
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, fdLimit); err != nil {
log.Error("max-open-fds failed: %v", err)
}
fdl := stats.NewInt("MaxFds")
fdl.Set(int64(fdLimit.Cur))
if err := exportBinaryVersion(); err != nil {
log.Critical("servenv.Init: exportBinaryVersion: %v", err)
}
onInitHooks.Fire()
}
func logError() {
if x := recover(); x != nil {
log.Error("%s", x.(*TabletError).Message)
}
}
