id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c15800 | != io.EOF {
s.error(s.cpos, err)
}
} | |
c15801 | ok := r.(io.RuneReader); ok {
return rr
}
return bufio.NewReader(r)
} | |
c15802 |
if c, ok := v.(Cloner); ok {
state[k] = c.Clone()
} else {
state[k] = v
}
}
return state
} | |
c15803 | every RuleRefExpr
set(r.ruleUsesRules, r.rule, expr.Name.Val)
set(r.ruleUsedByRules, expr.Name.Val, r.rule)
}
return r
} | |
c15804 | m[src] = make(map[string]struct{})
}
m[src][dst] = struct{}{}
} | |
c15805 | p.s.Init(filename, r, p.errs.add)
g := p.grammar()
return g, p.errs.err()
} | |
c15806 | numberLevelFormatter(),
)
origLogger := zap.New(enc, options...)
return &logger{
source: component,
origLogger: origLogger,
Logger: origLogger.With(zap.String("source", component)),
}
} | |
c15807 | negroni.Handler {
return &proxyHealthcheck{
userAgent: userAgent,
heartbeatOK: heartbeatOK,
logger: logger,
}
} | |
c15808 | accessLogger,
extraHeadersToLog: extraHeadersToLog,
logger: logger,
}
} | |
c15809 | config: config,
registry: routeRegistry,
logger: logger,
}
} | |
c15810 | headersToLog: headersToLog,
logger: logger,
}
} | |
c15811 | }
} else {
return traceID + "-" + spanID
}
if parentSpanID == "" {
return traceID + "-" + spanID + "-" + samplingBit
}
return traceID + "-" + spanID + "-" + samplingBit + "-" + parentSpanID
} | |
c15812 | if !contains(headersToLog, B3ParentSpanIdHeader) {
headersToLog = append(headersToLog, B3ParentSpanIdHeader)
}
if !contains(headersToLog, B3Header) {
headersToLog = append(headersToLog, B3Header)
}
return headersToLog
} | |
c15813 | = b.WriteString(strconv.Itoa(v))
b.writeSpace()
} | |
c15814 | b.writeSpace()
} else {
b.WriteIntValue(v)
}
} | |
c15815 | = b.WriteString(strconv.FormatFloat(v, 'f', -1, 64))
} else {
_, _ = b.WriteString(`"-"`)
}
b.writeSpace()
} | |
c15816 | strconv.AppendQuote(t, strings.Join(s, ` `))
_, _ = b.Write(t)
b.writeSpace()
} | |
c15817 |
b.writeSpace()
} else {
b.WriteStringValues(s)
}
} | |
c15818 | := w.Write(r.getRecord())
return int64(bytesWritten), err
} | |
c15819 | }
return r.RouteEndpoint.ApplicationId
} | |
c15820 | zap.Error(errors.New("timeout waiting for http response from backend")))
return 0
}
// we always write the header...
_, err = io.Copy(clientConn, headerBytes) // don't care about errors
if err != nil {
f.Logger.Error("websocket-copy", zap.Error(err))
return 0
}
if !isValidWebsocketResponse(resp) {
retu... | |
c15821 | negroni.Handler {
return &lookupHandler{
registry: registry,
reporter: rep,
logger: logger,
}
} | |
c15822 | > t {
break
}
n += x.t[i].n
}
copy(x.t, x.t[i:])
x.t = x.t[0:(l - i)]
x.n -= n
} | |
c15823 | tmpLogger = l.originalLogger.With(dataToFields(data)...)
}
return &LagerAdapter{
originalLogger: tmpLogger,
}
} | |
c15824 | ...lager.Data) {
l.originalLogger.Debug(action, dataToFields(data)...)
} | |
c15825 | l.originalLogger.Error(action, appendError(err, dataToFields(data))...)
} | |
c15826 | l.originalLogger.With(dataToFields([]lager.Data{data})...),
}
} | |
c15827 | &reporterHandler{
reporter: reporter,
logger: logger,
}
} | |
c15828 |
proxyWriter := rw.(utils.ProxyResponseWriter)
rh.reporter.CaptureRoutingResponse(proxyWriter.Status())
if requestInfo.StoppedAt.Equal(time.Time{}) {
return
}
rh.reporter.CaptureRoutingResponseLatency(
requestInfo.RouteEndpoint, proxyWriter.Status(),
requestInfo.StartedAt, requestInfo.StoppedAt.Sub(request... | |
c15829 | = true
for conn, _ := range r.idleConns {
conn.Close()
}
} | |
c15830 | := range cg {
if classifier.Classify(err) {
return true
}
}
return false
} | |
c15831 | if err != nil {
p.logger.Fatal("request-info-err", zap.Error(err))
return
}
proxyWriter := utils.NewProxyResponseWriter(rw)
reqInfo.ProxyResponseWriter = proxyWriter
next(proxyWriter, r)
} | |
c15832 | }
}
} else {
result = ADDED
e = &endpointElem{
endpoint: endpoint,
index: len(p.endpoints),
maxConnsPerBackend: p.maxConnsPerBackend,
}
p.endpoints = append(p.endpoints, e)
p.index[endpoint.CanonicalAddr()] = e
p.index[endpoint.PrivateInstanceId] = e
}
e.updated = t... | |
c15833 | e.endpoint.modificationTagSameOrNewer(endpoint) {
p.removeEndpoint(e)
return true
}
}
return false
} | |
c15834 | strings.HasPrefix(rm.RouteServiceURL, "https")
} | |
c15835 | rm.TLSPort, true, nil
}
return rm.Port, false, nil
} | |
c15836 | fmt.Sprintf("%d-%s", c.Index, guid),
minimumRegisterIntervalInSeconds: int(c.StartResponseDelayInterval.Seconds()),
pruneThresholdInSeconds: int(c.DropletStaleThreshold.Seconds()),
},
reconnected: reconnected,
natsPendingLimit: c.NatsClientMessageBufferSize,
logger: l,
... | |
c15837 | for {
select {
case <-s.reconnected:
err := s.sendStartMessage()
if err != nil {
s.logger.Error("failed-to-send-start-message", zap.Error(err))
}
case <-signals:
s.logger.Info("exited")
return nil
}
}
} | |
c15838 |
return
}
delete(r.Parent.ChildNodes, r.Segment)
r.Parent.Snip()
} | |
c15839 | negroni.Handler {
return &panicCheck{
heartbeatOK: healthcheck,
logger: logger,
}
} | |
c15840 | &httpStartStopHandler{
emitter: emitter,
logger: logger,
}
} | |
c15841 | err != nil {
hh.logger.Fatal("start-stop-handler-err", zap.String("error", "X-Vcap-Request-Id not found"))
return
}
startTime := time.Now()
next(rw, r)
startStopEvent := factories.NewHttpStartStop(r, prw.Status(), int64(prw.Size()), events.PeerType_Server, requestID)
startStopEvent.StartTimestamp = proto.I... | |
c15842 | ipnet.IP.To4() != nil {
ip = ipnet.IP.To4()
} else {
ip = ipnet.IP
break
}
}
}
return ip, nil
} | |
c15843 |
for _, v := range values {
if v.Status() == StatusAlive {
filtered = append(filtered, v)
}
}
return filtered
} | |
c15844 | (total=%d live=%d dead=%d)",
node.Address(),
knownNodes.length(),
knownNodes.lengthWithStatus(StatusAlive),
knownNodes.lengthWithStatus(StatusDead))
knownNodesModifiedFlag = true
return n, err
}
return node, nil
} | |
c15845 | = net.ParseIP(getStringVar(EnvVarListenIP, DefaultListenIP))
}
return listenIP
} | |
c15846 | DefaultMulticastEnabled))
}
multicastEnabled = len(multicastEnabledString) > 0 && []rune(multicastEnabledString)[0] == 't'
return multicastEnabled
} | |
c15847 | %s is not "+
"an integer. Using default.", key, valueString)
} else {
valueInt = i
}
}
return valueInt
} | |
c15848 | == "" {
valueString = defaultVal
}
valueSlice := splitDelimmitedString(valueString, stringListDelimitRegex)
return valueSlice
} | |
c15849 |
valueString = defaultVal
}
return valueString
} | |
c15850 | result[len(indices)] = str[lastStart:]
// Special case of single empty string
if len(result) == 1 && result[0] == "" {
result = make([]string, 0, 0)
}
}
return result
} | |
c15851 |
continue
}
if ip.String() == GetListenIP().String() {
logfInfo("Found interface with listen IP: %s", iface.Name)
return &iface, nil
}
}
}
}
return nil, errors.New("Could not determine the interface of the listen IP address")
} | |
c15852 |
}
for {
c, err := net.DialUDP("udp", laddr, address)
if err != nil {
logError(err)
return err
}
// Compose and send the multicast announcement
msgBytes := encodeMulticastAnnounceBytes()
_, err = c.Write(msgBytes)
if err != nil {
logError(err)
return err
}
logfTrace("Sent announcement m... | |
c15853 | level >= logThreshhold {
fmt.Fprint(os.Stderr, prefix(level)+" ")
return fmt.Fprintln(os.Stderr, a...)
}
return 0, nil
} | |
c15854 | return fmt.Fprintf(os.Stderr, prefix(level)+" "+format+"\n", a...)
}
return 0, nil
} | |
c15855 | n.address = nodeAddressString(n.ip, n.port)
}
return n.address
} | |
c15856 | senderHeartbeat: senderHeartbeat,
verb: verb,
}
} | |
c15857 | == StatusForwardTo {
return m.members[0]
}
return nil
} | |
c15858 | {
mean, stddev := pd.data()
return mean + (sigmas * stddev)
} | |
c15859 | 2.0)
}
squareDiffMean := accumulator / float64(len(pd.pings))
// Sqrt the square diffs mean and we have our stddev
pd.lastStddev = math.Sqrt(squareDiffMean)
pd.updated = false
pd.Unlock()
}
return pd.lastMean, pd.lastStddev
} | |
c15860 | {
m.RLock()
node, _ := m.nodes[address]
m.RUnlock()
return node
} | |
c15861 |
bytesCopy := make([]byte, length, length)
copy(bytesCopy, b.bytes)
return bytesCopy
} | |
c15862 | bytes,
emitCounter: int8(emitCount())}
broadcasts.m[bcast.Label()] = &bcast
indexCounter++
broadcasts.Unlock()
return nil
} | |
c15863 | }
broadcasts.Unlock()
if !contains {
logfInfo("Broadcast [%s]=%s",
label,
string(broadcast.Bytes()))
doBroadcastUpdate(broadcast)
}
} | |
c15864 | 0) || origin.Port() == 0 {
return errors.New("Received originless broadcast")
}
return nil
} | |
c15865 | newError(
C.yr_set_configuration(C.YR_CONFIG_NAME(name), unsafe.Pointer(&u)))
} | |
c15866 |
C.YR_CONFIG_NAME(name), unsafe.Pointer(&u)),
); err != nil {
return nil, err
}
return int(u), nil
} | |
c15867 |
C.free(p)
}
c.cdata = nil
} | |
c15868 |
if i, ok := metas[s].(int); ok {
metas[s] = int32(i)
}
}
*mr = append(*mr, MatchRule{
Rule: r.Identifier(),
Namespace: r.Namespace(),
Tags: r.Tags(),
Meta: metas,
Strings: r.getMatchStrings(),
})
return
} | |
c15869 | err = w.Write(buf[n:])
n += i
if err != nil {
break
}
}
return
} | |
c15870 | != nil {
return nil, err
}
c := &Compiler{compiler: &compiler{cptr: yrCompiler}}
runtime.SetFinalizer(c.compiler, (*compiler).finalize)
return c, nil
} | |
c15871 |
if c.compiler != nil {
c.compiler.finalize()
c.compiler = nil
}
} | |
c15872 | defer C.free(unsafe.Pointer(crules))
id := callbackData.Put(c)
defer callbackData.Delete(id)
C.yr_compiler_set_callback(c.cptr, C.YR_COMPILER_CALLBACK_FUNC(C.compilerCallback), id)
numErrors := int(C.yr_compiler_add_string(c.cptr, crules, ns))
if numErrors > 0 {
var buf [1024]C.char
msg := C.GoString(C.yr_com... | |
c15873 |
r := &Rules{rules: &rules{cptr: yrRules}}
runtime.SetFinalizer(r.rules, (*rules).finalize)
keepAlive(c)
return r, nil
} | |
c15874 | (r *Rules) {
r, err := Compile(rules, variables)
if err != nil {
panic(err)
}
return
} | |
c15875 | c.setCallbackData(nil)
keepAlive(c)
return
} | |
c15876 | err = r.ScanMemWithCallback(buf, flags, timeout, &cb)
matches = cb
return
} | |
c15877 | &scanCallbackContainer{ScanCallback: cb}
defer cbc.destroy()
id := callbackData.Put(cbc)
defer callbackData.Delete(id)
err = newError(C.yr_rules_scan_mem(
r.cptr,
ptr,
C.size_t(len(buf)),
C.int(flags),
C.YR_CALLBACK_FUNC(C.scanCallbackFunc),
id,
C.int(timeout/time.Second)))
keepAlive(r)
return
} | |
c15878 | err = r.ScanFileWithCallback(filename, flags, timeout, &cb)
matches = cb
return
} | |
c15879 | &scanCallbackContainer{ScanCallback: cb}
defer cbc.destroy()
id := callbackData.Put(cbc)
defer callbackData.Delete(id)
err = newError(C.yr_rules_scan_file(
r.cptr,
cfilename,
C.int(flags),
C.YR_CALLBACK_FUNC(C.scanCallbackFunc),
id,
C.int(timeout/time.Second)))
keepAlive(r)
return
} | |
c15880 | = r.ScanProcWithCallback(pid, flags, timeout, &cb)
matches = cb
return
} | |
c15881 |
id := callbackData.Put(cbc)
defer callbackData.Delete(id)
err = newError(C.yr_rules_scan_proc(
r.cptr,
C.int(pid),
C.int(flags),
C.YR_CALLBACK_FUNC(C.scanCallbackFunc),
id,
C.int(timeout/time.Second)))
keepAlive(r)
return
} | |
c15882 | err = newError(C.yr_rules_save(r.cptr, cfilename))
keepAlive(r)
return
} | |
c15883 | != nil {
return nil, err
}
runtime.SetFinalizer(r.rules, (*rules).finalize)
return r, nil
} | |
c15884 | r.rules.finalize()
r.rules = nil
}
} | |
c15885 | unsafe.Pointer(uintptr(p) + unsafe.Sizeof(*r.cptr.rules_list_head)) {
rv = append(rv, Rule{(*C.YR_RULE)(p)})
}
return
} | |
c15886 | id := callbackData.Put(c)
defer callbackData.Delete(id)
C.yr_compiler_set_callback(c.cptr, C.YR_COMPILER_CALLBACK_FUNC(C.compilerCallback), id)
numErrors := int(C.yr_compiler_add_fd(c.cptr, (C.YR_FILE_DESCRIPTOR)(file.Fd()), ns, filename))
if numErrors > 0 {
var buf [1024]C.char
msg := C.GoString(C.yr_compiler... | |
c15887 | C.size_t(unsafe.Sizeof(int(0)))))
hdr.Len = n
runtime.SetFinalizer(p, (*cbPool).Finalize)
return p
} | |
c15888 | = id + 1
p.objects[id] = obj
return unsafe.Pointer(&p.indices[id])
}
panic("cbPool storage exhausted")
} | |
c15889 | == -1 {
panic("Attempt to get nonexistent value from pool")
}
return p.objects[id]
} | |
c15890 | id := *(*int)(ptr) - 1
if id == -1 {
panic("Attempt to delete nonexistent value from pool")
}
p.indices[id] = 0
p.objects[id] = nil
return
} | |
c15891 | err = r.ScanFileDescriptorWithCallback(fd, flags, timeout, &cb)
matches = cb
return
} | |
c15892 | defer cbc.destroy()
id := callbackData.Put(cbc)
defer callbackData.Delete(id)
err = newError(C._yr_rules_scan_fd(
r.cptr,
C.int(fd),
C.int(flags),
C.YR_CALLBACK_FUNC(C.scanCallbackFunc),
id,
C.int(timeout/time.Second)))
keepAlive(r)
return
} | |
c15893 | user_data will be interpreted as
// an uintptr on the other side of the callback
user_data: id,
}
err = newError(C.yr_rules_save_stream(r.cptr, &stream))
keepAlive(r)
return
} | |
c15894 | see above.
user_data: id,
}
if err := newError(C.yr_rules_load_stream(&stream,
&(r.rules.cptr))); err != nil {
return nil, err
}
runtime.SetFinalizer(r.rules, (*rules).finalize)
return r, nil
} | |
c15895 | {
return C.GoString(C.rule_identifier(r.cptr))
} | |
c15896 | {
return C.GoString(C.rule_namespace(r.cptr))
} | |
c15897 | &tagptrs[0], &size)
for _, t := range tagptrs {
tags = append(tags, C.GoString(t))
}
return
} | |
c15898 | metas[id] = nil
case C.META_TYPE_STRING:
metas[id] = C.GoString(cstr)
case C.META_TYPE_INTEGER:
metas[id] = int(m.integer)
case C.META_TYPE_BOOLEAN:
metas[id] = m.integer != 0
}
}
return
} | |
c15899 | C.rule_strings(r.cptr, &ptrs[0], &size)
for _, ptr := range ptrs {
strs = append(strs, String{ptr})
}
return
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.