id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c27300 | self.runtime.toValue(self.runtime.newSyntaxError(self.runtime.toValue(message)))
} | |
c27301 | self.runtime.toValue(self.runtime.newTypeError(self.runtime.toValue(message)))
} | |
c27302 | self.ContextSkip(limit, true)
} | |
c27303 | ctx.Symbols = make(map[string]Value)
ctx.Stacktrace = append(ctx.Stacktrace, frame.location())
for limit != 0 {
// Get variables
stash := scope.lexical
for {
for _, name := range getStashProperties(stash) {
if _, ok := ctx.Symbols[name]; !ok {
ctx.Symbols[name] = stash.getBinding(name, true)
}
... | |
c27304 |
if !value.safe() {
value = Value{}
}
return value, err
} | |
c27305 | func(name string) bool {
keys = append(keys, name)
return true
})
return keys
} | |
c27306 | context.Context, p interface{}) error {
return f(p)
})
}
} | |
c27307 | *options) {
o.max = maxRetries
}}
} | |
c27308 | = BackoffFuncContext(func(ctx context.Context, attempt uint) time.Duration {
return bf(attempt)
})
}}
} | |
c27309 | func(o *options) {
o.backoffFunc = bf
}}
} | |
c27310 | := logrus.Fields{
"grpc.code": code.String(),
durField: durVal,
}
if err != nil {
fields[logrus.ErrorKey] = err
}
levelLogf(
ctx_logrus.Extract(newCtx).WithFields(fields), // re-extract logger from newCtx, as it may have extra fields that changed in the holder.
level,
"finished unary call... | |
c27311 | durField, durVal := o.durationFunc(time.Since(startTime))
fields := logrus.Fields{
"grpc.code": code.String(),
durField: durVal,
}
if err != nil {
fields[logrus.ErrorKey] = err
}
levelLogf(
ctx_logrus.Extract(newCtx).WithFields(fields), // re-extract logger from newCtx, as it may have extra f... | |
c27312 | clientStream, err := streamer(ctx, desc, cc, method, opts...)
logFinalClientLine(o, logger.With(fields...), startTime, err, "finished client streaming call")
return clientStream, err
}
} | |
c27313 | {
return func(o *options) {
o.requestFieldsFunc = f
o.requestFieldsFromInitial = true
}
} | |
c27314 |
if !ok {
return NiceMD(metadata.Pairs())
}
return NiceMD(md)
} | |
c27315 |
if !ok {
return NiceMD(metadata.Pairs())
}
return NiceMD(md)
} | |
c27316 | {
return metadata.NewOutgoingContext(ctx, metadata.MD(m))
} | |
c27317 | {
return metadata.NewIncomingContext(ctx, metadata.MD(m))
} | |
c27318 | "")
vv, ok := m[k]
if !ok {
return ""
}
return vv[0]
} | |
c27319 | encodeKeyValue(key, "")
delete(m, k)
return m
} | |
c27320 | := encodeKeyValue(key, value)
m[k] = []string{v}
return m
} | |
c27321 | := encodeKeyValue(key, value)
m[k] = append(m[k], v)
return m
} | |
c27322 | return
}
for k, v := range fields {
l.fields[k] = v
}
} | |
c27323 | range tags.Values() {
fields[k] = v
}
// Add logrus fields added until now.
for k, v := range l.fields {
fields[k] = v
}
return l.logger.WithFields(fields)
} | |
c27324 | fields: logrus.Fields{},
}
return context.WithValue(ctx, ctxLoggerKey, l)
} | |
c27325 | clientStream, err := streamer(ctx, desc, cc, method, opts...)
logFinalClientLine(o, entry.WithFields(fields), startTime, err, "finished client streaming call")
return clientStream, err
}
} | |
c27326 | func(o *options) {
o.tracer = tracer
}
} | |
c27327 | := recover(); r != nil {
err = recoverFrom(ctx, r, o.recoveryHandlerFunc)
}
}()
return handler(ctx, req)
}
} | |
c27328 | recover(); r != nil {
err = recoverFrom(stream.Context(), r, o.recoveryHandlerFunc)
}
}()
return handler(srv, stream)
}
} | |
c27329 | func(o *options) {
o.shouldLog = f
}
} | |
c27330 | func(o *options) {
o.codeFunc = f
}
} | |
c27331 |
return zap.WarnLevel
case codes.OutOfRange:
return zap.WarnLevel
case codes.Unimplemented:
return zap.ErrorLevel
case codes.Internal:
return zap.ErrorLevel
case codes.Unavailable:
return zap.WarnLevel
case codes.DataLoss:
return zap.ErrorLevel
default:
return zap.ErrorLevel
}
} | |
c27332 | {
return zap.Float32("grpc.time_ms", durationToMilliseconds(duration))
} | |
c27333 | // re-extract logger from newCtx, as it may have extra fields that changed in the holder.
ctx_zap.Extract(newCtx).Check(level, "finished unary call with code "+code.String()).Write(
zap.Error(err),
zap.String("grpc.code", code.String()),
o.durationFunc(time.Since(startTime)),
)
return resp, err
}
} | |
c27334 | := o.levelFunc(code)
// re-extract logger from newCtx, as it may have extra fields that changed in the holder.
ctx_zap.Extract(newCtx).Check(level, "finished streaming call with code "+code.String()).Write(
zap.Error(err),
zap.String("grpc.code", code.String()),
o.durationFunc(time.Since(startTime)),
)... | |
c27335 | grpc.UnaryInterceptor(ChainUnaryServer(interceptors...))
} | |
c27336 | grpc.StreamInterceptor(ChainStreamServer(interceptors...))
} | |
c27337 | req, reply, cc, opts...)
}
newCtx, clientSpan := newClientSpanFromContext(parentCtx, o.tracer, method)
err := invoker(newCtx, method, req, reply, cc, opts...)
finishClientSpan(clientSpan, err)
return err
}
} | |
c27338 |
newCtx, clientSpan := newClientSpanFromContext(parentCtx, o.tracer, method)
clientStream, err := streamer(newCtx, desc, cc, method, opts...)
if err != nil {
finishClientSpan(clientSpan, err)
return nil, err
}
return &tracedClientStream{ClientStream: clientStream, clientSpan: clientSpan}, nil
}
} | |
c27339 |
return logrus.WarnLevel
case codes.OutOfRange:
return logrus.WarnLevel
case codes.Unimplemented:
return logrus.ErrorLevel
case codes.Internal:
return logrus.ErrorLevel
case codes.Unavailable:
return logrus.WarnLevel
case codes.DataLoss:
return logrus.ErrorLevel
default:
return logrus.ErrorLevel
}
... | |
c27340 |
// The metadata object is a multimap, and previous values may exist, but for opentracing headers, we do not append
// we just override.
m[encodedKey] = []string{encodedVal}
} | |
c27341 | nil {
return err
}
} else {
return fmt.Errorf("failed decoding opentracing from gRPC metadata: %v", err)
}
}
}
return nil
} | |
c27342 |
if !ok || l == nil {
return
}
l.fields = append(l.fields, fields...)
} | |
c27343 | fields added until now.
fields = append(fields, l.fields...)
return l.logger.With(fields...)
} | |
c27344 | tags.Values() {
fields = append(fields, zap.Any(k, v))
}
return fields
} | |
c27345 |
}
return context.WithValue(ctx, ctxMarkerKey, l)
} | |
c27346 | req)
}
newCtx, serverSpan := newServerSpanFromInbound(ctx, o.tracer, info.FullMethod)
resp, err := handler(newCtx, req)
finishServerSpan(ctx, serverSpan, err)
return resp, err
}
} | |
c27347 | o.tracer, info.FullMethod)
wrappedStream := grpc_middleware.WrapServerStream(stream)
wrappedStream.WrappedContext = newCtx
err := handler(srv, wrappedStream)
finishServerSpan(newCtx, serverSpan, err)
return err
}
} | |
c27348 | v.Validate(); err != nil {
return nil, grpc.Errorf(codes.InvalidArgument, err.Error())
}
}
return handler(ctx, req)
}
} | |
c27349 | newTagsForCtx(ctx)
if o.requestFieldsFunc != nil {
setRequestFieldTags(newCtx, o.requestFieldsFunc, info.FullMethod, req)
}
return handler(newCtx, req)
}
} | |
c27350 | allocating a wrappedStream.
wrappedStream := grpc_middleware.WrapServerStream(stream)
wrappedStream.WrappedContext = newCtx
return handler(srv, wrappedStream)
}
wrapped := &wrappedStream{stream, info, o, newCtx, true}
err := handler(srv, wrapped)
return err
}
} | |
c27351 | uint) time.Duration {
return scalar * time.Duration(backoffutils.ExponentBase2(attempt))
}
} | |
c27352 | func(attempt uint) time.Duration {
return backoffutils.JitterUp(scalar*time.Duration(backoffutils.ExponentBase2(attempt)), jitterFraction)
}
} | |
c27353 | ext.ExtractRequestFields(retMap)
if len(retMap) == 0 {
return nil
}
return retMap
}
return nil
} | |
c27354 | }
c.state = state
c.error = err
c.exitStatus = exitStatus
c.streamsMtx.RLock()
defer c.streamsMtx.RUnlock()
for ch := range c.streams {
ch <- StateChange{State: state, Error: err, ExitStatus: exitStatus}
}
} | |
c27355 |
signal.Notify(c, syscall.SIGUSR2)
for range c {
pprof.Lookup("goroutine").WriteTo(out, 1)
}
} | |
c27356 | log15.StreamHandler(logW, log15.LogfmtFormat())))
// Propagate the plugin-specific container env variable
config.Env["container"] = os.Getenv("container")
if err := containerInitApp(config, logR); err != nil {
os.Exit(70)
}
} | |
c27357 | != nil {
return false
}
return true
} | |
c27358 |
c.stoppingValue.Store(false)
c.Stdout = os.Stdout
c.Stderr = os.Stderr
return c
} | |
c27359 | err != nil {
return err
}
go cmd.monitor()
return nil
} | |
c27360 | cmd.Process.Signal(syscall.SIGKILL); err != nil {
return err
}
return nil
} | |
c27361 | cmd.err = err
}
close(cmd.stopped)
} | |
c27362 | return c.StreamWithHeader(method, path, make(http.Header), in, out)
} | |
c27363 | return context.WithValue(ctx, ctxKeyComponent, componentName)
} | |
c27364 | string, ok bool) {
componentName, ok = ctx.Value(ctxKeyComponent).(string)
return
} | |
c27365 | context.WithValue(ctx, ctxKeyLogger, logger)
} | |
c27366 | ok bool) {
logger, ok = ctx.Value(ctxKeyLogger).(log.Logger)
return
} | |
c27367 | context.WithValue(ctx, ctxKeyParams, params)
} | |
c27368 | ok bool) {
params, ok = ctx.Value(ctxKeyParams).(httprouter.Params)
return
} | |
c27369 | context.WithValue(ctx, ctxKeyReqID, id)
} | |
c27370 | string, ok bool) {
id, ok = ctx.Value(ctxKeyReqID).(string)
return
} | |
c27371 | context.WithValue(ctx, ctxKeyStartTime, start)
} | |
c27372 | ok bool) {
start, ok = ctx.Value(ctxKeyStartTime).(time.Time)
return
} | |
c27373 | != nil {
respondWithError(w, err)
return
}
if err := c.sinkRepo.Add(&sink); err != nil {
respondWithError(w, err)
return
}
httphelper.JSON(w, 200, &sink)
} | |
c27374 |
sink, err := c.sinkRepo.Get(params.ByName("sink_id"))
if err != nil {
respondWithError(w, err)
return
}
httphelper.JSON(w, 200, sink)
} | |
c27375 | return
}
if err = c.sinkRepo.Remove(sinkID); err != nil {
respondWithError(w, err)
return
}
httphelper.JSON(w, 200, sink)
} | |
c27376 | }
versions = append(versions, &EC2Version{
Version: version,
Images: []*EC2Image{image},
})
sort.Sort(sort.Reverse(versions))
m.Versions = make([]*EC2Version, 0, maxVersions)
for i := 0; i < len(versions) && i < maxVersions; i++ {
m.Versions = append(m.Versions, versions[i].(*EC2Version))
}
} | |
c27377 | providers = append(providers, provider)
}
v.Providers = providers
return
}
versions = append(versions, v)
}
versions = append(versions, &VagrantVersion{
Version: version,
Providers: []*VagrantProvider{provider},
})
sort.Sort(sort.Reverse(versions))
m.Versions = make([]*VagrantVersion, 0, max... | |
c27378 | handlers: make(map[byte]*handler),
Timeout: 30 * time.Second,
LogOutput: os.Stderr,
}
} | |
c27379 | close handlers.
mux.wg.Wait()
for _, h := range mux.handlers {
h.Close()
}
})
return
} | |
c27380 | mux.Close()
return err
}
// Hand off connection to a separate goroutine.
mux.wg.Add(1)
go func(conn net.Conn) {
defer mux.wg.Done()
if err := mux.handleConn(conn); err != nil {
conn.Close()
logger.Printf("tcp.Mux: %s", err)
}
}(conn)
}
} | |
c27381 | Create a new listener and assign it.
mux.handlers[hdr] = h
}
return h
} | |
c27382 | &handler{
mux: mux,
c: make(chan net.Conn),
}
} | |
c27383 | errors.New("network connection closed")
}
return conn, nil
} | |
c27384 |
h.once.Do(func() { close(h.c) })
return nil
} | |
c27385 | &bufConn{
conn: conn,
r: bufio.NewReader(conn),
}
} | |
c27386 | := 0; i < count; i++ {
if err := d.scaleNewFormationUpByOne(typ, log); err != nil {
return err
}
if err := discDeploy.Wait(d.ID, d.timeout, log); err != nil {
return err
}
if err := d.scaleOldFormationDownByOne(typ, log); err != nil {
return err
}
}
}
return nil
} | |
c27387 | err != nil {
return nil, err
}
return newClient(u.String(), httpClient), nil
} | |
c27388 | dec: json.NewDecoder(conn),
enc: json.NewEncoder(conn),
c: conn,
pending: make(map[uint64]string),
}
} | |
c27389 | {
return rpc.NewClientWithCodec(NewClientCodec(conn))
} | |
c27390 | a.Meta["flynn-system-critical"]
return ok && v == "true"
} | |
c27391 |
if msg != nil {
m := make([]byte, len(msg))
copy(m, msg)
msg = m
}
return &Message{Header: h, Msg: msg}
} | |
c27392 |
}
log.Info(fmt.Sprintf("got %d active job(s) for host %s", len(jobs), h.ID))
go func() {
defer stream.Close()
defer close(h.jobsDone)
for {
eventLoop:
for {
select {
case event, ok := <-events:
if !ok {
break eventLoop
}
ch <- event
// if the host is a FakeHostClient w... | |
c27393 | := gob.NewEncoder(w)
return writeTo(buffers, enc)
} | |
c27394 | for msg := range msgc {
if err := enc.Encode(msg); err != nil {
return err
}
}
return nil
} | |
c27395 | {
return &Scanner{dec: gob.NewDecoder(r)}
} | |
c27396 | return status.Unhealthy
}
return status.Healthy
} | |
c27397 | {
return err
}
// Wait for leadership.
if err := m.waitForLeader(60 * time.Second); err != nil {
return err
}
// Wait for store to catchup
for m.store.LastIndex() < targetLogIndex.LastIndex {
m.logger.Println("Waiting for store to catchup, current:", m.store.LastIndex(), "target:", targetLogInde... | |
c27398 | peer set.
if leaderAddr == m.advertiseAddr {
if err := m.store.RemovePeer(m.advertiseAddr); err != nil {
rollback()
return err
}
} else {
if err := discoverd.DefaultClient.RaftRemovePeer(m.advertiseAddr); err != nil {
rollback()
return err
}
}
// Close the raft store.
if m.store != nil {
m.... | |
c27399 |
m.dnsServer = nil
}
if m.ln != nil {
m.ln.Close()
m.ln = nil
}
if m.store != nil {
info.LastIndex, err = m.store.Close()
m.store = nil
}
return info, err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.