_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q32200 | WaitReplication | train | func (l *Ledis) WaitReplication() error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
for i := 0; i < 100; i++ {
l.noticeReplication()
select {
case <-l.rDoneCh:
case <-l.quit:
return nil
}
time.Sleep(100 * time.Millisecond)
b, err := l.r.CommitIDBehind()
if err != nil {
return er... | go | {
"resource": ""
} |
q32201 | StoreLogsFromReader | train | func (l *Ledis) StoreLogsFromReader(rb io.Reader) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
} else if !l.cfg.Readonly {
return ErrRplInRDWR
}
log := &rpl.Log{}
for {
if err := log.Decode(rb); err != nil {
if err == io.EOF {
break
} else {
return err
}
}
if err := l.r.S... | go | {
"resource": ""
} |
q32202 | StoreLogsFromData | train | func (l *Ledis) StoreLogsFromData(data []byte) error {
rb := bytes.NewReader(data)
return l.StoreLogsFromReader(rb)
} | go | {
"resource": ""
} |
q32203 | ReadLogsTo | train | func (l *Ledis) ReadLogsTo(startLogID uint64, w io.Writer) (n int, nextLogID uint64, err error) {
if !l.ReplicationUsed() {
// no replication log
nextLogID = 0
err = ErrRplNotSupport
return
}
var firtID, lastID uint64
firtID, err = l.r.FirstLogID()
if err != nil {
return
}
if startLogID < firtID {
... | go | {
"resource": ""
} |
q32204 | ReadLogsToTimeout | train | func (l *Ledis) ReadLogsToTimeout(startLogID uint64, w io.Writer, timeout int, quitCh chan struct{}) (n int, nextLogID uint64, err error) {
n, nextLogID, err = l.ReadLogsTo(startLogID, w)
if err != nil {
return
} else if n != 0 {
return
}
//no events read
select {
case <-l.r.WaitLog():
case <-time.After(tim... | go | {
"resource": ""
} |
q32205 | AddNewLogEventHandler | train | func (l *Ledis) AddNewLogEventHandler(h NewLogEventHandler) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
l.rhs = append(l.rhs, h)
return nil
} | go | {
"resource": ""
} |
q32206 | ReplicationStat | train | func (l *Ledis) ReplicationStat() (*rpl.Stat, error) {
if !l.ReplicationUsed() {
return nil, ErrRplNotSupport
}
return l.r.Stat()
} | go | {
"resource": ""
} |
q32207 | ZAdd | train | func (db *DB) ZAdd(key []byte, args ...ScorePair) (int64, error) {
if len(args) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(args); i++ {
score := args[i].Score
member := args[i].Member
if err := checkZSetKMSize(key, member); err != nil {
retu... | go | {
"resource": ""
} |
q32208 | ZCard | train | func (db *DB) ZCard(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
return Int64(db.bucket.Get(sk))
} | go | {
"resource": ""
} |
q32209 | ZScore | train | func (db *DB) ZScore(key []byte, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
score := InvalidScore
k := db.zEncodeSetKey(key, member)
if v, err := db.bucket.Get(k); err != nil {
return InvalidScore, err
} else if v == nil {
return Invalid... | go | {
"resource": ""
} |
q32210 | ZRem | train | func (db *DB) ZRem(key []byte, members ...[]byte) (int64, error) {
if len(members) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(members); i++ {
if err := checkZSetKMSize(key, members[i]); err != nil {
return 0, err
}
if n, err := db.zDelItem(t... | go | {
"resource": ""
} |
q32211 | ZIncrBy | train | func (db *DB) ZIncrBy(key []byte, delta int64, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
ek := db.zEncodeSetKey(key, member)
var oldScore int64
v, err := db.bucket.Get(ek)
if err != nil {
re... | go | {
"resource": ""
} |
q32212 | ZClear | train | func (db *DB) ZClear(key []byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1)
if err == nil {
err = t.Commit()
}
return rmCnt, err
} | go | {
"resource": ""
} |
q32213 | ZMclear | train | func (db *DB) ZMclear(keys ...[]byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if _, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1); err != nil {
return 0, err
}
}
err := t.Commit()
return int64(len(keys)), err
} | go | {
"resource": ""
} |
q32214 | ZRange | train | func (db *DB) ZRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, false)
} | go | {
"resource": ""
} |
q32215 | ZRangeByScore | train | func (db *DB) ZRangeByScore(key []byte, min int64, max int64,
offset int, count int) ([]ScorePair, error) {
return db.ZRangeByScoreGeneric(key, min, max, offset, count, false)
} | go | {
"resource": ""
} |
q32216 | ZRank | train | func (db *DB) ZRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, false)
} | go | {
"resource": ""
} |
q32217 | ZRemRangeByRank | train | func (db *DB) ZRemRangeByRank(key []byte, start int, stop int) (int64, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return 0, err
}
var rmCnt int64
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err = db.zRemRange(t, key, MinScore, MaxScore, offset, count)
if err == ... | go | {
"resource": ""
} |
q32218 | ZRevRange | train | func (db *DB) ZRevRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, true)
} | go | {
"resource": ""
} |
q32219 | ZRevRank | train | func (db *DB) ZRevRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, true)
} | go | {
"resource": ""
} |
q32220 | ZRangeGeneric | train | func (db *DB) ZRangeGeneric(key []byte, start int, stop int, reverse bool) ([]ScorePair, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return nil, err
}
return db.zRange(key, MinScore, MaxScore, offset, count, reverse)
} | go | {
"resource": ""
} |
q32221 | ZRangeByScoreGeneric | train | func (db *DB) ZRangeByScoreGeneric(key []byte, min int64, max int64,
offset int, count int, reverse bool) ([]ScorePair, error) {
return db.zRange(key, min, max, offset, count, reverse)
} | go | {
"resource": ""
} |
q32222 | ZExpire | train | func (db *DB) ZExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.zExpireAt(key, time.Now().Unix()+duration)
} | go | {
"resource": ""
} |
q32223 | ZExpireAt | train | func (db *DB) ZExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.zExpireAt(key, when)
} | go | {
"resource": ""
} |
q32224 | ZTTL | train | func (db *DB) ZTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(ZSetType, key)
} | go | {
"resource": ""
} |
q32225 | ZPersist | train | func (db *DB) ZPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, ZSetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | {
"resource": ""
} |
q32226 | ZUnionStore | train | func (db *DB) ZUnionStore(destKey []byte, srcKeys [][]byte, weights []int64, aggregate byte) (int64, error) {
var destMap = map[string]int64{}
aggregateFunc := getAggregateFunc(aggregate)
if aggregateFunc == nil {
return 0, errInvalidAggregate
}
if len(srcKeys) < 1 {
return 0, errInvalidSrcKeyNum
}
if weigh... | go | {
"resource": ""
} |
q32227 | ZRangeByLex | train | func (db *DB) ZRangeByLex(key []byte, min []byte, max []byte, rangeType uint8, offset int, count int) ([][]byte, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}... | go | {
"resource": ""
} |
q32228 | ZLexCount | train | func (db *DB) ZLexCount(key []byte, min []byte, max []byte, rangeType uint8) (int64, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}
it := db.bucket.RangeIter... | go | {
"resource": ""
} |
q32229 | ZKeyExists | train | func (db *DB) ZKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | {
"resource": ""
} |
q32230 | handleXSelectCmd | train | func (c *respClient) handleXSelectCmd() error {
if len(c.args) <= 2 {
// invalid command format
return fmt.Errorf("invalid format for XSELECT, must XSELECT db THEN your command")
}
if hack.String(upperSlice(c.args[1])) != "THEN" {
// invalid command format, just resturn here
return fmt.Errorf("invalid forma... | go | {
"resource": ""
} |
q32231 | buildDataScanKeyRange | train | func (db *DB) buildDataScanKeyRange(storeDataType byte, key []byte, cursor []byte, reverse bool) (minKey []byte, maxKey []byte, err error) {
if !reverse {
if minKey, err = db.encodeDataScanMinKey(storeDataType, key, cursor); err != nil {
return
}
if maxKey, err = db.encodeDataScanMaxKey(storeDataType, key, ni... | go | {
"resource": ""
} |
q32232 | HScan | train | func (db *DB) HScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, false)
} | go | {
"resource": ""
} |
q32233 | HRevScan | train | func (db *DB) HRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, true)
} | go | {
"resource": ""
} |
q32234 | SScan | train | func (db *DB) SScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, false)
} | go | {
"resource": ""
} |
q32235 | SRevScan | train | func (db *DB) SRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, true)
} | go | {
"resource": ""
} |
q32236 | ZScan | train | func (db *DB) ZScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, false)
} | go | {
"resource": ""
} |
q32237 | ZRevScan | train | func (db *DB) ZRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, true)
} | go | {
"resource": ""
} |
q32238 | BatchData | train | func (wb *WriteBatch) BatchData() *BatchData {
data := wb.wb.Data()
if wb.data == nil {
wb.data = new(BatchData)
}
wb.data.Load(data)
return wb.data
} | go | {
"resource": ""
} |
q32239 | Uint64 | train | func Uint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil || len(v) == 0 {
return 0, nil
} else if len(v) != 8 {
return 0, errIntNumber
}
return binary.LittleEndian.Uint64(v), nil
} | go | {
"resource": ""
} |
q32240 | PutInt64 | train | func PutInt64(v int64) []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, uint64(v))
return b
} | go | {
"resource": ""
} |
q32241 | StrInt64 | train | func StrInt64(v []byte, err error) (int64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseInt(hack.String(v), 10, 64)
}
} | go | {
"resource": ""
} |
q32242 | StrUint64 | train | func StrUint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseUint(hack.String(v), 10, 64)
}
} | go | {
"resource": ""
} |
q32243 | StrInt32 | train | func StrInt32(v []byte, err error) (int32, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 32)
return int32(res), err
}
} | go | {
"resource": ""
} |
q32244 | StrInt8 | train | func StrInt8(v []byte, err error) (int8, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 8)
return int8(res), err
}
} | go | {
"resource": ""
} |
q32245 | XLSort | train | func (db *DB) XLSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.LRange(key, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | go | {
"resource": ""
} |
q32246 | XZSort | train | func (db *DB) XZSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.ZRangeByLex(key, nil, nil, store.RangeClose, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | go | {
"resource": ""
} |
q32247 | HLen | train | func (db *DB) HLen(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
return Int64(db.bucket.Get(db.hEncodeSizeKey(key)))
} | go | {
"resource": ""
} |
q32248 | HSet | train | func (db *DB) HSet(key []byte, field []byte, value []byte) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.hSetItem(key, field, value)
if err != ... | go | {
"resource": ""
} |
q32249 | HGet | train | func (db *DB) HGet(key []byte, field []byte) ([]byte, error) {
if err := checkHashKFSize(key, field); err != nil {
return nil, err
}
return db.bucket.Get(db.hEncodeHashKey(key, field))
} | go | {
"resource": ""
} |
q32250 | HMset | train | func (db *DB) HMset(key []byte, args ...FVPair) error {
t := db.hashBatch
t.Lock()
defer t.Unlock()
var err error
var ek []byte
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i].Field); err != nil {
return err
} else if err := checkValueSize(args[i].Value); err != nil ... | go | {
"resource": ""
} |
q32251 | HMget | train | func (db *DB) HMget(key []byte, args ...[]byte) ([][]byte, error) {
var ek []byte
it := db.bucket.NewIterator()
defer it.Close()
r := make([][]byte, len(args))
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
return nil, err
}
ek = db.hEncodeHashKey(key, args[i])
... | go | {
"resource": ""
} |
q32252 | HDel | train | func (db *DB) HDel(key []byte, args ...[]byte) (int64, error) {
t := db.hashBatch
var ek []byte
var v []byte
var err error
t.Lock()
defer t.Unlock()
it := db.bucket.NewIterator()
defer it.Close()
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
retu... | go | {
"resource": ""
} |
q32253 | HIncrBy | train | func (db *DB) HIncrBy(key []byte, field []byte, delta int64) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
}
t := db.hashBatch
var ek []byte
var err error
t.Lock()
defer t.Unlock()
ek = db.hEncodeHashKey(key, field)
var n int64
if n, err = StrInt64(db.bucket.Get(ek))... | go | {
"resource": ""
} |
q32254 | HGetAll | train | func (db *DB) HGetAll(key []byte) ([]FVPair, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.hEncodeStartKey(key)
stop := db.hEncodeStopKey(key)
v := make([]FVPair, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Va... | go | {
"resource": ""
} |
q32255 | HClear | train | func (db *DB) HClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
num := db.hDelete(t, key)
db.rmExpire(t, HashType, key)
err := t.Commit()
return num, err
} | go | {
"resource": ""
} |
q32256 | HMclear | train | func (db *DB) HMclear(keys ...[]byte) (int64, error) {
t := db.hashBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.hDelete(t, key)
db.rmExpire(t, HashType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | go | {
"resource": ""
} |
q32257 | HExpire | train | func (db *DB) HExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.hExpireAt(key, time.Now().Unix()+duration)
} | go | {
"resource": ""
} |
q32258 | HExpireAt | train | func (db *DB) HExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.hExpireAt(key, when)
} | go | {
"resource": ""
} |
q32259 | HTTL | train | func (db *DB) HTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(HashType, key)
} | go | {
"resource": ""
} |
q32260 | HPersist | train | func (db *DB) HPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, HashType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | {
"resource": ""
} |
q32261 | HKeyExists | train | func (db *DB) HKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.hEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | {
"resource": ""
} |
q32262 | Contains | train | func (e *domEngine) Contains(c Compo) bool {
e.mutex.RLock()
defer e.mutex.RUnlock()
_, ok := e.compos[c]
return ok
} | go | {
"resource": ""
} |
q32263 | CompoByID | train | func (e *domEngine) CompoByID(id string) (Compo, error) {
e.mutex.RLock()
defer e.mutex.RUnlock()
c, ok := e.compoIDs[id]
if !ok {
return nil, ErrCompoNotMounted
}
return c.Compo, nil
} | go | {
"resource": ""
} |
q32264 | New | train | func (e *domEngine) New(c Compo) error {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
if err := e.render(c); err != nil {
return err
}
ic := e.compos[c]
e.rootID = ic.ID
e.changes = append(e.changes, change{
Action: setRoot,
NodeID: ic.ID,
})
return e.sync()
} | go | {
"resource": ""
} |
q32265 | Close | train | func (e *domEngine) Close() {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
} | go | {
"resource": ""
} |
q32266 | CacheHandler | train | func CacheHandler(h http.Handler, webDir string) http.Handler {
return &cacheHandler{
Handler: h,
webDir: webDir,
}
} | go | {
"resource": ""
} |
q32267 | GenerateEtag | train | func GenerateEtag() string {
t := time.Now().UTC().String()
return fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
} | go | {
"resource": ""
} |
q32268 | GetEtag | train | func GetEtag(webDir string) string {
filename := filepath.Join(webDir, ".etag")
etag, err := ioutil.ReadFile(filename)
if err != nil {
return ""
}
return string(etag)
} | go | {
"resource": ""
} |
q32269 | jsToGoHandler | train | func jsToGoHandler(name, value string) (string, string) {
if !strings.HasPrefix(name, "on") {
return name, value
}
if strings.HasPrefix(value, "js:") {
return name, strings.TrimPrefix(value, "js:")
}
return name, fmt.Sprintf("callCompoHandler(this, event, '%s')", value)
} | go | {
"resource": ""
} |
q32270 | Import | train | func Import(c ...Compo) {
for _, compo := range c {
if _, err := components.register(compo); err != nil {
Panicf("import component failed: %s", err)
}
}
} | go | {
"resource": ""
} |
q32271 | Log | train | func Log(a ...interface{}) {
format := ""
for range a {
format += "%v "
}
format = format[:len(format)-1]
Logger(format, a...)
} | go | {
"resource": ""
} |
q32272 | Render | train | func Render(c Compo) {
WhenDebug(func() {
Logf("rendering %T")
})
if err := render(c); err != nil {
Log(err)
}
} | go | {
"resource": ""
} |
q32273 | Map | train | func (m *mapping) Map(c Compo) (f func(), err error) {
if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
return nil, err
}
return m.mapTo(reflect.ValueOf(c))
} | go | {
"resource": ""
} |
q32274 | OnMenuClick | train | func (h *Hello) OnMenuClick() {
app.NewContextMenu(
app.MenuItem{
Label: "Reload",
Keys: "cmdorctrl+r",
OnClick: app.Reload},
app.MenuItem{Separator: true},
app.MenuItem{
Label: "Go to repository",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app")
}},
app.Men... | go | {
"resource": ""
} |
q32275 | FileHandler | train | func FileHandler(webDir string) http.Handler {
return http.FileServer(http.Dir(webDir))
} | go | {
"resource": ""
} |
q32276 | GzipHandler | train | func GzipHandler(h http.Handler, webDir string) http.Handler {
return &gzipHandler{
Handler: h,
webDir: webDir,
}
} | go | {
"resource": ""
} |
q32277 | Subscribe | train | func (s *Subscriber) Subscribe(e Event, f interface{}) *Subscriber {
unsubscribe := s.events.subscribe(e, f)
s.unsuscribes = append(s.unsuscribes, unsubscribe)
return s
} | go | {
"resource": ""
} |
q32278 | Emit | train | func (r *eventRegistry) Emit(e Event, args ...interface{}) {
r.mutex.RLock()
defer r.mutex.RUnlock()
for _, h := range r.handlers[e] {
if err := r.callHandler(h.MsgHandler, args...); err != nil {
Logf("emitting %s failed: %s", e, err)
}
}
} | go | {
"resource": ""
} |
q32279 | main | train | func main() {
// Imports the hello component declared above in order to make it loadable
// in a page or usable in other components.
//
// Imported component can be used as URL or html tags by referencing them by
// their lowercased names.
// E.g:
// Hello => hello
// foo.Bar => foo.bar
app.Import(&Hello{}... | go | {
"resource": ""
} |
q32280 | New | train | func New(cfg *Config) *Transport {
ctx, cancel := context.WithCancel(context.Background())
if cfg.RaftID != "" {
ctx = log.WithField(ctx, "raft_id", cfg.RaftID)
}
t := &Transport{
peers: make(map[uint64]*peer),
config: cfg,
unknownc: make(chan raftpb.Message),
done: make(chan struct{}),
ctx: ... | go | {
"resource": ""
} |
q32281 | Send | train | func (t *Transport) Send(m raftpb.Message) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
if t.config.IsIDRemoved(m.To) {
return errors.Errorf("refusing to send message %s to removed member %x", m.Type, m.To)
}
p, ok := t.peers[m.To]
if !ok {
log.G(t.ctx).W... | go | {
"resource": ""
} |
q32282 | RemovePeer | train | func (t *Transport) RemovePeer(id uint64) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
delete(t.peers, id)
cc := p.conn()
p.stop()
timer := time.AfterFunc(8*time.Second, func() {
t.mu.Lock()
if !t... | go | {
"resource": ""
} |
q32283 | UpdatePeer | train | func (t *Transport) UpdatePeer(id uint64, addr string) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
if err := p.update(addr); err != nil {
return err
}
log.G(t.ctx).Debugf("peer %x updated to address... | go | {
"resource": ""
} |
q32284 | UpdatePeerAddr | train | func (t *Transport) UpdatePeerAddr(id uint64, addr string) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
return p.updateAddr(addr)
} | go | {
"resource": ""
} |
q32285 | PeerConn | train | func (t *Transport) PeerConn(id uint64) (*grpc.ClientConn, error) {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return nil, ErrIsNotFound
}
p.mu.Lock()
active := p.active
p.mu.Unlock()
if !active {
return nil, errors.New("peer is inactive")
}
return p.conn(), nil
} | go | {
"resource": ""
} |
q32286 | PeerAddr | train | func (t *Transport) PeerAddr(id uint64) (string, error) {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return "", ErrIsNotFound
}
return p.address(), nil
} | go | {
"resource": ""
} |
q32287 | HealthCheck | train | func (t *Transport) HealthCheck(ctx context.Context, id uint64) error {
t.mu.Lock()
p, ok := t.peers[id]
t.mu.Unlock()
if !ok {
return ErrIsNotFound
}
ctx, cancel := t.withContext(ctx)
defer cancel()
return p.healthCheck(ctx)
} | go | {
"resource": ""
} |
q32288 | Active | train | func (t *Transport) Active(id uint64) bool {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return false
}
p.mu.Lock()
active := p.active
p.mu.Unlock()
return active
} | go | {
"resource": ""
} |
q32289 | LongestActive | train | func (t *Transport) LongestActive() (uint64, error) {
p, err := t.longestActive()
if err != nil {
return 0, err
}
return p.id, nil
} | go | {
"resource": ""
} |
q32290 | longestActive | train | func (t *Transport) longestActive() (*peer, error) {
var longest *peer
var longestTime time.Time
t.mu.Lock()
defer t.mu.Unlock()
for _, p := range t.peers {
becameActive := p.activeTime()
if becameActive.IsZero() {
continue
}
if longest == nil {
longest = p
continue
}
if becameActive.Before(lo... | go | {
"resource": ""
} |
q32291 | EventUpdate | train | func (e extensionEntry) EventUpdate(oldObject api.StoreObject) api.Event {
if oldObject != nil {
return api.EventUpdateExtension{Extension: e.Extension, OldExtension: oldObject.(extensionEntry).Extension}
}
return api.EventUpdateExtension{Extension: e.Extension}
} | go | {
"resource": ""
} |
q32292 | CreateExtension | train | func CreateExtension(tx Tx, e *api.Extension) error {
// Ensure the name is not already in use.
if tx.lookup(tableExtension, indexName, strings.ToLower(e.Annotations.Name)) != nil {
return ErrNameConflict
}
// It can't conflict with built-in kinds either.
if _, ok := schema.Tables[e.Annotations.Name]; ok {
re... | go | {
"resource": ""
} |
q32293 | DeleteExtension | train | func DeleteExtension(tx Tx, id string) error {
e := tx.get(tableExtension, id)
if e == nil {
return ErrNotExist
}
resources, err := FindResources(tx, ByKind(e.(extensionEntry).Annotations.Name))
if err != nil {
return err
}
if len(resources) != 0 {
return errors.New("cannot delete extension because objec... | go | {
"resource": ""
} |
q32294 | GetExtension | train | func GetExtension(tx ReadTx, id string) *api.Extension {
e := tx.get(tableExtension, id)
if e == nil {
return nil
}
return e.(extensionEntry).Extension
} | go | {
"resource": ""
} |
q32295 | FindExtensions | train | func FindExtensions(tx ReadTx, by By) ([]*api.Extension, error) {
checkType := func(by By) error {
switch by.(type) {
case byIDPrefix, byName, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
extensionList := []*api.Extension{}
appendResult := func(o api.StoreObject) {
exte... | go | {
"resource": ""
} |
q32296 | GetNode | train | func (s *Server) GetNode(ctx context.Context, request *api.GetNodeRequest) (*api.GetNodeResponse, error) {
if request.NodeID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var node *api.Node
s.store.View(func(tx store.ReadTx) {
node = store.GetNode(tx, request.NodeID)
}... | go | {
"resource": ""
} |
q32297 | UpdateNode | train | func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest) (*api.UpdateNodeResponse, error) {
if request.NodeID == "" || request.NodeVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
if err := validateNodeSpec(request.Spec); err != nil {
return ... | go | {
"resource": ""
} |
q32298 | BySlot | train | func BySlot(serviceID string, slot uint64) By {
return bySlot{serviceID: serviceID, slot: slot}
} | go | {
"resource": ""
} |
q32299 | ByCustom | train | func ByCustom(objType, index, value string) By {
return byCustom{
objType: objType,
index: index,
value: value,
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.