id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c24900 | if err != nil {
return fmt.Errorf("new bolt store: %s", err)
}
s.raftStable = s.boltStore
s.raftLog, err = raft.NewLogCache(raftLogCacheSize, s.boltStore)
if err != nil {
return fmt.Errorf("new cached store: %s", err)
}
// Instantiate the Raft system.
ra, err := raft.NewRaft(config, s, s.raftLog, s.raftSta... | |
c24901 | {
return nil, err
}
f := s.raft.Apply(b, s.ApplyTimeout)
if e := f.(raft.Future); e.Error() != nil {
if e.Error() == raft.ErrNotLeader {
return nil, ErrNotLeader
}
return nil, e.Error()
}
s.connsMu.RLock()
defer s.connsMu.RUnlock()
stats.Add(numConnects, 1)
return s.conns[connID], nil
} | |
c24902 | {
return s.execute(nil, ex)
} | |
c24903 | {
return s.executeOrAbort(nil, ex)
} | |
c24904 | {
return s.query(nil, qr)
} | |
c24905 | if e := f.(raft.Future); e.Error() != nil {
return e.Error()
}
}
s.raft = nil
}
if s.boltStore != nil {
if err := s.boltStore.Close(); err != nil {
return err
}
s.boltStore = nil
}
s.raftLog = nil
s.raftStable = nil
return nil
} | |
c24906 | timeout)
if err := s.WaitForAppliedIndex(s.raft.LastIndex(), timeout); err != nil {
return ErrOpenTimeout
}
return nil
} | |
c24907 | case raft.Follower:
return Follower
case raft.Shutdown:
return Shutdown
default:
return Unknown
}
} | |
c24908 | defer s.connsMu.RUnlock()
c, ok := s.conns[id]
return c, ok
} | |
c24909 | := range configFuture.Configuration().Servers {
if srv.Address == raft.ServerAddress(addr) {
return string(srv.ID), nil
}
}
return "", nil
} | |
c24910 | ID: string(rs[i].ID),
Addr: string(rs[i].Address),
}
}
sort.Sort(Servers(servers))
return servers, nil
} | |
c24911 | l := s.LeaderAddr()
if l != "" {
return l, nil
}
case <-tmr.C:
return "", fmt.Errorf("timeout expired")
}
}
} | |
c24912 | <-tck.C:
if s.raft.AppliedIndex() >= idx {
return nil
}
case <-tmr.C:
return fmt.Errorf("timeout expired")
}
}
} | |
c24913 |
"addr": s.Addr(),
"leader": map[string]string{
"node_id": leaderID,
"addr": s.LeaderAddr(),
},
"apply_timeout": s.ApplyTimeout.String(),
"heartbeat_timeout": s.HeartbeatTimeout.String(),
"snapshot_threshold": s.SnapshotThreshold,
"conn_poll_period": s.connPollPeriod.String(),
"metad... | |
c24914 | else if fmt == BackupSQL {
if err := s.dbConn.Dump(dst); err != nil {
return err
}
} else {
return ErrInvalidBackupFormat
}
stats.Add(numBackups, 1)
return nil
} | |
c24915 | return nil
}
if err := s.remove(id); err != nil {
s.logger.Printf("failed to remove node: %v", err)
return err
}
}
}
f := s.raft.AddVoter(raft.ServerID(id), raft.ServerAddress(addr), 0, 0)
if e := f.(raft.Future); e.Error() != nil {
if e.Error() == raft.ErrNotLeader {
return ErrNotLeader
... | |
c24916 | node %s: %s", id, err.Error())
return err
}
s.logger.Printf("node %s removed successfully", id)
return nil
} | |
c24917 |
if _, ok := s.meta[id]; !ok {
return ""
}
v, ok := s.meta[id][key]
if ok {
return v
}
return ""
} | |
c24918 | s.setMetadata(s.raftID, md)
} | |
c24919 | if err != nil {
return err
}
b, err := json.Marshal(c)
if err != nil {
return err
}
f := s.raft.Apply(b, s.ApplyTimeout)
if e := f.(raft.Future); e.Error() != nil {
if e.Error() == raft.ErrNotLeader {
return ErrNotLeader
}
return e.Error()
}
return f.Response().(*fsmGenericResponse).error
} | |
c24920 | err != nil {
return err
}
f := s.raft.Apply(b, s.ApplyTimeout)
if e := f.(raft.Future); e.Error() != nil {
if e.Error() == raft.ErrNotLeader {
return ErrNotLeader
}
return e.Error()
}
stats.Add(numDisconnects, 1)
return f.Response().(*fsmGenericResponse).error
} | |
c24921 | }
b, err := json.Marshal(cmd)
if err != nil {
return nil, err
}
f := s.raft.Apply(b, s.ApplyTimeout)
if e := f.(raft.Future); e.Error() != nil {
if e.Error() == raft.ErrNotLeader {
return nil, ErrNotLeader
}
return nil, e.Error()
}
switch r := f.Response().(type) {
case *fsmExecuteResponse:
retu... | |
c24922 |
return &QueryResponse{
Rows: r.rows,
Time: time.Since(start).Seconds(),
Raft: &RaftResponse{f.Index(), s.raftID},
}, r.error
case *fsmGenericResponse:
return nil, r.error
default:
panic("unsupported type")
}
}
if qr.Lvl == Weak && s.raft.State() != raft.Leader {
return nil, ErrNotLea... | |
c24923 | opened at", s.dbPath)
} else {
db, err = sdb.New(s.dbPath, s.dbConf.DSN, true)
if err != nil {
return err
}
s.logger.Println("SQLite in-memory database opened")
}
s.db = db
return nil
} | |
c24924 | != nil {
return err
}
f = s.raft.Apply(b, s.ApplyTimeout)
if e := f.(raft.Future); e.Error() != nil {
if e.Error() == raft.ErrNotLeader {
return ErrNotLeader
}
e.Error()
}
return nil
} | |
c24925 |
config.SnapshotInterval = s.SnapshotInterval
}
if s.HeartbeatTimeout != 0 {
config.HeartbeatTimeout = s.HeartbeatTimeout
}
return config
} | |
c24926 | c.IdleTimedOut() || c.TxTimedOut() {
conns = append(conns, c)
}
}
s.connsMu.RUnlock()
for _, c := range conns {
if err := c.Close(); err != nil {
if err == ErrNotLeader {
// Not an issue, the actual leader will close it.
continue
}
s.logger.Printf("%s failed... | |
c24927 |
}
if err := s.dbConn.Backup(conn); err != nil {
return err
}
if err := conn.Close(); err != nil {
return err
}
of, err := os.Open(f.Name())
if err != nil {
return err
}
defer of.Close()
_, err = io.Copy(dst, of)
return err
} | |
c24928 | err = s.database(false, &buf)
if err != nil {
s.logger.Printf("failed to read database for snapshot: %s", err.Error())
return nil, err
}
fsm.database = buf.Bytes()
// Copy the node metadata.
fsm.meta, err = json.Marshal(s.meta)
if err != nil {
s.logger.Printf("failed to encode meta for snapshot: %s", err.... | |
c24929 | *raft.Observer) {
s.raft.RegisterObserver(o)
} | |
c24930 | *raft.Observer) {
s.raft.DeregisterObserver(o)
} | |
c24931 | os.IsNotExist(err) {
return false
}
return true
} | |
c24932 | != nil {
return nil, err
}
return f, nil
} | |
c24933 | credentialStore: credentials,
logger: log.New(os.Stderr, "[http] ", log.LstdFlags),
}
} | |
c24934 | s.rootHandler.Handler(s).ServeHTTP(w, r)
} | |
c24935 |
return fmt.Errorf("status already registered with key %s", key)
}
s.statuses[key] = stat
return nil
} | |
c24936 | if b {
opts.IdleTimeout = d
}
conn, err := s.store.Connect(&opts)
if err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return
}
w.Header().Set("Location", s.FormConnectionURL(r, conn.ID))
w.WriteHeader(http.StatusCreated)
} | |
c24937 | if !ok {
return nil
}
return conn.Close()
} | |
c24938 | }
var m map[string]string
if _, ok := md["meta"].(map[string]interface{}); ok {
m = make(map[string]string)
for k, v := range md["meta"].(map[string]interface{}) {
m[k] = v.(string)
}
}
if err := s.store.Join(remoteID.(string), remoteAddr.(string), m); err != nil {
if err == store.ErrNotLeader {
lea... | |
c24939 | err == store.ErrNotLeader {
leader := s.leaderAPIAddr()
if leader == "" {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return
}
redirect := s.FormRedirect(r, leader)
http.Redirect(w, r, redirect, http.StatusMovedPermanently)
return
}
w.WriteHeader(http.StatusInternalServerE... | |
c24940 | http.StatusInternalServerError)
return
}
err = s.store.Backup(!noLeader, bf, w)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
s.lastBackup = time.Now()
} | |
c24941 | http.Error(w, err.Error(), http.StatusServiceUnavailable)
return
}
redirect := s.FormRedirect(r, leader)
http.Redirect(w, r, redirect, http.StatusMovedPermanently)
return
}
resp.Error = err.Error()
} else {
resp.Results = results.Results
if timings {
resp.Time = results.Time
}
resp.R... | |
c24942 | != nil {
status["build"] = s.BuildInfo
}
// Add any registered statusers.
func() {
s.statusMu.RLock()
defer s.statusMu.RUnlock()
for k, v := range s.statuses {
stat, err := v.Stats()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
status[k] = stat
}... | |
c24943 | := execer.Execute(&store.ExecuteRequest{queries, timings, isAtomic})
if err != nil {
if err == store.ErrNotLeader {
leader := s.leaderAPIAddr()
if leader == "" {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return
}
redirect := s.FormRedirect(r, leader)
http.Redirect(w, r, redir... | |
c24944 | := queryer.Query(&store.QueryRequest{queries, timings, isAtomic, lvl})
if err != nil {
if err == store.ErrNotLeader {
leader := s.leaderAPIAddr()
if leader == "" {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return
}
redirect := s.FormRedirect(r, leader)
http.Redirect(w, r, red... | |
c24945 | if rq != "" {
rq = fmt.Sprintf("?%s", rq)
}
return fmt.Sprintf("%s://%s%s%s", s.protocol(), host, r.URL.Path, rq)
} | |
c24946 | fmt.Sprintf("%s://%s/db/connections/%d", s.protocol(), r.Host, id)
} | |
c24947 |
return false
}
return s.credentialStore.HasAnyPerm(username, perm, PermAll)
} | |
c24948 | ok := s.BuildInfo["version"].(string); ok {
version = v
}
w.Header().Add(VersionHTTPHeader, version)
} | |
c24949 | req.Form[param]; ok {
return true, nil
}
return false, nil
} | |
c24950 | time.ParseDuration(t)
if err != nil {
return 0, false, err
}
return dur, true, nil
} | |
c24951 | {
q := req.URL.Query()
return strings.TrimSpace(q.Get("q")), nil
} | |
c24952 | libraries.
for _, q := range []string{"atomic", "transaction"} {
if a, err := queryParam(req, q); err != nil || a {
return a, err
}
}
return false, nil
} | |
c24953 | return durationParam(req, "tx_timeout")
} | |
c24954 | store.Weak, nil
case "strong":
return store.Strong, nil
default:
return store.Weak, nil
}
} | |
c24955 |
}
if fmt == "sql" {
w.Header().Set("Content-Type", "application/sql")
return store.BackupSQL, nil
}
w.Header().Set("Content-Type", "application/octet-stream")
return store.BackupBinary, nil
} | |
c24956 | fqdsn string
if len(q) > 0 {
fqdsn = fmt.Sprintf("%s?%s", path, q.Encode())
} else {
fqdsn = path
}
return &DB{
path: path,
dsnQuery: dsnQuery,
memory: memory,
fqdsn: fqdsn,
}, nil
} | |
c24957 |
if err != nil {
return nil, err
}
return &Conn{
sqlite: c.(*sqlite3.SQLiteConn),
}, nil
} | |
c24958 | := &Result{}
start := time.Now()
r, err := execer.Exec(q, nil)
if err != nil {
if handleError(result, err) {
continue
}
break
}
if r == nil {
continue
}
lid, err := r.LastInsertId()
if err != nil {
if handleError(result, err) {
continue
}
break
}
re... | |
c24959 | t, err = c.sqlite.Begin()
if err != nil {
return err
}
}
for _, q := range queries {
if q == "" {
continue
}
rows := &Rows{}
start := time.Now()
rs, err := queryer.Query(q, nil)
if err != nil {
rows.Error = err.Error()
allRows = append(allRows, rows)
continue
}
... | |
c24960 |
}
_, err := c.sqlite.Exec(q, nil)
return err
} | |
c24961 | types := r.(*sqlite3.SQLiteRows).DeclTypes()
if err := r.Next(dest); err != nil {
return false, err
}
values := normalizeRowValues(dest, types)
if values[0] == int64(1) {
return true, nil
}
return false, nil
} | |
c24962 | {
return copyDatabase(c.sqlite, src.sqlite)
} | |
c24963 | {
return copyDatabase(dst.sqlite, c.sqlite)
} | |
c24964 | fmt.Sprintf(`SELECT 'INSERT INTO "%s" VALUES(%s)' FROM "%s";`,
tableIndent,
strings.Join(columnNames, ","),
tableIndent)
r, err = c.Query([]string{query}, false, false)
if err != nil {
return err
}
for _, x := range r[0].Values {
y := fmt.Sprintf("%s;\n", x[0].(string))
if _, err := w.Write([... | |
c24965 | == http.StatusUnauthorized {
return fmt.Errorf("unauthorized")
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
ret := make(map[string]interface{})
if err := json.Unmarshal(body, &ret); err != nil {
return err
}
// Specific key requested?
parts := strings.Split(line, " ")
if len... | |
c24966 | url,
logger: log.New(os.Stderr, "[discovery] ", log.LstdFlags),
}
} | |
c24967 | json.Unmarshal(b, r); err != nil {
return nil, err
}
c.logger.Printf("discovery client successfully registered %s at %s", addr, url)
return r, nil
case http.StatusMovedPermanently:
url = resp.Header.Get("location")
c.logger.Println("discovery client redirecting to", url)
continue
default:
... | |
c24968 | log.Fatalf("failed to create memory profile file at %s: %s", cpuprofile, err.Error())
}
log.Printf("writing memory profile to: %s\n", memprofile)
prof.mem = f
runtime.MemProfileRate = 4096
}
} | |
c24969 | {
pprof.Lookup("heap").WriteTo(prof.mem, 0)
prof.mem.Close()
log.Println("memory profiling stopped")
}
} | |
c24970 | }
}
logger.Printf("failed to join cluster at %s, sleeping %s before retry", joinAddr, attemptInterval)
time.Sleep(attemptInterval)
}
logger.Printf("failed to join cluster at %s, after %d attempts", joinAddr, numAttempts)
return "", err
} | |
c24971 |
return "NULL"
}
if j >= len(r.Values[i-1]) {
return "NULL"
}
return fmt.Sprintf("%v", r.Values[i-1][j])
} | |
c24972 |
perms: make(map[string]map[string]bool),
}
} | |
c24973 | if err != nil {
return err
}
c.store[cred.Username] = cred.Password
c.perms[cred.Username] = make(map[string]bool, len(cred.Perms))
for _, p := range cred.Perms {
c.perms[cred.Username][p] = true
}
}
// Read closing bracket.
_, err = dec.Token()
if err != nil {
return err
}
return nil
} | |
c24974 | bcrypt.CompareHashAndPassword([]byte(pw), []byte(password)) == nil
} | |
c24975 | password, ok := b.BasicAuth()
if !ok || !c.Check(username, password) {
return false
}
return true
} | |
c24976 | := c.perms[username]
if !ok {
return false
}
if _, ok := m[perm]; !ok {
return false
}
return true
} | |
c24977 | bool {
for i := range p {
if c.HasPerm(username, p[i]) {
return true
}
}
return false
}(perm)
} | |
c24978 | if !ok {
return false
}
return c.HasPerm(username, perm)
} | |
c24979 |
IdleTimeout: it,
TxTimeout: tt,
logger: log.New(os.Stderr, connectionLogPrefix(id), log.LstdFlags),
}
return &conn
} | |
c24980 |
c.logger = log.New(os.Stderr, connectionLogPrefix(c.ID), log.LstdFlags)
} | |
c24981 | c.timeMu.Unlock()
c.LastUsedAt = time.Now()
} | |
c24982 |
return false
}
return c.db.TransactionActive()
} | |
c24983 |
return nil, ErrConnectionDoesNotExist
}
return c.store.execute(c, ex)
} | |
c24984 | nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.executeOrAbort(c, ex)
} | |
c24985 |
return nil, ErrConnectionDoesNotExist
}
return c.store.query(c, qr)
} | |
c24986 | == nil {
return nil
}
if err := c.db.Close(); err != nil {
return err
}
c.db = nil
return nil
} | |
c24987 | m["idle_timeout"] = c.IdleTimeout.String()
m["tx_timeout"] = c.TxTimeout.String()
m["id"] = c.ID
m["fk_constraints"] = enabledFromBool(fkEnabled)
if !c.TxStartedAt.IsZero() {
m["tx_started_at"] = c.TxStartedAt.String()
}
return m, nil
} | |
c24988 | c.timeMu.Unlock()
return time.Since(c.LastUsedAt) > c.IdleTimeout && c.IdleTimeout != 0
} | |
c24989 | !c.TxStartedAt.IsZero() && time.Since(lau) > c.TxTimeout && c.TxTimeout != 0
} | |
c24990 | {
return &TxStateChange{
c: c,
tx: c.TransactionActive(),
}
} | |
c24991 | = time.Now()
} else if t.tx && !t.c.TransactionActive() && !t.c.TxStartedAt.IsZero() {
t.c.TxStartedAt = time.Time{}
}
} | |
c24992 | &DBConfig{DSN: dsn, Memory: memory}
} | |
c24993 |
l.PushValue(-2)
l.SetMetaTable(-2)
l.Pop(1)
l.PushValue(-2)
l.SetField(-2, "__index")
l.Pop(1)
return 1
} | |
c24994 | l.global.panicFunction, panicFunction
return panicFunction
} | |
c24995 | c, isLua := c.(*luaClosure); isLua {
name = c.prototype.upValues[index-1].name
}
l.apiPush(c.upValue(index - 1))
}
}
return
} | |
c24996 | {
u1 := l.upValue(f1, n1)
u2 := l.upValue(f2, n2)
*u1 = *u2
} | |
c24997 | "pi")
l.PushNumber(math.MaxFloat64)
l.SetField(-2, "huge")
return 1
} | |
c24998 | "stdin")
registerStdFile(l, os.Stdout, output, "stdout")
registerStdFile(l, os.Stderr, "", "stderr")
return 1
} | |
c24999 | d, _ := Info(l1, "Slnt", f)
buf += "\n\t" + d.ShortSource + ":"
if d.CurrentLine > 0 {
buf += fmt.Sprintf("%d:", d.CurrentLine)
}
buf += " in " + functionName(l, d)
if d.IsTailCall {
buf += "\n\t(...tail calls...)"
}
}
}
l.PushString(buf)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.