id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c174500 | name)
if name == "default" {
defaultLogger = nil
}
lock.Unlock()
} | |
c174501 | *Logger) {
logger.WaitForUnprocessedRecords()
wg.Done()
}(logger)
}
wg.Wait()
lock.Unlock()
} | |
c174502 | select {
case state := <-logger.stateChannel:
switch state {
case stopped:
break recordLoop
case running:
break stateLoop
default:
continue
}
}
}
}
}
}
} | |
c174503 | if i >= 100 {
return
}
if diff > 0 {
diffPrev = diff
time.Sleep(10 * time.Millisecond)
} else {
return
}
}
} | |
c174504 | if length != logger.buffer.Len() {
logger.buffer = ring.New(length)
}
logger.lock.Unlock()
} | |
c174505 | handler)
logger.flushBuffer()
logger.lock.Unlock()
} | |
c174506 |
logger.Handlers = make([]Handler, 0)
logger.flushBuffer()
logger.lock.Unlock()
} | |
c174507 |
logger.flushBuffer()
logger.lock.Unlock()
} | |
c174508 | } else {
message = fmt.Sprintf(format, a...)
}
atomic.AddUint64(&logger.countIn, 1)
logger.recordChannel <- &Record{
Level: level,
Message: message,
Time: time.Now(),
}
} | |
c174509 |
logger.log(level, format, a...)
} | |
c174510 | logger.log(level, "", a...)
} | |
c174511 | logger.log(EMERGENCY, format, a...)
} | |
c174512 | logger.log(ALERT, format, a...)
} | |
c174513 | logger.log(CRITICAL, format, a...)
} | |
c174514 | logger.log(ERROR, format, a...)
} | |
c174515 | logger.log(WARNING, format, a...)
} | |
c174516 | logger.log(NOTICE, format, a...)
} | |
c174517 | logger.log(INFO, format, a...)
} | |
c174518 | logger.log(DEBUG, format, a...)
} | |
c174519 | nil {
return errors.New("Duplicate Route registration")
}
e.handler = h
return nil
} | |
c174520 | != nil {
return errors.New("Duplicate Route registration")
}
e.handlers[method] = h
return nil
} | |
c174521 | := e.handlers[method]
if handler == nil {
handler = e.handler
}
return handler
} | |
c174522 | entry.Pattern() {
return entry
}
}
return nil
} | |
c174523 | }
return child.MergePatterns(patterns[size:])
}
return e.addPatterns(patterns)
} | |
c174524 |
e.entries = append(e.entries, child)
return
}
e.entries = append(e.entries, nil)
copy(e.entries[index+1:], e.entries[index:])
e.entries[index] = child
} | |
c174525 | else if isMatchPattern(pat) {
entry = newMatchEntry(pat)
} else {
entry = newStaticEntry(pat)
}
currentNode.AddEntry(entry)
currentNode = entry
patterns = patterns[size:]
}
return currentNode
} | |
c174526 |
return nil, nil
}
if len(urlStr) == len(e.pattern) {
return e.GetHandler(method), nil
}
return e.traverse(method, urlStr[len(e.pattern):])
} | |
c174527 | := entry.exec(method, urlStr); h != nil {
return h, params
}
}
return nil, nil
} | |
c174528 |
}
for _, entry := range e.entries {
if h, params := entry.exec(method, urlStr[offset:]); h != nil {
params = append(params, name, matchStr)
return h, params
}
}
return nil, nil
}
} | |
c174529 |
routes = append(routes, v.Routes()...)
}
return routes
} | |
c174530 |
l.logger.Output(2, "DEBUG: "+s)
l.callHandlers(LevelDebug, s)
} | |
c174531 | l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "DEBUG: "+s)
l.callHandlers(LevelDebug, s)
} | |
c174532 | l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "VERBOSE: "+s)
l.callHandlers(LevelVerbose, s)
} | |
c174533 |
l.logger.Output(2, "INFO: "+s)
l.callHandlers(LevelInfo, s)
} | |
c174534 | l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "INFO: "+s)
l.callHandlers(LevelInfo, s)
} | |
c174535 |
l.logger.Output(2, "OK: "+s)
l.callHandlers(LevelOK, s)
} | |
c174536 | l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "OK: "+s)
l.callHandlers(LevelOK, s)
} | |
c174537 |
l.logger.Output(2, "FATAL: "+s)
l.callHandlers(LevelFatal, s)
os.Exit(1)
} | |
c174538 | vals...)
l.logger.Output(2, "FATAL: "+s)
l.callHandlers(LevelFatal, s)
os.Exit(1)
} | |
c174539 | res := l.debug[facility]
l.mut.Unlock()
return res
} | |
c174540 |
l.debug[facility] = enabled
l.mut.Unlock()
} | |
c174541 | {
if isEnabled {
enabled = append(enabled, facility)
} else {
disabled = append(disabled, facility)
}
}
l.mut.Unlock()
return
} | |
c174542 | l.mut.Unlock()
return &facilityLogger{
logger: l,
facility: facility,
}
} | |
c174543 |
f.theString = rp.ReplaceAllString(f.theString, "")
} | |
c174544 | f.theString = rp.ReplaceAllString(f.theString, "")
}
} | |
c174545 |
f.theString = rp.ReplaceAllString(f.theString, "%20")
} | |
c174546 | nil {
tmpIndex = int(randBytes[0]) % length
}
return a[tmpIndex]
} | |
c174547 |
timeformat = TimeDateFormat
}
return &StdFormatter{
Delim: []byte(delim),
Tmpl: []byte(tmpl),
E: entry,
Map: values,
Idx: mkindex(entry),
TimeFormat: timeformat,
}, nil
} | |
c174548 | 0; i-- {
handler = s[i](handler)
}
return handler
} | |
c174549 | "" {
matchType = "default"
}
matcher = MatcherMap[matchType]
if matcher == nil {
panic(errors.New("no such match type: " + matchType))
}
return matcher, name
} | |
c174550 | && s[0] == '<' && s[len(s)-1] == '>'
} | |
c174551 | static entry
if slashIndex == -1 && matchIndex == -1 {
return len(data), data, nil
}
// split by '<'
// return data before '<'
if matchIndex != -1 && (slashIndex == -1 || slashIndex > matchIndex) {
return matchIndex, data[:matchIndex], nil
}
// split by '/'
// return data before '/' including '/'
return slashIndex + 1, data[:(slashIndex + 1)], nil
} | |
c174552 |
scanner.Split(routeSplitFunc)
for scanner.Scan() {
routes = append(routes, scanner.Text())
}
err = scanner.Err()
return
} | |
c174553 | }
r, _ := utf8.DecodeRuneInString(p[1])
return matcher.MatchRune(r)
}
return false
} | |
c174554 | {
pat, size = (p[0] + p[1]), 2
} else {
pat, size = p[0], 1
}
return
} | |
c174555 | storage.Store(p)
if err != nil {
return nil, errors.New(err.Error() + " - Could not write player to storage")
}
return p, nil
} | |
c174556 | append(r.readers, reader)
} | |
c174557 | info")
}
if err := storage.Store(c); err != nil {
return nil, errors.New(err.Error() + " - Could not write catering to storage")
}
return c, nil
} | |
c174558 | y, m := entry.Info.Scheduled.Year(), entry.Info.Scheduled.Month()
if y == season {
byMonth[m] = append(byMonth[m], entry)
}
}
return byMonth
} | |
c174559 |
if info.Season == 0 {
return errors.New("Tournament needs a season")
}
return nil
} | |
c174560 | != nil {
return nil, errors.New(err.Error() + " - Could not set initial tournament data")
}
// Merge seems to not handle time.Time for some reason, thus fixup
fixupTournamentInfo(&t.Info, tdata)
if err := storage.Store(t); err != nil {
return nil, errors.New(err.Error() + " - Could not write tournament to storage")
}
return t, nil
} | |
c174561 | if str == v {
return i
}
}
return -1
} | |
c174562 | if str == strings.ToLower(v) {
return i
}
}
return -1
} | |
c174563 | make(map[string]*cacheItem),
lifetime: d,
}
} | |
c174564 |
defer s.RUnlock()
}
return len(s.values)
} | |
c174565 | = make(map[string]*cacheItem)
} | |
c174566 | if !writeLocked {
s.RUnlock()
s.Lock()
writeLocked = true
}
delete(s.values, i)
}
}
if writeLocked {
return raiqub.WriteLocked
} else {
return raiqub.ReadLocked
}
} | |
c174567 |
docker: d,
name: name,
}
} | |
c174568 | return false
}
return strings.Contains(out, s.name)
} | |
c174569 | != nil {
return err
}
return nil
} | |
c174570 | strings.TrimSpace(out),
}
if container.id == "" {
return nil, UnexpectedOutputError(
"Unexpected empty output when running docker container")
}
return container, nil
} | |
c174571 | if err := s.Pull(); err != nil {
return err
}
}
return nil
} | |
c174572 | profile")
}
if err := storage.Store(l); err != nil {
return nil, errors.New(err.Error() + " - Could not write location to storage")
}
return l, nil
} | |
c174573 | counter++
continue
}
return k, v
}
return "", nil
} | |
c174574 | strconv.ParseUint(vect[0], 10, 16)
return uint16(port), vect[1]
} | |
c174575 | {
return syslogPriorities[strings.ToLower(s.String())]
} | |
c174576 | syslogPriorities[strings.ToLower(s.String())]
return
} | |
c174577 | _ := json.Marshal(record)
return string(data)
} | |
c174578 | error) {
db, err := bolt.Open(path, mode, options)
return DB{db}, errorsp.WithStacks(err)
} | |
c174579 | return Tx{tx}, errorsp.WithStacks(err)
} | |
c174580 | *bolt.Tx) error {
return errorsp.WithStacks(f(Tx{tx}))
}))
} | |
c174581 | errorsp.WithStacks(tx.Tx.CopyFile(path, mode))
} | |
c174582 | {
return Bucket{b}, nil
}
return Bucket{b}.CreateBucketIfNotExists(folders[1:])
} | |
c174583 |
}
return tx.Bucket(k[:len(k)-1], func(b Bucket) error {
return errorsp.WithStacks(b.Bucket.Delete(k[len(k)-1]))
})
} | |
c174584 | []byte) error {
return errorsp.WithStacks(f(b, bytesp.Slice(k), bytesp.Slice(v)))
}))
})
} | |
c174585 | return errorsp.WithStacksAndMessage(err, "decoding %d bytes value for key %q failed", len(bs), string(k))
}
return errorsp.WithStacks(f(b, k, v))
})
} | |
c174586 | err
}
return errorsp.WithStacks(b.Bucket.Put(k[len(k)-1], v))
} | |
c174587 | Bucket) error {
v := b.Bucket.Get(k[len(k)-1])
if v == nil {
return nil
}
return errorsp.WithStacks(f(bytesp.Slice(v)))
})
} | |
c174588 |
}
if v == nil {
return errorsp.WithStacks(b.Bucket.Delete(k[len(k)-1]))
}
return errorsp.WithStacks(b.Bucket.Put(k[len(k)-1], v))
} | |
c174589 | nil {
return nil
}
}
return errorsp.WithStacks(f(Bucket{bb}))
} | |
c174590 | {
var err error
if bb, err = bb.CreateBucketIfNotExists(fld); err != nil {
return Bucket{}, errorsp.WithStacks(err)
}
}
return Bucket{bb}, nil
} | |
c174591 | func(b Bucket) error {
return errorsp.WithStacks(b.Bucket.Delete(k[len(k)-1]))
})
} | |
c174592 | interface{}
if err := gob.NewDecoder(&bs).Decode(&v); err != nil {
return errorsp.WithStacksAndMessage(err, "decoding %d bytes buffer failed", len(bs))
}
return f(v)
})
} | |
c174593 | b.Bucket.NextSequence()
return s, errorsp.WithStacks(err)
} | |
c174594 | string(bytes.Join(k[:len(k)-1], []byte(" "))))
}
return errorsp.WithStacks(bb.Bucket.Put(k[len(k)-1], v))
} | |
c174595 | err != nil {
return errorsp.WithStacksAndMessage(err, "encoding %+v failed", v)
}
return b.Put(k, bs)
} | |
c174596 | m.db = m.session.DB(m.dbname)
m.c = m.db.C(m.collection)
return nil
} | |
c174597 | %s\n", time.Now(), err.Error()))
return nil
} | |
c174598 | handler.Writer.Write([]byte(handler.Formatter.Format(record) + "\n"))
return err
} | |
c174599 | handler.Formatter.Format(record))
handler.lock.Unlock()
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.