id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c27900 | r.GetCpusetMems(),
},
Memory: &rspec.LinuxMemory{
Limit: proto.Int64(r.GetMemoryLimitInBytes()),
},
// TODO(runcom): OOMScoreAdj is missing
}
} | |
c27901 | if err != nil {
switch err {
case errCtrNotFound:
http.Error(w, fmt.Sprintf("can't find the container with id %s", containerID), http.StatusNotFound)
case errCtrStateNil:
http.Error(w, fmt.Sprintf("can't find container state for container with id %s", containerID), http.StatusInternalServerError)
... | |
c27902 | }
certPool := x509.NewCertPool()
certPool.AppendCertsFromPEM(caBytes)
config.ClientCAs = certPool
config.ClientAuth = tls.RequireAndVerifyClientCert
}
cc.config = config
cc.expires = time.Now().Add(certRefreshInterval)
return config, nil
} | |
c27903 | s.stream.streamServer.GetExec(req)
} | |
c27904 | s.stream.streamServer.GetAttach(req)
} | |
c27905 | return s.stream.streamServer.GetPortForward(req)
} | |
c27906 |
logrus.Debugf("shutting down all sandboxes, on shutdown")
s.stopAllPodSandboxes(ctx)
err = os.Remove(shutdownFile)
if err != nil {
logrus.Warnf("Failed to remove %q", shutdownFile)
}
}
} | |
c27907 | err != nil {
logrus.Warnf("Failed to update sandbox infra container status %s: %v", c.ID(), err)
} else {
s.ContainerStateToDisk(c)
}
}
}
}
case err := <-watcher.Errors:
logrus.Debugf("watch error: %v", err)
return
case <-s.monitorsChan:
logrus.Debug("clos... | |
c27908 | != nil {
sel := fields.SelectorFromSet(filter.LabelSelector)
if !sel.Matches(fields.Set(c.Labels)) {
return false
}
}
}
return true
} | |
c27909 | %s", filter.Id)
return []*oci.Container{}
}
c := s.ContainerServer.GetContainer(id)
if c != nil {
switch {
case filter.PodSandboxId == "":
return []*oci.Container{c}
case c.Sandbox() == filter.PodSandboxId:
return []*oci.Container{c}
default:
return []*oci.Container{}
}
}
} else ... | |
c27910 | "Spec")
typeurl.Register(&rspec.Process{}, prefix, "opencontainers/runtime-spec", major, "Process")
typeurl.Register(&rspec.LinuxResources{}, prefix, "opencontainers/runtime-spec", major, "LinuxResources")
typeurl.Register(&rspec.WindowsResources{}, prefix, "opencontainers/runtime-spec", major, "WindowsResources")
... | |
c27911 | r.task.Resume(r.ctx, &task.ResumeRequest{
ID: c.ID(),
}); err != nil {
return errdefs.FromGRPC(err)
}
return nil
} | |
c27912 | if err != nil {
return "", fmt.Errorf("`%v %v` failed: %v %v (%v)", name, strings.Join(args, " "), stderr.String(), stdout.String(), err)
}
return stdout.String(), nil
} | |
c27913 | stderr
if v, found := os.LookupEnv("XDG_RUNTIME_DIR"); found {
cmd.Env = append(cmd.Env, fmt.Sprintf("XDG_RUNTIME_DIR=%s", v))
}
err := cmd.Run()
if err != nil {
return fmt.Errorf("`%v %v` failed: %v", name, strings.Join(args, " "), err)
}
return nil
} | |
c27914 | []uint32{uint32(pid)}))
properties = append(properties, newProp("Delegate", true))
properties = append(properties, newProp("DefaultDependencies", false))
ch := make(chan string)
_, err = conn.StartTransientUnit(unitName, "replace", properties, ch)
if err != nil {
return err
}
defer conn.Close()
// Block unt... | |
c27915 |
nr, er = src.Read(buf)
}
nw, ew := dst.Write(preservBuf)
nr = len(preservBuf)
if nw > 0 {
written += int64(nw)
}
if ew != nil {
err = ew
break
}
if nr != nw {
err = io.ErrShortWrite
break
}
}
if er != nil {
if er != io.EOF {
err = er
}
break
}
}
r... | |
c27916 | i++ {
n := runtime.Stack(buf, true)
if n < len(buf) {
buf = buf[:n]
break
}
if len(buf) >= 32<<20 {
break
}
buf = make([]byte, 2*len(buf))
}
_, err := w.Write(buf)
return err
} | |
c27917 | return err
}
defer f.Close()
defer f.Sync()
return WriteGoroutineStacks(f)
} | |
c27918 | return hex.EncodeToString(b)
} | |
c27919 | rootfs)
if err != nil {
return nil, err
}
return os.Open(fp)
} | |
c27920 |
defer g.mu.Unlock()
if g.closed {
w.Close()
return
}
g.writers[key] = w
} | |
c27921 | defer g.mu.Unlock()
return g.writers[key]
} | |
c27922 |
return
}
w.Close()
delete(g.writers, key)
} | |
c27923 | len(p) == n {
continue
}
// The writer is closed or in bad state, remove it.
w.Close()
delete(g.writers, k)
}
if len(g.writers) == 0 {
return 0, errors.New("writer group is empty")
}
return len(p), nil
} | |
c27924 | w.Close()
}
g.writers = nil
g.closed = true
} | |
c27925 | conmonEnv: conmonEnv,
cgroupManager: cgroupManager,
containerExitsDir: containerExitsDir,
containerAttachSocketDir: containerAttachSocketDir,
logSizeMax: logSizeMax,
logToJournald: logToJournald,
noPivot: noPivot,
ctrStopTimeout: ... | |
c27926 |
handler, r.runtimes)
}
if runtimeHandler.RuntimePath == "" {
return RuntimeHandler{}, fmt.Errorf("empty runtime path for runtime handler %s", handler)
}
return runtimeHandler, nil
} | |
c27927 | return r.newRuntimeImpl(c)
}
return impl, nil
} | |
c27928 |
if err != nil {
return nil, nil, err
}
return os.NewFile(uintptr(fds[1]), "parent"), os.NewFile(uintptr(fds[0]), "child"), nil
} | |
c27929 |
}
return "", errors.Errorf("unable to convert signal to string")
} | |
c27930 | != nil {
return nil, err
}
return c.store.Container(ociCtr.ID())
} | |
c27931 | {
ctr, err := c.GetStorageContainer(containerID)
if err != nil {
return "", err
}
return ctr.LayerID, nil
} | |
c27932 | calculating the size of the diff
// between the layer and its parent. The top layer of a container is
// the only RW layer, all others are immutable
layer, err := c.store.Layer(container.LayerID)
if err != nil {
return 0, err
}
return c.store.DiffSize(layer.Parent, layer.ID)
} | |
c27933 | found: %v", cid, err)
}
ctr := c.GetContainer(containerID)
if ctr == nil {
return nil, fmt.Errorf("specified container not found: %s", containerID)
}
return ctr, nil
} | |
c27934 | if err == registrar.ErrNameNotReserved {
ctrID = idOrName
} else {
return nil, err
}
}
return c.GetContainerFromShortID(ctrID)
} | |
c27935 |
if err == registrar.ErrNameNotReserved {
podID = idOrName
} else {
return nil, err
}
}
return c.getSandboxFromRequest(podID)
} | |
c27936 | %q: %v", containerID, err)
}
if err := ss.runtimeServer.Runtime().UpdateContainerStatus(c); err != nil {
return err
}
cState := c.State()
if !(cState.Status == oci.ContainerStateRunning || cState.Status == oci.ContainerStateCreated) {
return fmt.Errorf("container is not created or running")
}
return ss.r... | |
c27937 | f.field.Tag.Get(key)
} | |
c27938 | := f.FieldOk(name)
if !ok {
panic("field not found")
}
return field
} | |
c27939 | case reflect.Map, reflect.Struct:
isSubStruct = true
}
} else {
finalVal = val.Interface()
}
if tagOpts.Has("string") {
s, ok := val.Interface().(fmt.Stringer)
if ok {
out[name] = s.String()
}
continue
}
if isSubStruct && (tagOpts.Has("flatten")) {
for k := range finalVal.(map... | |
c27940 | := s.FieldOk(name)
if !ok {
panic("field not found")
}
return f
} | |
c27941 | field,
value: s.value.FieldByName(name),
defaultTag: s.TagName,
}, true
} | |
c27942 | // we can't access the value of unexported fields
if field.PkgPath != "" {
continue
}
// don't check if it's omitted
if tag := field.Tag.Get(s.TagName); tag == "-" {
continue
}
f = append(f, field)
}
return f
} | |
c27943 |
}
// uninitialized zero value of a struct
if v.Kind() == reflect.Invalid {
return false
}
return v.Kind() == reflect.Struct
} | |
c27944 | // TODO(arslan): should this be optional?
finalVal = val.Interface()
case reflect.Slice, reflect.Array:
if val.Type().Kind() == reflect.Interface {
finalVal = val.Interface()
break
}
// TODO(arslan): should this be optional?
// do not iterate of non struct types, just pass the value. Ie: []int,
// ... | |
c27945 | opt {
return true
}
}
return false
} | |
c27946 | tokenURL,
}
o.Context = context.WithValue(o.Context, contextHttpClient{}, newOAuthClient(c))
}
} | |
c27947 | Response: &awsxray.Response{
Status: getStatus(err),
},
}
} | |
c27948 | len(parentId) == 0 && len(s.Type) == 0 {
parentId = s.Id
}
if len(traceId) == 0 {
traceId = s.TraceId
}
}
// create segment
s := &awsxray.Segment{
Id: fmt.Sprintf("%x", getRandom(8)),
Name: name,
TraceId: traceId,
StartTime: float64(time.Now().Truncate(time.Millisecond).UnixNano()... | |
c27949 | := errors.Parse(err.Error()); e.Code > 0 {
return int(e.Code)
}
// could not parse, 500
return 500
} | |
c27950 |
case status >= 400:
s.Error = true
case err != nil:
s.Fault = true
}
} | |
c27951 | client.Client {
return &clientWrapper{c}
}
} | |
c27952 | ErrNotDecodable
}
return msgp.Decode(r, b)
} | |
c27953 | != nil {
return err
}
// No body to encode. Write a zero-length params array.
if bm == nil {
return w.WriteArrayHeader(0)
}
// 1-item array containing the body.
if err = w.WriteArrayHeader(1); err != nil {
return err
}
return msgp.Encode(w, bm)
} | |
c27954 | return err
}
// No body to encode. Write a zero-length params array.
if bm == nil {
return w.WriteArrayHeader(0)
}
// 1-item array containing the body.
if err = w.WriteArrayHeader(1); err != nil {
return err
}
return msgp.Encode(w, bm)
} | |
c27955 | <-w.stop:
return
default:
close(w.stop)
close(w.results)
}
} | |
c27956 | }
// Added for posterity, however Ack is a no-op.
if s.opts.AutoAck {
if err := p.Ack(); err != nil {
break
}
}
case redis.Subscription:
if x.Count == 0 {
return
}
case error:
return
}
}
} | |
c27957 | return errors.New("redis: cannot init while connected")
}
for _, o := range opts {
o(&b.opts)
}
return nil
} | |
c27958 |
b.pool = nil
b.addr = ""
return err
} | |
c27959 | b.pool.Get()
_, err = redis.Int(conn.Do("PUBLISH", topic, v))
conn.Close()
return err
} | |
c27960 |
s := subscriber{
codec: b.opts.Codec,
conn: &redis.PubSubConn{Conn: b.pool.Get()},
topic: topic,
handle: handler,
opts: options,
}
// Run the receiver routine.
go s.recv()
if err := s.conn.Subscribe(s.topic); err != nil {
return nil, err
}
return &s, nil
} | |
c27961 | o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
} | |
c27962 | o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
} | |
c27963 | o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
} | |
c27964 | return codes.DeadlineExceeded
}
switch {
case os.IsExist(err):
return codes.AlreadyExists
case os.IsNotExist(err):
return codes.NotFound
case os.IsPermission(err):
return codes.PermissionDenied
}
return codes.Unknown
} | |
c27965 | return func(c client.Client) client.Client {
return &clientWrapper{endpoints, cw, c}
}
} | |
c27966 | {
// execute the handler wrapper?
if !endpoints[req.Endpoint()] {
// no
return h(ctx, req, rsp)
}
// yes
return hw(h)(ctx, req, rsp)
}
}
} | |
c27967 | []string{},
allowedMethods: []string{},
}
} | |
c27968 | client.Client) client.Client {
return &clientWrapper{service, c}
}
} | |
c27969 | interface{}) error {
ctx = micro.NewContext(ctx, service)
return h(ctx, req, rsp)
}
}
} | |
c27970 | return &shard{
key: key,
Client: c,
}
}
} | |
c27971 | o.Context = context.WithValue(o.Context, clientOptionKey{}, c)
}
} | |
c27972 |
}
o.Context = context.WithValue(o.Context, projectIDKey{}, id)
}
} | |
c27973 | nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, createSubscription{}, b)
}
} | |
c27974 | nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, deleteSubscription{}, b)
}
} | |
c27975 |
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, maxExtensionKey{}, d)
}
} | |
c27976 | != nil {
tls := v.(*tls.Config)
creds := credentials.NewTLS(tls)
return grpc.WithTransportCredentials(creds)
}
}
return grpc.WithInsecure()
} | |
c27977 | var err error
s := getSegment(options.Name, ctx)
defer func() {
setCallStatus(s, node.Address, req.Endpoint(), err)
go record(x, s)
}()
ctx = newContext(ctx, s)
err = cf(ctx, node, req, rsp, opts)
return err
}
}
} | |
c27978 |
return func(c client.Client) client.Client {
return &xrayWrapper{options, newXRay(options), c}
}
} | |
c27979 | + req.Endpoint()
}
var err error
s := getSegment(name, ctx)
defer func() {
setCallStatus(s, req.Service(), req.Endpoint(), err)
go record(x, s)
}()
ctx = newContext(ctx, s)
err = h(ctx, req, rsp)
return err
}
}
} | |
c27980 | append(l, label{k, v})
o.Context = context.WithValue(o.Context, labelKey{}, l)
}
} | |
c27981 | username: username,
password: password,
})
} | |
c27982 | status: status,
header: header,
body: body,
},
}
} | |
c27983 | WaitTimeSeconds: s.getWaitSeconds(),
AttributeNames: aws.StringSlice([]string{
"SentTimestamp", // TODO: not currently exposing this to plugin users
}),
MessageAttributeNames: aws.StringSlice([]string{
"All",
}),
})
if err != nil {
time.Sleep(time.Second)
log.Log(fmt.Sprint... | |
c27984 | {
o(&b.options)
}
return nil
} | |
c27985 |
log.Log(fmt.Sprintf("Publishing SQS message, %d bytes", len(msg.Body)))
_, err = b.svc.SendMessage(input)
if err != nil {
return err
}
// Broker interfaces don't let us do anything with message ID or sequence number
return nil
} | |
c27986 | AutoAck: true,
Queue: queueName,
Context: context.Background(),
}
for _, o := range opts {
o(&options)
}
subscriber := &subscriber{
options: options,
URL: queueURL,
queueName: queueName,
svc: b.svc,
exit: make(chan bool),
}
go subscriber.run(h)
return subscriber, nil
} | |
c27987 | o := range opts {
o(&options)
}
return &sqsBroker{
options: options,
}
} | |
c27988 | Header: msg.Header,
Body: msg.Body,
}
p := &grpcPublication{m: m, t: msg.Topic}
h.g.RLock()
for _, subscriber := range h.g.subscribers[msg.Topic] {
if msg.Id == subscriber.id {
// sub is sync; crufty rate limiting
// so we don't hose the cpu
subscriber.fn(p)
}
}
h.g.RUnlock()
return new(proto... | |
c27989 | *Request {
r.method = method
return r
} | |
c27990 | *Request {
r.namespace = s
return r
} | |
c27991 | *Request {
r.resource = s
return r
} | |
c27992 | *Request {
r.resourceName = &s
return r
} | |
c27993 |
if err := json.NewEncoder(b).Encode(&in); err != nil {
r.err = err
return r
}
r.body = b
return r
} | |
c27994 |
r.params.Add("labelSelectors", k+"="+v)
}
return r
} | |
c27995 | r.header.Add(key, value)
return r
} | |
c27996 |
req, err := http.NewRequest(r.method, url, r.body)
if err != nil {
return nil, err
}
// set headers on request
req.Header = r.header
return req, nil
} | |
c27997 |
res, err := r.client.Do(req)
if err != nil {
return &Response{
err: err,
}
}
// return res, err
return newResponse(res, err)
} | |
c27998 |
req, err := r.request()
if err != nil {
return nil, err
}
w, err := watch.NewBodyWatcher(req, r.client)
return w, err
} | |
c27999 | }
if opts.BearerToken != nil {
req.SetHeader("Authorization", "Bearer "+*opts.BearerToken)
}
return req
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.