_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27300 | MakeSyntaxError | train | func (self Otto) MakeSyntaxError(message string) Value {
return self.runtime.toValue(self.runtime.newSyntaxError(self.runtime.toValue(message)))
} | go | {
"resource": ""
} |
q27301 | MakeTypeError | train | func (self Otto) MakeTypeError(message string) Value {
return self.runtime.toValue(self.runtime.newTypeError(self.runtime.toValue(message)))
} | go | {
"resource": ""
} |
q27302 | ContextLimit | train | func (self Otto) ContextLimit(limit int) Context {
return self.ContextSkip(limit, true)
} | go | {
"resource": ""
} |
q27303 | ContextSkip | train | func (self Otto) ContextSkip(limit int, skipNative bool) (ctx Context) {
// Ensure we are operating in a scope
if self.runtime.scope == nil {
self.runtime.enterGlobalScope()
defer self.runtime.leaveScope()
}
scope := self.runtime.scope
frame := scope.frame
for skipNative && frame.native && scope.outer != ni... | go | {
"resource": ""
} |
q27304 | Get | train | func (self Object) Get(name string) (Value, error) {
value := Value{}
err := catchPanic(func() {
value = self.object.get(name)
})
if !value.safe() {
value = Value{}
}
return value, err
} | go | {
"resource": ""
} |
q27305 | Keys | train | func (self Object) Keys() []string {
var keys []string
self.object.enumerate(false, func(name string) bool {
keys = append(keys, name)
return true
})
return keys
} | go | {
"resource": ""
} |
q27306 | WithRecoveryHandler | train | func WithRecoveryHandler(f RecoveryHandlerFunc) Option {
return func(o *options) {
o.recoveryHandlerFunc = RecoveryHandlerFuncContext(func(ctx context.Context, p interface{}) error {
return f(p)
})
}
} | go | {
"resource": ""
} |
q27307 | WithMax | train | func WithMax(maxRetries uint) CallOption {
return CallOption{applyFunc: func(o *options) {
o.max = maxRetries
}}
} | go | {
"resource": ""
} |
q27308 | WithBackoff | train | func WithBackoff(bf BackoffFunc) CallOption {
return CallOption{applyFunc: func(o *options) {
o.backoffFunc = BackoffFuncContext(func(ctx context.Context, attempt uint) time.Duration {
return bf(attempt)
})
}}
} | go | {
"resource": ""
} |
q27309 | WithBackoffContext | train | func WithBackoffContext(bf BackoffFuncContext) CallOption {
return CallOption{applyFunc: func(o *options) {
o.backoffFunc = bf
}}
} | go | {
"resource": ""
} |
q27310 | UnaryServerInterceptor | train | func UnaryServerInterceptor(entry *logrus.Entry, opts ...Option) grpc.UnaryServerInterceptor {
o := evaluateServerOpt(opts)
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
startTime := time.Now()
newCtx := newLoggerForCall(ctx, entry,... | go | {
"resource": ""
} |
q27311 | StreamServerInterceptor | train | func StreamServerInterceptor(entry *logrus.Entry, opts ...Option) grpc.StreamServerInterceptor {
o := evaluateServerOpt(opts)
return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
startTime := time.Now()
newCtx := newLoggerForCall(stream.Context(),... | go | {
"resource": ""
} |
q27312 | StreamClientInterceptor | train | func StreamClientInterceptor(logger *zap.Logger, opts ...Option) grpc.StreamClientInterceptor {
o := evaluateClientOpt(opts)
return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
fields := newClientLo... | go | {
"resource": ""
} |
q27313 | WithFieldExtractorForInitialReq | train | func WithFieldExtractorForInitialReq(f RequestFieldExtractorFunc) Option {
return func(o *options) {
o.requestFieldsFunc = f
o.requestFieldsFromInitial = true
}
} | go | {
"resource": ""
} |
q27314 | ExtractIncoming | train | func ExtractIncoming(ctx context.Context) NiceMD {
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
return NiceMD(metadata.Pairs())
}
return NiceMD(md)
} | go | {
"resource": ""
} |
q27315 | ExtractOutgoing | train | func ExtractOutgoing(ctx context.Context) NiceMD {
md, ok := metadata.FromOutgoingContext(ctx)
if !ok {
return NiceMD(metadata.Pairs())
}
return NiceMD(md)
} | go | {
"resource": ""
} |
q27316 | ToOutgoing | train | func (m NiceMD) ToOutgoing(ctx context.Context) context.Context {
return metadata.NewOutgoingContext(ctx, metadata.MD(m))
} | go | {
"resource": ""
} |
q27317 | ToIncoming | train | func (m NiceMD) ToIncoming(ctx context.Context) context.Context {
return metadata.NewIncomingContext(ctx, metadata.MD(m))
} | go | {
"resource": ""
} |
q27318 | Get | train | func (m NiceMD) Get(key string) string {
k, _ := encodeKeyValue(key, "")
vv, ok := m[k]
if !ok {
return ""
}
return vv[0]
} | go | {
"resource": ""
} |
q27319 | Del | train | func (m NiceMD) Del(key string) NiceMD {
k, _ := encodeKeyValue(key, "")
delete(m, k)
return m
} | go | {
"resource": ""
} |
q27320 | Set | train | func (m NiceMD) Set(key string, value string) NiceMD {
k, v := encodeKeyValue(key, value)
m[k] = []string{v}
return m
} | go | {
"resource": ""
} |
q27321 | Add | train | func (m NiceMD) Add(key string, value string) NiceMD {
k, v := encodeKeyValue(key, value)
m[k] = append(m[k], v)
return m
} | go | {
"resource": ""
} |
q27322 | AddFields | train | func AddFields(ctx context.Context, fields logrus.Fields) {
l, ok := ctx.Value(ctxLoggerKey).(*ctxLogger)
if !ok || l == nil {
return
}
for k, v := range fields {
l.fields[k] = v
}
} | go | {
"resource": ""
} |
q27323 | Extract | train | func Extract(ctx context.Context) *logrus.Entry {
l, ok := ctx.Value(ctxLoggerKey).(*ctxLogger)
if !ok || l == nil {
return logrus.NewEntry(nullLogger)
}
fields := logrus.Fields{}
// Add grpc_ctxtags tags metadata until now.
tags := grpc_ctxtags.Extract(ctx)
for k, v := range tags.Values() {
fields[k] = v
... | go | {
"resource": ""
} |
q27324 | ToContext | train | func ToContext(ctx context.Context, entry *logrus.Entry) context.Context {
l := &ctxLogger{
logger: entry,
fields: logrus.Fields{},
}
return context.WithValue(ctx, ctxLoggerKey, l)
} | go | {
"resource": ""
} |
q27325 | StreamClientInterceptor | train | func StreamClientInterceptor(entry *logrus.Entry, opts ...Option) grpc.StreamClientInterceptor {
o := evaluateClientOpt(opts)
return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
fields := newClientL... | go | {
"resource": ""
} |
q27326 | WithTracer | train | func WithTracer(tracer opentracing.Tracer) Option {
return func(o *options) {
o.tracer = tracer
}
} | go | {
"resource": ""
} |
q27327 | UnaryServerInterceptor | train | func UnaryServerInterceptor(opts ...Option) grpc.UnaryServerInterceptor {
o := evaluateOptions(opts)
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (_ interface{}, err error) {
defer func() {
if r := recover(); r != nil {
err = recoverFrom(ctx, r, o.r... | go | {
"resource": ""
} |
q27328 | StreamServerInterceptor | train | func StreamServerInterceptor(opts ...Option) grpc.StreamServerInterceptor {
o := evaluateOptions(opts)
return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) {
defer func() {
if r := recover(); r != nil {
err = recoverFrom(stream.Context(),... | go | {
"resource": ""
} |
q27329 | WithDecider | train | func WithDecider(f grpc_logging.Decider) Option {
return func(o *options) {
o.shouldLog = f
}
} | go | {
"resource": ""
} |
q27330 | WithCodes | train | func WithCodes(f grpc_logging.ErrorToCode) Option {
return func(o *options) {
o.codeFunc = f
}
} | go | {
"resource": ""
} |
q27331 | DefaultCodeToLevel | train | func DefaultCodeToLevel(code codes.Code) zapcore.Level {
switch code {
case codes.OK:
return zap.InfoLevel
case codes.Canceled:
return zap.InfoLevel
case codes.Unknown:
return zap.ErrorLevel
case codes.InvalidArgument:
return zap.InfoLevel
case codes.DeadlineExceeded:
return zap.WarnLevel
case codes.No... | go | {
"resource": ""
} |
q27332 | DurationToTimeMillisField | train | func DurationToTimeMillisField(duration time.Duration) zapcore.Field {
return zap.Float32("grpc.time_ms", durationToMilliseconds(duration))
} | go | {
"resource": ""
} |
q27333 | UnaryServerInterceptor | train | func UnaryServerInterceptor(logger *zap.Logger, opts ...Option) grpc.UnaryServerInterceptor {
o := evaluateServerOpt(opts)
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
startTime := time.Now()
newCtx := newLoggerForCall(ctx, logger... | go | {
"resource": ""
} |
q27334 | StreamServerInterceptor | train | func StreamServerInterceptor(logger *zap.Logger, opts ...Option) grpc.StreamServerInterceptor {
o := evaluateServerOpt(opts)
return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
startTime := time.Now()
newCtx := newLoggerForCall(stream.Context(), ... | go | {
"resource": ""
} |
q27335 | WithUnaryServerChain | train | func WithUnaryServerChain(interceptors ...grpc.UnaryServerInterceptor) grpc.ServerOption {
return grpc.UnaryInterceptor(ChainUnaryServer(interceptors...))
} | go | {
"resource": ""
} |
q27336 | WithStreamServerChain | train | func WithStreamServerChain(interceptors ...grpc.StreamServerInterceptor) grpc.ServerOption {
return grpc.StreamInterceptor(ChainStreamServer(interceptors...))
} | go | {
"resource": ""
} |
q27337 | UnaryClientInterceptor | train | func UnaryClientInterceptor(opts ...Option) grpc.UnaryClientInterceptor {
o := evaluateOptions(opts)
return func(parentCtx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
if o.filterOutFunc != nil && !o.filterOutFunc(parentCtx,... | go | {
"resource": ""
} |
q27338 | StreamClientInterceptor | train | func StreamClientInterceptor(opts ...Option) grpc.StreamClientInterceptor {
o := evaluateOptions(opts)
return func(parentCtx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
if o.filterOutFunc != nil && !o.filte... | go | {
"resource": ""
} |
q27339 | DefaultCodeToLevel | train | func DefaultCodeToLevel(code codes.Code) logrus.Level {
switch code {
case codes.OK:
return logrus.InfoLevel
case codes.Canceled:
return logrus.InfoLevel
case codes.Unknown:
return logrus.ErrorLevel
case codes.InvalidArgument:
return logrus.InfoLevel
case codes.DeadlineExceeded:
return logrus.WarnLevel
... | go | {
"resource": ""
} |
q27340 | Set | train | func (m metadataTextMap) Set(key, val string) {
// gRPC allows for complex binary values to be written.
encodedKey, encodedVal := encodeKeyValue(key, val)
// 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... | go | {
"resource": ""
} |
q27341 | ForeachKey | train | func (m metadataTextMap) ForeachKey(callback func(key, val string) error) error {
for k, vv := range m {
for _, v := range vv {
if decodedKey, decodedVal, err := metadata.DecodeKeyValue(k, v); err == nil {
if err = callback(decodedKey, decodedVal); err != nil {
return err
}
} else {
return fmt... | go | {
"resource": ""
} |
q27342 | AddFields | train | func AddFields(ctx context.Context, fields ...zapcore.Field) {
l, ok := ctx.Value(ctxMarkerKey).(*ctxLogger)
if !ok || l == nil {
return
}
l.fields = append(l.fields, fields...)
} | go | {
"resource": ""
} |
q27343 | Extract | train | func Extract(ctx context.Context) *zap.Logger {
l, ok := ctx.Value(ctxMarkerKey).(*ctxLogger)
if !ok || l == nil {
return nullLogger
}
// Add grpc_ctxtags tags metadata until now.
fields := TagsToFields(ctx)
// Add zap fields added until now.
fields = append(fields, l.fields...)
return l.logger.With(fields...... | go | {
"resource": ""
} |
q27344 | TagsToFields | train | func TagsToFields(ctx context.Context) []zapcore.Field {
fields := []zapcore.Field{}
tags := grpc_ctxtags.Extract(ctx)
for k, v := range tags.Values() {
fields = append(fields, zap.Any(k, v))
}
return fields
} | go | {
"resource": ""
} |
q27345 | ToContext | train | func ToContext(ctx context.Context, logger *zap.Logger) context.Context {
l := &ctxLogger{
logger: logger,
}
return context.WithValue(ctx, ctxMarkerKey, l)
} | go | {
"resource": ""
} |
q27346 | UnaryServerInterceptor | train | func UnaryServerInterceptor(opts ...Option) grpc.UnaryServerInterceptor {
o := evaluateOptions(opts)
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
if o.filterOutFunc != nil && !o.filterOutFunc(ctx, info.FullMethod) {
return handler... | go | {
"resource": ""
} |
q27347 | StreamServerInterceptor | train | func StreamServerInterceptor(opts ...Option) grpc.StreamServerInterceptor {
o := evaluateOptions(opts)
return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
if o.filterOutFunc != nil && !o.filterOutFunc(stream.Context(), info.FullMethod) {
return ... | go | {
"resource": ""
} |
q27348 | UnaryServerInterceptor | train | func UnaryServerInterceptor() grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
if v, ok := req.(validator); ok {
if err := v.Validate(); err != nil {
return nil, grpc.Errorf(codes.InvalidArgument, err.... | go | {
"resource": ""
} |
q27349 | UnaryServerInterceptor | train | func UnaryServerInterceptor(opts ...Option) grpc.UnaryServerInterceptor {
o := evaluateOptions(opts)
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
newCtx := newTagsForCtx(ctx)
if o.requestFieldsFunc != nil {
setRequestFieldTags(n... | go | {
"resource": ""
} |
q27350 | StreamServerInterceptor | train | func StreamServerInterceptor(opts ...Option) grpc.StreamServerInterceptor {
o := evaluateOptions(opts)
return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
newCtx := newTagsForCtx(stream.Context())
if o.requestFieldsFunc == nil {
// Short-circu... | go | {
"resource": ""
} |
q27351 | BackoffExponential | train | func BackoffExponential(scalar time.Duration) BackoffFunc {
return func(attempt uint) time.Duration {
return scalar * time.Duration(backoffutils.ExponentBase2(attempt))
}
} | go | {
"resource": ""
} |
q27352 | BackoffExponentialWithJitter | train | func BackoffExponentialWithJitter(scalar time.Duration, jitterFraction float64) BackoffFunc {
return func(attempt uint) time.Duration {
return backoffutils.JitterUp(scalar*time.Duration(backoffutils.ExponentBase2(attempt)), jitterFraction)
}
} | go | {
"resource": ""
} |
q27353 | CodeGenRequestFieldExtractor | train | func CodeGenRequestFieldExtractor(fullMethod string, req interface{}) map[string]interface{} {
if ext, ok := req.(requestFieldsExtractor); ok {
retMap := make(map[string]interface{})
ext.ExtractRequestFields(retMap)
if len(retMap) == 0 {
return nil
}
return retMap
}
return nil
} | go | {
"resource": ""
} |
q27354 | changeState | train | func (c *ContainerInit) changeState(state State, err string, exitStatus int) {
if err != "" {
logger.Debug("changing state", "fn", "changeState", "state", state, "err", err)
} else if exitStatus != -1 {
logger.Debug("changing state", "fn", "changeState", "state", state, "exitStatus", exitStatus)
} else {
logge... | go | {
"resource": ""
} |
q27355 | debugStackPrinter | train | func debugStackPrinter(out io.Writer) {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGUSR2)
for range c {
pprof.Lookup("goroutine").WriteTo(out, 1)
}
} | go | {
"resource": ""
} |
q27356 | Main | train | func Main() {
logR, logW, err := newSocketPair("log")
if err != nil {
os.Exit(70)
}
go debugStackPrinter(logW)
config := &Config{}
data, err := ioutil.ReadFile("/.containerconfig")
if err != nil {
os.Exit(70)
}
if err := json.Unmarshal(data, config); err != nil {
os.Exit(70)
}
logger = log15.New("com... | go | {
"resource": ""
} |
q27357 | Exists | train | func Exists(args ...string) bool {
if _, err := Raw(append([]string{"-C"}, args...)...); err != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q27358 | NewCmd | train | func NewCmd(cmd *exec.Cmd) *Cmd {
c := &Cmd{
Cmd: cmd,
stopped: make(chan struct{}, 1),
}
c.stoppingValue.Store(false)
c.Stdout = os.Stdout
c.Stderr = os.Stderr
return c
} | go | {
"resource": ""
} |
q27359 | Start | train | func (cmd *Cmd) Start() error {
if err := cmd.Cmd.Start(); err != nil {
return err
}
go cmd.monitor()
return nil
} | go | {
"resource": ""
} |
q27360 | Stop | train | func (cmd *Cmd) Stop() error {
cmd.stoppingValue.Store(true)
if err := cmd.Process.Signal(syscall.SIGKILL); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q27361 | monitor | train | func (cmd *Cmd) monitor() {
err := cmd.Wait()
if !cmd.stoppingValue.Load().(bool) {
cmd.err = err
}
close(cmd.stopped)
} | go | {
"resource": ""
} |
q27362 | Stream | train | func (c *Client) Stream(method, path string, in, out interface{}) (stream.Stream, error) {
return c.StreamWithHeader(method, path, make(http.Header), in, out)
} | go | {
"resource": ""
} |
q27363 | NewContextComponentName | train | func NewContextComponentName(ctx context.Context, componentName string) context.Context {
return context.WithValue(ctx, ctxKeyComponent, componentName)
} | go | {
"resource": ""
} |
q27364 | ComponentNameFromContext | train | func ComponentNameFromContext(ctx context.Context) (componentName string, ok bool) {
componentName, ok = ctx.Value(ctxKeyComponent).(string)
return
} | go | {
"resource": ""
} |
q27365 | NewContextLogger | train | func NewContextLogger(ctx context.Context, logger log.Logger) context.Context {
return context.WithValue(ctx, ctxKeyLogger, logger)
} | go | {
"resource": ""
} |
q27366 | LoggerFromContext | train | func LoggerFromContext(ctx context.Context) (logger log.Logger, ok bool) {
logger, ok = ctx.Value(ctxKeyLogger).(log.Logger)
return
} | go | {
"resource": ""
} |
q27367 | NewContextParams | train | func NewContextParams(ctx context.Context, params httprouter.Params) context.Context {
return context.WithValue(ctx, ctxKeyParams, params)
} | go | {
"resource": ""
} |
q27368 | ParamsFromContext | train | func ParamsFromContext(ctx context.Context) (params httprouter.Params, ok bool) {
params, ok = ctx.Value(ctxKeyParams).(httprouter.Params)
return
} | go | {
"resource": ""
} |
q27369 | NewContextRequestID | train | func NewContextRequestID(ctx context.Context, id string) context.Context {
return context.WithValue(ctx, ctxKeyReqID, id)
} | go | {
"resource": ""
} |
q27370 | RequestIDFromContext | train | func RequestIDFromContext(ctx context.Context) (id string, ok bool) {
id, ok = ctx.Value(ctxKeyReqID).(string)
return
} | go | {
"resource": ""
} |
q27371 | NewContextStartTime | train | func NewContextStartTime(ctx context.Context, start time.Time) context.Context {
return context.WithValue(ctx, ctxKeyStartTime, start)
} | go | {
"resource": ""
} |
q27372 | StartTimeFromContext | train | func StartTimeFromContext(ctx context.Context) (start time.Time, ok bool) {
start, ok = ctx.Value(ctxKeyStartTime).(time.Time)
return
} | go | {
"resource": ""
} |
q27373 | CreateSink | train | func (c *controllerAPI) CreateSink(ctx context.Context, w http.ResponseWriter, req *http.Request) {
var sink ct.Sink
if err := httphelper.DecodeJSON(req, &sink); err != nil {
respondWithError(w, err)
return
}
if err := schema.Validate(&sink); err != nil {
respondWithError(w, err)
return
}
if err := c.si... | go | {
"resource": ""
} |
q27374 | GetSink | train | func (c *controllerAPI) GetSink(ctx context.Context, w http.ResponseWriter, req *http.Request) {
params, _ := ctxhelper.ParamsFromContext(ctx)
sink, err := c.sinkRepo.Get(params.ByName("sink_id"))
if err != nil {
respondWithError(w, err)
return
}
httphelper.JSON(w, 200, sink)
} | go | {
"resource": ""
} |
q27375 | DeleteSink | train | func (c *controllerAPI) DeleteSink(ctx context.Context, w http.ResponseWriter, req *http.Request) {
params, _ := ctxhelper.ParamsFromContext(ctx)
sinkID := params.ByName("sink_id")
sink, err := c.sinkRepo.Get(sinkID)
if err != nil {
respondWithError(w, err)
return
}
if err = c.sinkRepo.Remove(sinkID); err !... | go | {
"resource": ""
} |
q27376 | Add | train | func (m *EC2Manifest) Add(version string, image *EC2Image) {
versions := make(sortVersions, 0, len(m.Versions)+1)
for _, v := range m.Versions {
if v.version() == version {
images := make([]*EC2Image, len(v.Images))
added := false
for n, i := range v.Images {
if i.Region == image.Region {
// repla... | go | {
"resource": ""
} |
q27377 | Add | train | func (m *VagrantManifest) Add(version string, provider *VagrantProvider) {
// strip the leading "v" from the version as Vagrant only supports
// versions like X.Y.Z, see https://github.com/flynn/flynn/issues/2230
version = strings.TrimPrefix(version, "v")
versions := make(sortVersions, 0, len(m.Versions)+1)
for _... | go | {
"resource": ""
} |
q27378 | New | train | func New(ln net.Listener) *Mux {
return &Mux{
ln: ln,
handlers: make(map[byte]*handler),
Timeout: 30 * time.Second,
LogOutput: os.Stderr,
}
} | go | {
"resource": ""
} |
q27379 | Close | train | func (mux *Mux) Close() (err error) {
mux.once.Do(func() {
// Close underlying listener.
if mux.ln != nil {
err = mux.ln.Close()
}
// Wait for open connections to close and then close handlers.
mux.wg.Wait()
for _, h := range mux.handlers {
h.Close()
}
})
return
} | go | {
"resource": ""
} |
q27380 | Serve | train | func (mux *Mux) Serve() error {
logger := log.New(mux.LogOutput, "", log.LstdFlags)
for {
// Handle incoming connections. Retry temporary errors.
conn, err := mux.ln.Accept()
if err, ok := err.(interface {
Temporary() bool
}); ok && err.Temporary() {
logger.Printf("tcp.Mux: temporary error: %s", err)
... | go | {
"resource": ""
} |
q27381 | Listen | train | func (mux *Mux) Listen(hdrs []byte) net.Listener {
// Create new handler.
h := mux.handler()
// Register each header byte.
for _, hdr := range hdrs {
// Create a new listener and assign it.
mux.handlers[hdr] = h
}
return h
} | go | {
"resource": ""
} |
q27382 | handler | train | func (mux *Mux) handler() *handler {
return &handler{
mux: mux,
c: make(chan net.Conn),
}
} | go | {
"resource": ""
} |
q27383 | Accept | train | func (h *handler) Accept() (c net.Conn, err error) {
conn, ok := <-h.c
if !ok {
return nil, errors.New("network connection closed")
}
return conn, nil
} | go | {
"resource": ""
} |
q27384 | Close | train | func (h *handler) Close() error {
h.once.Do(func() { close(h.c) })
return nil
} | go | {
"resource": ""
} |
q27385 | newBufConn | train | func newBufConn(conn net.Conn) *bufConn {
return &bufConn{
conn: conn,
r: bufio.NewReader(conn),
}
} | go | {
"resource": ""
} |
q27386 | deployDiscoverdMeta | train | func (d *DeployJob) deployDiscoverdMeta() (err error) {
log := d.logger.New("fn", "deployDiscoverdMeta")
log.Info("starting discoverd-meta deployment")
defer func() {
if err != nil {
// TODO: support rolling back
err = ErrSkipRollback{err.Error()}
}
}()
for typ, count := range d.Processes {
proc := d... | go | {
"resource": ""
} |
q27387 | NewWithHTTP | train | func NewWithHTTP(uri string, httpClient *http.Client) (*Client, error) {
if uri == "" {
uri = "http://logaggregator.discoverd"
}
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
return newClient(u.String(), httpClient), nil
} | go | {
"resource": ""
} |
q27388 | NewClientCodec | train | func NewClientCodec(conn io.ReadWriteCloser) rpc.ClientCodec {
return &clientCodec{
dec: json.NewDecoder(conn),
enc: json.NewEncoder(conn),
c: conn,
pending: make(map[uint64]string),
}
} | go | {
"resource": ""
} |
q27389 | NewClient | train | func NewClient(conn io.ReadWriteCloser) *rpc.Client {
return rpc.NewClientWithCodec(NewClientCodec(conn))
} | go | {
"resource": ""
} |
q27390 | Critical | train | func (a *App) Critical() bool {
v, ok := a.Meta["flynn-system-critical"]
return ok && v == "true"
} | go | {
"resource": ""
} |
q27391 | NewMessage | train | func NewMessage(hdr *Header, msg []byte) *Message {
var h Header
if hdr != nil {
h = *hdr
}
if h.Timestamp.IsZero() {
h.Timestamp = time.Now().UTC()
}
if h.Version == 0 {
h.Version = 1
}
if msg != nil {
m := make([]byte, len(msg))
copy(m, msg)
msg = m
}
return &Message{Header: h, Msg: msg}
} | go | {
"resource": ""
} |
q27392 | StreamJobEventsTo | train | func (h *Host) StreamJobEventsTo(ch chan *host.Event) (map[string]host.ActiveJob, error) {
log := h.logger.New("fn", "StreamJobEventsTo", "host.id", h.ID)
var events chan *host.Event
var stream stream.Stream
connect := func() (err error) {
log.Info("connecting job event stream")
events = make(chan *host.Event)
... | go | {
"resource": ""
} |
q27393 | WriteTo | train | func WriteTo(buffers [][]*rfc5424.Message, w io.Writer) error {
enc := gob.NewEncoder(w)
return writeTo(buffers, enc)
} | go | {
"resource": ""
} |
q27394 | StreamTo | train | func StreamTo(buffers [][]*rfc5424.Message, msgc <-chan *rfc5424.Message, w io.Writer) error {
enc := gob.NewEncoder(w)
if err := writeTo(buffers, enc); err != nil {
return err
}
for msg := range msgc {
if err := enc.Encode(msg); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q27395 | NewScanner | train | func NewScanner(r io.Reader) *Scanner {
return &Scanner{dec: gob.NewDecoder(r)}
} | go | {
"resource": ""
} |
q27396 | healthStatus | train | func (h *Handler) healthStatus() status.Status {
info, err := h.Process.Info()
if err != nil || !info.Running {
return status.Unhealthy
}
return status.Healthy
} | go | {
"resource": ""
} |
q27397 | Promote | train | func (m *Main) Promote() error {
m.mu.Lock()
defer m.mu.Unlock()
m.logger.Printf("attempting promotion")
// Request the leader joins us to the cluster.
m.logger.Println("requesting leader join us to cluster")
targetLogIndex, err := discoverd.DefaultClient.RaftAddPeer(m.advertiseAddr)
if err != nil {
m.logger... | go | {
"resource": ""
} |
q27398 | Demote | train | func (m *Main) Demote() error {
m.mu.Lock()
defer m.mu.Unlock()
m.logger.Println("demotion requested")
var leaderAddr string
if m.store != nil {
leaderAddr := m.store.Leader()
if leaderAddr == "" {
return server.ErrNoKnownLeader
}
} else {
leader, err := discoverd.DefaultClient.RaftLeader()
if err ... | go | {
"resource": ""
} |
q27399 | Close | train | func (m *Main) Close() (info dt.TargetLogIndex, err error) {
m.mu.Lock()
defer m.mu.Unlock()
m.logger.Println("discoverd shutting down")
if m.httpServer != nil {
// Disable keep alives so that persistent connections will close
m.httpServer.SetKeepAlivesEnabled(false)
}
if m.dnsServer != nil {
m.dnsServer.Cl... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.