_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q32500 | UpdateCluster | train | func UpdateCluster(tx Tx, c *api.Cluster) error {
// Ensure the name is either not in use or already used by this same Cluster.
if existing := tx.lookup(tableCluster, indexName, strings.ToLower(c.Spec.Annotations.Name)); existing != nil {
if existing.GetID() != c.ID {
return ErrNameConflict
}
}
return tx.up... | go | {
"resource": ""
} |
q32501 | DeleteCluster | train | func DeleteCluster(tx Tx, id string) error {
return tx.delete(tableCluster, id)
} | go | {
"resource": ""
} |
q32502 | GetCluster | train | func GetCluster(tx ReadTx, id string) *api.Cluster {
n := tx.get(tableCluster, id)
if n == nil {
return nil
}
return n.(*api.Cluster)
} | go | {
"resource": ""
} |
q32503 | FindClusters | train | func FindClusters(tx ReadTx, by By) ([]*api.Cluster, error) {
checkType := func(by By) error {
switch by.(type) {
case byName, byNamePrefix, byIDPrefix, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
clusterList := []*api.Cluster{}
appendResult := func(o api.StoreObject) {
... | go | {
"resource": ""
} |
q32504 | IsIngressNetwork | train | func IsIngressNetwork(nw *api.Network) bool {
if nw.Spec.Ingress {
return true
}
// Check if legacy defined ingress network
_, ok := nw.Spec.Annotations.Labels["com.docker.swarm.internal"]
return ok && nw.Spec.Annotations.Name == "ingress"
} | go | {
"resource": ""
} |
q32505 | IsIngressNetworkNeeded | train | func IsIngressNetworkNeeded(s *api.Service) bool {
if s == nil {
return false
}
if s.Spec.Endpoint == nil {
return false
}
for _, p := range s.Spec.Endpoint.Ports {
// The service to which this task belongs is trying to
// expose ports with PublishMode as Ingress to the
// external world. Automatically... | go | {
"resource": ""
} |
q32506 | PrintHeader | train | func PrintHeader(w io.Writer, columns ...string) {
underline := make([]string, len(columns))
for i := range underline {
underline[i] = strings.Repeat("-", len(columns[i]))
}
fmt.Fprintf(w, "%s\n", strings.Join(columns, "\t"))
fmt.Fprintf(w, "%s\n", strings.Join(underline, "\t"))
} | go | {
"resource": ""
} |
q32507 | NewRemotes | train | func NewRemotes(peers ...api.Peer) Remotes {
mwr := &remotesWeightedRandom{
remotes: make(map[api.Peer]int),
}
for _, peer := range peers {
mwr.Observe(peer, DefaultObservationWeight)
}
return mwr
} | go | {
"resource": ""
} |
q32508 | New | train | func New(store *store.MemoryStore, pg plugingetter.PluginGetter, netConfig *cnmallocator.NetworkConfig) (*Allocator, error) {
a := &Allocator{
store: store,
taskBallot: &taskBallot{
votes: make(map[string][]string),
},
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
pluginGetter:... | go | {
"resource": ""
} |
q32509 | Run | train | func (a *Allocator) Run(ctx context.Context) error {
// Setup cancel context for all goroutines to use.
ctx, cancel := context.WithCancel(ctx)
var (
wg sync.WaitGroup
actors []func() error
)
defer func() {
cancel()
wg.Wait()
close(a.doneChan)
}()
for _, aa := range []allocActor{
{
taskVoter:... | go | {
"resource": ""
} |
q32510 | Update | train | func (sc *StubController) Update(ctx context.Context, t *api.Task) error {
sc.called()
return sc.UpdateFn(ctx, t)
} | go | {
"resource": ""
} |
q32511 | Terminate | train | func (sc *StubController) Terminate(ctx context.Context) error {
sc.called()
return sc.TerminateFn(ctx)
} | go | {
"resource": ""
} |
q32512 | ParseAddConfig | train | func ParseAddConfig(cmd *cobra.Command, spec *api.ServiceSpec, flagName string) error {
flags := cmd.Flags()
if flags.Changed(flagName) {
configs, err := flags.GetStringSlice(flagName)
if err != nil {
return err
}
container := spec.Task.GetContainer()
if container == nil {
spec.Task.Runtime = &api.T... | go | {
"resource": ""
} |
q32513 | ParseRemoveConfig | train | func ParseRemoveConfig(cmd *cobra.Command, spec *api.ServiceSpec, flagName string) error {
flags := cmd.Flags()
if flags.Changed(flagName) {
configs, err := flags.GetStringSlice(flagName)
if err != nil {
return err
}
container := spec.Task.GetContainer()
if container == nil {
return nil
}
wantT... | go | {
"resource": ""
} |
q32514 | NewKeyReadWriter | train | func NewKeyReadWriter(paths CertPaths, kek []byte, headersObj PEMKeyHeaders) *KeyReadWriter {
return &KeyReadWriter{
kekData: KEKData{KEK: kek},
paths: paths,
headersObj: headersObj,
keyFormatter: keyutils.Default,
}
} | go | {
"resource": ""
} |
q32515 | SetKeyFormatter | train | func (k *KeyReadWriter) SetKeyFormatter(kf keyutils.Formatter) {
k.mu.Lock()
defer k.mu.Unlock()
k.keyFormatter = kf
} | go | {
"resource": ""
} |
q32516 | Migrate | train | func (k *KeyReadWriter) Migrate() error {
tmpPaths := k.genTempPaths()
keyBytes, err := ioutil.ReadFile(tmpPaths.Key)
if err != nil {
return nil // no key? no migration
}
// it does exist - no need to decrypt, because previous versions of swarmkit
// which supported this temporary key did not support encrypti... | go | {
"resource": ""
} |
q32517 | Read | train | func (k *KeyReadWriter) Read() ([]byte, []byte, error) {
k.mu.Lock()
defer k.mu.Unlock()
keyBlock, err := k.readKey()
if err != nil {
return nil, nil, err
}
if version, ok := keyBlock.Headers[versionHeader]; ok {
if versionInt, err := strconv.ParseUint(version, 10, 64); err == nil {
k.kekData.Version = ve... | go | {
"resource": ""
} |
q32518 | ViewAndRotateKEK | train | func (k *KeyReadWriter) ViewAndRotateKEK(cb func(KEKData, PEMKeyHeaders) (KEKData, PEMKeyHeaders, error)) error {
k.mu.Lock()
defer k.mu.Unlock()
updatedKEK, updatedHeaderObj, err := cb(k.kekData, k.headersObj)
if err != nil {
return err
}
keyBlock, err := k.readKey()
if err != nil {
return err
}
return... | go | {
"resource": ""
} |
q32519 | ViewAndUpdateHeaders | train | func (k *KeyReadWriter) ViewAndUpdateHeaders(cb func(PEMKeyHeaders) (PEMKeyHeaders, error)) error {
k.mu.Lock()
defer k.mu.Unlock()
pkh, err := cb(k.headersObj)
if err != nil {
return err
}
keyBlock, err := k.readKeyblock()
if err != nil {
return err
}
headers := make(map[string]string)
if pkh != nil {... | go | {
"resource": ""
} |
q32520 | GetCurrentState | train | func (k *KeyReadWriter) GetCurrentState() (PEMKeyHeaders, KEKData) {
k.mu.Lock()
defer k.mu.Unlock()
return k.headersObj, k.kekData
} | go | {
"resource": ""
} |
q32521 | writeKey | train | func (k *KeyReadWriter) writeKey(keyBlock *pem.Block, kekData KEKData, pkh PEMKeyHeaders) error {
if kekData.KEK != nil {
encryptedPEMBlock, err := k.keyFormatter.EncryptPEMBlock(keyBlock.Bytes, kekData.KEK)
if err != nil {
return err
}
if !keyutils.IsEncryptedPEMBlock(encryptedPEMBlock) {
return errors.... | go | {
"resource": ""
} |
q32522 | mergePEMHeaders | train | func mergePEMHeaders(original, newSet map[string]string) {
for key, value := range newSet {
normalizedKey := strings.TrimSpace(strings.ToLower(key))
if normalizedKey != "proc-type" && normalizedKey != "dek-info" {
original[key] = value
}
}
} | go | {
"resource": ""
} |
q32523 | Run | train | func (b *Benchmark) Run(ctx context.Context) error {
fmt.Printf("Listening for incoming connections at %s:%d\n", b.cfg.IP, b.cfg.Port)
if err := b.collector.Listen(b.cfg.Port); err != nil {
return err
}
j, err := b.launch(ctx)
if err != nil {
return err
}
fmt.Printf("Service %s launched (%d instances)\n", j.... | go | {
"resource": ""
} |
q32524 | NewTLSRenewer | train | func NewTLSRenewer(s *SecurityConfig, connBroker *connectionbroker.Broker, rootPaths CertPaths) *TLSRenewer {
return &TLSRenewer{
s: s,
connBroker: connBroker,
renew: make(chan struct{}, 1),
rootPaths: rootPaths,
}
} | go | {
"resource": ""
} |
q32525 | SetExpectedRole | train | func (t *TLSRenewer) SetExpectedRole(role string) {
t.mu.Lock()
t.expectedRole = role
t.mu.Unlock()
} | go | {
"resource": ""
} |
q32526 | NewSecretDriver | train | func (m *DriverProvider) NewSecretDriver(driver *api.Driver) (*SecretDriver, error) {
if m.pluginGetter == nil {
return nil, fmt.Errorf("plugin getter is nil")
}
if driver == nil && driver.Name == "" {
return nil, fmt.Errorf("driver specification is nil")
}
// Search for the specified plugin
plugin, err := m.... | go | {
"resource": ""
} |
q32527 | Set | train | func (m *ExternalCAOpt) Set(value string) error {
parsed, err := parseExternalCA(value)
if err != nil {
return err
}
m.values = append(m.values, parsed)
return nil
} | go | {
"resource": ""
} |
q32528 | AttachNetwork | train | func (ra *ResourceAllocator) AttachNetwork(ctx context.Context, request *api.AttachNetworkRequest) (*api.AttachNetworkResponse, error) {
nodeInfo, err := ca.RemoteNode(ctx)
if err != nil {
return nil, err
}
var network *api.Network
ra.store.View(func(tx store.ReadTx) {
network = store.GetNetwork(tx, request.C... | go | {
"resource": ""
} |
q32529 | DetachNetwork | train | func (ra *ResourceAllocator) DetachNetwork(ctx context.Context, request *api.DetachNetworkRequest) (*api.DetachNetworkResponse, error) {
if request.AttachmentID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
nodeInfo, err := ca.RemoteNode(ctx)
if err != nil {
return nil,... | go | {
"resource": ""
} |
q32530 | NewCollector | train | func NewCollector(store *store.MemoryStore) *Collector {
return &Collector{
store: store,
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
}
} | go | {
"resource": ""
} |
q32531 | Run | train | func (c *Collector) Run(ctx context.Context) error {
defer close(c.doneChan)
watcher, cancel, err := store.ViewAndWatch(c.store, func(readTx store.ReadTx) error {
nodes, err := store.FindNodes(readTx, store.All)
if err != nil {
return err
}
tasks, err := store.FindTasks(readTx, store.All)
if err != nil ... | go | {
"resource": ""
} |
q32532 | handleEvent | train | func (c *Collector) handleEvent(event events.Event) {
switch event.(type) {
case api.EventNode:
c.handleNodeEvent(event)
case api.EventTask:
c.handleTaskEvent(event)
case api.EventService:
c.handleServiceEvent(event)
case api.EventNetwork:
c.handleNetworkEvent(event)
case api.EventSecret:
c.handleSecret... | go | {
"resource": ""
} |
q32533 | GetTask | train | func (s *Server) GetTask(ctx context.Context, request *api.GetTaskRequest) (*api.GetTaskResponse, error) {
if request.TaskID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var task *api.Task
s.store.View(func(tx store.ReadTx) {
task = store.GetTask(tx, request.TaskID)
}... | go | {
"resource": ""
} |
q32534 | RemoveTask | train | func (s *Server) RemoveTask(ctx context.Context, request *api.RemoveTaskRequest) (*api.RemoveTaskResponse, error) {
if request.TaskID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
err := s.store.Update(func(tx store.Tx) error {
return store.DeleteTask(tx, request.TaskID)... | go | {
"resource": ""
} |
q32535 | NewSupervisor | train | func NewSupervisor(store *store.MemoryStore, restartSupervisor *restart.Supervisor) *Supervisor {
return &Supervisor{
store: store,
updates: make(map[string]*Updater),
restarts: restartSupervisor,
}
} | go | {
"resource": ""
} |
q32536 | CancelAll | train | func (u *Supervisor) CancelAll() {
u.l.Lock()
defer u.l.Unlock()
for _, update := range u.updates {
update.Cancel()
}
} | go | {
"resource": ""
} |
q32537 | NewUpdater | train | func NewUpdater(store *store.MemoryStore, restartSupervisor *restart.Supervisor, cluster *api.Cluster, newService *api.Service) *Updater {
return &Updater{
store: store,
watchQueue: store.WatchQueue(),
restarts: restartSupervisor,
cluster: cluster.Copy(),
newService: newService.Copy(),
... | go | {
"resource": ""
} |
q32538 | removeOldTasks | train | func (u *Updater) removeOldTasks(ctx context.Context, batch *store.Batch, removeTasks []*api.Task) (*api.Task, error) {
var (
lastErr error
removedTask *api.Task
)
for _, original := range removeTasks {
if original.DesiredState > api.TaskStateRunning {
continue
}
err := batch.Update(func(tx store.Tx... | go | {
"resource": ""
} |
q32539 | Update | train | func (tm *taskManager) Update(ctx context.Context, task *api.Task) error {
select {
case tm.updateq <- task:
return nil
case <-tm.closed:
return ErrClosed
case <-ctx.Done():
return ctx.Err()
}
} | go | {
"resource": ""
} |
q32540 | Close | train | func (tm *taskManager) Close() error {
tm.shutdownOnce.Do(func() {
close(tm.shutdown)
})
<-tm.closed
return nil
} | go | {
"resource": ""
} |
q32541 | Parse | train | func Parse(cmds []string) ([]*api.GenericResource, error) {
tokens := make(map[string][]string)
for _, term := range cmds {
kva := strings.Split(term, "=")
if len(kva) != 2 {
return nil, newParseError("incorrect term %s, missing"+
" '=' or malformed expression", term)
}
key := strings.TrimSpace(kva[0... | go | {
"resource": ""
} |
q32542 | newController | train | func newController(client engineapi.APIClient, nodeDescription *api.NodeDescription, task *api.Task, secrets exec.SecretGetter) (exec.Controller, error) {
adapter, err := newContainerAdapter(client, nodeDescription, task, secrets)
if err != nil {
return nil, err
}
return &controller{
task: task,
adapter: ... | go | {
"resource": ""
} |
q32543 | Update | train | func (r *controller) Update(ctx context.Context, t *api.Task) error {
log.G(ctx).Warnf("task updates not yet supported")
// TODO(stevvooe): While assignment of tasks is idempotent, we do allow
// updates of metadata, such as labelling, as well as any other properties
// that make sense.
return nil
} | go | {
"resource": ""
} |
q32544 | Prepare | train | func (r *controller) Prepare(ctx context.Context) error {
if err := r.checkClosed(); err != nil {
return err
}
// Make sure all the networks that the task needs are created.
if err := r.adapter.createNetworks(ctx); err != nil {
return err
}
// Make sure all the volumes that the task needs are created.
if e... | go | {
"resource": ""
} |
q32545 | Copy | train | func Copy(dst, src interface{}) {
switch dst := dst.(type) {
case *types.Any:
src := src.(*types.Any)
dst.TypeUrl = src.TypeUrl
if src.Value != nil {
dst.Value = make([]byte, len(src.Value))
copy(dst.Value, src.Value)
} else {
dst.Value = nil
}
case *types.Duration:
src := src.(*types.Duration)
... | go | {
"resource": ""
} |
q32546 | GetNetwork | train | func GetNetwork(ctx context.Context, c api.ControlClient, input string) (*api.Network, error) {
// GetService to match via full ID.
rg, err := c.GetNetwork(ctx, &api.GetNetworkRequest{NetworkID: input})
if err != nil {
// If any error (including NotFound), ListServices to match via full name.
rl, err := c.ListNe... | go | {
"resource": ""
} |
q32547 | ResolveServiceNetworks | train | func ResolveServiceNetworks(ctx context.Context, c api.ControlClient, spec *api.ServiceSpec) error {
if len(spec.Task.Networks) == 0 {
return nil
}
networks := make([]*api.NetworkAttachmentConfig, 0, len(spec.Task.Networks))
for _, na := range spec.Task.Networks {
n, err := GetNetwork(ctx, c, na.Target)
if er... | go | {
"resource": ""
} |
q32548 | runctx | train | func runctx(ctx context.Context, closed chan struct{}, errs chan error, fn func(ctx context.Context) error) {
select {
case errs <- fn(ctx):
case <-closed:
case <-ctx.Done():
}
} | go | {
"resource": ""
} |
q32549 | CreateTask | train | func CreateTask(tx Tx, t *api.Task) error {
return tx.create(tableTask, t)
} | go | {
"resource": ""
} |
q32550 | UpdateTask | train | func UpdateTask(tx Tx, t *api.Task) error {
return tx.update(tableTask, t)
} | go | {
"resource": ""
} |
q32551 | DeleteTask | train | func DeleteTask(tx Tx, id string) error {
return tx.delete(tableTask, id)
} | go | {
"resource": ""
} |
q32552 | GetTask | train | func GetTask(tx ReadTx, id string) *api.Task {
t := tx.get(tableTask, id)
if t == nil {
return nil
}
return t.(*api.Task)
} | go | {
"resource": ""
} |
q32553 | FindTasks | train | func FindTasks(tx ReadTx, by By) ([]*api.Task, error) {
checkType := func(by By) error {
switch by.(type) {
case byName, byNamePrefix, byIDPrefix, byRuntime, byDesiredState, byTaskState, byNode, byService, bySlot, byReferencedNetworkID, byReferencedSecretID, byReferencedConfigID, byCustom, byCustomPrefix:
retur... | go | {
"resource": ""
} |
q32554 | Pause | train | func (n *testNode) Pause(forceNewCluster bool) error {
rAddr, err := n.node.RemoteAPIAddr()
if err != nil {
rAddr = "127.0.0.1:0"
}
if err := n.stop(); err != nil {
return err
}
cfg := n.config
cfg.ListenRemoteAPI = rAddr
// If JoinAddr is set, the node will connect to the join addr and ignore any
// oth... | go | {
"resource": ""
} |
q32555 | Stop | train | func (n *testNode) Stop() error {
if err := n.stop(); err != nil {
return err
}
return os.RemoveAll(n.stateDir)
} | go | {
"resource": ""
} |
q32556 | ControlClient | train | func (n *testNode) ControlClient(ctx context.Context) (api.ControlClient, error) {
ctx, cancel := context.WithTimeout(ctx, opsTimeout)
defer cancel()
connChan := n.node.ListenControlSocket(ctx)
var controlConn *grpc.ClientConn
if err := testutils.PollFuncWithTimeout(nil, func() error {
select {
case controlCon... | go | {
"resource": ""
} |
q32557 | NewTask | train | func NewTask(cluster *api.Cluster, service *api.Service, slot uint64, nodeID string) *api.Task {
var logDriver *api.Driver
if service.Spec.Task.LogDriver != nil {
// use the log driver specific to the task, if we have it.
logDriver = service.Spec.Task.LogDriver
} else if cluster != nil {
// pick up the cluster... | go | {
"resource": ""
} |
q32558 | RestartCondition | train | func RestartCondition(task *api.Task) api.RestartPolicy_RestartCondition {
restartCondition := defaults.Service.Task.Restart.Condition
if task.Spec.Restart != nil {
restartCondition = task.Spec.Restart.Condition
}
return restartCondition
} | go | {
"resource": ""
} |
q32559 | nodeMatches | train | func nodeMatches(s *api.Service, n *api.Node) bool {
if n == nil {
return false
}
constraints, _ := constraint.Parse(s.Spec.Task.Placement.Constraints)
return constraint.NodeMatches(constraints, n)
} | go | {
"resource": ""
} |
q32560 | IsTaskDirtyPlacementConstraintsOnly | train | func IsTaskDirtyPlacementConstraintsOnly(serviceTaskSpec api.TaskSpec, t *api.Task) bool {
// Compare the task placement constraints.
if reflect.DeepEqual(serviceTaskSpec.Placement, t.Spec.Placement) {
return false
}
// Update spec placement to only the fields
// other than the placement constraints in the spec... | go | {
"resource": ""
} |
q32561 | InvalidNode | train | func InvalidNode(n *api.Node) bool {
return n == nil ||
n.Status.State == api.NodeStatus_DOWN ||
n.Spec.Availability == api.NodeAvailabilityDrain
} | go | {
"resource": ""
} |
q32562 | Swap | train | func (t TasksByTimestamp) Swap(i, j int) {
t[i], t[j] = t[j], t[i]
} | go | {
"resource": ""
} |
q32563 | Less | train | func (t TasksByTimestamp) Less(i, j int) bool {
iTimestamp := taskTimestamp(t[i])
jTimestamp := taskTimestamp(t[j])
if iTimestamp == nil {
return true
}
if jTimestamp == nil {
return false
}
if iTimestamp.Seconds < jTimestamp.Seconds {
return true
}
if iTimestamp.Seconds > jTimestamp.Seconds {
return ... | go | {
"resource": ""
} |
q32564 | NewChannelSink | train | func (s *TimeoutDropErrChanGen) NewChannelSink() (events.Sink, *events.Channel) {
ch := events.NewChannel(0)
return timeoutSink{
timeout: s.timeout,
sink: dropErrClosed{
sink: ch,
},
}, ch
} | go | {
"resource": ""
} |
q32565 | CreateNetwork | train | func CreateNetwork(tx Tx, n *api.Network) error {
// Ensure the name is not already in use.
if tx.lookup(tableNetwork, indexName, strings.ToLower(n.Spec.Annotations.Name)) != nil {
return ErrNameConflict
}
return tx.create(tableNetwork, n)
} | go | {
"resource": ""
} |
q32566 | UpdateNetwork | train | func UpdateNetwork(tx Tx, n *api.Network) error {
// Ensure the name is either not in use or already used by this same Network.
if existing := tx.lookup(tableNetwork, indexName, strings.ToLower(n.Spec.Annotations.Name)); existing != nil {
if existing.GetID() != n.ID {
return ErrNameConflict
}
}
return tx.up... | go | {
"resource": ""
} |
q32567 | DeleteNetwork | train | func DeleteNetwork(tx Tx, id string) error {
return tx.delete(tableNetwork, id)
} | go | {
"resource": ""
} |
q32568 | GetNetwork | train | func GetNetwork(tx ReadTx, id string) *api.Network {
n := tx.get(tableNetwork, id)
if n == nil {
return nil
}
return n.(*api.Network)
} | go | {
"resource": ""
} |
q32569 | FindNetworks | train | func FindNetworks(tx ReadTx, by By) ([]*api.Network, error) {
checkType := func(by By) error {
switch by.(type) {
case byName, byNamePrefix, byIDPrefix, byCustom, byCustomPrefix, byAll:
return nil
default:
return ErrInvalidFindBy
}
}
networkList := []*api.Network{}
appendResult := func(o api.StoreObj... | go | {
"resource": ""
} |
q32570 | AttachNetwork | train | func (r *resourceAllocator) AttachNetwork(ctx context.Context, id, target string, addresses []string) (string, error) {
var taskID string
if err := r.agent.withSession(ctx, func(session *session) error {
client := api.NewResourceAllocatorClient(session.conn.ClientConn)
r, err := client.AttachNetwork(ctx, &api.Att... | go | {
"resource": ""
} |
q32571 | DetachNetwork | train | func (r *resourceAllocator) DetachNetwork(ctx context.Context, aID string) error {
return r.agent.withSession(ctx, func(session *session) error {
client := api.NewResourceAllocatorClient(session.conn.ClientConn)
_, err := client.DetachNetwork(ctx, &api.DetachNetworkRequest{
AttachmentID: aID,
})
return err... | go | {
"resource": ""
} |
q32572 | CreateSecret | train | func CreateSecret(tx Tx, s *api.Secret) error {
// Ensure the name is not already in use.
if tx.lookup(tableSecret, indexName, strings.ToLower(s.Spec.Annotations.Name)) != nil {
return ErrNameConflict
}
return tx.create(tableSecret, s)
} | go | {
"resource": ""
} |
q32573 | UpdateSecret | train | func UpdateSecret(tx Tx, s *api.Secret) error {
// Ensure the name is either not in use or already used by this same Secret.
if existing := tx.lookup(tableSecret, indexName, strings.ToLower(s.Spec.Annotations.Name)); existing != nil {
if existing.GetID() != s.ID {
return ErrNameConflict
}
}
return tx.update... | go | {
"resource": ""
} |
q32574 | DeleteSecret | train | func DeleteSecret(tx Tx, id string) error {
return tx.delete(tableSecret, id)
} | go | {
"resource": ""
} |
q32575 | GetSecret | train | func GetSecret(tx ReadTx, id string) *api.Secret {
n := tx.get(tableSecret, id)
if n == nil {
return nil
}
return n.(*api.Secret)
} | go | {
"resource": ""
} |
q32576 | FindSecrets | train | func FindSecrets(tx ReadTx, by By) ([]*api.Secret, error) {
checkType := func(by By) error {
switch by.(type) {
case byName, byNamePrefix, byIDPrefix, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
secretList := []*api.Secret{}
appendResult := func(o api.StoreObject) {
se... | go | {
"resource": ""
} |
q32577 | getNodeNetworks | train | func (a *Allocator) getNodeNetworks(nodeID string) ([]*api.Network, error) {
var (
// no need to initialize networks. we only append to it, and appending
// to a nil slice is valid. this has the added bonus of making this nil
// if we return an error
networks []*api.Network
err error
)
a.store.View(fu... | go | {
"resource": ""
} |
q32578 | allocateServices | train | func (a *Allocator) allocateServices(ctx context.Context, existingAddressesOnly bool) error {
var (
nc = a.netCtx
services []*api.Service
err error
)
a.store.View(func(tx store.ReadTx) {
services, err = store.FindServices(tx, store.All)
})
if err != nil {
return errors.Wrap(err, "error listing... | go | {
"resource": ""
} |
q32579 | taskReadyForNetworkVote | train | func taskReadyForNetworkVote(t *api.Task, s *api.Service, nc *networkContext) bool {
// Task is ready for vote if the following is true:
//
// Task has no network attached or networks attached but all
// of them allocated AND Task's service has no endpoint or
// network configured or service endpoints have been
/... | go | {
"resource": ""
} |
q32580 | allocateNode | train | func (a *Allocator) allocateNode(ctx context.Context, node *api.Node, existingAddressesOnly bool, networks []*api.Network) bool {
var allocated bool
nc := a.netCtx
var nwIDs = make(map[string]struct{}, len(networks))
// go through all of the networks we've passed in
for _, network := range networks {
nwIDs[ne... | go | {
"resource": ""
} |
q32581 | allocateService | train | func (a *Allocator) allocateService(ctx context.Context, s *api.Service, existingAddressesOnly bool) error {
nc := a.netCtx
if s.Spec.Endpoint != nil {
// service has user-defined endpoint
if s.Endpoint == nil {
// service currently has no allocated endpoint, need allocated.
s.Endpoint = &api.Endpoint{
... | go | {
"resource": ""
} |
q32582 | updateTaskStatus | train | func updateTaskStatus(t *api.Task, newStatus api.TaskState, message string) {
t.Status = api.TaskStatus{
State: newStatus,
Message: message,
Timestamp: ptypes.MustTimestampProto(time.Now()),
}
} | go | {
"resource": ""
} |
q32583 | GetIngressNetwork | train | func GetIngressNetwork(s *store.MemoryStore) (*api.Network, error) {
var (
networks []*api.Network
err error
)
s.View(func(tx store.ReadTx) {
networks, err = store.FindNetworks(tx, store.All)
})
if err != nil {
return nil, err
}
for _, n := range networks {
if IsIngressNetwork(n) {
return n, ni... | go | {
"resource": ""
} |
q32584 | Check | train | func (s *Server) Check(ctx context.Context, in *api.HealthCheckRequest) (*api.HealthCheckResponse, error) {
s.mu.Lock()
defer s.mu.Unlock()
if in.Service == "" {
// check the server overall health status.
return &api.HealthCheckResponse{
Status: api.HealthCheckResponse_SERVING,
}, nil
}
if status, ok := s... | go | {
"resource": ""
} |
q32585 | CreateExtension | train | func (s *Server) CreateExtension(ctx context.Context, request *api.CreateExtensionRequest) (*api.CreateExtensionResponse, error) {
if request.Annotations == nil || request.Annotations.Name == "" {
return nil, status.Errorf(codes.InvalidArgument, "extension name must be provided")
}
extension := &api.Extension{
... | go | {
"resource": ""
} |
q32586 | GetExtension | train | func (s *Server) GetExtension(ctx context.Context, request *api.GetExtensionRequest) (*api.GetExtensionResponse, error) {
if request.ExtensionID == "" {
return nil, status.Errorf(codes.InvalidArgument, "extension ID must be provided")
}
var extension *api.Extension
s.store.View(func(tx store.ReadTx) {
extensio... | go | {
"resource": ""
} |
q32587 | RemoveExtension | train | func (s *Server) RemoveExtension(ctx context.Context, request *api.RemoveExtensionRequest) (*api.RemoveExtensionResponse, error) {
if request.ExtensionID == "" {
return nil, status.Errorf(codes.InvalidArgument, "extension ID must be provided")
}
err := s.store.Update(func(tx store.Tx) error {
// Check if the ex... | go | {
"resource": ""
} |
q32588 | WithFields | train | func WithFields(ctx context.Context, fields logrus.Fields) context.Context {
logger := ctx.Value(loggerKey{})
if logger == nil {
logger = L
}
return WithLogger(ctx, logger.(*logrus.Entry).WithFields(fields))
} | go | {
"resource": ""
} |
q32589 | WithField | train | func WithField(ctx context.Context, key, value string) context.Context {
return WithFields(ctx, logrus.Fields{key: value})
} | go | {
"resource": ""
} |
q32590 | GetModulePath | train | func GetModulePath(ctx context.Context) string {
module := ctx.Value(moduleKey{})
if module == nil {
return ""
}
return module.(string)
} | go | {
"resource": ""
} |
q32591 | Claim | train | func Claim(nodeAvailableResources, taskAssigned *[]*api.GenericResource,
taskReservations []*api.GenericResource) error {
var resSelected []*api.GenericResource
for _, res := range taskReservations {
tr := res.GetDiscreteResourceSpec()
if tr == nil {
return fmt.Errorf("task should only hold Discrete type")
... | go | {
"resource": ""
} |
q32592 | ClaimResources | train | func ClaimResources(nodeAvailableResources, taskAssigned *[]*api.GenericResource,
resSelected []*api.GenericResource) {
*taskAssigned = append(*taskAssigned, resSelected...)
ConsumeNodeResources(nodeAvailableResources, resSelected)
} | go | {
"resource": ""
} |
q32593 | Reclaim | train | func Reclaim(nodeAvailableResources *[]*api.GenericResource, taskAssigned, nodeRes []*api.GenericResource) error {
err := reclaimResources(nodeAvailableResources, taskAssigned)
if err != nil {
return err
}
sanitize(nodeRes, nodeAvailableResources)
return nil
} | go | {
"resource": ""
} |
q32594 | Kind | train | func Kind(res *api.GenericResource) string {
switch r := res.Resource.(type) {
case *api.GenericResource_DiscreteResourceSpec:
return r.DiscreteResourceSpec.Kind
case *api.GenericResource_NamedResourceSpec:
return r.NamedResourceSpec.Kind
}
return ""
} | go | {
"resource": ""
} |
q32595 | Value | train | func Value(res *api.GenericResource) string {
switch res := res.Resource.(type) {
case *api.GenericResource_DiscreteResourceSpec:
return discreteToString(res)
case *api.GenericResource_NamedResourceSpec:
return res.NamedResourceSpec.Value
}
return ""
} | go | {
"resource": ""
} |
q32596 | EnvFormat | train | func EnvFormat(res []*api.GenericResource, prefix string) []string {
envs := make(map[string][]string)
for _, v := range res {
key := Kind(v)
val := Value(v)
envs[key] = append(envs[key], val)
}
env := make([]string, 0, len(res))
for k, v := range envs {
k = strings.ToUpper(prefix + "_" + k)
env = appen... | go | {
"resource": ""
} |
q32597 | Merge | train | func Merge(cmd *cobra.Command, spec *api.ServiceSpec, c api.ControlClient) error {
flags := cmd.Flags()
if flags.Changed("force") {
force, err := flags.GetBool("force")
if err != nil {
return err
}
if force {
spec.Task.ForceUpdate++
}
}
if flags.Changed("name") {
name, err := flags.GetString("na... | go | {
"resource": ""
} |
q32598 | observe | train | func (l *lastSeenRole) observe(newRole api.NodeRole) bool {
changed := l.role != newRole
l.role = newRole
return changed
} | go | {
"resource": ""
} |
q32599 | RemoteAPIAddr | train | func (n *Node) RemoteAPIAddr() (string, error) {
n.RLock()
defer n.RUnlock()
if n.manager == nil {
return "", errors.New("manager is not running")
}
addr := n.manager.Addr()
if addr == "" {
return "", errors.New("manager addr is not set")
}
return addr, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.