_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24900 | Open | train | func (s *Store) Open(enableSingle bool) error {
s.closedMu.Lock()
defer s.closedMu.Unlock()
if s.closed {
return ErrStoreInvalidState
}
s.logger.Printf("opening store with node ID %s", s.raftID)
s.logger.Printf("ensuring directory at %s exists", s.raftDir)
if err := os.MkdirAll(s.raftDir, 0755); err != nil {... | go | {
"resource": ""
} |
q24901 | Connect | train | func (s *Store) Connect(opt *ConnectionOptions) (*Connection, error) {
// Randomly-selected connection ID must be part of command so
// that all nodes use the same value as connection ID.
connID := func() uint64 {
s.connsMu.Lock()
defer s.connsMu.Unlock()
for {
// Make sure we get an unused ID.
id := s.r... | go | {
"resource": ""
} |
q24902 | Execute | train | func (s *Store) Execute(ex *ExecuteRequest) (*ExecuteResponse, error) {
return s.execute(nil, ex)
} | go | {
"resource": ""
} |
q24903 | ExecuteOrAbort | train | func (s *Store) ExecuteOrAbort(ex *ExecuteRequest) (resp *ExecuteResponse, retErr error) {
return s.executeOrAbort(nil, ex)
} | go | {
"resource": ""
} |
q24904 | Query | train | func (s *Store) Query(qr *QueryRequest) (*QueryResponse, error) {
return s.query(nil, qr)
} | go | {
"resource": ""
} |
q24905 | Close | train | func (s *Store) Close(wait bool) error {
s.closedMu.Lock()
defer s.closedMu.Unlock()
if s.closed {
return nil
}
defer func() {
s.closed = true
}()
close(s.done)
s.wg.Wait()
// XXX CLOSE OTHER CONNECTIONS
if err := s.dbConn.Close(); err != nil {
return err
}
s.dbConn = nil
s.db = nil
if s.raft != ... | go | {
"resource": ""
} |
q24906 | WaitForApplied | train | func (s *Store) WaitForApplied(timeout time.Duration) error {
if timeout == 0 {
return nil
}
s.logger.Printf("waiting for up to %s for application of initial logs", timeout)
if err := s.WaitForAppliedIndex(s.raft.LastIndex(), timeout); err != nil {
return ErrOpenTimeout
}
return nil
} | go | {
"resource": ""
} |
q24907 | State | train | func (s *Store) State() ClusterState {
state := s.raft.State()
switch state {
case raft.Leader:
return Leader
case raft.Candidate:
return Candidate
case raft.Follower:
return Follower
case raft.Shutdown:
return Shutdown
default:
return Unknown
}
} | go | {
"resource": ""
} |
q24908 | Connection | train | func (s *Store) Connection(id uint64) (*Connection, bool) {
s.connsMu.RLock()
defer s.connsMu.RUnlock()
c, ok := s.conns[id]
return c, ok
} | go | {
"resource": ""
} |
q24909 | LeaderID | train | func (s *Store) LeaderID() (string, error) {
addr := s.LeaderAddr()
configFuture := s.raft.GetConfiguration()
if err := configFuture.Error(); err != nil {
s.logger.Printf("failed to get raft configuration: %v", err)
return "", err
}
for _, srv := range configFuture.Configuration().Servers {
if srv.Address =... | go | {
"resource": ""
} |
q24910 | Nodes | train | func (s *Store) Nodes() ([]*Server, error) {
f := s.raft.GetConfiguration()
if f.Error() != nil {
return nil, f.Error()
}
rs := f.Configuration().Servers
servers := make([]*Server, len(rs))
for i := range rs {
servers[i] = &Server{
ID: string(rs[i].ID),
Addr: string(rs[i].Address),
}
}
sort.Sort... | go | {
"resource": ""
} |
q24911 | WaitForLeader | train | func (s *Store) WaitForLeader(timeout time.Duration) (string, error) {
tck := time.NewTicker(leaderWaitDelay)
defer tck.Stop()
tmr := time.NewTimer(timeout)
defer tmr.Stop()
for {
select {
case <-tck.C:
l := s.LeaderAddr()
if l != "" {
return l, nil
}
case <-tmr.C:
return "", fmt.Errorf("tim... | go | {
"resource": ""
} |
q24912 | WaitForAppliedIndex | train | func (s *Store) WaitForAppliedIndex(idx uint64, timeout time.Duration) error {
tck := time.NewTicker(appliedWaitDelay)
defer tck.Stop()
tmr := time.NewTimer(timeout)
defer tmr.Stop()
for {
select {
case <-tck.C:
if s.raft.AppliedIndex() >= idx {
return nil
}
case <-tmr.C:
return fmt.Errorf("tim... | go | {
"resource": ""
} |
q24913 | Stats | train | func (s *Store) Stats() (map[string]interface{}, error) {
fkEnabled, err := s.dbConn.FKConstraints()
if err != nil {
return nil, err
}
dbStatus := map[string]interface{}{
"dsn": s.dbConf.DSN,
"fk_constraints": enabledFromBool(fkEnabled),
"version": sdb.DBVersion,
}
if !s.dbConf.Memory {... | go | {
"resource": ""
} |
q24914 | Backup | train | func (s *Store) Backup(leader bool, fmt BackupFormat, dst io.Writer) error {
s.restoreMu.RLock()
defer s.restoreMu.RUnlock()
if leader && s.raft.State() != raft.Leader {
return ErrNotLeader
}
var err error
if fmt == BackupBinary {
err = s.database(leader, dst)
if err != nil {
return err
}
} else if ... | go | {
"resource": ""
} |
q24915 | Join | train | func (s *Store) Join(id, addr string, metadata map[string]string) error {
s.logger.Printf("received request to join node at %s", addr)
if s.raft.State() != raft.Leader {
return ErrNotLeader
}
configFuture := s.raft.GetConfiguration()
if err := configFuture.Error(); err != nil {
s.logger.Printf("failed to get ... | go | {
"resource": ""
} |
q24916 | Remove | train | func (s *Store) Remove(id string) error {
s.logger.Printf("received request to remove node %s", id)
if err := s.remove(id); err != nil {
s.logger.Printf("failed to remove node %s: %s", id, err.Error())
return err
}
s.logger.Printf("node %s removed successfully", id)
return nil
} | go | {
"resource": ""
} |
q24917 | Metadata | train | func (s *Store) Metadata(id, key string) string {
s.metaMu.RLock()
defer s.metaMu.RUnlock()
if _, ok := s.meta[id]; !ok {
return ""
}
v, ok := s.meta[id][key]
if ok {
return v
}
return ""
} | go | {
"resource": ""
} |
q24918 | SetMetadata | train | func (s *Store) SetMetadata(md map[string]string) error {
return s.setMetadata(s.raftID, md)
} | go | {
"resource": ""
} |
q24919 | setMetadata | train | func (s *Store) setMetadata(id string, md map[string]string) error {
// Check local data first.
if func() bool {
s.metaMu.RLock()
defer s.metaMu.RUnlock()
if _, ok := s.meta[id]; ok {
for k, v := range md {
if s.meta[id][k] != v {
return false
}
}
return true
}
return false
}() {
//... | go | {
"resource": ""
} |
q24920 | disconnect | train | func (s *Store) disconnect(c *Connection) error {
d := &connectionSub{
ConnID: c.ID,
}
cmd, err := newCommand(disconnect, d)
if err != nil {
return err
}
b, err := json.Marshal(cmd)
if err != nil {
return err
}
f := s.raft.Apply(b, s.ApplyTimeout)
if e := f.(raft.Future); e.Error() != nil {
if e.Erro... | go | {
"resource": ""
} |
q24921 | execute | train | func (s *Store) execute(c *Connection, ex *ExecuteRequest) (*ExecuteResponse, error) {
if c == nil {
s.connsMu.RLock()
c = s.conns[defaultConnID]
s.connsMu.RUnlock()
}
c.SetLastUsedNow()
start := time.Now()
d := &databaseSub{
ConnID: c.ID,
Atomic: ex.Atomic,
Queries: ex.Queries,
Timings: ex.Timin... | go | {
"resource": ""
} |
q24922 | query | train | func (s *Store) query(c *Connection, qr *QueryRequest) (*QueryResponse, error) {
if c == nil {
s.connsMu.RLock()
c = s.conns[defaultConnID]
s.connsMu.RUnlock()
}
c.SetLastUsedNow()
s.restoreMu.RLock()
defer s.restoreMu.RUnlock()
start := time.Now()
if qr.Lvl == Strong {
d := &databaseSub{
ConnID: c... | go | {
"resource": ""
} |
q24923 | createDatabase | train | func (s *Store) createDatabase() error {
var db *sdb.DB
var err error
if !s.dbConf.Memory {
// as it will be rebuilt from (possibly) a snapshot and committed log entries.
if err := os.Remove(s.dbPath); err != nil && !os.IsNotExist(err) {
return err
}
db, err = sdb.New(s.dbPath, s.dbConf.DSN, false)
if e... | go | {
"resource": ""
} |
q24924 | remove | train | func (s *Store) remove(id string) error {
if s.raft.State() != raft.Leader {
return ErrNotLeader
}
f := s.raft.RemoveServer(raft.ServerID(id), 0, 0)
if f.Error() != nil {
if f.Error() == raft.ErrNotLeader {
return ErrNotLeader
}
return f.Error()
}
c, err := newCommand(metadataDelete, id)
if err != n... | go | {
"resource": ""
} |
q24925 | raftConfig | train | func (s *Store) raftConfig() *raft.Config {
config := raft.DefaultConfig()
if s.SnapshotThreshold != 0 {
config.SnapshotThreshold = s.SnapshotThreshold
}
if s.SnapshotInterval != 0 {
config.SnapshotInterval = s.SnapshotInterval
}
if s.HeartbeatTimeout != 0 {
config.HeartbeatTimeout = s.HeartbeatTimeout
}
... | go | {
"resource": ""
} |
q24926 | checkConnections | train | func (s *Store) checkConnections() {
s.wg.Add(1)
ticker := time.NewTicker(s.connPollPeriod)
go func() {
defer s.wg.Done()
defer ticker.Stop()
for {
select {
case <-s.done:
return
case <-ticker.C:
// This is not a 100% correct check, but is right almost all
// the time, and saves the node f... | go | {
"resource": ""
} |
q24927 | database | train | func (s *Store) database(leader bool, dst io.Writer) error {
if leader && s.raft.State() != raft.Leader {
return ErrNotLeader
}
f, err := ioutil.TempFile("", "rqlilte-snap-")
if err != nil {
return err
}
if err := f.Close(); err != nil {
return err
}
os.Remove(f.Name())
db, err := sdb.New(f.Name(), "", ... | go | {
"resource": ""
} |
q24928 | Snapshot | train | func (s *Store) Snapshot() (raft.FSMSnapshot, error) {
s.restoreMu.RLock()
defer s.restoreMu.RUnlock()
// Snapshots are not permitted while any connection has a transaction
// in progress, because it's not possible (not without a lot of extra
// code anyway) to capture the state of a connection during a transacti... | go | {
"resource": ""
} |
q24929 | RegisterObserver | train | func (s *Store) RegisterObserver(o *raft.Observer) {
s.raft.RegisterObserver(o)
} | go | {
"resource": ""
} |
q24930 | DeregisterObserver | train | func (s *Store) DeregisterObserver(o *raft.Observer) {
s.raft.DeregisterObserver(o)
} | go | {
"resource": ""
} |
q24931 | pathExists | train | func pathExists(p string) bool {
if _, err := os.Lstat(p); err != nil && os.IsNotExist(err) {
return false
}
return true
} | go | {
"resource": ""
} |
q24932 | tempfile | train | func tempfile() (*os.File, error) {
f, err := ioutil.TempFile("", "rqlilte-snap-")
if err != nil {
return nil, err
}
return f, nil
} | go | {
"resource": ""
} |
q24933 | New | train | func New(addr string, store Store, credentials CredentialStore) *Service {
return &Service{
addr: addr,
store: store,
start: time.Now(),
statuses: make(map[string]Statuser),
credentialStore: credentials,
logger: log.New(os.Stderr, "[http] ", log.LstdFlags),
}... | go | {
"resource": ""
} |
q24934 | ServeHTTP | train | func (s *Service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
s.rootHandler.Handler(s).ServeHTTP(w, r)
} | go | {
"resource": ""
} |
q24935 | RegisterStatus | train | func (s *Service) RegisterStatus(key string, stat Statuser) error {
s.statusMu.Lock()
defer s.statusMu.Unlock()
if _, ok := s.statuses[key]; ok {
return fmt.Errorf("status already registered with key %s", key)
}
s.statuses[key] = stat
return nil
} | go | {
"resource": ""
} |
q24936 | createConnection | train | func (s *Service) createConnection(w http.ResponseWriter, r *http.Request) {
opts := store.ConnectionOptions{
IdleTimeout: s.ConnIdleTimeout,
TxTimeout: s.ConnTxTimeout,
}
d, b, err := txTimeout(r)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
if b {
opts.TxTimeout = d
}
d, b, err ... | go | {
"resource": ""
} |
q24937 | deleteConnection | train | func (s *Service) deleteConnection(id uint64) error {
conn, ok := s.store.Connection(id)
if !ok {
return nil
}
return conn.Close()
} | go | {
"resource": ""
} |
q24938 | handleJoin | train | func (s *Service) handleJoin(w http.ResponseWriter, r *http.Request) {
b, err := ioutil.ReadAll(r.Body)
defer r.Body.Close()
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
md := map[string]interface{}{}
if err := json.Unmarshal(b, &md); err != nil {
w.WriteHeader(http.StatusBadRequest)
retu... | go | {
"resource": ""
} |
q24939 | handleRemove | train | func (s *Service) handleRemove(w http.ResponseWriter, r *http.Request) {
b, err := ioutil.ReadAll(r.Body)
defer r.Body.Close()
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
m := map[string]string{}
if err := json.Unmarshal(b, &m); err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}... | go | {
"resource": ""
} |
q24940 | handleBackup | train | func (s *Service) handleBackup(w http.ResponseWriter, r *http.Request) {
noLeader, err := noLeader(r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
bf, err := backupFormat(w, r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err... | go | {
"resource": ""
} |
q24941 | handleLoad | train | func (s *Service) handleLoad(w http.ResponseWriter, r *http.Request) {
timings, err := timings(r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
b, err := ioutil.ReadAll(r.Body)
defer r.Body.Close()
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
ret... | go | {
"resource": ""
} |
q24942 | handleStatus | train | func (s *Service) handleStatus(w http.ResponseWriter, r *http.Request) {
results, err := s.store.Stats()
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
rt := map[string]interface{}{
"GOARCH": runtime.GOARCH,
"GOOS": runtime.GOOS,
"GOMAXPROCS": runtime.GOMAXPROCS... | go | {
"resource": ""
} |
q24943 | handleExecute | train | func (s *Service) handleExecute(connID uint64, w http.ResponseWriter, r *http.Request) {
isAtomic, err := isAtomic(r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
timings, err := timings(r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
re... | go | {
"resource": ""
} |
q24944 | handleQuery | train | func (s *Service) handleQuery(connID uint64, w http.ResponseWriter, r *http.Request) {
isAtomic, err := isAtomic(r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
timings, err := timings(r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
retu... | go | {
"resource": ""
} |
q24945 | FormRedirect | train | func (s *Service) FormRedirect(r *http.Request, host string) string {
rq := r.URL.RawQuery
if rq != "" {
rq = fmt.Sprintf("?%s", rq)
}
return fmt.Sprintf("%s://%s%s%s", s.protocol(), host, r.URL.Path, rq)
} | go | {
"resource": ""
} |
q24946 | FormConnectionURL | train | func (s *Service) FormConnectionURL(r *http.Request, id uint64) string {
return fmt.Sprintf("%s://%s/db/connections/%d", s.protocol(), r.Host, id)
} | go | {
"resource": ""
} |
q24947 | CheckRequestPerm | train | func (s *Service) CheckRequestPerm(r *http.Request, perm string) bool {
if s.credentialStore == nil {
return true
}
username, _, ok := r.BasicAuth()
if !ok {
return false
}
return s.credentialStore.HasAnyPerm(username, perm, PermAll)
} | go | {
"resource": ""
} |
q24948 | addBuildVersion | train | func (s *Service) addBuildVersion(w http.ResponseWriter) {
// Add version header to every response, if available.
version := "unknown"
if v, ok := s.BuildInfo["version"].(string); ok {
version = v
}
w.Header().Add(VersionHTTPHeader, version)
} | go | {
"resource": ""
} |
q24949 | queryParam | train | func queryParam(req *http.Request, param string) (bool, error) {
err := req.ParseForm()
if err != nil {
return false, err
}
if _, ok := req.Form[param]; ok {
return true, nil
}
return false, nil
} | go | {
"resource": ""
} |
q24950 | durationParam | train | func durationParam(req *http.Request, param string) (time.Duration, bool, error) {
q := req.URL.Query()
t := strings.TrimSpace(q.Get(param))
if t == "" {
return 0, false, nil
}
dur, err := time.ParseDuration(t)
if err != nil {
return 0, false, err
}
return dur, true, nil
} | go | {
"resource": ""
} |
q24951 | stmtParam | train | func stmtParam(req *http.Request) (string, error) {
q := req.URL.Query()
return strings.TrimSpace(q.Get("q")), nil
} | go | {
"resource": ""
} |
q24952 | isAtomic | train | func isAtomic(req *http.Request) (bool, error) {
// "transaction" is checked for backwards compatibility with
// client libraries.
for _, q := range []string{"atomic", "transaction"} {
if a, err := queryParam(req, q); err != nil || a {
return a, err
}
}
return false, nil
} | go | {
"resource": ""
} |
q24953 | txTimeout | train | func txTimeout(req *http.Request) (time.Duration, bool, error) {
return durationParam(req, "tx_timeout")
} | go | {
"resource": ""
} |
q24954 | level | train | func level(req *http.Request) (store.ConsistencyLevel, error) {
q := req.URL.Query()
lvl := strings.TrimSpace(q.Get("level"))
switch strings.ToLower(lvl) {
case "none":
return store.None, nil
case "weak":
return store.Weak, nil
case "strong":
return store.Strong, nil
default:
return store.Weak, nil
}
} | go | {
"resource": ""
} |
q24955 | backupFormat | train | func backupFormat(w http.ResponseWriter, r *http.Request) (store.BackupFormat, error) {
fmt, err := fmtParam(r)
if err != nil {
return store.BackupBinary, err
}
if fmt == "sql" {
w.Header().Set("Content-Type", "application/sql")
return store.BackupSQL, nil
}
w.Header().Set("Content-Type", "application/octet... | go | {
"resource": ""
} |
q24956 | New | train | func New(path, dsnQuery string, memory bool) (*DB, error) {
q, err := url.ParseQuery(dsnQuery)
if err != nil {
return nil, err
}
if memory {
q.Set("mode", "memory")
q.Set("cache", "shared")
}
if !strings.HasPrefix(path, "file:") {
path = fmt.Sprintf("file:%s", path)
}
var fqdsn string
if len(q) > 0 {... | go | {
"resource": ""
} |
q24957 | Connect | train | func (d *DB) Connect() (*Conn, error) {
drv := sqlite3.SQLiteDriver{}
c, err := drv.Open(d.fqdsn)
if err != nil {
return nil, err
}
return &Conn{
sqlite: c.(*sqlite3.SQLiteConn),
}, nil
} | go | {
"resource": ""
} |
q24958 | Execute | train | func (c *Conn) Execute(queries []string, tx, xTime bool) ([]*Result, error) {
stats.Add(numExecutions, int64(len(queries)))
if tx {
stats.Add(numETx, 1)
}
type Execer interface {
Exec(query string, args []driver.Value) (driver.Result, error)
}
var allResults []*Result
err := func() error {
var execer Exe... | go | {
"resource": ""
} |
q24959 | Query | train | func (c *Conn) Query(queries []string, tx, xTime bool) ([]*Rows, error) {
stats.Add(numQueries, int64(len(queries)))
if tx {
stats.Add(numQTx, 1)
}
type Queryer interface {
Query(query string, args []driver.Value) (driver.Rows, error)
}
var allRows []*Rows
err := func() (err error) {
var queryer Queryer
... | go | {
"resource": ""
} |
q24960 | EnableFKConstraints | train | func (c *Conn) EnableFKConstraints(e bool) error {
q := fkChecksEnabled
if !e {
q = fkChecksDisabled
}
_, err := c.sqlite.Exec(q, nil)
return err
} | go | {
"resource": ""
} |
q24961 | FKConstraints | train | func (c *Conn) FKConstraints() (bool, error) {
r, err := c.sqlite.Query(fkChecks, nil)
if err != nil {
return false, err
}
dest := make([]driver.Value, len(r.Columns()))
types := r.(*sqlite3.SQLiteRows).DeclTypes()
if err := r.Next(dest); err != nil {
return false, err
}
values := normalizeRowValues(dest,... | go | {
"resource": ""
} |
q24962 | Load | train | func (c *Conn) Load(src *Conn) error {
return copyDatabase(c.sqlite, src.sqlite)
} | go | {
"resource": ""
} |
q24963 | Backup | train | func (c *Conn) Backup(dst *Conn) error {
return copyDatabase(dst.sqlite, c.sqlite)
} | go | {
"resource": ""
} |
q24964 | Dump | train | func (c *Conn) Dump(w io.Writer) error {
if _, err := w.Write([]byte("PRAGMA foreign_keys=OFF;\nBEGIN TRANSACTION;\n")); err != nil {
return err
}
// Get the schema.
query := `SELECT "name", "type", "sql" FROM "sqlite_master"
WHERE "sql" NOT NULL AND "type" == 'table' ORDER BY "name"`
rows, err :=... | go | {
"resource": ""
} |
q24965 | cliJSON | train | func cliJSON(ctx *cli.Context, cmd, line, url string, argv *argT) error {
// Recursive JSON printer.
var pprint func(indent int, m map[string]interface{})
pprint = func(indent int, m map[string]interface{}) {
indentation := " "
for k, v := range m {
if v == nil {
continue
}
switch v.(type) {
cas... | go | {
"resource": ""
} |
q24966 | New | train | func New(url string) *Client {
return &Client{
url: url,
logger: log.New(os.Stderr, "[discovery] ", log.LstdFlags),
}
} | go | {
"resource": ""
} |
q24967 | Register | train | func (c *Client) Register(id, addr string) (*Response, error) {
m := map[string]string{
"addr": addr,
}
url := c.registrationURL(c.url, id)
client := &http.Client{}
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
}
for {
b, err := json.Marshal(m)... | go | {
"resource": ""
} |
q24968 | startProfile | train | func startProfile(cpuprofile, memprofile string) {
if cpuprofile != "" {
f, err := os.Create(cpuprofile)
if err != nil {
log.Fatalf("failed to create CPU profile file at %s: %s", cpuprofile, err.Error())
}
log.Printf("writing CPU profile to: %s\n", cpuprofile)
prof.cpu = f
pprof.StartCPUProfile(prof.cpu... | go | {
"resource": ""
} |
q24969 | stopProfile | train | func stopProfile() {
if prof.cpu != nil {
pprof.StopCPUProfile()
prof.cpu.Close()
log.Println("CPU profiling stopped")
}
if prof.mem != nil {
pprof.Lookup("heap").WriteTo(prof.mem, 0)
prof.mem.Close()
log.Println("memory profiling stopped")
}
} | go | {
"resource": ""
} |
q24970 | Join | train | func Join(joinAddr []string, id, addr string, meta map[string]string, skip bool) (string, error) {
var err error
var j string
logger := log.New(os.Stderr, "[cluster-join] ", log.LstdFlags)
for i := 0; i < numAttempts; i++ {
for _, a := range joinAddr {
j, err = join(a, id, addr, meta, skip)
if err == nil {... | go | {
"resource": ""
} |
q24971 | Get | train | func (r *Rows) Get(i, j int) string {
if i == 0 {
if j >= len(r.Columns) {
return ""
}
return r.Columns[j]
}
if r.Values == nil {
return "NULL"
}
if i-1 >= len(r.Values) {
return "NULL"
}
if j >= len(r.Values[i-1]) {
return "NULL"
}
return fmt.Sprintf("%v", r.Values[i-1][j])
} | go | {
"resource": ""
} |
q24972 | NewCredentialsStore | train | func NewCredentialsStore() *CredentialsStore {
return &CredentialsStore{
store: make(map[string]string),
perms: make(map[string]map[string]bool),
}
} | go | {
"resource": ""
} |
q24973 | Load | train | func (c *CredentialsStore) Load(r io.Reader) error {
dec := json.NewDecoder(r)
// Read open bracket
_, err := dec.Token()
if err != nil {
return err
}
var cred Credential
for dec.More() {
err := dec.Decode(&cred)
if err != nil {
return err
}
c.store[cred.Username] = cred.Password
c.perms[cred.Use... | go | {
"resource": ""
} |
q24974 | Check | train | func (c *CredentialsStore) Check(username, password string) bool {
pw, ok := c.store[username]
if !ok {
return false
}
return password == pw ||
bcrypt.CompareHashAndPassword([]byte(pw), []byte(password)) == nil
} | go | {
"resource": ""
} |
q24975 | CheckRequest | train | func (c *CredentialsStore) CheckRequest(b BasicAuther) bool {
username, password, ok := b.BasicAuth()
if !ok || !c.Check(username, password) {
return false
}
return true
} | go | {
"resource": ""
} |
q24976 | HasPerm | train | func (c *CredentialsStore) HasPerm(username string, perm string) bool {
m, ok := c.perms[username]
if !ok {
return false
}
if _, ok := m[perm]; !ok {
return false
}
return true
} | go | {
"resource": ""
} |
q24977 | HasAnyPerm | train | func (c *CredentialsStore) HasAnyPerm(username string, perm ...string) bool {
return func(p []string) bool {
for i := range p {
if c.HasPerm(username, p[i]) {
return true
}
}
return false
}(perm)
} | go | {
"resource": ""
} |
q24978 | HasPermRequest | train | func (c *CredentialsStore) HasPermRequest(b BasicAuther, perm string) bool {
username, _, ok := b.BasicAuth()
if !ok {
return false
}
return c.HasPerm(username, perm)
} | go | {
"resource": ""
} |
q24979 | NewConnection | train | func NewConnection(c *sdb.Conn, s *Store, id uint64, it, tt time.Duration) *Connection {
now := time.Now()
conn := Connection{
db: c,
store: s,
ID: id,
CreatedAt: now,
LastUsedAt: now,
IdleTimeout: it,
TxTimeout: tt,
logger: log.New(os.Stderr, connectionLogPrefix(id),... | go | {
"resource": ""
} |
q24980 | Restore | train | func (c *Connection) Restore(dbConn *sdb.Conn, s *Store) {
c.dbMu.Lock()
defer c.dbMu.Unlock()
c.db = dbConn
c.store = s
c.logger = log.New(os.Stderr, connectionLogPrefix(c.ID), log.LstdFlags)
} | go | {
"resource": ""
} |
q24981 | SetLastUsedNow | train | func (c *Connection) SetLastUsedNow() {
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.LastUsedAt = time.Now()
} | go | {
"resource": ""
} |
q24982 | TransactionActive | train | func (c *Connection) TransactionActive() bool {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return false
}
return c.db.TransactionActive()
} | go | {
"resource": ""
} |
q24983 | Execute | train | func (c *Connection) Execute(ex *ExecuteRequest) (*ExecuteResponse, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.execute(c, ex)
} | go | {
"resource": ""
} |
q24984 | ExecuteOrAbort | train | func (c *Connection) ExecuteOrAbort(ex *ExecuteRequest) (resp *ExecuteResponse, retErr error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.executeOrAbort(c, ex)
} | go | {
"resource": ""
} |
q24985 | Query | train | func (c *Connection) Query(qr *QueryRequest) (*QueryResponse, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
if c.db == nil {
return nil, ErrConnectionDoesNotExist
}
return c.store.query(c, qr)
} | go | {
"resource": ""
} |
q24986 | Close | train | func (c *Connection) Close() error {
c.dbMu.Lock()
defer c.dbMu.Unlock()
if c.store != nil {
if err := c.store.disconnect(c); err != nil {
return err
}
}
if c.db == nil {
return nil
}
if err := c.db.Close(); err != nil {
return err
}
c.db = nil
return nil
} | go | {
"resource": ""
} |
q24987 | Stats | train | func (c *Connection) Stats() (interface{}, error) {
c.dbMu.RLock()
defer c.dbMu.RUnlock()
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.txStateMu.Lock()
defer c.txStateMu.Unlock()
fkEnabled, err := c.db.FKConstraints()
if err != nil {
return nil, err
}
m := make(map[string]interface{})
m["last_used_at"] = c.... | go | {
"resource": ""
} |
q24988 | IdleTimedOut | train | func (c *Connection) IdleTimedOut() bool {
c.timeMu.Lock()
defer c.timeMu.Unlock()
return time.Since(c.LastUsedAt) > c.IdleTimeout && c.IdleTimeout != 0
} | go | {
"resource": ""
} |
q24989 | TxTimedOut | train | func (c *Connection) TxTimedOut() bool {
c.timeMu.Lock()
defer c.timeMu.Unlock()
c.txStateMu.Lock()
defer c.txStateMu.Unlock()
lau := c.LastUsedAt
return !c.TxStartedAt.IsZero() && time.Since(lau) > c.TxTimeout && c.TxTimeout != 0
} | go | {
"resource": ""
} |
q24990 | NewTxStateChange | train | func NewTxStateChange(c *Connection) *TxStateChange {
return &TxStateChange{
c: c,
tx: c.TransactionActive(),
}
} | go | {
"resource": ""
} |
q24991 | CheckAndSet | train | func (t *TxStateChange) CheckAndSet() {
t.c.txStateMu.Lock()
defer t.c.txStateMu.Unlock()
defer func() { t.done = true }()
if t.done {
panic("CheckAndSet should only be called once")
}
if !t.tx && t.c.TransactionActive() && t.c.TxStartedAt.IsZero() {
t.c.TxStartedAt = time.Now()
} else if t.tx && !t.c.Tran... | go | {
"resource": ""
} |
q24992 | NewDBConfig | train | func NewDBConfig(dsn string, memory bool) *DBConfig {
return &DBConfig{DSN: dsn, Memory: memory}
} | go | {
"resource": ""
} |
q24993 | StringOpen | train | func StringOpen(l *State) int {
NewLibrary(l, stringLibrary)
l.CreateTable(0, 1)
l.PushString("")
l.PushValue(-2)
l.SetMetaTable(-2)
l.Pop(1)
l.PushValue(-2)
l.SetField(-2, "__index")
l.Pop(1)
return 1
} | go | {
"resource": ""
} |
q24994 | AtPanic | train | func AtPanic(l *State, panicFunction Function) Function {
panicFunction, l.global.panicFunction = l.global.panicFunction, panicFunction
return panicFunction
} | go | {
"resource": ""
} |
q24995 | UpValue | train | func UpValue(l *State, function, index int) (name string, ok bool) {
if c, isClosure := l.indexToValue(function).(closure); isClosure {
if ok = 1 <= index && index <= c.upValueCount(); ok {
if c, isLua := c.(*luaClosure); isLua {
name = c.prototype.upValues[index-1].name
}
l.apiPush(c.upValue(index - 1)... | go | {
"resource": ""
} |
q24996 | UpValueJoin | train | func UpValueJoin(l *State, f1, n1, f2, n2 int) {
u1 := l.upValue(f1, n1)
u2 := l.upValue(f2, n2)
*u1 = *u2
} | go | {
"resource": ""
} |
q24997 | MathOpen | train | func MathOpen(l *State) int {
NewLibrary(l, mathLibrary)
l.PushNumber(3.1415926535897932384626433832795) // TODO use math.Pi instead? Values differ.
l.SetField(-2, "pi")
l.PushNumber(math.MaxFloat64)
l.SetField(-2, "huge")
return 1
} | go | {
"resource": ""
} |
q24998 | IOOpen | train | func IOOpen(l *State) int {
NewLibrary(l, ioLibrary)
NewMetaTable(l, fileHandle)
l.PushValue(-1)
l.SetField(-2, "__index")
SetFunctions(l, fileHandleMethods, 0)
l.Pop(1)
registerStdFile(l, os.Stdin, input, "stdin")
registerStdFile(l, os.Stdout, output, "stdout")
registerStdFile(l, os.Stderr, "", "stderr")
... | go | {
"resource": ""
} |
q24999 | Traceback | train | func Traceback(l, l1 *State, message string, level int) {
const levels1, levels2 = 12, 10
levels := countLevels(l1)
mark := 0
if levels > levels1+levels2 {
mark = levels1
}
buf := message
if buf != "" {
buf += "\n"
}
buf += "stack traceback:"
for f, ok := Stack(l1, level); ok; f, ok = Stack(l1, level) {
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.