_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q15800 | fatalError | train | func (s *Scanner) fatalError(err error) {
s.cur = -1
s.eof = true
if err != io.EOF {
s.error(s.cpos, err)
}
} | go | {
"resource": ""
} |
q15801 | runeReader | train | func runeReader(r io.Reader) io.RuneReader {
if rr, ok := r.(io.RuneReader); ok {
return rr
}
return bufio.NewReader(r)
} | go | {
"resource": ""
} |
q15802 | cloneState | train | func (p *parser) cloneState() storeDict {
// ==template== {{ if not .Optimize }}
if p.debug {
defer p.out(p.in("cloneState"))
}
// {{ end }} ==template==
state := make(storeDict, len(p.cur.state))
for k, v := range p.cur.state {
if c, ok := v.(Cloner); ok {
state[k] = c.Clone()
} else {
state[k] = v
}
}
return state
} | go | {
"resource": ""
} |
q15803 | init | train | func (r *grammarOptimizer) init(expr Expression) Visitor {
switch expr := expr.(type) {
case *Rule:
// Keep track of current rule, which is processed
r.rule = expr.Name.Val
r.rules[expr.Name.Val] = expr
case *RuleRefExpr:
// Fill ruleUsesRules and ruleUsedByRules for every RuleRefExpr
set(r.ruleUsesRules, r.rule, expr.Name.Val)
set(r.ruleUsedByRules, expr.Name.Val, r.rule)
}
return r
} | go | {
"resource": ""
} |
q15804 | set | train | func set(m map[string]map[string]struct{}, src, dst string) {
if _, ok := m[src]; !ok {
m[src] = make(map[string]struct{})
}
m[src][dst] = struct{}{}
} | go | {
"resource": ""
} |
q15805 | Parse | train | func (p *Parser) Parse(filename string, r io.Reader) (*ast.Grammar, error) {
p.errs.reset()
p.s.Init(filename, r, p.errs.add)
g := p.grammar()
return g, p.errs.err()
} | go | {
"resource": ""
} |
q15806 | NewLogger | train | func NewLogger(component string, options ...zap.Option) Logger {
enc := zap.NewJSONEncoder(
zap.LevelString("log_level"),
zap.MessageKey("message"),
zap.EpochFormatter("timestamp"),
numberLevelFormatter(),
)
origLogger := zap.New(enc, options...)
return &logger{
source: component,
origLogger: origLogger,
Logger: origLogger.With(zap.String("source", component)),
}
} | go | {
"resource": ""
} |
q15807 | NewProxyHealthcheck | train | func NewProxyHealthcheck(userAgent string, heartbeatOK *threading.SharedBoolean, logger logger.Logger) negroni.Handler {
return &proxyHealthcheck{
userAgent: userAgent,
heartbeatOK: heartbeatOK,
logger: logger,
}
} | go | {
"resource": ""
} |
q15808 | NewAccessLog | train | func NewAccessLog(
accessLogger accesslog.AccessLogger,
extraHeadersToLog []string,
logger logger.Logger,
) negroni.Handler {
return &accessLog{
accessLogger: accessLogger,
extraHeadersToLog: extraHeadersToLog,
logger: logger,
}
} | go | {
"resource": ""
} |
q15809 | NewRouteService | train | func NewRouteService(config *routeservice.RouteServiceConfig, routeRegistry registry.Registry, logger logger.Logger) negroni.Handler {
return &RouteService{
config: config,
registry: routeRegistry,
logger: logger,
}
} | go | {
"resource": ""
} |
q15810 | NewZipkin | train | func NewZipkin(enabled bool, headersToLog []string, logger logger.Logger) *Zipkin {
return &Zipkin{
zipkinEnabled: enabled,
headersToLog: headersToLog,
logger: logger,
}
} | go | {
"resource": ""
} |
q15811 | BuildB3SingleHeader | train | func BuildB3SingleHeader(traceID, spanID, sampling, flags, parentSpanID string) string {
if traceID == "" || spanID == "" {
return ""
}
if sampling == "" && flags == "" {
return traceID + "-" + spanID
}
samplingBit := "0"
if flags == "1" {
samplingBit = "d"
} else if s, err := strconv.ParseBool(sampling); err == nil {
if s {
samplingBit = "1"
}
} else {
return traceID + "-" + spanID
}
if parentSpanID == "" {
return traceID + "-" + spanID + "-" + samplingBit
}
return traceID + "-" + spanID + "-" + samplingBit + "-" + parentSpanID
} | go | {
"resource": ""
} |
q15812 | HeadersToLog | train | func (z *Zipkin) HeadersToLog() []string {
if !z.zipkinEnabled {
return z.headersToLog
}
headersToLog := z.headersToLog
if !contains(headersToLog, B3TraceIdHeader) {
headersToLog = append(headersToLog, B3TraceIdHeader)
}
if !contains(headersToLog, B3SpanIdHeader) {
headersToLog = append(headersToLog, B3SpanIdHeader)
}
if !contains(headersToLog, B3ParentSpanIdHeader) {
headersToLog = append(headersToLog, B3ParentSpanIdHeader)
}
if !contains(headersToLog, B3Header) {
headersToLog = append(headersToLog, B3Header)
}
return headersToLog
} | go | {
"resource": ""
} |
q15813 | WriteIntValue | train | func (b *recordBuffer) WriteIntValue(v int) {
_, _ = b.WriteString(strconv.Itoa(v))
b.writeSpace()
} | go | {
"resource": ""
} |
q15814 | WriteDashOrIntValue | train | func (b *recordBuffer) WriteDashOrIntValue(v int) {
if v == 0 {
_, _ = b.WriteString(`"-"`)
b.writeSpace()
} else {
b.WriteIntValue(v)
}
} | go | {
"resource": ""
} |
q15815 | WriteDashOrFloatValue | train | func (b *recordBuffer) WriteDashOrFloatValue(v float64) {
if v >= 0 {
_, _ = b.WriteString(strconv.FormatFloat(v, 'f', -1, 64))
} else {
_, _ = b.WriteString(`"-"`)
}
b.writeSpace()
} | go | {
"resource": ""
} |
q15816 | WriteStringValues | train | func (b *recordBuffer) WriteStringValues(s ...string) {
var t []byte
t = strconv.AppendQuote(t, strings.Join(s, ` `))
_, _ = b.Write(t)
b.writeSpace()
} | go | {
"resource": ""
} |
q15817 | WriteDashOrStringValue | train | func (b *recordBuffer) WriteDashOrStringValue(s string) {
if s == "" {
_, _ = b.WriteString(`"-"`)
b.writeSpace()
} else {
b.WriteStringValues(s)
}
} | go | {
"resource": ""
} |
q15818 | WriteTo | train | func (r *AccessLogRecord) WriteTo(w io.Writer) (int64, error) {
bytesWritten, err := w.Write(r.getRecord())
return int64(bytesWritten), err
} | go | {
"resource": ""
} |
q15819 | ApplicationID | train | func (r *AccessLogRecord) ApplicationID() string {
if r.RouteEndpoint == nil {
return ""
}
return r.RouteEndpoint.ApplicationId
} | go | {
"resource": ""
} |
q15820 | ForwardIO | train | func (f *Forwarder) ForwardIO(clientConn, backendConn io.ReadWriter) int {
done := make(chan bool, 2)
copy := func(dst io.Writer, src io.Reader) {
// don't care about errors here
_, _ = io.Copy(dst, src)
done <- true
}
headerWasRead := make(chan struct{})
headerBytes := &bytes.Buffer{}
teedReader := io.TeeReader(backendConn, headerBytes)
var resp *http.Response
var err error
go func() {
resp, err = http.ReadResponse(bufio.NewReader(teedReader), nil)
headerWasRead <- struct{}{}
}()
select {
case <-headerWasRead:
if err != nil {
return 0
}
case <-time.After(f.BackendReadTimeout):
f.Logger.Error("websocket-forwardio", 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) {
return resp.StatusCode
}
// only now do we start copying body data
go copy(clientConn, backendConn)
go copy(backendConn, clientConn)
<-done
return http.StatusSwitchingProtocols
} | go | {
"resource": ""
} |
q15821 | NewLookup | train | func NewLookup(registry registry.Registry, rep metrics.ProxyReporter, logger logger.Logger) negroni.Handler {
return &lookupHandler{
registry: registry,
reporter: rep,
logger: logger,
}
} | go | {
"resource": ""
} |
q15822 | Trim | train | func (x *topAppsEntry) Trim(t int64) {
var i int
var n int64
// Collect slots that can be removed
l := len(x.t)
for i = 0; i < l; i++ {
if x.t[i].t > t {
break
}
n += x.t[i].n
}
copy(x.t, x.t[i:])
x.t = x.t[0:(l - i)]
x.n -= n
} | go | {
"resource": ""
} |
q15823 | Session | train | func (l *LagerAdapter) Session(task string, data ...lager.Data) lager.Logger {
tmpLogger := l.originalLogger.Session(task)
if data != nil {
tmpLogger = l.originalLogger.With(dataToFields(data)...)
}
return &LagerAdapter{
originalLogger: tmpLogger,
}
} | go | {
"resource": ""
} |
q15824 | Debug | train | func (l *LagerAdapter) Debug(action string, data ...lager.Data) {
l.originalLogger.Debug(action, dataToFields(data)...)
} | go | {
"resource": ""
} |
q15825 | Error | train | func (l *LagerAdapter) Error(action string, err error, data ...lager.Data) {
l.originalLogger.Error(action, appendError(err, dataToFields(data))...)
} | go | {
"resource": ""
} |
q15826 | WithData | train | func (l *LagerAdapter) WithData(data lager.Data) lager.Logger {
return &LagerAdapter{
originalLogger: l.originalLogger.With(dataToFields([]lager.Data{data})...),
}
} | go | {
"resource": ""
} |
q15827 | NewReporter | train | func NewReporter(reporter metrics.ProxyReporter, logger logger.Logger) negroni.Handler {
return &reporterHandler{
reporter: reporter,
logger: logger,
}
} | go | {
"resource": ""
} |
q15828 | ServeHTTP | train | func (rh *reporterHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
next(rw, r)
requestInfo, err := ContextRequestInfo(r)
// logger.Fatal does not cause gorouter to exit 1 but rather throw panic with
// stacktrace in error log
if err != nil {
rh.logger.Fatal("request-info-err", zap.Error(err))
return
}
if requestInfo.RouteEndpoint == nil {
return
}
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(requestInfo.StartedAt),
)
} | go | {
"resource": ""
} |
q15829 | closeIdleConns | train | func (r *Router) closeIdleConns() {
r.closeConnections = true
for conn, _ := range r.idleConns {
conn.Close()
}
} | go | {
"resource": ""
} |
q15830 | Classify | train | func (cg ClassifierGroup) Classify(err error) bool {
for _, classifier := range cg {
if classifier.Classify(err) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q15831 | ServeHTTP | train | func (p *proxyWriterHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
reqInfo, err := ContextRequestInfo(r)
if err != nil {
p.logger.Fatal("request-info-err", zap.Error(err))
return
}
proxyWriter := utils.NewProxyResponseWriter(rw)
reqInfo.ProxyResponseWriter = proxyWriter
next(proxyWriter, r)
} | go | {
"resource": ""
} |
q15832 | Put | train | func (p *Pool) Put(endpoint *Endpoint) PoolPutResult {
p.Lock()
defer p.Unlock()
var result PoolPutResult
e, found := p.index[endpoint.CanonicalAddr()]
if found {
result = UPDATED
if e.endpoint != endpoint {
e.Lock()
defer e.Unlock()
if !e.endpoint.ModificationTag.SucceededBy(&endpoint.ModificationTag) {
return UNMODIFIED
}
oldEndpoint := e.endpoint
e.endpoint = endpoint
if oldEndpoint.PrivateInstanceId != endpoint.PrivateInstanceId {
delete(p.index, oldEndpoint.PrivateInstanceId)
p.index[endpoint.PrivateInstanceId] = e
}
if oldEndpoint.ServerCertDomainSAN == endpoint.ServerCertDomainSAN {
endpoint.SetRoundTripper(oldEndpoint.RoundTripper())
}
}
} 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 = time.Now()
return result
} | go | {
"resource": ""
} |
q15833 | Remove | train | func (p *Pool) Remove(endpoint *Endpoint) bool {
var e *endpointElem
p.Lock()
defer p.Unlock()
l := len(p.endpoints)
if l > 0 {
e = p.index[endpoint.CanonicalAddr()]
if e != nil && e.endpoint.modificationTagSameOrNewer(endpoint) {
p.removeEndpoint(e)
return true
}
}
return false
} | go | {
"resource": ""
} |
q15834 | ValidateMessage | train | func (rm *RegistryMessage) ValidateMessage() bool {
return rm.RouteServiceURL == "" || strings.HasPrefix(rm.RouteServiceURL, "https")
} | go | {
"resource": ""
} |
q15835 | port | train | func (rm *RegistryMessage) port() (uint16, bool, error) {
if rm.TLSPort != 0 {
return rm.TLSPort, true, nil
}
return rm.Port, false, nil
} | go | {
"resource": ""
} |
q15836 | NewSubscriber | train | func NewSubscriber(
mbusClient Client,
routeRegistry registry.Registry,
c *config.Config,
reconnected <-chan Signal,
l logger.Logger,
) *Subscriber {
guid, err := uuid.GenerateUUID()
if err != nil {
l.Fatal("failed-to-generate-uuid", zap.Error(err))
}
return &Subscriber{
mbusClient: mbusClient,
routeRegistry: routeRegistry,
params: startMessageParams{
id: fmt.Sprintf("%d-%s", c.Index, guid),
minimumRegisterIntervalInSeconds: int(c.StartResponseDelayInterval.Seconds()),
pruneThresholdInSeconds: int(c.DropletStaleThreshold.Seconds()),
},
reconnected: reconnected,
natsPendingLimit: c.NatsClientMessageBufferSize,
logger: l,
}
} | go | {
"resource": ""
} |
q15837 | Run | train | func (s *Subscriber) Run(signals <-chan os.Signal, ready chan<- struct{}) error {
s.logger.Info("subscriber-starting")
if s.mbusClient == nil {
return errors.New("subscriber: nil mbus client")
}
err := s.sendStartMessage()
if err != nil {
return err
}
err = s.subscribeToGreetMessage()
if err != nil {
return err
}
s.subscription, err = s.subscribeRoutes()
if err != nil {
return err
}
close(ready)
s.logger.Info("subscriber-started")
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
}
}
} | go | {
"resource": ""
} |
q15838 | Snip | train | func (r *Trie) Snip() {
if r.Pool != nil && r.Pool.IsEmpty() {
r.Pool = nil
}
if (r.Pool != nil && !r.Pool.IsEmpty()) || r.isRoot() || !r.isLeaf() {
return
}
delete(r.Parent.ChildNodes, r.Segment)
r.Parent.Snip()
} | go | {
"resource": ""
} |
q15839 | NewPanicCheck | train | func NewPanicCheck(healthcheck *threading.SharedBoolean, logger logger.Logger) negroni.Handler {
return &panicCheck{
heartbeatOK: healthcheck,
logger: logger,
}
} | go | {
"resource": ""
} |
q15840 | NewHTTPStartStop | train | func NewHTTPStartStop(emitter dropsonde.EventEmitter, logger logger.Logger) negroni.Handler {
return &httpStartStopHandler{
emitter: emitter,
logger: logger,
}
} | go | {
"resource": ""
} |
q15841 | ServeHTTP | train | func (hh *httpStartStopHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
prw, ok := rw.(utils.ProxyResponseWriter)
if !ok {
hh.logger.Fatal("request-info-err", zap.String("error", "ProxyResponseWriter not found"))
return
}
requestID, err := uuid.ParseHex(r.Header.Get(VcapRequestIdHeader))
if 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.Int64(startTime.UnixNano())
err = hh.emitter.Emit(startStopEvent)
if err != nil {
hh.logger.Info("failed-to-emit-startstop-event", zap.Error(err))
}
} | go | {
"resource": ""
} |
q15842 | GetLocalIP | train | func GetLocalIP() (net.IP, error) {
var ip net.IP
addrs, err := net.InterfaceAddrs()
if err != nil {
return ip, err
}
for _, a := range addrs {
if ipnet, ok := a.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
if ipnet.IP.To4() != nil {
ip = ipnet.IP.To4()
} else {
ip = ipnet.IP
break
}
}
}
return ip, nil
} | go | {
"resource": ""
} |
q15843 | HealthyNodes | train | func HealthyNodes() []*Node {
values := knownNodes.values()
filtered := make([]*Node, 0, len(values))
for _, v := range values {
if v.Status() == StatusAlive {
filtered = append(filtered, v)
}
}
return filtered
} | go | {
"resource": ""
} |
q15844 | RemoveNode | train | func RemoveNode(node *Node) (*Node, error) {
if knownNodes.contains(node) {
node.Touch()
_, n, err := knownNodes.delete(node)
logfInfo("Removing host: %s (total=%d live=%d dead=%d)",
node.Address(),
knownNodes.length(),
knownNodes.lengthWithStatus(StatusAlive),
knownNodes.lengthWithStatus(StatusDead))
knownNodesModifiedFlag = true
return n, err
}
return node, nil
} | go | {
"resource": ""
} |
q15845 | GetListenIP | train | func GetListenIP() net.IP {
if listenIP == nil {
listenIP = net.ParseIP(getStringVar(EnvVarListenIP, DefaultListenIP))
}
return listenIP
} | go | {
"resource": ""
} |
q15846 | GetMulticastEnabled | train | func GetMulticastEnabled() bool {
if multicastEnabledString == "" {
multicastEnabledString = strings.ToLower(getStringVar(EnvVarMulticastEnabled, DefaultMulticastEnabled))
}
multicastEnabled = len(multicastEnabledString) > 0 && []rune(multicastEnabledString)[0] == 't'
return multicastEnabled
} | go | {
"resource": ""
} |
q15847 | getIntVar | train | func getIntVar(key string, defaultVal int) int {
valueString := os.Getenv(key)
valueInt := defaultVal
if valueString != "" {
i, err := strconv.Atoi(valueString)
if err != nil {
logfWarn("Failed to parse env property %s: %s is not "+
"an integer. Using default.", key, valueString)
} else {
valueInt = i
}
}
return valueInt
} | go | {
"resource": ""
} |
q15848 | getStringArrayVar | train | func getStringArrayVar(key string, defaultVal string) []string {
valueString := os.Getenv(key)
if valueString == "" {
valueString = defaultVal
}
valueSlice := splitDelimmitedString(valueString, stringListDelimitRegex)
return valueSlice
} | go | {
"resource": ""
} |
q15849 | getStringVar | train | func getStringVar(key string, defaultVal string) string {
valueString := os.Getenv(key)
if valueString == "" {
valueString = defaultVal
}
return valueString
} | go | {
"resource": ""
} |
q15850 | splitDelimmitedString | train | func splitDelimmitedString(str string, regex string) []string {
var result []string
str = strings.TrimSpace(str)
if str != "" {
reg := regexp.MustCompile(regex)
indices := reg.FindAllStringIndex(str, -1)
result = make([]string, len(indices)+1)
lastStart := 0
for i, val := range indices {
result[i] = str[lastStart:val[0]]
lastStart = val[1]
}
result[len(indices)] = str[lastStart:]
// Special case of single empty string
if len(result) == 1 && result[0] == "" {
result = make([]string, 0, 0)
}
}
return result
} | go | {
"resource": ""
} |
q15851 | getListenInterface | train | func getListenInterface() (*net.Interface, error) {
ifaces, err := net.Interfaces()
if err == nil {
for _, iface := range ifaces {
addrs, err := iface.Addrs()
if err != nil {
logfWarn("Can not get addresses of interface %s", iface.Name)
continue
}
for _, addr := range addrs {
ip, _, err := net.ParseCIDR(addr.String())
if err != nil {
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")
} | go | {
"resource": ""
} |
q15852 | multicastAnnounce | train | func multicastAnnounce(addr string) error {
if addr == "" {
addr = guessMulticastAddress()
}
fullAddr := addr + ":" + strconv.FormatInt(int64(GetMulticastPort()), 10)
logInfo("Announcing presence on", fullAddr)
address, err := net.ResolveUDPAddr("udp", fullAddr)
if err != nil {
logError(err)
return err
}
laddr := &net.UDPAddr{
IP: GetListenIP(),
Port: 0,
}
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 multicast from %v to %v", laddr, fullAddr)
if GetMulticastAnnounceIntervalSeconds() > 0 {
time.Sleep(time.Second * time.Duration(GetMulticastAnnounceIntervalSeconds()))
} else {
return nil
}
}
} | go | {
"resource": ""
} |
q15853 | Log | train | func (d DefaultLogger) Log(level LogLevel, a ...interface{}) (n int, err error) {
if level >= logThreshhold {
fmt.Fprint(os.Stderr, prefix(level)+" ")
return fmt.Fprintln(os.Stderr, a...)
}
return 0, nil
} | go | {
"resource": ""
} |
q15854 | Logf | train | func (d DefaultLogger) Logf(level LogLevel, format string, a ...interface{}) (n int, err error) {
if level >= logThreshhold {
return fmt.Fprintf(os.Stderr, prefix(level)+" "+format+"\n", a...)
}
return 0, nil
} | go | {
"resource": ""
} |
q15855 | Address | train | func (n *Node) Address() string {
if n.address == "" {
n.address = nodeAddressString(n.ip, n.port)
}
return n.address
} | go | {
"resource": ""
} |
q15856 | newMessage | train | func newMessage(verb messageVerb, sender *Node, senderHeartbeat uint32) message {
return message{
sender: sender,
senderHeartbeat: senderHeartbeat,
verb: verb,
}
} | go | {
"resource": ""
} |
q15857 | getForwardTo | train | func (m *message) getForwardTo() *messageMember {
if len(m.members) > 0 && m.members[0].status == StatusForwardTo {
return m.members[0]
}
return nil
} | go | {
"resource": ""
} |
q15858 | nSigma | train | func (pd *pingData) nSigma(sigmas float64) float64 {
mean, stddev := pd.data()
return mean + (sigmas * stddev)
} | go | {
"resource": ""
} |
q15859 | data | train | func (pd *pingData) data() (float64, float64) {
if pd.updated {
pd.Lock()
// Calculate the mean
var accumulator float64
for _, d := range pd.pings {
accumulator += float64(d)
}
pd.lastMean = accumulator / float64(len(pd.pings))
// Subtract the mean and square the result; calculcate the mean
accumulator = 0.0 // Reusing accumulator.
for _, d := range pd.pings {
diff := pd.lastMean - float64(d)
accumulator += math.Pow(diff, 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
} | go | {
"resource": ""
} |
q15860 | getByAddress | train | func (m *nodeMap) getByAddress(address string) *Node {
m.RLock()
node, _ := m.nodes[address]
m.RUnlock()
return node
} | go | {
"resource": ""
} |
q15861 | Bytes | train | func (b *Broadcast) Bytes() []byte {
length := len(b.bytes)
bytesCopy := make([]byte, length, length)
copy(bytesCopy, b.bytes)
return bytesCopy
} | go | {
"resource": ""
} |
q15862 | BroadcastBytes | train | func BroadcastBytes(bytes []byte) error {
if len(bytes) > GetMaxBroadcastBytes() {
emsg := fmt.Sprintf(
"broadcast payload length exceeds %d bytes",
GetMaxBroadcastBytes())
return errors.New(emsg)
}
broadcasts.Lock()
bcast := Broadcast{
origin: thisHost,
index: indexCounter,
bytes: bytes,
emitCounter: int8(emitCount())}
broadcasts.m[bcast.Label()] = &bcast
indexCounter++
broadcasts.Unlock()
return nil
} | go | {
"resource": ""
} |
q15863 | receiveBroadcast | train | func receiveBroadcast(broadcast *Broadcast) {
if broadcast == nil {
return
}
err := checkOrigin(broadcast.Origin())
if err != nil {
logWarn(err)
return
}
label := broadcast.Label()
broadcasts.Lock()
_, contains := broadcasts.m[label]
if !contains {
broadcasts.m[label] = broadcast
}
broadcasts.Unlock()
if !contains {
logfInfo("Broadcast [%s]=%s",
label,
string(broadcast.Bytes()))
doBroadcastUpdate(broadcast)
}
} | go | {
"resource": ""
} |
q15864 | checkOrigin | train | func checkOrigin(origin *Node) error {
// normalize to IPv4 or IPv6 to check below
ip := origin.IP()
if ip.To4() != nil {
ip = ip.To4()
}
if (ip[0] == 0) || origin.Port() == 0 {
return errors.New("Received originless broadcast")
}
return nil
} | go | {
"resource": ""
} |
q15865 | SetConfiguration | train | func SetConfiguration(name ConfigName, src interface{}) error {
i, ok := src.(int)
if !ok {
return newError(C.ERROR_INTERNAL_FATAL_ERROR)
}
u := C.uint32_t(i)
return newError(
C.yr_set_configuration(C.YR_CONFIG_NAME(name), unsafe.Pointer(&u)))
} | go | {
"resource": ""
} |
q15866 | GetConfiguration | train | func GetConfiguration(name ConfigName) (interface{}, error) {
var u C.uint32_t
if err := newError(C.yr_get_configuration(
C.YR_CONFIG_NAME(name), unsafe.Pointer(&u)),
); err != nil {
return nil, err
}
return int(u), nil
} | go | {
"resource": ""
} |
q15867 | destroy | train | func (c *scanCallbackContainer) destroy() {
for _, p := range c.cdata {
C.free(p)
}
c.cdata = nil
} | go | {
"resource": ""
} |
q15868 | RuleMatching | train | func (mr *MatchRules) RuleMatching(r *Rule) (abort bool, err error) {
metas := r.Metas()
// convert int to int32 for code that relies on previous behavior
for s := range metas {
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
} | go | {
"resource": ""
} |
q15869 | writeFull | train | func writeFull(w io.Writer, buf []byte) (n int, err error) {
var i int
for n < len(buf) {
i, err = w.Write(buf[n:])
n += i
if err != nil {
break
}
}
return
} | go | {
"resource": ""
} |
q15870 | NewCompiler | train | func NewCompiler() (*Compiler, error) {
var yrCompiler *C.YR_COMPILER
if err := newError(C.yr_compiler_create(&yrCompiler)); err != nil {
return nil, err
}
c := &Compiler{compiler: &compiler{cptr: yrCompiler}}
runtime.SetFinalizer(c.compiler, (*compiler).finalize)
return c, nil
} | go | {
"resource": ""
} |
q15871 | Destroy | train | func (c *Compiler) Destroy() {
c.setCallbackData(nil)
if c.compiler != nil {
c.compiler.finalize()
c.compiler = nil
}
} | go | {
"resource": ""
} |
q15872 | AddString | train | func (c *Compiler) AddString(rules string, namespace string) (err error) {
if c.cptr.errors != 0 {
return errors.New("Compiler cannot be used after parse error")
}
var ns *C.char
if namespace != "" {
ns = C.CString(namespace)
defer C.free(unsafe.Pointer(ns))
}
crules := C.CString(rules)
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_compiler_get_error_message(
c.cptr, (*C.char)(unsafe.Pointer(&buf[0])), 1024))
err = errors.New(msg)
}
keepAlive(c)
return
} | go | {
"resource": ""
} |
q15873 | GetRules | train | func (c *Compiler) GetRules() (*Rules, error) {
if c.cptr.errors != 0 {
return nil, errors.New("Compiler cannot be used after parse error")
}
var yrRules *C.YR_RULES
if err := newError(C.yr_compiler_get_rules(c.cptr, &yrRules)); err != nil {
return nil, err
}
r := &Rules{rules: &rules{cptr: yrRules}}
runtime.SetFinalizer(r.rules, (*rules).finalize)
keepAlive(c)
return r, nil
} | go | {
"resource": ""
} |
q15874 | MustCompile | train | func MustCompile(rules string, variables map[string]interface{}) (r *Rules) {
r, err := Compile(rules, variables)
if err != nil {
panic(err)
}
return
} | go | {
"resource": ""
} |
q15875 | DisableIncludes | train | func (c *Compiler) DisableIncludes() {
C.yr_compiler_set_include_callback(c.compiler.cptr, nil, nil, nil)
c.setCallbackData(nil)
keepAlive(c)
return
} | go | {
"resource": ""
} |
q15876 | ScanMem | train | func (r *Rules) ScanMem(buf []byte, flags ScanFlags, timeout time.Duration) (matches []MatchRule, err error) {
cb := MatchRules{}
err = r.ScanMemWithCallback(buf, flags, timeout, &cb)
matches = cb
return
} | go | {
"resource": ""
} |
q15877 | ScanMemWithCallback | train | func (r *Rules) ScanMemWithCallback(buf []byte, flags ScanFlags, timeout time.Duration, cb ScanCallback) (err error) {
var ptr *C.uint8_t
if len(buf) > 0 {
ptr = (*C.uint8_t)(unsafe.Pointer(&(buf[0])))
}
cbc := &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
} | go | {
"resource": ""
} |
q15878 | ScanFile | train | func (r *Rules) ScanFile(filename string, flags ScanFlags, timeout time.Duration) (matches []MatchRule, err error) {
cb := MatchRules{}
err = r.ScanFileWithCallback(filename, flags, timeout, &cb)
matches = cb
return
} | go | {
"resource": ""
} |
q15879 | ScanFileWithCallback | train | func (r *Rules) ScanFileWithCallback(filename string, flags ScanFlags, timeout time.Duration, cb ScanCallback) (err error) {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
cbc := &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
} | go | {
"resource": ""
} |
q15880 | ScanProc | train | func (r *Rules) ScanProc(pid int, flags ScanFlags, timeout time.Duration) (matches []MatchRule, err error) {
cb := MatchRules{}
err = r.ScanProcWithCallback(pid, flags, timeout, &cb)
matches = cb
return
} | go | {
"resource": ""
} |
q15881 | ScanProcWithCallback | train | func (r *Rules) ScanProcWithCallback(pid int, flags ScanFlags, timeout time.Duration, cb ScanCallback) (err error) {
cbc := &scanCallbackContainer{ScanCallback: cb}
defer cbc.destroy()
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
} | go | {
"resource": ""
} |
q15882 | Save | train | func (r *Rules) Save(filename string) (err error) {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
err = newError(C.yr_rules_save(r.cptr, cfilename))
keepAlive(r)
return
} | go | {
"resource": ""
} |
q15883 | LoadRules | train | func LoadRules(filename string) (*Rules, error) {
r := &Rules{rules: &rules{}}
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
if err := newError(C.yr_rules_load(cfilename,
&(r.rules.cptr))); err != nil {
return nil, err
}
runtime.SetFinalizer(r.rules, (*rules).finalize)
return r, nil
} | go | {
"resource": ""
} |
q15884 | Destroy | train | func (r *Rules) Destroy() {
if r.rules != nil {
r.rules.finalize()
r.rules = nil
}
} | go | {
"resource": ""
} |
q15885 | GetRules | train | func (r *Rules) GetRules() (rv []Rule) {
for p := unsafe.Pointer(r.cptr.rules_list_head); (*C.YR_RULE)(p).g_flags&C.RULE_GFLAGS_NULL == 0; p = unsafe.Pointer(uintptr(p) + unsafe.Sizeof(*r.cptr.rules_list_head)) {
rv = append(rv, Rule{(*C.YR_RULE)(p)})
}
return
} | go | {
"resource": ""
} |
q15886 | AddFile | train | func (c *Compiler) AddFile(file *os.File, namespace string) (err error) {
if c.cptr.errors != 0 {
return errors.New("Compiler cannot be used after parse error")
}
var ns *C.char
if namespace != "" {
ns = C.CString(namespace)
defer C.free(unsafe.Pointer(ns))
}
filename := C.CString(file.Name())
defer C.free(unsafe.Pointer(filename))
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_get_error_message(
c.cptr, (*C.char)(unsafe.Pointer(&buf[0])), 1024))
err = errors.New(msg)
}
keepAlive(c)
return
} | go | {
"resource": ""
} |
q15887 | makecbPool | train | func makecbPool(n int) *cbPool {
p := &cbPool{
indices: make([]int, 0),
objects: make([]interface{}, n),
}
hdr := (*reflect.SliceHeader)(unsafe.Pointer(&p.indices))
hdr.Data = uintptr(C.calloc(C.size_t(n), C.size_t(unsafe.Sizeof(int(0)))))
hdr.Len = n
runtime.SetFinalizer(p, (*cbPool).Finalize)
return p
} | go | {
"resource": ""
} |
q15888 | Put | train | func (p *cbPool) Put(obj interface{}) unsafe.Pointer {
p.m.Lock()
defer p.m.Unlock()
for id, val := range p.indices {
if val != 0 {
continue
}
p.indices[id] = id + 1
p.objects[id] = obj
return unsafe.Pointer(&p.indices[id])
}
panic("cbPool storage exhausted")
} | go | {
"resource": ""
} |
q15889 | Get | train | func (p *cbPool) Get(ptr unsafe.Pointer) interface{} {
p.m.RLock()
defer p.m.RUnlock()
p.checkPointer(ptr)
id := *(*int)(ptr) - 1
if id == -1 {
panic("Attempt to get nonexistent value from pool")
}
return p.objects[id]
} | go | {
"resource": ""
} |
q15890 | Delete | train | func (p *cbPool) Delete(ptr unsafe.Pointer) {
p.m.Lock()
defer p.m.Unlock()
p.checkPointer(ptr)
id := *(*int)(ptr) - 1
if id == -1 {
panic("Attempt to delete nonexistent value from pool")
}
p.indices[id] = 0
p.objects[id] = nil
return
} | go | {
"resource": ""
} |
q15891 | ScanFileDescriptor | train | func (r *Rules) ScanFileDescriptor(fd uintptr, flags ScanFlags, timeout time.Duration) (matches []MatchRule, err error) {
cb := MatchRules{}
err = r.ScanFileDescriptorWithCallback(fd, flags, timeout, &cb)
matches = cb
return
} | go | {
"resource": ""
} |
q15892 | ScanFileDescriptorWithCallback | train | func (r *Rules) ScanFileDescriptorWithCallback(fd uintptr, flags ScanFlags, timeout time.Duration, cb ScanCallback) (err error) {
cbc := &scanCallbackContainer{ScanCallback: cb}
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
} | go | {
"resource": ""
} |
q15893 | Write | train | func (r *Rules) Write(wr io.Writer) (err error) {
id := callbackData.Put(wr)
defer callbackData.Delete(id)
stream := C.YR_STREAM{
write: C.YR_STREAM_WRITE_FUNC(C.streamWrite),
// The complaint from go vet about possible misuse of
// unsafe.Pointer is wrong: 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
} | go | {
"resource": ""
} |
q15894 | ReadRules | train | func ReadRules(rd io.Reader) (*Rules, error) {
r := &Rules{rules: &rules{}}
id := callbackData.Put(rd)
defer callbackData.Delete(id)
stream := C.YR_STREAM{
read: C.YR_STREAM_READ_FUNC(C.streamRead),
// The complaint from go vet about possible misuse of
// unsafe.Pointer is wrong, 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
} | go | {
"resource": ""
} |
q15895 | Identifier | train | func (r *Rule) Identifier() string {
return C.GoString(C.rule_identifier(r.cptr))
} | go | {
"resource": ""
} |
q15896 | Namespace | train | func (r *Rule) Namespace() string {
return C.GoString(C.rule_namespace(r.cptr))
} | go | {
"resource": ""
} |
q15897 | Tags | train | func (r *Rule) Tags() (tags []string) {
var size C.int
C.rule_tags(r.cptr, nil, &size)
if size == 0 {
return
}
tagptrs := make([]*C.char, int(size))
C.rule_tags(r.cptr, &tagptrs[0], &size)
for _, t := range tagptrs {
tags = append(tags, C.GoString(t))
}
return
} | go | {
"resource": ""
} |
q15898 | Metas | train | func (r *Rule) Metas() (metas map[string]interface{}) {
metas = make(map[string]interface{})
var size C.int
C.rule_metas(r.cptr, nil, &size)
if size == 0 {
return
}
mptrs := make([]*C.YR_META, int(size))
C.rule_metas(r.cptr, &mptrs[0], &size)
for _, m := range mptrs {
var cid, cstr *C.char
C.meta_get(m, &cid, &cstr)
id := C.GoString(cid)
switch m._type {
case C.META_TYPE_NULL:
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
} | go | {
"resource": ""
} |
q15899 | Strings | train | func (r *Rule) Strings() (strs []String) {
var size C.int
C.rule_strings(r.cptr, nil, &size)
if size == 0 {
return
}
ptrs := make([]*C.YR_STRING, int(size))
C.rule_strings(r.cptr, &ptrs[0], &size)
for _, ptr := range ptrs {
strs = append(strs, String{ptr})
}
return
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.