_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27900 | toOCIResources | train | func toOCIResources(r *pb.LinuxContainerResources) *rspec.LinuxResources {
return &rspec.LinuxResources{
CPU: &rspec.LinuxCPU{
Shares: proto.Uint64(uint64(r.GetCpuShares())),
Quota: proto.Int64(r.GetCpuQuota()),
Period: proto.Uint64(uint64(r.GetCpuPeriod())),
Cpus: r.GetCpusetCpus(),
Mems: r.GetC... | go | {
"resource": ""
} |
q27901 | GetInfoMux | train | func (s *Server) GetInfoMux() *bone.Mux {
mux := bone.New()
mux.Get("/info", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
ci := s.getInfo()
js, err := json.Marshal(ci)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type... | go | {
"resource": ""
} |
q27902 | GetConfigForClient | train | func (cc *certConfigCache) GetConfigForClient(hello *tls.ClientHelloInfo) (*tls.Config, error) {
if cc.config != nil && time.Now().Before(cc.expires) {
return cc.config, nil
}
config := new(tls.Config)
cert, err := tls.LoadX509KeyPair(cc.tlsCert, cc.tlsKey)
if err != nil {
return nil, err
}
config.Certificat... | go | {
"resource": ""
} |
q27903 | getExec | train | func (s *Server) getExec(req *pb.ExecRequest) (*pb.ExecResponse, error) {
return s.stream.streamServer.GetExec(req)
} | go | {
"resource": ""
} |
q27904 | getAttach | train | func (s *Server) getAttach(req *pb.AttachRequest) (*pb.AttachResponse, error) {
return s.stream.streamServer.GetAttach(req)
} | go | {
"resource": ""
} |
q27905 | getPortForward | train | func (s *Server) getPortForward(req *pb.PortForwardRequest) (*pb.PortForwardResponse, error) {
return s.stream.streamServer.GetPortForward(req)
} | go | {
"resource": ""
} |
q27906 | cleanupSandboxesOnShutdown | train | func (s *Server) cleanupSandboxesOnShutdown(ctx context.Context) {
_, err := os.Stat(shutdownFile)
if err == nil || !os.IsNotExist(err) {
logrus.Debugf("shutting down all sandboxes, on shutdown")
s.stopAllPodSandboxes(ctx)
err = os.Remove(shutdownFile)
if err != nil {
logrus.Warnf("Failed to remove %q", sh... | go | {
"resource": ""
} |
q27907 | StartExitMonitor | train | func (s *Server) StartExitMonitor() {
watcher, err := fsnotify.NewWatcher()
if err != nil {
logrus.Fatalf("Failed to create new watch: %v", err)
}
defer watcher.Close()
done := make(chan struct{})
go func() {
for {
select {
case event := <-watcher.Events:
logrus.Debugf("event: %v", event)
if ev... | go | {
"resource": ""
} |
q27908 | filterContainer | train | func filterContainer(c *pb.Container, filter *pb.ContainerFilter) bool {
if filter != nil {
if filter.State != nil {
if c.State != filter.State.State {
return false
}
}
if filter.LabelSelector != nil {
sel := fields.SelectorFromSet(filter.LabelSelector)
if !sel.Matches(fields.Set(c.Labels)) {
... | go | {
"resource": ""
} |
q27909 | filterContainerList | train | func (s *Server) filterContainerList(filter *pb.ContainerFilter, origCtrList []*oci.Container) []*oci.Container {
// Filter using container id and pod id first.
if filter.Id != "" {
id, err := s.CtrIDIndex().Get(filter.Id)
if err != nil {
// If we don't find a container ID with a filter, it should not
// be... | go | {
"resource": ""
} |
q27910 | newRuntimeVM | train | func newRuntimeVM(path string) RuntimeImpl {
logrus.Debug("oci.newRuntimeVM() start")
defer logrus.Debug("oci.newRuntimeVM() end")
// FIXME: We need to register those types for now, but this should be
// defined as a specific package that would be shared both by CRI-O and
// containerd. This would allow shim impl... | go | {
"resource": ""
} |
q27911 | UnpauseContainer | train | func (r *runtimeVM) UnpauseContainer(c *Container) error {
logrus.Debug("runtimeVM.UnpauseContainer() start")
defer logrus.Debug("runtimeVM.UnpauseContainer() end")
// Lock the container
c.opLock.Lock()
defer c.opLock.Unlock()
if _, err := r.task.Resume(r.ctx, &task.ResumeRequest{
ID: c.ID(),
}); err != nil ... | go | {
"resource": ""
} |
q27912 | ExecCmd | train | func ExecCmd(name string, args ...string) (string, error) {
cmd := exec.Command(name, args...)
var stdout bytes.Buffer
var stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if v, found := os.LookupEnv("XDG_RUNTIME_DIR"); found {
cmd.Env = append(cmd.Env, fmt.Sprintf("XDG_RUNTIME_DIR=%s", v))
}
er... | go | {
"resource": ""
} |
q27913 | ExecCmdWithStdStreams | train | func ExecCmdWithStdStreams(stdin io.Reader, stdout, stderr io.Writer, name string, args ...string) error {
cmd := exec.Command(name, args...)
cmd.Stdin = stdin
cmd.Stdout = stdout
cmd.Stderr = stderr
if v, found := os.LookupEnv("XDG_RUNTIME_DIR"); found {
cmd.Env = append(cmd.Env, fmt.Sprintf("XDG_RUNTIME_DIR=%s... | go | {
"resource": ""
} |
q27914 | RunUnderSystemdScope | train | func RunUnderSystemdScope(pid int, slice string, unitName string) error {
var properties []systemdDbus.Property
conn, err := systemdDbus.New()
if err != nil {
return err
}
properties = append(properties, systemdDbus.PropSlice(slice))
properties = append(properties, newProp("PIDs", []uint32{uint32(pid)}))
prope... | go | {
"resource": ""
} |
q27915 | CopyDetachable | train | func CopyDetachable(dst io.Writer, src io.Reader, keys []byte) (written int64, err error) {
// Sanity check interfaces
if dst == nil || src == nil {
return 0, fmt.Errorf("src/dst reader/writer nil")
}
if len(keys) == 0 {
// Default keys : ctrl-p ctrl-q
keys = []byte{16, 17}
}
buf := make([]byte, 32*1024)
... | go | {
"resource": ""
} |
q27916 | WriteGoroutineStacks | train | func WriteGoroutineStacks(w io.Writer) error {
if w == nil {
return fmt.Errorf("writer nil")
}
buf := make([]byte, 1<<20)
for i := 0; ; 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.Wr... | go | {
"resource": ""
} |
q27917 | WriteGoroutineStacksToFile | train | func WriteGoroutineStacksToFile(path string) error {
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0666)
if err != nil {
return err
}
defer f.Close()
defer f.Sync()
return WriteGoroutineStacks(f)
} | go | {
"resource": ""
} |
q27918 | GenerateID | train | func GenerateID() string {
b := make([]byte, 32)
rand.Read(b)
return hex.EncodeToString(b)
} | go | {
"resource": ""
} |
q27919 | openContainerFile | train | func openContainerFile(rootfs string, path string) (io.ReadCloser, error) {
fp, err := symlink.FollowSymlinkInScope(filepath.Join(rootfs, path), rootfs)
if err != nil {
return nil, err
}
return os.Open(fp)
} | go | {
"resource": ""
} |
q27920 | Add | train | func (g *WriterGroup) Add(key string, w io.WriteCloser) {
g.mu.Lock()
defer g.mu.Unlock()
if g.closed {
w.Close()
return
}
g.writers[key] = w
} | go | {
"resource": ""
} |
q27921 | Get | train | func (g *WriterGroup) Get(key string) io.WriteCloser {
g.mu.Lock()
defer g.mu.Unlock()
return g.writers[key]
} | go | {
"resource": ""
} |
q27922 | Remove | train | func (g *WriterGroup) Remove(key string) {
g.mu.Lock()
defer g.mu.Unlock()
w, ok := g.writers[key]
if !ok {
return
}
w.Close()
delete(g.writers, key)
} | go | {
"resource": ""
} |
q27923 | Write | train | func (g *WriterGroup) Write(p []byte) (int, error) {
g.mu.Lock()
defer g.mu.Unlock()
for k, w := range g.writers {
n, err := w.Write(p)
if err == nil && 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, ... | go | {
"resource": ""
} |
q27924 | Close | train | func (g *WriterGroup) Close() {
g.mu.Lock()
defer g.mu.Unlock()
for _, w := range g.writers {
w.Close()
}
g.writers = nil
g.closed = true
} | go | {
"resource": ""
} |
q27925 | New | train | func New(defaultRuntime string,
runtimes map[string]RuntimeHandler,
conmonPath string,
conmonEnv []string,
cgroupManager string,
containerExitsDir string,
containerAttachSocketDir string,
logSizeMax int64,
logToJournald bool,
noPivot bool,
ctrStopTimeout int64) (*Runtime, error) {
defRuntime, ok := runtimes... | go | {
"resource": ""
} |
q27926 | ValidateRuntimeHandler | train | func (r *Runtime) ValidateRuntimeHandler(handler string) (RuntimeHandler, error) {
if handler == "" {
return RuntimeHandler{}, fmt.Errorf("empty runtime handler")
}
runtimeHandler, ok := r.runtimes[handler]
if !ok {
return RuntimeHandler{}, fmt.Errorf("failed to find runtime handler %s from runtime list %v",
... | go | {
"resource": ""
} |
q27927 | RuntimeImpl | train | func (r *Runtime) RuntimeImpl(c *Container) (RuntimeImpl, error) {
impl, ok := r.runtimeImplList[c.ID()]
if !ok {
return r.newRuntimeImpl(c)
}
return impl, nil
} | go | {
"resource": ""
} |
q27928 | newPipe | train | func newPipe() (parent *os.File, child *os.File, err error) {
fds, err := unix.Socketpair(unix.AF_LOCAL, unix.SOCK_STREAM|unix.SOCK_CLOEXEC, 0)
if err != nil {
return nil, nil, err
}
return os.NewFile(uintptr(fds[1]), "parent"), os.NewFile(uintptr(fds[0]), "child"), nil
} | go | {
"resource": ""
} |
q27929 | findStringInSignalMap | train | func findStringInSignalMap(killSignal syscall.Signal) (string, error) {
for k, v := range signal.SignalMap {
if v == killSignal {
return k, nil
}
}
return "", errors.Errorf("unable to convert signal to string")
} | go | {
"resource": ""
} |
q27930 | GetStorageContainer | train | func (c *ContainerServer) GetStorageContainer(container string) (*cstorage.Container, error) {
ociCtr, err := c.LookupContainer(container)
if err != nil {
return nil, err
}
return c.store.Container(ociCtr.ID())
} | go | {
"resource": ""
} |
q27931 | GetContainerTopLayerID | train | func (c *ContainerServer) GetContainerTopLayerID(containerID string) (string, error) {
ctr, err := c.GetStorageContainer(containerID)
if err != nil {
return "", err
}
return ctr.LayerID, nil
} | go | {
"resource": ""
} |
q27932 | GetContainerRwSize | train | func (c *ContainerServer) GetContainerRwSize(containerID string) (int64, error) {
container, err := c.store.Container(containerID)
if err != nil {
return 0, err
}
// Get the size of the top layer by calculating the size of the diff
// between the layer and its parent. The top layer of a container is
// the on... | go | {
"resource": ""
} |
q27933 | GetContainerFromShortID | train | func (c *ContainerServer) GetContainerFromShortID(cid string) (*oci.Container, error) {
if cid == "" {
return nil, fmt.Errorf("container ID should not be empty")
}
containerID, err := c.ctrIDIndex.Get(cid)
if err != nil {
return nil, fmt.Errorf("container with ID starting with %s not found: %v", cid, err)
}
... | go | {
"resource": ""
} |
q27934 | LookupContainer | train | func (c *ContainerServer) LookupContainer(idOrName string) (*oci.Container, error) {
if idOrName == "" {
return nil, fmt.Errorf("container ID or name should not be empty")
}
ctrID, err := c.ctrNameIndex.Get(idOrName)
if err != nil {
if err == registrar.ErrNameNotReserved {
ctrID = idOrName
} else {
ret... | go | {
"resource": ""
} |
q27935 | LookupSandbox | train | func (c *ContainerServer) LookupSandbox(idOrName string) (*sandbox.Sandbox, error) {
if idOrName == "" {
return nil, fmt.Errorf("container ID or name should not be empty")
}
podID, err := c.podNameIndex.Get(idOrName)
if err != nil {
if err == registrar.ErrNameNotReserved {
podID = idOrName
} else {
ret... | go | {
"resource": ""
} |
q27936 | Exec | train | func (ss StreamService) Exec(containerID string, cmd []string, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error {
c, err := ss.runtimeServer.GetContainerFromShortID(containerID)
if err != nil {
return fmt.Errorf("could not find container %q: %v", containerID,... | go | {
"resource": ""
} |
q27937 | Tag | train | func (f *Field) Tag(key string) string {
return f.field.Tag.Get(key)
} | go | {
"resource": ""
} |
q27938 | Field | train | func (f *Field) Field(name string) *Field {
field, ok := f.FieldOk(name)
if !ok {
panic("field not found")
}
return field
} | go | {
"resource": ""
} |
q27939 | FillMap | train | func (s *Struct) FillMap(out map[string]interface{}) {
if out == nil {
return
}
fields := s.structFields()
for _, field := range fields {
name := field.Name
val := s.value.FieldByName(name)
isSubStruct := false
var finalVal interface{}
tagName, tagOpts := parseTag(field.Tag.Get(s.TagName))
if tagNa... | go | {
"resource": ""
} |
q27940 | Field | train | func (s *Struct) Field(name string) *Field {
f, ok := s.FieldOk(name)
if !ok {
panic("field not found")
}
return f
} | go | {
"resource": ""
} |
q27941 | FieldOk | train | func (s *Struct) FieldOk(name string) (*Field, bool) {
t := s.value.Type()
field, ok := t.FieldByName(name)
if !ok {
return nil, false
}
return &Field{
field: field,
value: s.value.FieldByName(name),
defaultTag: s.TagName,
}, true
} | go | {
"resource": ""
} |
q27942 | structFields | train | func (s *Struct) structFields() []reflect.StructField {
t := s.value.Type()
var f []reflect.StructField
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
// we can't access the value of unexported fields
if field.PkgPath != "" {
continue
}
// don't check if it's omitted
if tag := field.Tag.Ge... | go | {
"resource": ""
} |
q27943 | IsStruct | train | func IsStruct(s interface{}) bool {
v := reflect.ValueOf(s)
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
// uninitialized zero value of a struct
if v.Kind() == reflect.Invalid {
return false
}
return v.Kind() == reflect.Struct
} | go | {
"resource": ""
} |
q27944 | nested | train | func (s *Struct) nested(val reflect.Value) interface{} {
var finalVal interface{}
v := reflect.ValueOf(val.Interface())
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
switch v.Kind() {
case reflect.Struct:
n := New(val.Interface())
n.TagName = s.TagName
m := n.Map()
// do not add the converted value if ... | go | {
"resource": ""
} |
q27945 | Has | train | func (t tagOptions) Has(opt string) bool {
for _, tagOpt := range t {
if tagOpt == opt {
return true
}
}
return false
} | go | {
"resource": ""
} |
q27946 | OAuth2ClientCredentials | train | func OAuth2ClientCredentials(clientID, clientSecret, tokenURL string) registry.Option {
return func(o *registry.Options) {
c := clientcredentials.Config{
ClientID: clientID,
ClientSecret: clientSecret,
TokenURL: tokenURL,
}
o.Context = context.WithValue(o.Context, contextHttpClient{}, newOAuthC... | go | {
"resource": ""
} |
q27947 | getHTTP | train | func getHTTP(url, method string, err error) *awsxray.HTTP {
return &awsxray.HTTP{
Request: &awsxray.Request{
Method: method,
URL: url,
},
Response: &awsxray.Response{
Status: getStatus(err),
},
}
} | go | {
"resource": ""
} |
q27948 | getSegment | train | func getSegment(name string, ctx context.Context) *awsxray.Segment {
md, _ := metadata.FromContext(ctx)
parentId := getParentId(md)
traceId := getTraceId(md)
// try get existing segment for parent Id
if s, ok := awsxray.FromContext(ctx); ok {
// only set existing segment as parent if its not a subsegment itself... | go | {
"resource": ""
} |
q27949 | getStatus | train | func getStatus(err error) int {
// no error
if err == nil {
return 200
}
// try get errors.Error
if e, ok := err.(*errors.Error); ok {
return int(e.Code)
}
// try parse marshalled error
if e := errors.Parse(err.Error()); e.Code > 0 {
return int(e.Code)
}
// could not parse, 500
return 500
} | go | {
"resource": ""
} |
q27950 | setCallStatus | train | func setCallStatus(s *awsxray.Segment, url, method string, err error) {
s.HTTP = getHTTP(url, method, err)
status := getStatus(err)
switch {
case status >= 500:
s.Fault = true
case status >= 400:
s.Error = true
case err != nil:
s.Fault = true
}
} | go | {
"resource": ""
} |
q27951 | NewClientWrapper | train | func NewClientWrapper() client.Wrapper {
return func(c client.Client) client.Client {
return &clientWrapper{c}
}
} | go | {
"resource": ""
} |
q27952 | decodeBody | train | func decodeBody(r *msgp.Reader, v interface{}) error {
b, ok := v.(msgp.Decodable)
if !ok {
return ErrNotDecodable
}
return msgp.Decode(r, b)
} | go | {
"resource": ""
} |
q27953 | EncodeMsg | train | func (r *Request) EncodeMsg(w *msgp.Writer) error {
var bm msgp.Encodable
if r.Body != nil {
var ok bool
bm, ok = r.Body.(msgp.Encodable)
if !ok {
return ErrNotEncodable
}
}
var err error
if err = w.WriteArrayHeader(RequestPackSize); err != nil {
return err
}
if err = w.WriteInt(RequestType); er... | go | {
"resource": ""
} |
q27954 | EncodeMsg | train | func (n *Notification) EncodeMsg(w *msgp.Writer) error {
var bm msgp.Encodable
if n.Body != nil {
var ok bool
bm, ok = n.Body.(msgp.Encodable)
if !ok {
return ErrNotEncodable
}
}
var err error
if err = w.WriteArrayHeader(NotificationPackSize); err != nil {
return err
}
if err = w.WriteInt(Notifi... | go | {
"resource": ""
} |
q27955 | Stop | train | func (w *mockWatcher) Stop() {
select {
case <-w.stop:
return
default:
close(w.stop)
close(w.results)
}
} | go | {
"resource": ""
} |
q27956 | recv | train | func (s *subscriber) recv() {
// Close the connection once the subscriber stops receiving.
defer s.conn.Close()
for {
switch x := s.conn.Receive().(type) {
case redis.Message:
var m broker.Message
// Handle error? Only a log would be necessary since this type
// of issue cannot be fixed.
if err := ... | go | {
"resource": ""
} |
q27957 | Init | train | func (b *redisBroker) Init(opts ...broker.Option) error {
if b.pool != nil {
return errors.New("redis: cannot init while connected")
}
for _, o := range opts {
o(&b.opts)
}
return nil
} | go | {
"resource": ""
} |
q27958 | Disconnect | train | func (b *redisBroker) Disconnect() error {
err := b.pool.Close()
b.pool = nil
b.addr = ""
return err
} | go | {
"resource": ""
} |
q27959 | Publish | train | func (b *redisBroker) Publish(topic string, msg *broker.Message, opts ...broker.PublishOption) error {
v, err := b.opts.Codec.Marshal(msg)
if err != nil {
return err
}
conn := b.pool.Get()
_, err = redis.Int(conn.Do("PUBLISH", topic, v))
conn.Close()
return err
} | go | {
"resource": ""
} |
q27960 | Subscribe | train | func (b *redisBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
var options broker.SubscribeOptions
for _, o := range opts {
o(&options)
}
s := subscriber{
codec: b.opts.Codec,
conn: &redis.PubSubConn{Conn: b.pool.Get()},
topic: topic,
... | go | {
"resource": ""
} |
q27961 | setSubscribeOption | train | func setSubscribeOption(k, v interface{}) broker.SubscribeOption {
return func(o *broker.SubscribeOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
} | go | {
"resource": ""
} |
q27962 | setBrokerOption | train | func setBrokerOption(k, v interface{}) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
} | go | {
"resource": ""
} |
q27963 | setPublishOption | train | func setPublishOption(k, v interface{}) broker.PublishOption {
return func(o *broker.PublishOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
} | go | {
"resource": ""
} |
q27964 | convertCode | train | func convertCode(err error) codes.Code {
switch err {
case nil:
return codes.OK
case io.EOF:
return codes.OutOfRange
case io.ErrClosedPipe, io.ErrNoProgress, io.ErrShortBuffer, io.ErrShortWrite, io.ErrUnexpectedEOF:
return codes.FailedPrecondition
case os.ErrInvalid:
return codes.InvalidArgument
case cont... | go | {
"resource": ""
} |
q27965 | NewClientWrapper | train | func NewClientWrapper(cw client.Wrapper, eps ...string) client.Wrapper {
// create map of endpoints
endpoints := make(map[string]bool)
for _, ep := range eps {
endpoints[ep] = true
}
return func(c client.Client) client.Client {
return &clientWrapper{endpoints, cw, c}
}
} | go | {
"resource": ""
} |
q27966 | NewHandlerWrapper | train | func NewHandlerWrapper(hw server.HandlerWrapper, eps ...string) server.HandlerWrapper {
// create map of endpoints
endpoints := make(map[string]bool)
for _, ep := range eps {
endpoints[ep] = true
}
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp ... | go | {
"resource": ""
} |
q27967 | NewPlugin | train | func NewPlugin() plugin.Plugin {
return &allowedCors{
allowedHeaders: []string{},
allowedOrigins: []string{},
allowedMethods: []string{},
}
} | go | {
"resource": ""
} |
q27968 | NewClientWrapper | train | func NewClientWrapper(service micro.Service) client.Wrapper {
return func(c client.Client) client.Client {
return &clientWrapper{service, c}
}
} | go | {
"resource": ""
} |
q27969 | NewHandlerWrapper | train | func NewHandlerWrapper(service micro.Service) server.HandlerWrapper {
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) error {
ctx = micro.NewContext(ctx, service)
return h(ctx, req, rsp)
}
}
} | go | {
"resource": ""
} |
q27970 | NewClientWrapper | train | func NewClientWrapper(key string) client.Wrapper {
return func(c client.Client) client.Client {
return &shard{
key: key,
Client: c,
}
}
} | go | {
"resource": ""
} |
q27971 | ClientOption | train | func ClientOption(c ...option.ClientOption) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, clientOptionKey{}, c)
}
} | go | {
"resource": ""
} |
q27972 | ProjectID | train | func ProjectID(id string) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, projectIDKey{}, id)
}
} | go | {
"resource": ""
} |
q27973 | CreateSubscription | train | func CreateSubscription(b bool) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, createSubscription{}, b)
}
} | go | {
"resource": ""
} |
q27974 | DeleteSubscription | train | func DeleteSubscription(b bool) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, deleteSubscription{}, b)
}
} | go | {
"resource": ""
} |
q27975 | MaxExtension | train | func MaxExtension(d time.Duration) broker.SubscribeOption {
return func(o *broker.SubscribeOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, maxExtensionKey{}, d)
}
} | go | {
"resource": ""
} |
q27976 | secure | train | func (g *grpcClient) secure() grpc.DialOption {
if g.opts.Context != nil {
if v := g.opts.Context.Value(tlsAuth{}); v != nil {
tls := v.(*tls.Config)
creds := credentials.NewTLS(tls)
return grpc.WithTransportCredentials(creds)
}
}
return grpc.WithInsecure()
} | go | {
"resource": ""
} |
q27977 | NewCallWrapper | train | func NewCallWrapper(opts ...Option) client.CallWrapper {
options := Options{
Name: "go.micro.client.CallFunc",
Daemon: "localhost:2000",
}
for _, o := range opts {
o(&options)
}
x := newXRay(options)
return func(cf client.CallFunc) client.CallFunc {
return func(ctx context.Context, node *registry.Nod... | go | {
"resource": ""
} |
q27978 | NewClientWrapper | train | func NewClientWrapper(opts ...Option) client.Wrapper {
options := Options{
Name: "go.micro.client.Call",
Daemon: "localhost:2000",
}
for _, o := range opts {
o(&options)
}
return func(c client.Client) client.Client {
return &xrayWrapper{options, newXRay(options), c}
}
} | go | {
"resource": ""
} |
q27979 | NewHandlerWrapper | train | func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
options := Options{
Daemon: "localhost:2000",
}
for _, o := range opts {
o(&options)
}
x := newXRay(options)
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) error {
... | go | {
"resource": ""
} |
q27980 | Label | train | func Label(k, v string) selector.Option {
return func(o *selector.Options) {
l, ok := o.Context.Value(labelKey{}).([]label)
if !ok {
l = []label{}
}
l = append(l, label{k, v})
o.Context = context.WithValue(o.Context, labelKey{}, l)
}
} | go | {
"resource": ""
} |
q27981 | Auth | train | func Auth(username string, password string) broker.Option {
return setBrokerOption(authKey{}, &authRecord{
username: username,
password: password,
})
} | go | {
"resource": ""
} |
q27982 | WithResponse | train | func WithResponse(status int, header http.Header, body []byte) plugin.Plugin {
return &index{
r: &response{
status: status,
header: header,
body: body,
},
}
} | go | {
"resource": ""
} |
q27983 | run | train | func (s *subscriber) run(hdlr broker.Handler) {
log.Log(fmt.Sprintf("SQS subscription started. Queue:%s, URL: %s", s.queueName, s.URL))
for {
select {
case <-s.exit:
return
default:
result, err := s.svc.ReceiveMessage(&sqs.ReceiveMessageInput{
QueueUrl: &s.URL,
MaxNumberOfMessages: s.ge... | go | {
"resource": ""
} |
q27984 | Init | train | func (b *sqsBroker) Init(opts ...broker.Option) error {
for _, o := range opts {
o(&b.options)
}
return nil
} | go | {
"resource": ""
} |
q27985 | Publish | train | func (b *sqsBroker) Publish(queueName string, msg *broker.Message, opts ...broker.PublishOption) error {
queueURL, err := b.urlFromQueueName(queueName)
if err != nil {
return err
}
input := &sqs.SendMessageInput{
MessageBody: aws.String(string(msg.Body[:])),
QueueUrl: &queueURL,
}
input.MessageAttribute... | go | {
"resource": ""
} |
q27986 | Subscribe | train | func (b *sqsBroker) Subscribe(queueName string, h broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
queueURL, err := b.urlFromQueueName(queueName)
if err != nil {
return nil, err
}
options := broker.SubscribeOptions{
AutoAck: true,
Queue: queueName,
Context: context.Background(... | go | {
"resource": ""
} |
q27987 | NewBroker | train | func NewBroker(opts ...broker.Option) broker.Broker {
options := broker.Options{
Context: context.Background(),
}
for _, o := range opts {
o(&options)
}
return &sqsBroker{
options: options,
}
} | go | {
"resource": ""
} |
q27988 | Publish | train | func (h *grpcHandler) Publish(ctx context.Context, msg *proto.Message) (*proto.Empty, error) {
if len(msg.Topic) == 0 {
return nil, merr.InternalServerError("go.micro.broker", "Topic not found")
}
m := &broker.Message{
Header: msg.Header,
Body: msg.Body,
}
p := &grpcPublication{m: m, t: msg.Topic}
h.g.... | go | {
"resource": ""
} |
q27989 | verb | train | func (r *Request) verb(method string) *Request {
r.method = method
return r
} | go | {
"resource": ""
} |
q27990 | Namespace | train | func (r *Request) Namespace(s string) *Request {
r.namespace = s
return r
} | go | {
"resource": ""
} |
q27991 | Resource | train | func (r *Request) Resource(s string) *Request {
r.resource = s
return r
} | go | {
"resource": ""
} |
q27992 | Name | train | func (r *Request) Name(s string) *Request {
r.resourceName = &s
return r
} | go | {
"resource": ""
} |
q27993 | Body | train | func (r *Request) Body(in interface{}) *Request {
b := new(bytes.Buffer)
if err := json.NewEncoder(b).Encode(&in); err != nil {
r.err = err
return r
}
r.body = b
return r
} | go | {
"resource": ""
} |
q27994 | Params | train | func (r *Request) Params(p *Params) *Request {
for k, v := range p.LabelSelector {
r.params.Add("labelSelectors", k+"="+v)
}
return r
} | go | {
"resource": ""
} |
q27995 | SetHeader | train | func (r *Request) SetHeader(key, value string) *Request {
r.header.Add(key, value)
return r
} | go | {
"resource": ""
} |
q27996 | request | train | func (r *Request) request() (*http.Request, error) {
url := fmt.Sprintf("%s/api/v1/namespaces/%s/%s/", r.host, r.namespace, r.resource)
// append resourceName if it is present
if r.resourceName != nil {
url += *r.resourceName
}
// append any query params
if len(r.params) > 0 {
url += "?" + r.params.Encode()... | go | {
"resource": ""
} |
q27997 | Do | train | func (r *Request) Do() *Response {
if r.err != nil {
return &Response{
err: r.err,
}
}
req, err := r.request()
if err != nil {
return &Response{
err: err,
}
}
res, err := r.client.Do(req)
if err != nil {
return &Response{
err: err,
}
}
// return res, err
return newResponse(res, err)
} | go | {
"resource": ""
} |
q27998 | Watch | train | func (r *Request) Watch() (watch.Watch, error) {
if r.err != nil {
return nil, r.err
}
r.params.Set("watch", "true")
req, err := r.request()
if err != nil {
return nil, err
}
w, err := watch.NewBodyWatcher(req, r.client)
return w, err
} | go | {
"resource": ""
} |
q27999 | NewRequest | train | func NewRequest(opts *Options) *Request {
req := &Request{
header: make(http.Header),
params: make(url.Values),
client: opts.Client,
namespace: opts.Namespace,
host: opts.Host,
}
if opts.BearerToken != nil {
req.SetHeader("Authorization", "Bearer "+*opts.BearerToken)
}
return req
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.