repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
docker/swarmkit | agent/storage.go | GetTask | func GetTask(tx *bolt.Tx, id string) (*api.Task, error) {
var t api.Task
if err := withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
p := bkt.Get(bucketKeyData)
if p == nil {
return errTaskUnknown
}
return proto.Unmarshal(p, &t)
}); err != nil {
return nil, err
}
return &t, nil
} | go | func GetTask(tx *bolt.Tx, id string) (*api.Task, error) {
var t api.Task
if err := withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
p := bkt.Get(bucketKeyData)
if p == nil {
return errTaskUnknown
}
return proto.Unmarshal(p, &t)
}); err != nil {
return nil, err
}
return &t, nil
} | [
"func",
"GetTask",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"id",
"string",
")",
"(",
"*",
"api",
".",
"Task",
",",
"error",
")",
"{",
"var",
"t",
"api",
".",
"Task",
"\n",
"if",
"err",
":=",
"withTaskBucket",
"(",
"tx",
",",
"id",
",",
"func",
... | // GetTask retrieves the task with id from the datastore. | [
"GetTask",
"retrieves",
"the",
"task",
"with",
"id",
"from",
"the",
"datastore",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L34-L49 | train |
docker/swarmkit | agent/storage.go | WalkTasks | func WalkTasks(tx *bolt.Tx, fn func(task *api.Task) error) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.ForEach(func(k, v []byte) error {
tbkt := bkt.Bucket(k)
p := tbkt.Get(bucketKeyData)
var t api.Task
if err := proto.Unmarshal(p, &t); err != nil {
return err
}
return fn(&t)
})
} | go | func WalkTasks(tx *bolt.Tx, fn func(task *api.Task) error) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.ForEach(func(k, v []byte) error {
tbkt := bkt.Bucket(k)
p := tbkt.Get(bucketKeyData)
var t api.Task
if err := proto.Unmarshal(p, &t); err != nil {
return err
}
return fn(&t)
})
} | [
"func",
"WalkTasks",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"fn",
"func",
"(",
"task",
"*",
"api",
".",
"Task",
")",
"error",
")",
"error",
"{",
"bkt",
":=",
"getTasksBucket",
"(",
"tx",
")",
"\n",
"if",
"bkt",
"==",
"nil",
"{",
"return",
"nil",... | // WalkTasks walks all tasks in the datastore. | [
"WalkTasks",
"walks",
"all",
"tasks",
"in",
"the",
"datastore",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L52-L69 | train |
docker/swarmkit | agent/storage.go | TaskAssigned | func TaskAssigned(tx *bolt.Tx, id string) bool {
bkt := getTaskBucket(tx, id)
if bkt == nil {
return false
}
return len(bkt.Get(bucketKeyAssigned)) > 0
} | go | func TaskAssigned(tx *bolt.Tx, id string) bool {
bkt := getTaskBucket(tx, id)
if bkt == nil {
return false
}
return len(bkt.Get(bucketKeyAssigned)) > 0
} | [
"func",
"TaskAssigned",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"id",
"string",
")",
"bool",
"{",
"bkt",
":=",
"getTaskBucket",
"(",
"tx",
",",
"id",
")",
"\n",
"if",
"bkt",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"len",
"... | // TaskAssigned returns true if the task is assigned to the node. | [
"TaskAssigned",
"returns",
"true",
"if",
"the",
"task",
"is",
"assigned",
"to",
"the",
"node",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L72-L79 | train |
docker/swarmkit | agent/storage.go | GetTaskStatus | func GetTaskStatus(tx *bolt.Tx, id string) (*api.TaskStatus, error) {
var ts api.TaskStatus
if err := withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
p := bkt.Get(bucketKeyStatus)
if p == nil {
return errTaskUnknown
}
return proto.Unmarshal(p, &ts)
}); err != nil {
return nil, err
}
return &ts, nil
} | go | func GetTaskStatus(tx *bolt.Tx, id string) (*api.TaskStatus, error) {
var ts api.TaskStatus
if err := withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
p := bkt.Get(bucketKeyStatus)
if p == nil {
return errTaskUnknown
}
return proto.Unmarshal(p, &ts)
}); err != nil {
return nil, err
}
return &ts, nil
} | [
"func",
"GetTaskStatus",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"id",
"string",
")",
"(",
"*",
"api",
".",
"TaskStatus",
",",
"error",
")",
"{",
"var",
"ts",
"api",
".",
"TaskStatus",
"\n",
"if",
"err",
":=",
"withTaskBucket",
"(",
"tx",
",",
"id"... | // GetTaskStatus returns the current status for the task. | [
"GetTaskStatus",
"returns",
"the",
"current",
"status",
"for",
"the",
"task",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L82-L96 | train |
docker/swarmkit | agent/storage.go | WalkTaskStatus | func WalkTaskStatus(tx *bolt.Tx, fn func(id string, status *api.TaskStatus) error) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.ForEach(func(k, v []byte) error {
tbkt := bkt.Bucket(k)
p := tbkt.Get(bucketKeyStatus)
var ts api.TaskStatus
if err := proto.Unmarshal(p, &ts); err != nil {
return err
}
return fn(string(k), &ts)
})
} | go | func WalkTaskStatus(tx *bolt.Tx, fn func(id string, status *api.TaskStatus) error) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.ForEach(func(k, v []byte) error {
tbkt := bkt.Bucket(k)
p := tbkt.Get(bucketKeyStatus)
var ts api.TaskStatus
if err := proto.Unmarshal(p, &ts); err != nil {
return err
}
return fn(string(k), &ts)
})
} | [
"func",
"WalkTaskStatus",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"fn",
"func",
"(",
"id",
"string",
",",
"status",
"*",
"api",
".",
"TaskStatus",
")",
"error",
")",
"error",
"{",
"bkt",
":=",
"getTasksBucket",
"(",
"tx",
")",
"\n",
"if",
"bkt",
"=... | // WalkTaskStatus calls fn for the status of each task. | [
"WalkTaskStatus",
"calls",
"fn",
"for",
"the",
"status",
"of",
"each",
"task",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L99-L116 | train |
docker/swarmkit | agent/storage.go | PutTask | func PutTask(tx *bolt.Tx, task *api.Task) error {
return withCreateTaskBucketIfNotExists(tx, task.ID, func(bkt *bolt.Bucket) error {
taskCopy := *task
taskCopy.Status = api.TaskStatus{} // blank out the status.
p, err := proto.Marshal(&taskCopy)
if err != nil {
return err
}
return bkt.Put(bucketKeyData, p)
})
} | go | func PutTask(tx *bolt.Tx, task *api.Task) error {
return withCreateTaskBucketIfNotExists(tx, task.ID, func(bkt *bolt.Bucket) error {
taskCopy := *task
taskCopy.Status = api.TaskStatus{} // blank out the status.
p, err := proto.Marshal(&taskCopy)
if err != nil {
return err
}
return bkt.Put(bucketKeyData, p)
})
} | [
"func",
"PutTask",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"task",
"*",
"api",
".",
"Task",
")",
"error",
"{",
"return",
"withCreateTaskBucketIfNotExists",
"(",
"tx",
",",
"task",
".",
"ID",
",",
"func",
"(",
"bkt",
"*",
"bolt",
".",
"Bucket",
")",
... | // PutTask places the task into the database. | [
"PutTask",
"places",
"the",
"task",
"into",
"the",
"database",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L119-L130 | train |
docker/swarmkit | agent/storage.go | PutTaskStatus | func PutTaskStatus(tx *bolt.Tx, id string, status *api.TaskStatus) error {
return withCreateTaskBucketIfNotExists(tx, id, func(bkt *bolt.Bucket) error {
p, err := proto.Marshal(status)
if err != nil {
return err
}
return bkt.Put(bucketKeyStatus, p)
})
} | go | func PutTaskStatus(tx *bolt.Tx, id string, status *api.TaskStatus) error {
return withCreateTaskBucketIfNotExists(tx, id, func(bkt *bolt.Bucket) error {
p, err := proto.Marshal(status)
if err != nil {
return err
}
return bkt.Put(bucketKeyStatus, p)
})
} | [
"func",
"PutTaskStatus",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"id",
"string",
",",
"status",
"*",
"api",
".",
"TaskStatus",
")",
"error",
"{",
"return",
"withCreateTaskBucketIfNotExists",
"(",
"tx",
",",
"id",
",",
"func",
"(",
"bkt",
"*",
"bolt",
"... | // PutTaskStatus updates the status for the task with id. | [
"PutTaskStatus",
"updates",
"the",
"status",
"for",
"the",
"task",
"with",
"id",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L133-L141 | train |
docker/swarmkit | agent/storage.go | DeleteTask | func DeleteTask(tx *bolt.Tx, id string) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.DeleteBucket([]byte(id))
} | go | func DeleteTask(tx *bolt.Tx, id string) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.DeleteBucket([]byte(id))
} | [
"func",
"DeleteTask",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"id",
"string",
")",
"error",
"{",
"bkt",
":=",
"getTasksBucket",
"(",
"tx",
")",
"\n",
"if",
"bkt",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"bkt",
".",
"DeleteBuck... | // DeleteTask completely removes the task from the database. | [
"DeleteTask",
"completely",
"removes",
"the",
"task",
"from",
"the",
"database",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L144-L151 | train |
docker/swarmkit | agent/storage.go | SetTaskAssignment | func SetTaskAssignment(tx *bolt.Tx, id string, assigned bool) error {
return withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
if assigned {
return bkt.Put(bucketKeyAssigned, []byte{0xFF})
}
return bkt.Delete(bucketKeyAssigned)
})
} | go | func SetTaskAssignment(tx *bolt.Tx, id string, assigned bool) error {
return withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
if assigned {
return bkt.Put(bucketKeyAssigned, []byte{0xFF})
}
return bkt.Delete(bucketKeyAssigned)
})
} | [
"func",
"SetTaskAssignment",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"id",
"string",
",",
"assigned",
"bool",
")",
"error",
"{",
"return",
"withTaskBucket",
"(",
"tx",
",",
"id",
",",
"func",
"(",
"bkt",
"*",
"bolt",
".",
"Bucket",
")",
"error",
"{",... | // SetTaskAssignment sets the current assignment state. | [
"SetTaskAssignment",
"sets",
"the",
"current",
"assignment",
"state",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/storage.go#L154-L161 | train |
docker/swarmkit | api/defaults/service.go | InterpolateService | func InterpolateService(origSpec *api.ServiceSpec) *api.ServiceSpec {
spec := origSpec.Copy()
container := spec.Task.GetContainer()
defaultContainer := Service.Task.GetContainer()
if container != nil {
if container.StopGracePeriod == nil {
container.StopGracePeriod = &gogotypes.Duration{}
deepcopy.Copy(container.StopGracePeriod, defaultContainer.StopGracePeriod)
}
if container.PullOptions == nil {
container.PullOptions = defaultContainer.PullOptions.Copy()
}
if container.DNSConfig == nil {
container.DNSConfig = defaultContainer.DNSConfig.Copy()
}
}
if spec.Task.Resources == nil {
spec.Task.Resources = Service.Task.Resources.Copy()
}
if spec.Task.Restart == nil {
spec.Task.Restart = Service.Task.Restart.Copy()
} else {
if spec.Task.Restart.Delay == nil {
spec.Task.Restart.Delay = &gogotypes.Duration{}
deepcopy.Copy(spec.Task.Restart.Delay, Service.Task.Restart.Delay)
}
}
if spec.Task.Placement == nil {
spec.Task.Placement = Service.Task.Placement.Copy()
}
if spec.Update == nil {
spec.Update = Service.Update.Copy()
} else {
if spec.Update.Monitor == nil {
spec.Update.Monitor = &gogotypes.Duration{}
deepcopy.Copy(spec.Update.Monitor, Service.Update.Monitor)
}
}
if spec.Rollback == nil {
spec.Rollback = Service.Rollback.Copy()
} else {
if spec.Rollback.Monitor == nil {
spec.Rollback.Monitor = &gogotypes.Duration{}
deepcopy.Copy(spec.Rollback.Monitor, Service.Rollback.Monitor)
}
}
return spec
} | go | func InterpolateService(origSpec *api.ServiceSpec) *api.ServiceSpec {
spec := origSpec.Copy()
container := spec.Task.GetContainer()
defaultContainer := Service.Task.GetContainer()
if container != nil {
if container.StopGracePeriod == nil {
container.StopGracePeriod = &gogotypes.Duration{}
deepcopy.Copy(container.StopGracePeriod, defaultContainer.StopGracePeriod)
}
if container.PullOptions == nil {
container.PullOptions = defaultContainer.PullOptions.Copy()
}
if container.DNSConfig == nil {
container.DNSConfig = defaultContainer.DNSConfig.Copy()
}
}
if spec.Task.Resources == nil {
spec.Task.Resources = Service.Task.Resources.Copy()
}
if spec.Task.Restart == nil {
spec.Task.Restart = Service.Task.Restart.Copy()
} else {
if spec.Task.Restart.Delay == nil {
spec.Task.Restart.Delay = &gogotypes.Duration{}
deepcopy.Copy(spec.Task.Restart.Delay, Service.Task.Restart.Delay)
}
}
if spec.Task.Placement == nil {
spec.Task.Placement = Service.Task.Placement.Copy()
}
if spec.Update == nil {
spec.Update = Service.Update.Copy()
} else {
if spec.Update.Monitor == nil {
spec.Update.Monitor = &gogotypes.Duration{}
deepcopy.Copy(spec.Update.Monitor, Service.Update.Monitor)
}
}
if spec.Rollback == nil {
spec.Rollback = Service.Rollback.Copy()
} else {
if spec.Rollback.Monitor == nil {
spec.Rollback.Monitor = &gogotypes.Duration{}
deepcopy.Copy(spec.Rollback.Monitor, Service.Rollback.Monitor)
}
}
return spec
} | [
"func",
"InterpolateService",
"(",
"origSpec",
"*",
"api",
".",
"ServiceSpec",
")",
"*",
"api",
".",
"ServiceSpec",
"{",
"spec",
":=",
"origSpec",
".",
"Copy",
"(",
")",
"\n",
"container",
":=",
"spec",
".",
"Task",
".",
"GetContainer",
"(",
")",
"\n",
... | // InterpolateService returns a ServiceSpec based on the provided spec, which
// has all unspecified values filled in with default values. | [
"InterpolateService",
"returns",
"a",
"ServiceSpec",
"based",
"on",
"the",
"provided",
"spec",
"which",
"has",
"all",
"unspecified",
"values",
"filled",
"in",
"with",
"default",
"values",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/api/defaults/service.go#L45-L99 | train |
docker/swarmkit | manager/controlapi/network.go | CreateNetwork | func (s *Server) CreateNetwork(ctx context.Context, request *api.CreateNetworkRequest) (*api.CreateNetworkResponse, error) {
if err := validateNetworkSpec(request.Spec, s.pg); err != nil {
return nil, err
}
// TODO(mrjana): Consider using `Name` as a primary key to handle
// duplicate creations. See #65
n := &api.Network{
ID: identity.NewID(),
Spec: *request.Spec,
}
err := s.store.Update(func(tx store.Tx) error {
if request.Spec.Ingress {
if n, err := allocator.GetIngressNetwork(s.store); err == nil {
return status.Errorf(codes.AlreadyExists, "ingress network (%s) is already present", n.ID)
} else if err != allocator.ErrNoIngress {
return status.Errorf(codes.Internal, "failed ingress network presence check: %v", err)
}
}
return store.CreateNetwork(tx, n)
})
if err != nil {
return nil, err
}
return &api.CreateNetworkResponse{
Network: n,
}, nil
} | go | func (s *Server) CreateNetwork(ctx context.Context, request *api.CreateNetworkRequest) (*api.CreateNetworkResponse, error) {
if err := validateNetworkSpec(request.Spec, s.pg); err != nil {
return nil, err
}
// TODO(mrjana): Consider using `Name` as a primary key to handle
// duplicate creations. See #65
n := &api.Network{
ID: identity.NewID(),
Spec: *request.Spec,
}
err := s.store.Update(func(tx store.Tx) error {
if request.Spec.Ingress {
if n, err := allocator.GetIngressNetwork(s.store); err == nil {
return status.Errorf(codes.AlreadyExists, "ingress network (%s) is already present", n.ID)
} else if err != allocator.ErrNoIngress {
return status.Errorf(codes.Internal, "failed ingress network presence check: %v", err)
}
}
return store.CreateNetwork(tx, n)
})
if err != nil {
return nil, err
}
return &api.CreateNetworkResponse{
Network: n,
}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"CreateNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"CreateNetworkRequest",
")",
"(",
"*",
"api",
".",
"CreateNetworkResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validat... | // CreateNetwork creates and returns a Network based on the provided NetworkSpec.
// - Returns `InvalidArgument` if the NetworkSpec is malformed.
// - Returns an error if the creation fails. | [
"CreateNetwork",
"creates",
"and",
"returns",
"a",
"Network",
"based",
"on",
"the",
"provided",
"NetworkSpec",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"NetworkSpec",
"is",
"malformed",
".",
"-",
"Returns",
"an",
"error",
"if",
"the",
"creation",
"... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/network.go#L105-L134 | train |
docker/swarmkit | manager/controlapi/network.go | GetNetwork | func (s *Server) GetNetwork(ctx context.Context, request *api.GetNetworkRequest) (*api.GetNetworkResponse, error) {
if request.NetworkID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var n *api.Network
s.store.View(func(tx store.ReadTx) {
n = store.GetNetwork(tx, request.NetworkID)
})
if n == nil {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.NetworkID)
}
return &api.GetNetworkResponse{
Network: n,
}, nil
} | go | func (s *Server) GetNetwork(ctx context.Context, request *api.GetNetworkRequest) (*api.GetNetworkResponse, error) {
if request.NetworkID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var n *api.Network
s.store.View(func(tx store.ReadTx) {
n = store.GetNetwork(tx, request.NetworkID)
})
if n == nil {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.NetworkID)
}
return &api.GetNetworkResponse{
Network: n,
}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"GetNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"GetNetworkRequest",
")",
"(",
"*",
"api",
".",
"GetNetworkResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"NetworkID",
... | // GetNetwork returns a Network given a NetworkID.
// - Returns `InvalidArgument` if NetworkID is not provided.
// - Returns `NotFound` if the Network is not found. | [
"GetNetwork",
"returns",
"a",
"Network",
"given",
"a",
"NetworkID",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"NetworkID",
"is",
"not",
"provided",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Network",
"is",
"not",
"found",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/network.go#L139-L154 | train |
docker/swarmkit | manager/controlapi/network.go | RemoveNetwork | func (s *Server) RemoveNetwork(ctx context.Context, request *api.RemoveNetworkRequest) (*api.RemoveNetworkResponse, error) {
if request.NetworkID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var (
n *api.Network
rm = s.removeNetwork
)
s.store.View(func(tx store.ReadTx) {
n = store.GetNetwork(tx, request.NetworkID)
})
if n == nil {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.NetworkID)
}
if allocator.IsIngressNetwork(n) {
rm = s.removeIngressNetwork
}
if v, ok := n.Spec.Annotations.Labels[networkallocator.PredefinedLabel]; ok && v == "true" {
return nil, status.Errorf(codes.FailedPrecondition, "network %s (%s) is a swarm predefined network and cannot be removed",
request.NetworkID, n.Spec.Annotations.Name)
}
if err := rm(n.ID); err != nil {
if err == store.ErrNotExist {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.NetworkID)
}
return nil, err
}
return &api.RemoveNetworkResponse{}, nil
} | go | func (s *Server) RemoveNetwork(ctx context.Context, request *api.RemoveNetworkRequest) (*api.RemoveNetworkResponse, error) {
if request.NetworkID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var (
n *api.Network
rm = s.removeNetwork
)
s.store.View(func(tx store.ReadTx) {
n = store.GetNetwork(tx, request.NetworkID)
})
if n == nil {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.NetworkID)
}
if allocator.IsIngressNetwork(n) {
rm = s.removeIngressNetwork
}
if v, ok := n.Spec.Annotations.Labels[networkallocator.PredefinedLabel]; ok && v == "true" {
return nil, status.Errorf(codes.FailedPrecondition, "network %s (%s) is a swarm predefined network and cannot be removed",
request.NetworkID, n.Spec.Annotations.Name)
}
if err := rm(n.ID); err != nil {
if err == store.ErrNotExist {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.NetworkID)
}
return nil, err
}
return &api.RemoveNetworkResponse{}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"RemoveNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"RemoveNetworkRequest",
")",
"(",
"*",
"api",
".",
"RemoveNetworkResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"Netw... | // RemoveNetwork removes a Network referenced by NetworkID.
// - Returns `InvalidArgument` if NetworkID is not provided.
// - Returns `NotFound` if the Network is not found.
// - Returns an error if the deletion fails. | [
"RemoveNetwork",
"removes",
"a",
"Network",
"referenced",
"by",
"NetworkID",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"NetworkID",
"is",
"not",
"provided",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Network",
"is",
"not",
"found",
".",
"-",
"Returns",... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/network.go#L160-L193 | train |
docker/swarmkit | manager/controlapi/network.go | ListNetworks | func (s *Server) ListNetworks(ctx context.Context, request *api.ListNetworksRequest) (*api.ListNetworksResponse, error) {
var (
networks []*api.Network
err error
)
s.store.View(func(tx store.ReadTx) {
switch {
case request.Filters != nil && len(request.Filters.Names) > 0:
networks, err = store.FindNetworks(tx, buildFilters(store.ByName, request.Filters.Names))
case request.Filters != nil && len(request.Filters.NamePrefixes) > 0:
networks, err = store.FindNetworks(tx, buildFilters(store.ByNamePrefix, request.Filters.NamePrefixes))
case request.Filters != nil && len(request.Filters.IDPrefixes) > 0:
networks, err = store.FindNetworks(tx, buildFilters(store.ByIDPrefix, request.Filters.IDPrefixes))
default:
networks, err = store.FindNetworks(tx, store.All)
}
})
if err != nil {
return nil, err
}
if request.Filters != nil {
networks = filterNetworks(networks,
func(e *api.Network) bool {
return filterContains(e.Spec.Annotations.Name, request.Filters.Names)
},
func(e *api.Network) bool {
return filterContainsPrefix(e.Spec.Annotations.Name, request.Filters.NamePrefixes)
},
func(e *api.Network) bool {
return filterContainsPrefix(e.ID, request.Filters.IDPrefixes)
},
func(e *api.Network) bool {
return filterMatchLabels(e.Spec.Annotations.Labels, request.Filters.Labels)
},
)
}
return &api.ListNetworksResponse{
Networks: networks,
}, nil
} | go | func (s *Server) ListNetworks(ctx context.Context, request *api.ListNetworksRequest) (*api.ListNetworksResponse, error) {
var (
networks []*api.Network
err error
)
s.store.View(func(tx store.ReadTx) {
switch {
case request.Filters != nil && len(request.Filters.Names) > 0:
networks, err = store.FindNetworks(tx, buildFilters(store.ByName, request.Filters.Names))
case request.Filters != nil && len(request.Filters.NamePrefixes) > 0:
networks, err = store.FindNetworks(tx, buildFilters(store.ByNamePrefix, request.Filters.NamePrefixes))
case request.Filters != nil && len(request.Filters.IDPrefixes) > 0:
networks, err = store.FindNetworks(tx, buildFilters(store.ByIDPrefix, request.Filters.IDPrefixes))
default:
networks, err = store.FindNetworks(tx, store.All)
}
})
if err != nil {
return nil, err
}
if request.Filters != nil {
networks = filterNetworks(networks,
func(e *api.Network) bool {
return filterContains(e.Spec.Annotations.Name, request.Filters.Names)
},
func(e *api.Network) bool {
return filterContainsPrefix(e.Spec.Annotations.Name, request.Filters.NamePrefixes)
},
func(e *api.Network) bool {
return filterContainsPrefix(e.ID, request.Filters.IDPrefixes)
},
func(e *api.Network) bool {
return filterMatchLabels(e.Spec.Annotations.Labels, request.Filters.Labels)
},
)
}
return &api.ListNetworksResponse{
Networks: networks,
}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"ListNetworks",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"ListNetworksRequest",
")",
"(",
"*",
"api",
".",
"ListNetworksResponse",
",",
"error",
")",
"{",
"var",
"(",
"networks",
"[",
... | // ListNetworks returns a list of all networks. | [
"ListNetworks",
"returns",
"a",
"list",
"of",
"all",
"networks",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/network.go#L256-L298 | train |
docker/swarmkit | agent/session.go | start | func (s *session) start(ctx context.Context, description *api.NodeDescription) error {
log.G(ctx).Debugf("(*session).start")
errChan := make(chan error, 1)
var (
msg *api.SessionMessage
stream api.Dispatcher_SessionClient
err error
)
// Note: we don't defer cancellation of this context, because the
// streaming RPC is used after this function returned. We only cancel
// it in the timeout case to make sure the goroutine completes.
// We also fork this context again from the `run` context, because on
// `dispatcherRPCTimeout`, we want to cancel establishing a session and
// return an error. If we cancel the `run` context instead of forking,
// then in `run` it's possible that we just terminate the function because
// `ctx` is done and hence fail to propagate the timeout error to the agent.
// If the error is not propogated to the agent, the agent will not close
// the session or rebuild a new session.
sessionCtx, cancelSession := context.WithCancel(ctx) // nolint: vet
// Need to run Session in a goroutine since there's no way to set a
// timeout for an individual Recv call in a stream.
go func() {
client := api.NewDispatcherClient(s.conn.ClientConn)
stream, err = client.Session(sessionCtx, &api.SessionRequest{
Description: description,
SessionID: s.sessionID,
})
if err != nil {
errChan <- err
return
}
msg, err = stream.Recv()
errChan <- err
}()
select {
case err := <-errChan:
if err != nil {
return err // nolint: vet
}
case <-time.After(dispatcherRPCTimeout):
cancelSession()
return errors.New("session initiation timed out")
}
s.sessionID = msg.SessionID
s.session = stream
return s.handleSessionMessage(ctx, msg)
} | go | func (s *session) start(ctx context.Context, description *api.NodeDescription) error {
log.G(ctx).Debugf("(*session).start")
errChan := make(chan error, 1)
var (
msg *api.SessionMessage
stream api.Dispatcher_SessionClient
err error
)
// Note: we don't defer cancellation of this context, because the
// streaming RPC is used after this function returned. We only cancel
// it in the timeout case to make sure the goroutine completes.
// We also fork this context again from the `run` context, because on
// `dispatcherRPCTimeout`, we want to cancel establishing a session and
// return an error. If we cancel the `run` context instead of forking,
// then in `run` it's possible that we just terminate the function because
// `ctx` is done and hence fail to propagate the timeout error to the agent.
// If the error is not propogated to the agent, the agent will not close
// the session or rebuild a new session.
sessionCtx, cancelSession := context.WithCancel(ctx) // nolint: vet
// Need to run Session in a goroutine since there's no way to set a
// timeout for an individual Recv call in a stream.
go func() {
client := api.NewDispatcherClient(s.conn.ClientConn)
stream, err = client.Session(sessionCtx, &api.SessionRequest{
Description: description,
SessionID: s.sessionID,
})
if err != nil {
errChan <- err
return
}
msg, err = stream.Recv()
errChan <- err
}()
select {
case err := <-errChan:
if err != nil {
return err // nolint: vet
}
case <-time.After(dispatcherRPCTimeout):
cancelSession()
return errors.New("session initiation timed out")
}
s.sessionID = msg.SessionID
s.session = stream
return s.handleSessionMessage(ctx, msg)
} | [
"func",
"(",
"s",
"*",
"session",
")",
"start",
"(",
"ctx",
"context",
".",
"Context",
",",
"description",
"*",
"api",
".",
"NodeDescription",
")",
"error",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Debugf",
"(",
"\"(*session).start\"",
")",
"\n",
... | // start begins the session and returns the first SessionMessage. | [
"start",
"begins",
"the",
"session",
"and",
"returns",
"the",
"first",
"SessionMessage",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/session.go#L119-L173 | train |
docker/swarmkit | agent/session.go | sendTaskStatus | func (s *session) sendTaskStatus(ctx context.Context, taskID string, taskStatus *api.TaskStatus) error {
client := api.NewDispatcherClient(s.conn.ClientConn)
if _, err := client.UpdateTaskStatus(ctx, &api.UpdateTaskStatusRequest{
SessionID: s.sessionID,
Updates: []*api.UpdateTaskStatusRequest_TaskStatusUpdate{
{
TaskID: taskID,
Status: taskStatus,
},
},
}); err != nil {
// TODO(stevvooe): Dispatcher should not return this error. Status
// reports for unknown tasks should be ignored.
st, _ := status.FromError(err)
if st.Code() == codes.NotFound {
return errTaskUnknown
}
return err
}
return nil
} | go | func (s *session) sendTaskStatus(ctx context.Context, taskID string, taskStatus *api.TaskStatus) error {
client := api.NewDispatcherClient(s.conn.ClientConn)
if _, err := client.UpdateTaskStatus(ctx, &api.UpdateTaskStatusRequest{
SessionID: s.sessionID,
Updates: []*api.UpdateTaskStatusRequest_TaskStatusUpdate{
{
TaskID: taskID,
Status: taskStatus,
},
},
}); err != nil {
// TODO(stevvooe): Dispatcher should not return this error. Status
// reports for unknown tasks should be ignored.
st, _ := status.FromError(err)
if st.Code() == codes.NotFound {
return errTaskUnknown
}
return err
}
return nil
} | [
"func",
"(",
"s",
"*",
"session",
")",
"sendTaskStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"taskID",
"string",
",",
"taskStatus",
"*",
"api",
".",
"TaskStatus",
")",
"error",
"{",
"client",
":=",
"api",
".",
"NewDispatcherClient",
"(",
"s",
"."... | // sendTaskStatus uses the current session to send the status of a single task. | [
"sendTaskStatus",
"uses",
"the",
"current",
"session",
"to",
"send",
"the",
"status",
"of",
"a",
"single",
"task",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/session.go#L368-L390 | train |
docker/swarmkit | agent/session.go | sendError | func (s *session) sendError(err error) {
select {
case s.errs <- err:
case <-s.closed:
}
} | go | func (s *session) sendError(err error) {
select {
case s.errs <- err:
case <-s.closed:
}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"sendError",
"(",
"err",
"error",
")",
"{",
"select",
"{",
"case",
"s",
".",
"errs",
"<-",
"err",
":",
"case",
"<-",
"s",
".",
"closed",
":",
"}",
"\n",
"}"
] | // sendError is used to send errors to errs channel and trigger session recreation | [
"sendError",
"is",
"used",
"to",
"send",
"errors",
"to",
"errs",
"channel",
"and",
"trigger",
"session",
"recreation"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/session.go#L430-L435 | train |
docker/swarmkit | agent/session.go | close | func (s *session) close() error {
s.closeOnce.Do(func() {
s.cancel()
if s.conn != nil {
s.conn.Close(false)
}
close(s.closed)
})
return nil
} | go | func (s *session) close() error {
s.closeOnce.Do(func() {
s.cancel()
if s.conn != nil {
s.conn.Close(false)
}
close(s.closed)
})
return nil
} | [
"func",
"(",
"s",
"*",
"session",
")",
"close",
"(",
")",
"error",
"{",
"s",
".",
"closeOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"s",
".",
"cancel",
"(",
")",
"\n",
"if",
"s",
".",
"conn",
"!=",
"nil",
"{",
"s",
".",
"conn",
".",
"Clos... | // close the given session. It should be called only in <-session.errs branch
// of event loop, or when cleaning up the agent. | [
"close",
"the",
"given",
"session",
".",
"It",
"should",
"be",
"called",
"only",
"in",
"<",
"-",
"session",
".",
"errs",
"branch",
"of",
"event",
"loop",
"or",
"when",
"cleaning",
"up",
"the",
"agent",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/session.go#L439-L449 | train |
docker/swarmkit | agent/exec/dockerapi/container.go | volumeCreateRequest | func (c *containerConfig) volumeCreateRequest(mount *api.Mount) *volume.VolumeCreateBody {
var (
driverName string
driverOpts map[string]string
labels map[string]string
)
if mount.VolumeOptions != nil && mount.VolumeOptions.DriverConfig != nil {
driverName = mount.VolumeOptions.DriverConfig.Name
driverOpts = mount.VolumeOptions.DriverConfig.Options
labels = mount.VolumeOptions.Labels
}
return &volume.VolumeCreateBody{
Name: mount.Source,
Driver: driverName,
DriverOpts: driverOpts,
Labels: labels,
}
} | go | func (c *containerConfig) volumeCreateRequest(mount *api.Mount) *volume.VolumeCreateBody {
var (
driverName string
driverOpts map[string]string
labels map[string]string
)
if mount.VolumeOptions != nil && mount.VolumeOptions.DriverConfig != nil {
driverName = mount.VolumeOptions.DriverConfig.Name
driverOpts = mount.VolumeOptions.DriverConfig.Options
labels = mount.VolumeOptions.Labels
}
return &volume.VolumeCreateBody{
Name: mount.Source,
Driver: driverName,
DriverOpts: driverOpts,
Labels: labels,
}
} | [
"func",
"(",
"c",
"*",
"containerConfig",
")",
"volumeCreateRequest",
"(",
"mount",
"*",
"api",
".",
"Mount",
")",
"*",
"volume",
".",
"VolumeCreateBody",
"{",
"var",
"(",
"driverName",
"string",
"\n",
"driverOpts",
"map",
"[",
"string",
"]",
"string",
"\n... | // This handles the case of volumes that are defined inside a service Mount | [
"This",
"handles",
"the",
"case",
"of",
"volumes",
"that",
"are",
"defined",
"inside",
"a",
"service",
"Mount"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/dockerapi/container.go#L418-L437 | train |
docker/swarmkit | agent/exec/dockerapi/container.go | networks | func (c *containerConfig) networks() []string {
var networks []string
for name := range c.networksAttachments {
networks = append(networks, name)
}
return networks
} | go | func (c *containerConfig) networks() []string {
var networks []string
for name := range c.networksAttachments {
networks = append(networks, name)
}
return networks
} | [
"func",
"(",
"c",
"*",
"containerConfig",
")",
"networks",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"networks",
"[",
"]",
"string",
"\n",
"for",
"name",
":=",
"range",
"c",
".",
"networksAttachments",
"{",
"networks",
"=",
"append",
"(",
"networks",
"... | // networks returns a list of network names attached to the container. The
// returned name can be used to lookup the corresponding network create
// options. | [
"networks",
"returns",
"a",
"list",
"of",
"network",
"names",
"attached",
"to",
"the",
"container",
".",
"The",
"returned",
"name",
"can",
"be",
"used",
"to",
"lookup",
"the",
"corresponding",
"network",
"create",
"options",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/dockerapi/container.go#L526-L534 | train |
docker/swarmkit | manager/state/raft/storage/walwrap.go | NewWALFactory | func NewWALFactory(encrypter encryption.Encrypter, decrypter encryption.Decrypter) WALFactory {
return walCryptor{
encrypter: encrypter,
decrypter: decrypter,
}
} | go | func NewWALFactory(encrypter encryption.Encrypter, decrypter encryption.Decrypter) WALFactory {
return walCryptor{
encrypter: encrypter,
decrypter: decrypter,
}
} | [
"func",
"NewWALFactory",
"(",
"encrypter",
"encryption",
".",
"Encrypter",
",",
"decrypter",
"encryption",
".",
"Decrypter",
")",
"WALFactory",
"{",
"return",
"walCryptor",
"{",
"encrypter",
":",
"encrypter",
",",
"decrypter",
":",
"decrypter",
",",
"}",
"\n",
... | // NewWALFactory returns an object that can be used to produce objects that
// will read from and write to encrypted WALs on disk. | [
"NewWALFactory",
"returns",
"an",
"object",
"that",
"can",
"be",
"used",
"to",
"produce",
"objects",
"that",
"will",
"read",
"from",
"and",
"write",
"to",
"encrypted",
"WALs",
"on",
"disk",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/walwrap.go#L97-L102 | train |
docker/swarmkit | manager/state/raft/storage/walwrap.go | Create | func (wc walCryptor) Create(dirpath string, metadata []byte) (WAL, error) {
w, err := wal.Create(dirpath, metadata)
if err != nil {
return nil, err
}
return &wrappedWAL{
WAL: w,
encrypter: wc.encrypter,
decrypter: wc.decrypter,
}, nil
} | go | func (wc walCryptor) Create(dirpath string, metadata []byte) (WAL, error) {
w, err := wal.Create(dirpath, metadata)
if err != nil {
return nil, err
}
return &wrappedWAL{
WAL: w,
encrypter: wc.encrypter,
decrypter: wc.decrypter,
}, nil
} | [
"func",
"(",
"wc",
"walCryptor",
")",
"Create",
"(",
"dirpath",
"string",
",",
"metadata",
"[",
"]",
"byte",
")",
"(",
"WAL",
",",
"error",
")",
"{",
"w",
",",
"err",
":=",
"wal",
".",
"Create",
"(",
"dirpath",
",",
"metadata",
")",
"\n",
"if",
"... | // Create returns a new WAL object with the given encrypters and decrypters. | [
"Create",
"returns",
"a",
"new",
"WAL",
"object",
"with",
"the",
"given",
"encrypters",
"and",
"decrypters",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/walwrap.go#L105-L115 | train |
docker/swarmkit | manager/state/raft/storage/walwrap.go | Open | func (wc walCryptor) Open(dirpath string, snap walpb.Snapshot) (WAL, error) {
w, err := wal.Open(dirpath, snap)
if err != nil {
return nil, err
}
return &wrappedWAL{
WAL: w,
encrypter: wc.encrypter,
decrypter: wc.decrypter,
}, nil
} | go | func (wc walCryptor) Open(dirpath string, snap walpb.Snapshot) (WAL, error) {
w, err := wal.Open(dirpath, snap)
if err != nil {
return nil, err
}
return &wrappedWAL{
WAL: w,
encrypter: wc.encrypter,
decrypter: wc.decrypter,
}, nil
} | [
"func",
"(",
"wc",
"walCryptor",
")",
"Open",
"(",
"dirpath",
"string",
",",
"snap",
"walpb",
".",
"Snapshot",
")",
"(",
"WAL",
",",
"error",
")",
"{",
"w",
",",
"err",
":=",
"wal",
".",
"Open",
"(",
"dirpath",
",",
"snap",
")",
"\n",
"if",
"err"... | // Open returns a new WAL object with the given encrypters and decrypters. | [
"Open",
"returns",
"a",
"new",
"WAL",
"object",
"with",
"the",
"given",
"encrypters",
"and",
"decrypters",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/walwrap.go#L118-L128 | train |
docker/swarmkit | manager/state/raft/storage/walwrap.go | ReadRepairWAL | func ReadRepairWAL(
ctx context.Context,
walDir string,
walsnap walpb.Snapshot,
factory WALFactory,
) (WAL, WALData, error) {
var (
reader WAL
metadata []byte
st raftpb.HardState
ents []raftpb.Entry
err error
)
repaired := false
for {
if reader, err = factory.Open(walDir, walsnap); err != nil {
return nil, WALData{}, errors.Wrap(err, "failed to open WAL")
}
if metadata, st, ents, err = reader.ReadAll(); err != nil {
if closeErr := reader.Close(); closeErr != nil {
return nil, WALData{}, closeErr
}
if _, ok := err.(encryption.ErrCannotDecrypt); ok {
return nil, WALData{}, errors.Wrap(err, "failed to decrypt WAL")
}
// we can only repair ErrUnexpectedEOF and we never repair twice.
if repaired || err != io.ErrUnexpectedEOF {
return nil, WALData{}, errors.Wrap(err, "irreparable WAL error")
}
if !wal.Repair(walDir) {
return nil, WALData{}, errors.Wrap(err, "WAL error cannot be repaired")
}
log.G(ctx).WithError(err).Info("repaired WAL error")
repaired = true
continue
}
break
}
return reader, WALData{
Metadata: metadata,
HardState: st,
Entries: ents,
}, nil
} | go | func ReadRepairWAL(
ctx context.Context,
walDir string,
walsnap walpb.Snapshot,
factory WALFactory,
) (WAL, WALData, error) {
var (
reader WAL
metadata []byte
st raftpb.HardState
ents []raftpb.Entry
err error
)
repaired := false
for {
if reader, err = factory.Open(walDir, walsnap); err != nil {
return nil, WALData{}, errors.Wrap(err, "failed to open WAL")
}
if metadata, st, ents, err = reader.ReadAll(); err != nil {
if closeErr := reader.Close(); closeErr != nil {
return nil, WALData{}, closeErr
}
if _, ok := err.(encryption.ErrCannotDecrypt); ok {
return nil, WALData{}, errors.Wrap(err, "failed to decrypt WAL")
}
// we can only repair ErrUnexpectedEOF and we never repair twice.
if repaired || err != io.ErrUnexpectedEOF {
return nil, WALData{}, errors.Wrap(err, "irreparable WAL error")
}
if !wal.Repair(walDir) {
return nil, WALData{}, errors.Wrap(err, "WAL error cannot be repaired")
}
log.G(ctx).WithError(err).Info("repaired WAL error")
repaired = true
continue
}
break
}
return reader, WALData{
Metadata: metadata,
HardState: st,
Entries: ents,
}, nil
} | [
"func",
"ReadRepairWAL",
"(",
"ctx",
"context",
".",
"Context",
",",
"walDir",
"string",
",",
"walsnap",
"walpb",
".",
"Snapshot",
",",
"factory",
"WALFactory",
",",
")",
"(",
"WAL",
",",
"WALData",
",",
"error",
")",
"{",
"var",
"(",
"reader",
"WAL",
... | // ReadRepairWAL opens a WAL for reading, and attempts to read it. If we can't read it, attempts to repair
// and read again. | [
"ReadRepairWAL",
"opens",
"a",
"WAL",
"for",
"reading",
"and",
"attempts",
"to",
"read",
"it",
".",
"If",
"we",
"can",
"t",
"read",
"it",
"attempts",
"to",
"repair",
"and",
"read",
"again",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/walwrap.go#L152-L195 | train |
docker/swarmkit | agent/exec/controller.go | Publish | func (fn LogPublisherFunc) Publish(ctx context.Context, message api.LogMessage) error {
return fn(ctx, message)
} | go | func (fn LogPublisherFunc) Publish(ctx context.Context, message api.LogMessage) error {
return fn(ctx, message)
} | [
"func",
"(",
"fn",
"LogPublisherFunc",
")",
"Publish",
"(",
"ctx",
"context",
".",
"Context",
",",
"message",
"api",
".",
"LogMessage",
")",
"error",
"{",
"return",
"fn",
"(",
"ctx",
",",
"message",
")",
"\n",
"}"
] | // Publish calls the wrapped function. | [
"Publish",
"calls",
"the",
"wrapped",
"function",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/controller.go#L66-L68 | train |
docker/swarmkit | agent/exec/controller.go | Resolve | func Resolve(ctx context.Context, task *api.Task, executor Executor) (Controller, *api.TaskStatus, error) {
status := task.Status.Copy()
defer func() {
logStateChange(ctx, task.DesiredState, task.Status.State, status.State)
}()
ctlr, err := executor.Controller(task)
// depending on the tasks state, a failed controller resolution has varying
// impact. The following expresses that impact.
if err != nil {
status.Message = "resolving controller failed"
status.Err = err.Error()
// before the task has been started, we consider it a rejection.
// if task is running, consider the task has failed
// otherwise keep the existing state
if task.Status.State < api.TaskStateStarting {
status.State = api.TaskStateRejected
} else if task.Status.State <= api.TaskStateRunning {
status.State = api.TaskStateFailed
}
} else if task.Status.State < api.TaskStateAccepted {
// we always want to proceed to accepted when we resolve the controller
status.Message = "accepted"
status.State = api.TaskStateAccepted
status.Err = ""
}
return ctlr, status, err
} | go | func Resolve(ctx context.Context, task *api.Task, executor Executor) (Controller, *api.TaskStatus, error) {
status := task.Status.Copy()
defer func() {
logStateChange(ctx, task.DesiredState, task.Status.State, status.State)
}()
ctlr, err := executor.Controller(task)
// depending on the tasks state, a failed controller resolution has varying
// impact. The following expresses that impact.
if err != nil {
status.Message = "resolving controller failed"
status.Err = err.Error()
// before the task has been started, we consider it a rejection.
// if task is running, consider the task has failed
// otherwise keep the existing state
if task.Status.State < api.TaskStateStarting {
status.State = api.TaskStateRejected
} else if task.Status.State <= api.TaskStateRunning {
status.State = api.TaskStateFailed
}
} else if task.Status.State < api.TaskStateAccepted {
// we always want to proceed to accepted when we resolve the controller
status.Message = "accepted"
status.State = api.TaskStateAccepted
status.Err = ""
}
return ctlr, status, err
} | [
"func",
"Resolve",
"(",
"ctx",
"context",
".",
"Context",
",",
"task",
"*",
"api",
".",
"Task",
",",
"executor",
"Executor",
")",
"(",
"Controller",
",",
"*",
"api",
".",
"TaskStatus",
",",
"error",
")",
"{",
"status",
":=",
"task",
".",
"Status",
".... | // Resolve attempts to get a controller from the executor and reports the
// correct status depending on the tasks current state according to the result.
//
// Unlike Do, if an error is returned, the status should still be reported. The
// error merely reports the failure at getting the controller. | [
"Resolve",
"attempts",
"to",
"get",
"a",
"controller",
"from",
"the",
"executor",
"and",
"reports",
"the",
"correct",
"status",
"depending",
"on",
"the",
"tasks",
"current",
"state",
"according",
"to",
"the",
"result",
".",
"Unlike",
"Do",
"if",
"an",
"error... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/controller.go#L96-L126 | train |
docker/swarmkit | manager/state/store/nodes.go | CreateNode | func CreateNode(tx Tx, n *api.Node) error {
return tx.create(tableNode, n)
} | go | func CreateNode(tx Tx, n *api.Node) error {
return tx.create(tableNode, n)
} | [
"func",
"CreateNode",
"(",
"tx",
"Tx",
",",
"n",
"*",
"api",
".",
"Node",
")",
"error",
"{",
"return",
"tx",
".",
"create",
"(",
"tableNode",
",",
"n",
")",
"\n",
"}"
] | // CreateNode adds a new node to the store.
// Returns ErrExist if the ID is already taken. | [
"CreateNode",
"adds",
"a",
"new",
"node",
"to",
"the",
"store",
".",
"Returns",
"ErrExist",
"if",
"the",
"ID",
"is",
"already",
"taken",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/nodes.go#L76-L78 | train |
docker/swarmkit | manager/state/store/nodes.go | UpdateNode | func UpdateNode(tx Tx, n *api.Node) error {
return tx.update(tableNode, n)
} | go | func UpdateNode(tx Tx, n *api.Node) error {
return tx.update(tableNode, n)
} | [
"func",
"UpdateNode",
"(",
"tx",
"Tx",
",",
"n",
"*",
"api",
".",
"Node",
")",
"error",
"{",
"return",
"tx",
".",
"update",
"(",
"tableNode",
",",
"n",
")",
"\n",
"}"
] | // UpdateNode updates an existing node in the store.
// Returns ErrNotExist if the node doesn't exist. | [
"UpdateNode",
"updates",
"an",
"existing",
"node",
"in",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"node",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/nodes.go#L82-L84 | train |
docker/swarmkit | manager/state/store/nodes.go | DeleteNode | func DeleteNode(tx Tx, id string) error {
return tx.delete(tableNode, id)
} | go | func DeleteNode(tx Tx, id string) error {
return tx.delete(tableNode, id)
} | [
"func",
"DeleteNode",
"(",
"tx",
"Tx",
",",
"id",
"string",
")",
"error",
"{",
"return",
"tx",
".",
"delete",
"(",
"tableNode",
",",
"id",
")",
"\n",
"}"
] | // DeleteNode removes a node from the store.
// Returns ErrNotExist if the node doesn't exist. | [
"DeleteNode",
"removes",
"a",
"node",
"from",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"node",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/nodes.go#L88-L90 | train |
docker/swarmkit | manager/state/store/nodes.go | GetNode | func GetNode(tx ReadTx, id string) *api.Node {
n := tx.get(tableNode, id)
if n == nil {
return nil
}
return n.(*api.Node)
} | go | func GetNode(tx ReadTx, id string) *api.Node {
n := tx.get(tableNode, id)
if n == nil {
return nil
}
return n.(*api.Node)
} | [
"func",
"GetNode",
"(",
"tx",
"ReadTx",
",",
"id",
"string",
")",
"*",
"api",
".",
"Node",
"{",
"n",
":=",
"tx",
".",
"get",
"(",
"tableNode",
",",
"id",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"n",
... | // GetNode looks up a node by ID.
// Returns nil if the node doesn't exist. | [
"GetNode",
"looks",
"up",
"a",
"node",
"by",
"ID",
".",
"Returns",
"nil",
"if",
"the",
"node",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/nodes.go#L94-L100 | train |
docker/swarmkit | manager/state/store/nodes.go | FindNodes | func FindNodes(tx ReadTx, by By) ([]*api.Node, error) {
checkType := func(by By) error {
switch by.(type) {
case byName, byNamePrefix, byIDPrefix, byRole, byMembership, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
nodeList := []*api.Node{}
appendResult := func(o api.StoreObject) {
nodeList = append(nodeList, o.(*api.Node))
}
err := tx.find(tableNode, by, checkType, appendResult)
return nodeList, err
} | go | func FindNodes(tx ReadTx, by By) ([]*api.Node, error) {
checkType := func(by By) error {
switch by.(type) {
case byName, byNamePrefix, byIDPrefix, byRole, byMembership, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
nodeList := []*api.Node{}
appendResult := func(o api.StoreObject) {
nodeList = append(nodeList, o.(*api.Node))
}
err := tx.find(tableNode, by, checkType, appendResult)
return nodeList, err
} | [
"func",
"FindNodes",
"(",
"tx",
"ReadTx",
",",
"by",
"By",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Node",
",",
"error",
")",
"{",
"checkType",
":=",
"func",
"(",
"by",
"By",
")",
"error",
"{",
"switch",
"by",
".",
"(",
"type",
")",
"{",
"case",
... | // FindNodes selects a set of nodes and returns them. | [
"FindNodes",
"selects",
"a",
"set",
"of",
"nodes",
"and",
"returns",
"them",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/nodes.go#L103-L120 | train |
docker/swarmkit | manager/watchapi/server.go | Start | func (s *Server) Start(ctx context.Context) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.cancelAll != nil {
return errAlreadyRunning
}
s.pctx, s.cancelAll = context.WithCancel(ctx)
return nil
} | go | func (s *Server) Start(ctx context.Context) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.cancelAll != nil {
return errAlreadyRunning
}
s.pctx, s.cancelAll = context.WithCancel(ctx)
return nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Start",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"cancelAll",
"!=",
"... | // Start starts the watch server. | [
"Start",
"starts",
"the",
"watch",
"server",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/watchapi/server.go#L32-L42 | train |
docker/swarmkit | manager/watchapi/server.go | Stop | func (s *Server) Stop() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.cancelAll == nil {
return errNotRunning
}
s.cancelAll()
s.cancelAll = nil
return nil
} | go | func (s *Server) Stop() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.cancelAll == nil {
return errNotRunning
}
s.cancelAll()
s.cancelAll = nil
return nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Stop",
"(",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"cancelAll",
"==",
"nil",
"{",
"return",
"errNotRunning",... | // Stop stops the watch server. | [
"Stop",
"stops",
"the",
"watch",
"server",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/watchapi/server.go#L45-L56 | train |
docker/swarmkit | manager/deks.go | UpdateKEK | func (r RaftDEKData) UpdateKEK(oldKEK, candidateKEK ca.KEKData) ca.PEMKeyHeaders {
if _, unlockedToLocked, err := compareKEKs(oldKEK, candidateKEK); err == nil && unlockedToLocked {
return RaftDEKData{
EncryptionKeys: r.EncryptionKeys,
NeedsRotation: true,
FIPS: r.FIPS,
}
}
return r
} | go | func (r RaftDEKData) UpdateKEK(oldKEK, candidateKEK ca.KEKData) ca.PEMKeyHeaders {
if _, unlockedToLocked, err := compareKEKs(oldKEK, candidateKEK); err == nil && unlockedToLocked {
return RaftDEKData{
EncryptionKeys: r.EncryptionKeys,
NeedsRotation: true,
FIPS: r.FIPS,
}
}
return r
} | [
"func",
"(",
"r",
"RaftDEKData",
")",
"UpdateKEK",
"(",
"oldKEK",
",",
"candidateKEK",
"ca",
".",
"KEKData",
")",
"ca",
".",
"PEMKeyHeaders",
"{",
"if",
"_",
",",
"unlockedToLocked",
",",
"err",
":=",
"compareKEKs",
"(",
"oldKEK",
",",
"candidateKEK",
")",... | // UpdateKEK sets NeedRotation to true if we go from unlocked to locked. | [
"UpdateKEK",
"sets",
"NeedRotation",
"to",
"true",
"if",
"we",
"go",
"from",
"unlocked",
"to",
"locked",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/deks.go#L105-L114 | train |
docker/swarmkit | manager/deks.go | NewRaftDEKManager | func NewRaftDEKManager(kw ca.KeyWriter, fips bool) (*RaftDEKManager, error) {
// If there is no current DEK, generate one and write it to disk
err := kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
dekData, ok := h.(RaftDEKData)
// it wasn't a raft DEK manager before - just replace it
if !ok || dekData.CurrentDEK == nil {
return RaftDEKData{
EncryptionKeys: raft.EncryptionKeys{
CurrentDEK: encryption.GenerateSecretKey(),
},
FIPS: fips,
}, nil
}
return nil, errNoUpdateNeeded
})
if err != nil && err != errNoUpdateNeeded {
return nil, err
}
return &RaftDEKManager{
kw: kw,
FIPS: fips,
rotationCh: make(chan struct{}, 1),
}, nil
} | go | func NewRaftDEKManager(kw ca.KeyWriter, fips bool) (*RaftDEKManager, error) {
// If there is no current DEK, generate one and write it to disk
err := kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
dekData, ok := h.(RaftDEKData)
// it wasn't a raft DEK manager before - just replace it
if !ok || dekData.CurrentDEK == nil {
return RaftDEKData{
EncryptionKeys: raft.EncryptionKeys{
CurrentDEK: encryption.GenerateSecretKey(),
},
FIPS: fips,
}, nil
}
return nil, errNoUpdateNeeded
})
if err != nil && err != errNoUpdateNeeded {
return nil, err
}
return &RaftDEKManager{
kw: kw,
FIPS: fips,
rotationCh: make(chan struct{}, 1),
}, nil
} | [
"func",
"NewRaftDEKManager",
"(",
"kw",
"ca",
".",
"KeyWriter",
",",
"fips",
"bool",
")",
"(",
"*",
"RaftDEKManager",
",",
"error",
")",
"{",
"err",
":=",
"kw",
".",
"ViewAndUpdateHeaders",
"(",
"func",
"(",
"h",
"ca",
".",
"PEMKeyHeaders",
")",
"(",
"... | // NewRaftDEKManager returns a RaftDEKManager that uses the current key writer
// and header manager | [
"NewRaftDEKManager",
"returns",
"a",
"RaftDEKManager",
"that",
"uses",
"the",
"current",
"key",
"writer",
"and",
"header",
"manager"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/deks.go#L147-L170 | train |
docker/swarmkit | manager/deks.go | NeedsRotation | func (r *RaftDEKManager) NeedsRotation() bool {
h, _ := r.kw.GetCurrentState()
data, ok := h.(RaftDEKData)
if !ok {
return false
}
return data.NeedsRotation || data.EncryptionKeys.PendingDEK != nil
} | go | func (r *RaftDEKManager) NeedsRotation() bool {
h, _ := r.kw.GetCurrentState()
data, ok := h.(RaftDEKData)
if !ok {
return false
}
return data.NeedsRotation || data.EncryptionKeys.PendingDEK != nil
} | [
"func",
"(",
"r",
"*",
"RaftDEKManager",
")",
"NeedsRotation",
"(",
")",
"bool",
"{",
"h",
",",
"_",
":=",
"r",
".",
"kw",
".",
"GetCurrentState",
"(",
")",
"\n",
"data",
",",
"ok",
":=",
"h",
".",
"(",
"RaftDEKData",
")",
"\n",
"if",
"!",
"ok",
... | // NeedsRotation returns a boolean about whether we should do a rotation | [
"NeedsRotation",
"returns",
"a",
"boolean",
"about",
"whether",
"we",
"should",
"do",
"a",
"rotation"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/deks.go#L173-L180 | train |
docker/swarmkit | manager/deks.go | GetKeys | func (r *RaftDEKManager) GetKeys() raft.EncryptionKeys {
var newKeys, originalKeys raft.EncryptionKeys
err := r.kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
data, ok := h.(RaftDEKData)
if !ok {
return nil, errNotUsingRaftDEKData
}
originalKeys = data.EncryptionKeys
if !data.NeedsRotation || data.PendingDEK != nil {
return nil, errNoUpdateNeeded
}
newKeys = raft.EncryptionKeys{
CurrentDEK: data.CurrentDEK,
PendingDEK: encryption.GenerateSecretKey(),
}
return RaftDEKData{
EncryptionKeys: newKeys,
FIPS: data.FIPS,
}, nil
})
if err != nil {
return originalKeys
}
return newKeys
} | go | func (r *RaftDEKManager) GetKeys() raft.EncryptionKeys {
var newKeys, originalKeys raft.EncryptionKeys
err := r.kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
data, ok := h.(RaftDEKData)
if !ok {
return nil, errNotUsingRaftDEKData
}
originalKeys = data.EncryptionKeys
if !data.NeedsRotation || data.PendingDEK != nil {
return nil, errNoUpdateNeeded
}
newKeys = raft.EncryptionKeys{
CurrentDEK: data.CurrentDEK,
PendingDEK: encryption.GenerateSecretKey(),
}
return RaftDEKData{
EncryptionKeys: newKeys,
FIPS: data.FIPS,
}, nil
})
if err != nil {
return originalKeys
}
return newKeys
} | [
"func",
"(",
"r",
"*",
"RaftDEKManager",
")",
"GetKeys",
"(",
")",
"raft",
".",
"EncryptionKeys",
"{",
"var",
"newKeys",
",",
"originalKeys",
"raft",
".",
"EncryptionKeys",
"\n",
"err",
":=",
"r",
".",
"kw",
".",
"ViewAndUpdateHeaders",
"(",
"func",
"(",
... | // GetKeys returns the current set of DEKs. If NeedsRotation is true, and there
// is no existing PendingDEK, it will try to create one. If it successfully creates
// and writes a PendingDEK, it sets NeedRotation to false. If there are any errors
// doing so, just return the original set of keys. | [
"GetKeys",
"returns",
"the",
"current",
"set",
"of",
"DEKs",
".",
"If",
"NeedsRotation",
"is",
"true",
"and",
"there",
"is",
"no",
"existing",
"PendingDEK",
"it",
"will",
"try",
"to",
"create",
"one",
".",
"If",
"it",
"successfully",
"creates",
"and",
"wri... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/deks.go#L186-L210 | train |
docker/swarmkit | manager/deks.go | UpdateKeys | func (r *RaftDEKManager) UpdateKeys(newKeys raft.EncryptionKeys) error {
return r.kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
data, ok := h.(RaftDEKData)
if !ok {
return nil, errNotUsingRaftDEKData
}
// If there is no current DEK, we are basically wiping out all DEKs (no header object)
if newKeys.CurrentDEK == nil {
return nil, nil
}
return RaftDEKData{
EncryptionKeys: newKeys,
NeedsRotation: data.NeedsRotation,
FIPS: data.FIPS,
}, nil
})
} | go | func (r *RaftDEKManager) UpdateKeys(newKeys raft.EncryptionKeys) error {
return r.kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
data, ok := h.(RaftDEKData)
if !ok {
return nil, errNotUsingRaftDEKData
}
// If there is no current DEK, we are basically wiping out all DEKs (no header object)
if newKeys.CurrentDEK == nil {
return nil, nil
}
return RaftDEKData{
EncryptionKeys: newKeys,
NeedsRotation: data.NeedsRotation,
FIPS: data.FIPS,
}, nil
})
} | [
"func",
"(",
"r",
"*",
"RaftDEKManager",
")",
"UpdateKeys",
"(",
"newKeys",
"raft",
".",
"EncryptionKeys",
")",
"error",
"{",
"return",
"r",
".",
"kw",
".",
"ViewAndUpdateHeaders",
"(",
"func",
"(",
"h",
"ca",
".",
"PEMKeyHeaders",
")",
"(",
"ca",
".",
... | // UpdateKeys will set the updated encryption keys in the headers. This finishes
// a rotation, and is expected to set the CurrentDEK to the previous PendingDEK. | [
"UpdateKeys",
"will",
"set",
"the",
"updated",
"encryption",
"keys",
"in",
"the",
"headers",
".",
"This",
"finishes",
"a",
"rotation",
"and",
"is",
"expected",
"to",
"set",
"the",
"CurrentDEK",
"to",
"the",
"previous",
"PendingDEK",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/deks.go#L220-L236 | train |
docker/swarmkit | manager/deks.go | MaybeUpdateKEK | func (r *RaftDEKManager) MaybeUpdateKEK(candidateKEK ca.KEKData) (bool, bool, error) {
var updated, unlockedToLocked bool
err := r.kw.ViewAndRotateKEK(func(currentKEK ca.KEKData, h ca.PEMKeyHeaders) (ca.KEKData, ca.PEMKeyHeaders, error) {
var err error
updated, unlockedToLocked, err = compareKEKs(currentKEK, candidateKEK)
if err == nil && !updated { // if we don't need to rotate the KEK, don't bother updating
err = errNoUpdateNeeded
}
if err != nil {
return ca.KEKData{}, nil, err
}
data, ok := h.(RaftDEKData)
if !ok {
return ca.KEKData{}, nil, errNotUsingRaftDEKData
}
if unlockedToLocked {
data.NeedsRotation = true
}
return candidateKEK, data, nil
})
if err == errNoUpdateNeeded {
err = nil
}
if err == nil && unlockedToLocked {
r.rotationCh <- struct{}{}
}
return updated, unlockedToLocked, err
} | go | func (r *RaftDEKManager) MaybeUpdateKEK(candidateKEK ca.KEKData) (bool, bool, error) {
var updated, unlockedToLocked bool
err := r.kw.ViewAndRotateKEK(func(currentKEK ca.KEKData, h ca.PEMKeyHeaders) (ca.KEKData, ca.PEMKeyHeaders, error) {
var err error
updated, unlockedToLocked, err = compareKEKs(currentKEK, candidateKEK)
if err == nil && !updated { // if we don't need to rotate the KEK, don't bother updating
err = errNoUpdateNeeded
}
if err != nil {
return ca.KEKData{}, nil, err
}
data, ok := h.(RaftDEKData)
if !ok {
return ca.KEKData{}, nil, errNotUsingRaftDEKData
}
if unlockedToLocked {
data.NeedsRotation = true
}
return candidateKEK, data, nil
})
if err == errNoUpdateNeeded {
err = nil
}
if err == nil && unlockedToLocked {
r.rotationCh <- struct{}{}
}
return updated, unlockedToLocked, err
} | [
"func",
"(",
"r",
"*",
"RaftDEKManager",
")",
"MaybeUpdateKEK",
"(",
"candidateKEK",
"ca",
".",
"KEKData",
")",
"(",
"bool",
",",
"bool",
",",
"error",
")",
"{",
"var",
"updated",
",",
"unlockedToLocked",
"bool",
"\n",
"err",
":=",
"r",
".",
"kw",
".",... | // MaybeUpdateKEK does a KEK rotation if one is required. Returns whether
// the kek was updated, whether it went from unlocked to locked, and any errors. | [
"MaybeUpdateKEK",
"does",
"a",
"KEK",
"rotation",
"if",
"one",
"is",
"required",
".",
"Returns",
"whether",
"the",
"kek",
"was",
"updated",
"whether",
"it",
"went",
"from",
"unlocked",
"to",
"locked",
"and",
"any",
"errors",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/deks.go#L240-L270 | train |
docker/swarmkit | cmd/swarm-bench/collector.go | Listen | func (c *Collector) Listen(port int) error {
var err error
c.ln, err = net.Listen("tcp", ":"+strconv.Itoa(port))
return err
} | go | func (c *Collector) Listen(port int) error {
var err error
c.ln, err = net.Listen("tcp", ":"+strconv.Itoa(port))
return err
} | [
"func",
"(",
"c",
"*",
"Collector",
")",
"Listen",
"(",
"port",
"int",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"c",
".",
"ln",
",",
"err",
"=",
"net",
".",
"Listen",
"(",
"\"tcp\"",
",",
"\":\"",
"+",
"strconv",
".",
"Itoa",
"(",
"port",
... | // Listen starts listening on a TCP port. Tasks have to connect to this address
// once they come online. | [
"Listen",
"starts",
"listening",
"on",
"a",
"TCP",
"port",
".",
"Tasks",
"have",
"to",
"connect",
"to",
"this",
"address",
"once",
"they",
"come",
"online",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarm-bench/collector.go#L23-L27 | train |
docker/swarmkit | cmd/swarm-bench/collector.go | Collect | func (c *Collector) Collect(ctx context.Context, count uint64) {
start := time.Now()
for i := uint64(0); i < count; i++ {
conn, err := c.ln.Accept()
if err != nil {
log.G(ctx).WithError(err).Error("failure accepting connection")
continue
}
c.t.UpdateSince(start)
conn.Close()
}
} | go | func (c *Collector) Collect(ctx context.Context, count uint64) {
start := time.Now()
for i := uint64(0); i < count; i++ {
conn, err := c.ln.Accept()
if err != nil {
log.G(ctx).WithError(err).Error("failure accepting connection")
continue
}
c.t.UpdateSince(start)
conn.Close()
}
} | [
"func",
"(",
"c",
"*",
"Collector",
")",
"Collect",
"(",
"ctx",
"context",
".",
"Context",
",",
"count",
"uint64",
")",
"{",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"for",
"i",
":=",
"uint64",
"(",
"0",
")",
";",
"i",
"<",
"count",
"... | // Collect blocks until `count` tasks phoned home. | [
"Collect",
"blocks",
"until",
"count",
"tasks",
"phoned",
"home",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarm-bench/collector.go#L30-L41 | train |
docker/swarmkit | cmd/swarm-bench/collector.go | Stats | func (c *Collector) Stats(w io.Writer, unit time.Duration) {
du := float64(unit)
duSuffix := unit.String()[1:]
t := c.t.Snapshot()
ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
fmt.Fprintln(w, "stats:")
fmt.Fprintf(w, " count: %9d\n", t.Count())
fmt.Fprintf(w, " min: %12.2f%s\n", float64(t.Min())/du, duSuffix)
fmt.Fprintf(w, " max: %12.2f%s\n", float64(t.Max())/du, duSuffix)
fmt.Fprintf(w, " mean: %12.2f%s\n", t.Mean()/du, duSuffix)
fmt.Fprintf(w, " stddev: %12.2f%s\n", t.StdDev()/du, duSuffix)
fmt.Fprintf(w, " median: %12.2f%s\n", ps[0]/du, duSuffix)
fmt.Fprintf(w, " 75%%: %12.2f%s\n", ps[1]/du, duSuffix)
fmt.Fprintf(w, " 95%%: %12.2f%s\n", ps[2]/du, duSuffix)
fmt.Fprintf(w, " 99%%: %12.2f%s\n", ps[3]/du, duSuffix)
fmt.Fprintf(w, " 99.9%%: %12.2f%s\n", ps[4]/du, duSuffix)
fmt.Fprintf(w, " 1-min rate: %12.2f\n", t.Rate1())
fmt.Fprintf(w, " 5-min rate: %12.2f\n", t.Rate5())
fmt.Fprintf(w, " 15-min rate: %12.2f\n", t.Rate15())
fmt.Fprintf(w, " mean rate: %12.2f\n", t.RateMean())
} | go | func (c *Collector) Stats(w io.Writer, unit time.Duration) {
du := float64(unit)
duSuffix := unit.String()[1:]
t := c.t.Snapshot()
ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
fmt.Fprintln(w, "stats:")
fmt.Fprintf(w, " count: %9d\n", t.Count())
fmt.Fprintf(w, " min: %12.2f%s\n", float64(t.Min())/du, duSuffix)
fmt.Fprintf(w, " max: %12.2f%s\n", float64(t.Max())/du, duSuffix)
fmt.Fprintf(w, " mean: %12.2f%s\n", t.Mean()/du, duSuffix)
fmt.Fprintf(w, " stddev: %12.2f%s\n", t.StdDev()/du, duSuffix)
fmt.Fprintf(w, " median: %12.2f%s\n", ps[0]/du, duSuffix)
fmt.Fprintf(w, " 75%%: %12.2f%s\n", ps[1]/du, duSuffix)
fmt.Fprintf(w, " 95%%: %12.2f%s\n", ps[2]/du, duSuffix)
fmt.Fprintf(w, " 99%%: %12.2f%s\n", ps[3]/du, duSuffix)
fmt.Fprintf(w, " 99.9%%: %12.2f%s\n", ps[4]/du, duSuffix)
fmt.Fprintf(w, " 1-min rate: %12.2f\n", t.Rate1())
fmt.Fprintf(w, " 5-min rate: %12.2f\n", t.Rate5())
fmt.Fprintf(w, " 15-min rate: %12.2f\n", t.Rate15())
fmt.Fprintf(w, " mean rate: %12.2f\n", t.RateMean())
} | [
"func",
"(",
"c",
"*",
"Collector",
")",
"Stats",
"(",
"w",
"io",
".",
"Writer",
",",
"unit",
"time",
".",
"Duration",
")",
"{",
"du",
":=",
"float64",
"(",
"unit",
")",
"\n",
"duSuffix",
":=",
"unit",
".",
"String",
"(",
")",
"[",
"1",
":",
"]... | // Stats prints various statistics related to the collection. | [
"Stats",
"prints",
"various",
"statistics",
"related",
"to",
"the",
"collection",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarm-bench/collector.go#L44-L66 | train |
docker/swarmkit | manager/orchestrator/replicated/slot.go | Less | func (is slotsByRunningState) Less(i, j int) bool {
iRunning := false
jRunning := false
for _, ii := range is[i] {
if ii.Status.State == api.TaskStateRunning {
iRunning = true
break
}
}
for _, ij := range is[j] {
if ij.Status.State == api.TaskStateRunning {
jRunning = true
break
}
}
if iRunning && !jRunning {
return true
}
if !iRunning && jRunning {
return false
}
// Use Slot number as a tie-breaker to prefer to remove tasks in reverse
// order of Slot number. This would help us avoid unnecessary master
// migration when scaling down a stateful service because the master
// task of a stateful service is usually in a low numbered Slot.
return is[i][0].Slot < is[j][0].Slot
} | go | func (is slotsByRunningState) Less(i, j int) bool {
iRunning := false
jRunning := false
for _, ii := range is[i] {
if ii.Status.State == api.TaskStateRunning {
iRunning = true
break
}
}
for _, ij := range is[j] {
if ij.Status.State == api.TaskStateRunning {
jRunning = true
break
}
}
if iRunning && !jRunning {
return true
}
if !iRunning && jRunning {
return false
}
// Use Slot number as a tie-breaker to prefer to remove tasks in reverse
// order of Slot number. This would help us avoid unnecessary master
// migration when scaling down a stateful service because the master
// task of a stateful service is usually in a low numbered Slot.
return is[i][0].Slot < is[j][0].Slot
} | [
"func",
"(",
"is",
"slotsByRunningState",
")",
"Less",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"iRunning",
":=",
"false",
"\n",
"jRunning",
":=",
"false",
"\n",
"for",
"_",
",",
"ii",
":=",
"range",
"is",
"[",
"i",
"]",
"{",
"if",
"ii",
".",... | // Less returns true if the first task should be preferred over the second task,
// all other things being equal in terms of node balance. | [
"Less",
"returns",
"true",
"if",
"the",
"first",
"task",
"should",
"be",
"preferred",
"over",
"the",
"second",
"task",
"all",
"other",
"things",
"being",
"equal",
"in",
"terms",
"of",
"node",
"balance",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/orchestrator/replicated/slot.go#L18-L48 | train |
docker/swarmkit | manager/orchestrator/replicated/slot.go | updatableAndDeadSlots | func (r *Orchestrator) updatableAndDeadSlots(ctx context.Context, service *api.Service) (map[uint64]orchestrator.Slot, map[uint64]orchestrator.Slot, error) {
var (
tasks []*api.Task
err error
)
r.store.View(func(tx store.ReadTx) {
tasks, err = store.FindTasks(tx, store.ByServiceID(service.ID))
})
if err != nil {
return nil, nil, err
}
updatableSlots := make(map[uint64]orchestrator.Slot)
for _, t := range tasks {
updatableSlots[t.Slot] = append(updatableSlots[t.Slot], t)
}
deadSlots := make(map[uint64]orchestrator.Slot)
for slotID, slot := range updatableSlots {
updatable := r.restarts.UpdatableTasksInSlot(ctx, slot, service)
if len(updatable) != 0 {
updatableSlots[slotID] = updatable
} else {
delete(updatableSlots, slotID)
deadSlots[slotID] = slot
}
}
return updatableSlots, deadSlots, nil
} | go | func (r *Orchestrator) updatableAndDeadSlots(ctx context.Context, service *api.Service) (map[uint64]orchestrator.Slot, map[uint64]orchestrator.Slot, error) {
var (
tasks []*api.Task
err error
)
r.store.View(func(tx store.ReadTx) {
tasks, err = store.FindTasks(tx, store.ByServiceID(service.ID))
})
if err != nil {
return nil, nil, err
}
updatableSlots := make(map[uint64]orchestrator.Slot)
for _, t := range tasks {
updatableSlots[t.Slot] = append(updatableSlots[t.Slot], t)
}
deadSlots := make(map[uint64]orchestrator.Slot)
for slotID, slot := range updatableSlots {
updatable := r.restarts.UpdatableTasksInSlot(ctx, slot, service)
if len(updatable) != 0 {
updatableSlots[slotID] = updatable
} else {
delete(updatableSlots, slotID)
deadSlots[slotID] = slot
}
}
return updatableSlots, deadSlots, nil
} | [
"func",
"(",
"r",
"*",
"Orchestrator",
")",
"updatableAndDeadSlots",
"(",
"ctx",
"context",
".",
"Context",
",",
"service",
"*",
"api",
".",
"Service",
")",
"(",
"map",
"[",
"uint64",
"]",
"orchestrator",
".",
"Slot",
",",
"map",
"[",
"uint64",
"]",
"o... | // updatableAndDeadSlots returns two maps of slots. The first contains slots
// that have at least one task with a desired state above NEW and lesser or
// equal to RUNNING, or a task that shouldn't be restarted. The second contains
// all other slots with at least one task. | [
"updatableAndDeadSlots",
"returns",
"two",
"maps",
"of",
"slots",
".",
"The",
"first",
"contains",
"slots",
"that",
"have",
"at",
"least",
"one",
"task",
"with",
"a",
"desired",
"state",
"above",
"NEW",
"and",
"lesser",
"or",
"equal",
"to",
"RUNNING",
"or",
... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/orchestrator/replicated/slot.go#L78-L107 | train |
docker/swarmkit | manager/orchestrator/replicated/slot.go | SlotTuple | func (r *Orchestrator) SlotTuple(t *api.Task) orchestrator.SlotTuple {
return orchestrator.SlotTuple{
ServiceID: t.ServiceID,
Slot: t.Slot,
}
} | go | func (r *Orchestrator) SlotTuple(t *api.Task) orchestrator.SlotTuple {
return orchestrator.SlotTuple{
ServiceID: t.ServiceID,
Slot: t.Slot,
}
} | [
"func",
"(",
"r",
"*",
"Orchestrator",
")",
"SlotTuple",
"(",
"t",
"*",
"api",
".",
"Task",
")",
"orchestrator",
".",
"SlotTuple",
"{",
"return",
"orchestrator",
".",
"SlotTuple",
"{",
"ServiceID",
":",
"t",
".",
"ServiceID",
",",
"Slot",
":",
"t",
"."... | // SlotTuple returns a slot tuple for the replicated service task. | [
"SlotTuple",
"returns",
"a",
"slot",
"tuple",
"for",
"the",
"replicated",
"service",
"task",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/orchestrator/replicated/slot.go#L110-L115 | train |
docker/swarmkit | manager/state/store/clusters.go | CreateCluster | func CreateCluster(tx Tx, c *api.Cluster) error {
// Ensure the name is not already in use.
if tx.lookup(tableCluster, indexName, strings.ToLower(c.Spec.Annotations.Name)) != nil {
return ErrNameConflict
}
return tx.create(tableCluster, c)
} | go | func CreateCluster(tx Tx, c *api.Cluster) error {
// Ensure the name is not already in use.
if tx.lookup(tableCluster, indexName, strings.ToLower(c.Spec.Annotations.Name)) != nil {
return ErrNameConflict
}
return tx.create(tableCluster, c)
} | [
"func",
"CreateCluster",
"(",
"tx",
"Tx",
",",
"c",
"*",
"api",
".",
"Cluster",
")",
"error",
"{",
"if",
"tx",
".",
"lookup",
"(",
"tableCluster",
",",
"indexName",
",",
"strings",
".",
"ToLower",
"(",
"c",
".",
"Spec",
".",
"Annotations",
".",
"Name... | // CreateCluster adds a new cluster to the store.
// Returns ErrExist if the ID is already taken. | [
"CreateCluster",
"adds",
"a",
"new",
"cluster",
"to",
"the",
"store",
".",
"Returns",
"ErrExist",
"if",
"the",
"ID",
"is",
"already",
"taken",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/clusters.go#L72-L79 | train |
docker/swarmkit | manager/state/store/clusters.go | UpdateCluster | 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.update(tableCluster, c)
} | go | 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.update(tableCluster, c)
} | [
"func",
"UpdateCluster",
"(",
"tx",
"Tx",
",",
"c",
"*",
"api",
".",
"Cluster",
")",
"error",
"{",
"if",
"existing",
":=",
"tx",
".",
"lookup",
"(",
"tableCluster",
",",
"indexName",
",",
"strings",
".",
"ToLower",
"(",
"c",
".",
"Spec",
".",
"Annota... | // UpdateCluster updates an existing cluster in the store.
// Returns ErrNotExist if the cluster doesn't exist. | [
"UpdateCluster",
"updates",
"an",
"existing",
"cluster",
"in",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"cluster",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/clusters.go#L83-L92 | train |
docker/swarmkit | manager/state/store/clusters.go | DeleteCluster | func DeleteCluster(tx Tx, id string) error {
return tx.delete(tableCluster, id)
} | go | func DeleteCluster(tx Tx, id string) error {
return tx.delete(tableCluster, id)
} | [
"func",
"DeleteCluster",
"(",
"tx",
"Tx",
",",
"id",
"string",
")",
"error",
"{",
"return",
"tx",
".",
"delete",
"(",
"tableCluster",
",",
"id",
")",
"\n",
"}"
] | // DeleteCluster removes a cluster from the store.
// Returns ErrNotExist if the cluster doesn't exist. | [
"DeleteCluster",
"removes",
"a",
"cluster",
"from",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"cluster",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/clusters.go#L96-L98 | train |
docker/swarmkit | manager/state/store/clusters.go | GetCluster | func GetCluster(tx ReadTx, id string) *api.Cluster {
n := tx.get(tableCluster, id)
if n == nil {
return nil
}
return n.(*api.Cluster)
} | go | func GetCluster(tx ReadTx, id string) *api.Cluster {
n := tx.get(tableCluster, id)
if n == nil {
return nil
}
return n.(*api.Cluster)
} | [
"func",
"GetCluster",
"(",
"tx",
"ReadTx",
",",
"id",
"string",
")",
"*",
"api",
".",
"Cluster",
"{",
"n",
":=",
"tx",
".",
"get",
"(",
"tableCluster",
",",
"id",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",... | // GetCluster looks up a cluster by ID.
// Returns nil if the cluster doesn't exist. | [
"GetCluster",
"looks",
"up",
"a",
"cluster",
"by",
"ID",
".",
"Returns",
"nil",
"if",
"the",
"cluster",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/clusters.go#L102-L108 | train |
docker/swarmkit | manager/state/store/clusters.go | FindClusters | 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) {
clusterList = append(clusterList, o.(*api.Cluster))
}
err := tx.find(tableCluster, by, checkType, appendResult)
return clusterList, err
} | go | 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) {
clusterList = append(clusterList, o.(*api.Cluster))
}
err := tx.find(tableCluster, by, checkType, appendResult)
return clusterList, err
} | [
"func",
"FindClusters",
"(",
"tx",
"ReadTx",
",",
"by",
"By",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Cluster",
",",
"error",
")",
"{",
"checkType",
":=",
"func",
"(",
"by",
"By",
")",
"error",
"{",
"switch",
"by",
".",
"(",
"type",
")",
"{",
"ca... | // FindClusters selects a set of clusters and returns them. | [
"FindClusters",
"selects",
"a",
"set",
"of",
"clusters",
"and",
"returns",
"them",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/clusters.go#L111-L128 | train |
docker/swarmkit | manager/allocator/networkallocator/networkallocator.go | IsIngressNetwork | 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 | 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"
} | [
"func",
"IsIngressNetwork",
"(",
"nw",
"*",
"api",
".",
"Network",
")",
"bool",
"{",
"if",
"nw",
".",
"Spec",
".",
"Ingress",
"{",
"return",
"true",
"\n",
"}",
"\n",
"_",
",",
"ok",
":=",
"nw",
".",
"Spec",
".",
"Annotations",
".",
"Labels",
"[",
... | // IsIngressNetwork check if the network is an ingress network | [
"IsIngressNetwork",
"check",
"if",
"the",
"network",
"is",
"an",
"ingress",
"network"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/allocator/networkallocator/networkallocator.go#L95-L102 | train |
docker/swarmkit | manager/allocator/networkallocator/networkallocator.go | IsIngressNetworkNeeded | 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 attach the task to
// the ingress network.
if p.PublishMode == api.PublishModeIngress {
return true
}
}
return false
} | go | 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 attach the task to
// the ingress network.
if p.PublishMode == api.PublishModeIngress {
return true
}
}
return false
} | [
"func",
"IsIngressNetworkNeeded",
"(",
"s",
"*",
"api",
".",
"Service",
")",
"bool",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"s",
".",
"Spec",
".",
"Endpoint",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n"... | // IsIngressNetworkNeeded checks whether the service requires the routing-mesh | [
"IsIngressNetworkNeeded",
"checks",
"whether",
"the",
"service",
"requires",
"the",
"routing",
"-",
"mesh"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/allocator/networkallocator/networkallocator.go#L105-L125 | train |
docker/swarmkit | cmd/swarmctl/common/print.go | PrintHeader | 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 | 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"))
} | [
"func",
"PrintHeader",
"(",
"w",
"io",
".",
"Writer",
",",
"columns",
"...",
"string",
")",
"{",
"underline",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"columns",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"underline",
"{",
"underline",... | // PrintHeader prints a nice little header. | [
"PrintHeader",
"prints",
"a",
"nice",
"little",
"header",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarmctl/common/print.go#L13-L20 | train |
docker/swarmkit | remotes/remotes.go | NewRemotes | 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 | func NewRemotes(peers ...api.Peer) Remotes {
mwr := &remotesWeightedRandom{
remotes: make(map[api.Peer]int),
}
for _, peer := range peers {
mwr.Observe(peer, DefaultObservationWeight)
}
return mwr
} | [
"func",
"NewRemotes",
"(",
"peers",
"...",
"api",
".",
"Peer",
")",
"Remotes",
"{",
"mwr",
":=",
"&",
"remotesWeightedRandom",
"{",
"remotes",
":",
"make",
"(",
"map",
"[",
"api",
".",
"Peer",
"]",
"int",
")",
",",
"}",
"\n",
"for",
"_",
",",
"peer... | // NewRemotes returns a Remotes instance with the provided set of addresses.
// Entries provided are heavily weighted initially. | [
"NewRemotes",
"returns",
"a",
"Remotes",
"instance",
"with",
"the",
"provided",
"set",
"of",
"addresses",
".",
"Entries",
"provided",
"are",
"heavily",
"weighted",
"initially",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/remotes/remotes.go#L47-L57 | train |
docker/swarmkit | manager/allocator/allocator.go | New | 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: pg,
networkConfig: netConfig,
}
return a, nil
} | go | 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: pg,
networkConfig: netConfig,
}
return a, nil
} | [
"func",
"New",
"(",
"store",
"*",
"store",
".",
"MemoryStore",
",",
"pg",
"plugingetter",
".",
"PluginGetter",
",",
"netConfig",
"*",
"cnmallocator",
".",
"NetworkConfig",
")",
"(",
"*",
"Allocator",
",",
"error",
")",
"{",
"a",
":=",
"&",
"Allocator",
"... | // New returns a new instance of Allocator for use during allocation
// stage of the manager. | [
"New",
"returns",
"a",
"new",
"instance",
"of",
"Allocator",
"for",
"use",
"during",
"allocation",
"stage",
"of",
"the",
"manager",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/allocator/allocator.go#L72-L85 | train |
docker/swarmkit | manager/allocator/allocator.go | Run | 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: networkVoter,
init: a.doNetworkInit,
action: a.doNetworkAlloc,
},
} {
if aa.taskVoter != "" {
a.registerToVote(aa.taskVoter)
}
// Assign a pointer for variable capture
aaPtr := &aa
actor := func() error {
wg.Add(1)
defer wg.Done()
// init might return an allocator specific context
// which is a child of the passed in context to hold
// allocator specific state
watch, watchCancel, err := a.init(ctx, aaPtr)
if err != nil {
return err
}
wg.Add(1)
go func(watch <-chan events.Event, watchCancel func()) {
defer func() {
wg.Done()
watchCancel()
}()
a.run(ctx, *aaPtr, watch)
}(watch, watchCancel)
return nil
}
actors = append(actors, actor)
}
for _, actor := range actors {
if err := actor(); err != nil {
return err
}
}
<-a.stopChan
return nil
} | go | 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: networkVoter,
init: a.doNetworkInit,
action: a.doNetworkAlloc,
},
} {
if aa.taskVoter != "" {
a.registerToVote(aa.taskVoter)
}
// Assign a pointer for variable capture
aaPtr := &aa
actor := func() error {
wg.Add(1)
defer wg.Done()
// init might return an allocator specific context
// which is a child of the passed in context to hold
// allocator specific state
watch, watchCancel, err := a.init(ctx, aaPtr)
if err != nil {
return err
}
wg.Add(1)
go func(watch <-chan events.Event, watchCancel func()) {
defer func() {
wg.Done()
watchCancel()
}()
a.run(ctx, *aaPtr, watch)
}(watch, watchCancel)
return nil
}
actors = append(actors, actor)
}
for _, actor := range actors {
if err := actor(); err != nil {
return err
}
}
<-a.stopChan
return nil
} | [
"func",
"(",
"a",
"*",
"Allocator",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"var",
"(",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"actors",
"... | // Run starts all allocator go-routines and waits for Stop to be called. | [
"Run",
"starts",
"all",
"allocator",
"go",
"-",
"routines",
"and",
"waits",
"for",
"Stop",
"to",
"be",
"called",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/allocator/allocator.go#L88-L149 | train |
docker/swarmkit | agent/exec/controller_stub.go | Update | func (sc *StubController) Update(ctx context.Context, t *api.Task) error {
sc.called()
return sc.UpdateFn(ctx, t)
} | go | func (sc *StubController) Update(ctx context.Context, t *api.Task) error {
sc.called()
return sc.UpdateFn(ctx, t)
} | [
"func",
"(",
"sc",
"*",
"StubController",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"t",
"*",
"api",
".",
"Task",
")",
"error",
"{",
"sc",
".",
"called",
"(",
")",
"\n",
"return",
"sc",
".",
"UpdateFn",
"(",
"ctx",
",",
"t",
")",... | // Update is part of the Controller interface | [
"Update",
"is",
"part",
"of",
"the",
"Controller",
"interface"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/controller_stub.go#L49-L52 | train |
docker/swarmkit | agent/exec/controller_stub.go | Terminate | func (sc *StubController) Terminate(ctx context.Context) error {
sc.called()
return sc.TerminateFn(ctx)
} | go | func (sc *StubController) Terminate(ctx context.Context) error {
sc.called()
return sc.TerminateFn(ctx)
} | [
"func",
"(",
"sc",
"*",
"StubController",
")",
"Terminate",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"sc",
".",
"called",
"(",
")",
"\n",
"return",
"sc",
".",
"TerminateFn",
"(",
"ctx",
")",
"\n",
"}"
] | // Terminate is part of the Controller interface | [
"Terminate",
"is",
"part",
"of",
"the",
"Controller",
"interface"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/controller_stub.go#L67-L70 | train |
docker/swarmkit | cmd/swarmctl/service/flagparser/config.go | ParseAddConfig | 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.TaskSpec_Container{
Container: &api.ContainerSpec{},
}
}
lookupConfigNames := []string{}
var needConfigs []*api.ConfigReference
for _, config := range configs {
n, p, err := parseConfigString(config)
if err != nil {
return err
}
// TODO(diogo): defaults to File targets, but in the future will take different types
configRef := &api.ConfigReference{
ConfigName: n,
Target: &api.ConfigReference_File{
File: &api.FileTarget{
Name: p,
Mode: 0444,
},
},
}
lookupConfigNames = append(lookupConfigNames, n)
needConfigs = append(needConfigs, configRef)
}
client, err := common.Dial(cmd)
if err != nil {
return err
}
r, err := client.ListConfigs(common.Context(cmd),
&api.ListConfigsRequest{Filters: &api.ListConfigsRequest_Filters{Names: lookupConfigNames}})
if err != nil {
return err
}
foundConfigs := make(map[string]*api.Config)
for _, config := range r.Configs {
foundConfigs[config.Spec.Annotations.Name] = config
}
for _, configRef := range needConfigs {
config, ok := foundConfigs[configRef.ConfigName]
if !ok {
return fmt.Errorf("config not found: %s", configRef.ConfigName)
}
configRef.ConfigID = config.ID
container.Configs = append(container.Configs, configRef)
}
}
return nil
} | go | 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.TaskSpec_Container{
Container: &api.ContainerSpec{},
}
}
lookupConfigNames := []string{}
var needConfigs []*api.ConfigReference
for _, config := range configs {
n, p, err := parseConfigString(config)
if err != nil {
return err
}
// TODO(diogo): defaults to File targets, but in the future will take different types
configRef := &api.ConfigReference{
ConfigName: n,
Target: &api.ConfigReference_File{
File: &api.FileTarget{
Name: p,
Mode: 0444,
},
},
}
lookupConfigNames = append(lookupConfigNames, n)
needConfigs = append(needConfigs, configRef)
}
client, err := common.Dial(cmd)
if err != nil {
return err
}
r, err := client.ListConfigs(common.Context(cmd),
&api.ListConfigsRequest{Filters: &api.ListConfigsRequest_Filters{Names: lookupConfigNames}})
if err != nil {
return err
}
foundConfigs := make(map[string]*api.Config)
for _, config := range r.Configs {
foundConfigs[config.Spec.Annotations.Name] = config
}
for _, configRef := range needConfigs {
config, ok := foundConfigs[configRef.ConfigName]
if !ok {
return fmt.Errorf("config not found: %s", configRef.ConfigName)
}
configRef.ConfigID = config.ID
container.Configs = append(container.Configs, configRef)
}
}
return nil
} | [
"func",
"ParseAddConfig",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"spec",
"*",
"api",
".",
"ServiceSpec",
",",
"flagName",
"string",
")",
"error",
"{",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n",
"if",
"flags",
".",
"Changed",
"(",
"fl... | // ParseAddConfig validates configs passed on the command line | [
"ParseAddConfig",
"validates",
"configs",
"passed",
"on",
"the",
"command",
"line"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarmctl/service/flagparser/config.go#L36-L104 | train |
docker/swarmkit | cmd/swarmctl/service/flagparser/config.go | ParseRemoveConfig | 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
}
wantToDelete := make(map[string]struct{})
for _, config := range configs {
n, _, err := parseConfigString(config)
if err != nil {
return err
}
wantToDelete[n] = struct{}{}
}
configRefs := []*api.ConfigReference{}
for _, configRef := range container.Configs {
if _, ok := wantToDelete[configRef.ConfigName]; ok {
continue
}
configRefs = append(configRefs, configRef)
}
container.Configs = configRefs
}
return nil
} | go | 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
}
wantToDelete := make(map[string]struct{})
for _, config := range configs {
n, _, err := parseConfigString(config)
if err != nil {
return err
}
wantToDelete[n] = struct{}{}
}
configRefs := []*api.ConfigReference{}
for _, configRef := range container.Configs {
if _, ok := wantToDelete[configRef.ConfigName]; ok {
continue
}
configRefs = append(configRefs, configRef)
}
container.Configs = configRefs
}
return nil
} | [
"func",
"ParseRemoveConfig",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"spec",
"*",
"api",
".",
"ServiceSpec",
",",
"flagName",
"string",
")",
"error",
"{",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n",
"if",
"flags",
".",
"Changed",
"(",
... | // ParseRemoveConfig removes a set of configs from the task spec's config references | [
"ParseRemoveConfig",
"removes",
"a",
"set",
"of",
"configs",
"from",
"the",
"task",
"spec",
"s",
"config",
"references"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarmctl/service/flagparser/config.go#L107-L144 | train |
docker/swarmkit | ca/keyreadwriter.go | NewKeyReadWriter | func NewKeyReadWriter(paths CertPaths, kek []byte, headersObj PEMKeyHeaders) *KeyReadWriter {
return &KeyReadWriter{
kekData: KEKData{KEK: kek},
paths: paths,
headersObj: headersObj,
keyFormatter: keyutils.Default,
}
} | go | func NewKeyReadWriter(paths CertPaths, kek []byte, headersObj PEMKeyHeaders) *KeyReadWriter {
return &KeyReadWriter{
kekData: KEKData{KEK: kek},
paths: paths,
headersObj: headersObj,
keyFormatter: keyutils.Default,
}
} | [
"func",
"NewKeyReadWriter",
"(",
"paths",
"CertPaths",
",",
"kek",
"[",
"]",
"byte",
",",
"headersObj",
"PEMKeyHeaders",
")",
"*",
"KeyReadWriter",
"{",
"return",
"&",
"KeyReadWriter",
"{",
"kekData",
":",
"KEKData",
"{",
"KEK",
":",
"kek",
"}",
",",
"path... | // NewKeyReadWriter creates a new KeyReadWriter | [
"NewKeyReadWriter",
"creates",
"a",
"new",
"KeyReadWriter"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L136-L143 | train |
docker/swarmkit | ca/keyreadwriter.go | SetKeyFormatter | func (k *KeyReadWriter) SetKeyFormatter(kf keyutils.Formatter) {
k.mu.Lock()
defer k.mu.Unlock()
k.keyFormatter = kf
} | go | func (k *KeyReadWriter) SetKeyFormatter(kf keyutils.Formatter) {
k.mu.Lock()
defer k.mu.Unlock()
k.keyFormatter = kf
} | [
"func",
"(",
"k",
"*",
"KeyReadWriter",
")",
"SetKeyFormatter",
"(",
"kf",
"keyutils",
".",
"Formatter",
")",
"{",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"k",
".",
"keyFormatter",
"=",
... | // SetKeyFormatter sets the keyformatter with which to encrypt and decrypt keys | [
"SetKeyFormatter",
"sets",
"the",
"keyformatter",
"with",
"which",
"to",
"encrypt",
"and",
"decrypt",
"keys"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L146-L150 | train |
docker/swarmkit | ca/keyreadwriter.go | Migrate | 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 encrypting TLS keys
cert, err := ioutil.ReadFile(k.paths.Cert)
if err != nil {
return os.RemoveAll(tmpPaths.Key) // no cert? no migration
}
// nope, this does not match the cert
if _, err = tls.X509KeyPair(cert, keyBytes); err != nil {
return os.RemoveAll(tmpPaths.Key)
}
return os.Rename(tmpPaths.Key, k.paths.Key)
} | go | 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 encrypting TLS keys
cert, err := ioutil.ReadFile(k.paths.Cert)
if err != nil {
return os.RemoveAll(tmpPaths.Key) // no cert? no migration
}
// nope, this does not match the cert
if _, err = tls.X509KeyPair(cert, keyBytes); err != nil {
return os.RemoveAll(tmpPaths.Key)
}
return os.Rename(tmpPaths.Key, k.paths.Key)
} | [
"func",
"(",
"k",
"*",
"KeyReadWriter",
")",
"Migrate",
"(",
")",
"error",
"{",
"tmpPaths",
":=",
"k",
".",
"genTempPaths",
"(",
")",
"\n",
"keyBytes",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"tmpPaths",
".",
"Key",
")",
"\n",
"if",
"err",
... | // Migrate checks to see if a temporary key file exists. Older versions of
// swarmkit wrote temporary keys instead of temporary certificates, so
// migrate that temporary key if it exists. We want to write temporary certificates,
// instead of temporary keys, because we may need to periodically re-encrypt the
// keys and modify the headers, and it's easier to have a single canonical key
// location than two possible key locations. | [
"Migrate",
"checks",
"to",
"see",
"if",
"a",
"temporary",
"key",
"file",
"exists",
".",
"Older",
"versions",
"of",
"swarmkit",
"wrote",
"temporary",
"keys",
"instead",
"of",
"temporary",
"certificates",
"so",
"migrate",
"that",
"temporary",
"key",
"if",
"it",
... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L158-L178 | train |
docker/swarmkit | ca/keyreadwriter.go | Read | 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 = versionInt
}
}
delete(keyBlock.Headers, versionHeader)
if k.headersObj != nil {
newHeaders, err := k.headersObj.UnmarshalHeaders(keyBlock.Headers, k.kekData)
if err != nil {
return nil, nil, errors.Wrap(err, "unable to read TLS key headers")
}
k.headersObj = newHeaders
}
keyBytes := pem.EncodeToMemory(keyBlock)
cert, err := ioutil.ReadFile(k.paths.Cert)
// The cert is written to a temporary file first, then the key, and then
// the cert gets renamed - so, if interrupted, it's possible to end up with
// a cert that only exists in the temporary location.
switch {
case err == nil:
_, err = tls.X509KeyPair(cert, keyBytes)
case os.IsNotExist(err): //continue to try temp location
break
default:
return nil, nil, err
}
// either the cert doesn't exist, or it doesn't match the key - try the temp file, if it exists
if err != nil {
var tempErr error
tmpPaths := k.genTempPaths()
cert, tempErr = ioutil.ReadFile(tmpPaths.Cert)
if tempErr != nil {
return nil, nil, err // return the original error
}
if _, tempErr := tls.X509KeyPair(cert, keyBytes); tempErr != nil {
os.RemoveAll(tmpPaths.Cert) // nope, it doesn't match either - remove and return the original error
return nil, nil, err
}
os.Rename(tmpPaths.Cert, k.paths.Cert) // try to move the temp cert back to the regular location
}
return cert, keyBytes, nil
} | go | 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 = versionInt
}
}
delete(keyBlock.Headers, versionHeader)
if k.headersObj != nil {
newHeaders, err := k.headersObj.UnmarshalHeaders(keyBlock.Headers, k.kekData)
if err != nil {
return nil, nil, errors.Wrap(err, "unable to read TLS key headers")
}
k.headersObj = newHeaders
}
keyBytes := pem.EncodeToMemory(keyBlock)
cert, err := ioutil.ReadFile(k.paths.Cert)
// The cert is written to a temporary file first, then the key, and then
// the cert gets renamed - so, if interrupted, it's possible to end up with
// a cert that only exists in the temporary location.
switch {
case err == nil:
_, err = tls.X509KeyPair(cert, keyBytes)
case os.IsNotExist(err): //continue to try temp location
break
default:
return nil, nil, err
}
// either the cert doesn't exist, or it doesn't match the key - try the temp file, if it exists
if err != nil {
var tempErr error
tmpPaths := k.genTempPaths()
cert, tempErr = ioutil.ReadFile(tmpPaths.Cert)
if tempErr != nil {
return nil, nil, err // return the original error
}
if _, tempErr := tls.X509KeyPair(cert, keyBytes); tempErr != nil {
os.RemoveAll(tmpPaths.Cert) // nope, it doesn't match either - remove and return the original error
return nil, nil, err
}
os.Rename(tmpPaths.Cert, k.paths.Cert) // try to move the temp cert back to the regular location
}
return cert, keyBytes, nil
} | [
"func",
"(",
"k",
"*",
"KeyReadWriter",
")",
"Read",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"keyBl... | // Read will read a TLS cert and key from the given paths | [
"Read",
"will",
"read",
"a",
"TLS",
"cert",
"and",
"key",
"from",
"the",
"given",
"paths"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L181-L235 | train |
docker/swarmkit | ca/keyreadwriter.go | ViewAndRotateKEK | 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 k.writeKey(keyBlock, updatedKEK, updatedHeaderObj)
} | go | 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 k.writeKey(keyBlock, updatedKEK, updatedHeaderObj)
} | [
"func",
"(",
"k",
"*",
"KeyReadWriter",
")",
"ViewAndRotateKEK",
"(",
"cb",
"func",
"(",
"KEKData",
",",
"PEMKeyHeaders",
")",
"(",
"KEKData",
",",
"PEMKeyHeaders",
",",
"error",
")",
")",
"error",
"{",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"d... | // ViewAndRotateKEK re-encrypts the key with a new KEK | [
"ViewAndRotateKEK",
"re",
"-",
"encrypts",
"the",
"key",
"with",
"a",
"new",
"KEK"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L238-L253 | train |
docker/swarmkit | ca/keyreadwriter.go | ViewAndUpdateHeaders | 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 {
var err error
headers, err = pkh.MarshalHeaders(k.kekData)
if err != nil {
return err
}
}
// we WANT any original encryption headers
for key, value := range keyBlock.Headers {
normalizedKey := strings.TrimSpace(strings.ToLower(key))
if normalizedKey == "proc-type" || normalizedKey == "dek-info" {
headers[key] = value
}
}
headers[versionHeader] = strconv.FormatUint(k.kekData.Version, 10)
keyBlock.Headers = headers
if err = ioutils.AtomicWriteFile(k.paths.Key, pem.EncodeToMemory(keyBlock), keyPerms); err != nil {
return err
}
k.headersObj = pkh
return nil
} | go | 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 {
var err error
headers, err = pkh.MarshalHeaders(k.kekData)
if err != nil {
return err
}
}
// we WANT any original encryption headers
for key, value := range keyBlock.Headers {
normalizedKey := strings.TrimSpace(strings.ToLower(key))
if normalizedKey == "proc-type" || normalizedKey == "dek-info" {
headers[key] = value
}
}
headers[versionHeader] = strconv.FormatUint(k.kekData.Version, 10)
keyBlock.Headers = headers
if err = ioutils.AtomicWriteFile(k.paths.Key, pem.EncodeToMemory(keyBlock), keyPerms); err != nil {
return err
}
k.headersObj = pkh
return nil
} | [
"func",
"(",
"k",
"*",
"KeyReadWriter",
")",
"ViewAndUpdateHeaders",
"(",
"cb",
"func",
"(",
"PEMKeyHeaders",
")",
"(",
"PEMKeyHeaders",
",",
"error",
")",
")",
"error",
"{",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"mu",
".",
... | // ViewAndUpdateHeaders updates the header manager, and updates any headers on the existing key | [
"ViewAndUpdateHeaders",
"updates",
"the",
"header",
"manager",
"and",
"updates",
"any",
"headers",
"on",
"the",
"existing",
"key"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L256-L293 | train |
docker/swarmkit | ca/keyreadwriter.go | GetCurrentState | func (k *KeyReadWriter) GetCurrentState() (PEMKeyHeaders, KEKData) {
k.mu.Lock()
defer k.mu.Unlock()
return k.headersObj, k.kekData
} | go | func (k *KeyReadWriter) GetCurrentState() (PEMKeyHeaders, KEKData) {
k.mu.Lock()
defer k.mu.Unlock()
return k.headersObj, k.kekData
} | [
"func",
"(",
"k",
"*",
"KeyReadWriter",
")",
"GetCurrentState",
"(",
")",
"(",
"PEMKeyHeaders",
",",
"KEKData",
")",
"{",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"k",
".",
"he... | // GetCurrentState returns the current KEK data, including version | [
"GetCurrentState",
"returns",
"the",
"current",
"KEK",
"data",
"including",
"version"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L296-L300 | train |
docker/swarmkit | ca/keyreadwriter.go | writeKey | 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.New("unable to encrypt key - invalid PEM file produced")
}
keyBlock = encryptedPEMBlock
}
if pkh != nil {
headers, err := pkh.MarshalHeaders(kekData)
if err != nil {
return err
}
mergePEMHeaders(keyBlock.Headers, headers)
}
keyBlock.Headers[versionHeader] = strconv.FormatUint(kekData.Version, 10)
if err := ioutils.AtomicWriteFile(k.paths.Key, pem.EncodeToMemory(keyBlock), keyPerms); err != nil {
return err
}
k.kekData = kekData
k.headersObj = pkh
return nil
} | go | 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.New("unable to encrypt key - invalid PEM file produced")
}
keyBlock = encryptedPEMBlock
}
if pkh != nil {
headers, err := pkh.MarshalHeaders(kekData)
if err != nil {
return err
}
mergePEMHeaders(keyBlock.Headers, headers)
}
keyBlock.Headers[versionHeader] = strconv.FormatUint(kekData.Version, 10)
if err := ioutils.AtomicWriteFile(k.paths.Key, pem.EncodeToMemory(keyBlock), keyPerms); err != nil {
return err
}
k.kekData = kekData
k.headersObj = pkh
return nil
} | [
"func",
"(",
"k",
"*",
"KeyReadWriter",
")",
"writeKey",
"(",
"keyBlock",
"*",
"pem",
".",
"Block",
",",
"kekData",
"KEKData",
",",
"pkh",
"PEMKeyHeaders",
")",
"error",
"{",
"if",
"kekData",
".",
"KEK",
"!=",
"nil",
"{",
"encryptedPEMBlock",
",",
"err",... | // writeKey takes an unencrypted keyblock and, if the kek is not nil, encrypts it before
// writing it to disk. If the kek is nil, writes it to disk unencrypted. | [
"writeKey",
"takes",
"an",
"unencrypted",
"keyblock",
"and",
"if",
"the",
"kek",
"is",
"not",
"nil",
"encrypts",
"it",
"before",
"writing",
"it",
"to",
"disk",
".",
"If",
"the",
"kek",
"is",
"nil",
"writes",
"it",
"to",
"disk",
"unencrypted",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L413-L440 | train |
docker/swarmkit | ca/keyreadwriter.go | mergePEMHeaders | 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 | 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
}
}
} | [
"func",
"mergePEMHeaders",
"(",
"original",
",",
"newSet",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"for",
"key",
",",
"value",
":=",
"range",
"newSet",
"{",
"normalizedKey",
":=",
"strings",
".",
"TrimSpace",
"(",
"strings",
".",
"ToLower",
"(",
"... | // merges one set of PEM headers onto another, excepting for key encryption value
// "proc-type" and "dek-info" | [
"merges",
"one",
"set",
"of",
"PEM",
"headers",
"onto",
"another",
"excepting",
"for",
"key",
"encryption",
"value",
"proc",
"-",
"type",
"and",
"dek",
"-",
"info"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/keyreadwriter.go#L486-L493 | train |
docker/swarmkit | cmd/swarm-bench/benchmark.go | Run | 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.ID, b.cfg.Count)
// Periodically print stats.
doneCh := make(chan struct{})
go func() {
for {
select {
case <-time.After(5 * time.Second):
fmt.Printf("\n%s: Progression report\n", time.Now())
b.collector.Stats(os.Stdout, time.Second)
case <-doneCh:
return
}
}
}()
fmt.Println("Collecting metrics...")
b.collector.Collect(ctx, b.cfg.Count)
doneCh <- struct{}{}
fmt.Printf("\n%s: Benchmark completed\n", time.Now())
b.collector.Stats(os.Stdout, time.Second)
return nil
} | go | 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.ID, b.cfg.Count)
// Periodically print stats.
doneCh := make(chan struct{})
go func() {
for {
select {
case <-time.After(5 * time.Second):
fmt.Printf("\n%s: Progression report\n", time.Now())
b.collector.Stats(os.Stdout, time.Second)
case <-doneCh:
return
}
}
}()
fmt.Println("Collecting metrics...")
b.collector.Collect(ctx, b.cfg.Count)
doneCh <- struct{}{}
fmt.Printf("\n%s: Benchmark completed\n", time.Now())
b.collector.Stats(os.Stdout, time.Second)
return nil
} | [
"func",
"(",
"b",
"*",
"Benchmark",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"fmt",
".",
"Printf",
"(",
"\"Listening for incoming connections at %s:%d\\n\"",
",",
"\\n",
",",
"b",
".",
"cfg",
".",
"IP",
")",
"\n",
"b",
".",
... | // Run starts the benchmark session and waits for it to be completed. | [
"Run",
"starts",
"the",
"benchmark",
"session",
"and",
"waits",
"for",
"it",
"to",
"be",
"completed",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarm-bench/benchmark.go#L38-L71 | train |
docker/swarmkit | ca/renewer.go | NewTLSRenewer | func NewTLSRenewer(s *SecurityConfig, connBroker *connectionbroker.Broker, rootPaths CertPaths) *TLSRenewer {
return &TLSRenewer{
s: s,
connBroker: connBroker,
renew: make(chan struct{}, 1),
rootPaths: rootPaths,
}
} | go | func NewTLSRenewer(s *SecurityConfig, connBroker *connectionbroker.Broker, rootPaths CertPaths) *TLSRenewer {
return &TLSRenewer{
s: s,
connBroker: connBroker,
renew: make(chan struct{}, 1),
rootPaths: rootPaths,
}
} | [
"func",
"NewTLSRenewer",
"(",
"s",
"*",
"SecurityConfig",
",",
"connBroker",
"*",
"connectionbroker",
".",
"Broker",
",",
"rootPaths",
"CertPaths",
")",
"*",
"TLSRenewer",
"{",
"return",
"&",
"TLSRenewer",
"{",
"s",
":",
"s",
",",
"connBroker",
":",
"connBro... | // NewTLSRenewer creates a new TLS renewer. It must be started with Start. | [
"NewTLSRenewer",
"creates",
"a",
"new",
"TLS",
"renewer",
".",
"It",
"must",
"be",
"started",
"with",
"Start",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/renewer.go#L34-L41 | train |
docker/swarmkit | ca/renewer.go | SetExpectedRole | func (t *TLSRenewer) SetExpectedRole(role string) {
t.mu.Lock()
t.expectedRole = role
t.mu.Unlock()
} | go | func (t *TLSRenewer) SetExpectedRole(role string) {
t.mu.Lock()
t.expectedRole = role
t.mu.Unlock()
} | [
"func",
"(",
"t",
"*",
"TLSRenewer",
")",
"SetExpectedRole",
"(",
"role",
"string",
")",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"t",
".",
"expectedRole",
"=",
"role",
"\n",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // SetExpectedRole sets the expected role. If a renewal is forced, and the role
// doesn't match this expectation, renewal will be retried with exponential
// backoff until it does match. | [
"SetExpectedRole",
"sets",
"the",
"expected",
"role",
".",
"If",
"a",
"renewal",
"is",
"forced",
"and",
"the",
"role",
"doesn",
"t",
"match",
"this",
"expectation",
"renewal",
"will",
"be",
"retried",
"with",
"exponential",
"backoff",
"until",
"it",
"does",
... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/renewer.go#L46-L50 | train |
docker/swarmkit | manager/drivers/provider.go | NewSecretDriver | 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.pluginGetter.Get(driver.Name, SecretsProviderCapability, plugingetter.Lookup)
if err != nil {
return nil, err
}
return NewSecretDriver(plugin), nil
} | go | 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.pluginGetter.Get(driver.Name, SecretsProviderCapability, plugingetter.Lookup)
if err != nil {
return nil, err
}
return NewSecretDriver(plugin), nil
} | [
"func",
"(",
"m",
"*",
"DriverProvider",
")",
"NewSecretDriver",
"(",
"driver",
"*",
"api",
".",
"Driver",
")",
"(",
"*",
"SecretDriver",
",",
"error",
")",
"{",
"if",
"m",
".",
"pluginGetter",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Err... | // NewSecretDriver creates a new driver for fetching secrets | [
"NewSecretDriver",
"creates",
"a",
"new",
"driver",
"for",
"fetching",
"secrets"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/drivers/provider.go#L21-L34 | train |
docker/swarmkit | cli/external_ca.go | Set | 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 | func (m *ExternalCAOpt) Set(value string) error {
parsed, err := parseExternalCA(value)
if err != nil {
return err
}
m.values = append(m.values, parsed)
return nil
} | [
"func",
"(",
"m",
"*",
"ExternalCAOpt",
")",
"Set",
"(",
"value",
"string",
")",
"error",
"{",
"parsed",
",",
"err",
":=",
"parseExternalCA",
"(",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"m",
".",
"value... | // Set parses an external CA option. | [
"Set",
"parses",
"an",
"external",
"CA",
"option",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cli/external_ca.go#L18-L26 | train |
docker/swarmkit | manager/resourceapi/allocator.go | AttachNetwork | 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.Config.Target)
if network == nil {
if networks, err := store.FindNetworks(tx, store.ByName(request.Config.Target)); err == nil && len(networks) == 1 {
network = networks[0]
}
}
})
if network == nil {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.Config.Target)
}
if !network.Spec.Attachable {
return nil, status.Errorf(codes.PermissionDenied, "network %s not manually attachable", request.Config.Target)
}
t := &api.Task{
ID: identity.NewID(),
NodeID: nodeInfo.NodeID,
Spec: api.TaskSpec{
Runtime: &api.TaskSpec_Attachment{
Attachment: &api.NetworkAttachmentSpec{
ContainerID: request.ContainerID,
},
},
Networks: []*api.NetworkAttachmentConfig{
{
Target: network.ID,
Addresses: request.Config.Addresses,
},
},
},
Status: api.TaskStatus{
State: api.TaskStateNew,
Timestamp: ptypes.MustTimestampProto(time.Now()),
Message: "created",
},
DesiredState: api.TaskStateRunning,
// TODO: Add Network attachment.
}
if err := ra.store.Update(func(tx store.Tx) error {
return store.CreateTask(tx, t)
}); err != nil {
return nil, err
}
return &api.AttachNetworkResponse{AttachmentID: t.ID}, nil
} | go | 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.Config.Target)
if network == nil {
if networks, err := store.FindNetworks(tx, store.ByName(request.Config.Target)); err == nil && len(networks) == 1 {
network = networks[0]
}
}
})
if network == nil {
return nil, status.Errorf(codes.NotFound, "network %s not found", request.Config.Target)
}
if !network.Spec.Attachable {
return nil, status.Errorf(codes.PermissionDenied, "network %s not manually attachable", request.Config.Target)
}
t := &api.Task{
ID: identity.NewID(),
NodeID: nodeInfo.NodeID,
Spec: api.TaskSpec{
Runtime: &api.TaskSpec_Attachment{
Attachment: &api.NetworkAttachmentSpec{
ContainerID: request.ContainerID,
},
},
Networks: []*api.NetworkAttachmentConfig{
{
Target: network.ID,
Addresses: request.Config.Addresses,
},
},
},
Status: api.TaskStatus{
State: api.TaskStateNew,
Timestamp: ptypes.MustTimestampProto(time.Now()),
Message: "created",
},
DesiredState: api.TaskStateRunning,
// TODO: Add Network attachment.
}
if err := ra.store.Update(func(tx store.Tx) error {
return store.CreateTask(tx, t)
}); err != nil {
return nil, err
}
return &api.AttachNetworkResponse{AttachmentID: t.ID}, nil
} | [
"func",
"(",
"ra",
"*",
"ResourceAllocator",
")",
"AttachNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"AttachNetworkRequest",
")",
"(",
"*",
"api",
".",
"AttachNetworkResponse",
",",
"error",
")",
"{",
"nodeInfo",
",",
... | // AttachNetwork allows the node to request the resources
// allocation needed for a network attachment on the specific node.
// - Returns `InvalidArgument` if the Spec is malformed.
// - Returns `NotFound` if the Network is not found.
// - Returns `PermissionDenied` if the Network is not manually attachable.
// - Returns an error if the creation fails. | [
"AttachNetwork",
"allows",
"the",
"node",
"to",
"request",
"the",
"resources",
"allocation",
"needed",
"for",
"a",
"network",
"attachment",
"on",
"the",
"specific",
"node",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"Spec",
"is",
"malformed",
".",
"-... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/resourceapi/allocator.go#L37-L92 | train |
docker/swarmkit | manager/resourceapi/allocator.go | DetachNetwork | 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, err
}
if err := ra.store.Update(func(tx store.Tx) error {
t := store.GetTask(tx, request.AttachmentID)
if t == nil {
return status.Errorf(codes.NotFound, "attachment %s not found", request.AttachmentID)
}
if t.NodeID != nodeInfo.NodeID {
return status.Errorf(codes.PermissionDenied, "attachment %s doesn't belong to this node", request.AttachmentID)
}
return store.DeleteTask(tx, request.AttachmentID)
}); err != nil {
return nil, err
}
return &api.DetachNetworkResponse{}, nil
} | go | 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, err
}
if err := ra.store.Update(func(tx store.Tx) error {
t := store.GetTask(tx, request.AttachmentID)
if t == nil {
return status.Errorf(codes.NotFound, "attachment %s not found", request.AttachmentID)
}
if t.NodeID != nodeInfo.NodeID {
return status.Errorf(codes.PermissionDenied, "attachment %s doesn't belong to this node", request.AttachmentID)
}
return store.DeleteTask(tx, request.AttachmentID)
}); err != nil {
return nil, err
}
return &api.DetachNetworkResponse{}, nil
} | [
"func",
"(",
"ra",
"*",
"ResourceAllocator",
")",
"DetachNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"DetachNetworkRequest",
")",
"(",
"*",
"api",
".",
"DetachNetworkResponse",
",",
"error",
")",
"{",
"if",
"request",
... | // DetachNetwork allows the node to request the release of
// the resources associated to the network attachment.
// - Returns `InvalidArgument` if attachment ID is not provided.
// - Returns `NotFound` if the attachment is not found.
// - Returns an error if the deletion fails. | [
"DetachNetwork",
"allows",
"the",
"node",
"to",
"request",
"the",
"release",
"of",
"the",
"resources",
"associated",
"to",
"the",
"network",
"attachment",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"attachment",
"ID",
"is",
"not",
"provided",
".",
"-",
"Ret... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/resourceapi/allocator.go#L99-L124 | train |
docker/swarmkit | manager/metrics/collector.go | NewCollector | func NewCollector(store *store.MemoryStore) *Collector {
return &Collector{
store: store,
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
}
} | go | func NewCollector(store *store.MemoryStore) *Collector {
return &Collector{
store: store,
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
}
} | [
"func",
"NewCollector",
"(",
"store",
"*",
"store",
".",
"MemoryStore",
")",
"*",
"Collector",
"{",
"return",
"&",
"Collector",
"{",
"store",
":",
"store",
",",
"stopChan",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"doneChan",
":",
"make"... | // NewCollector creates a new metrics collector | [
"NewCollector",
"creates",
"a",
"new",
"metrics",
"collector"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/metrics/collector.go#L52-L58 | train |
docker/swarmkit | manager/metrics/collector.go | Run | 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 {
return err
}
services, err := store.FindServices(readTx, store.All)
if err != nil {
return err
}
networks, err := store.FindNetworks(readTx, store.All)
if err != nil {
return err
}
secrets, err := store.FindSecrets(readTx, store.All)
if err != nil {
return err
}
configs, err := store.FindConfigs(readTx, store.All)
if err != nil {
return err
}
for _, obj := range nodes {
c.handleEvent(obj.EventCreate())
}
for _, obj := range tasks {
c.handleEvent(obj.EventCreate())
}
for _, obj := range services {
c.handleEvent(obj.EventCreate())
}
for _, obj := range networks {
c.handleEvent(obj.EventCreate())
}
for _, obj := range secrets {
c.handleEvent(obj.EventCreate())
}
for _, obj := range configs {
c.handleEvent(obj.EventCreate())
}
return nil
})
if err != nil {
return err
}
defer cancel()
for {
select {
case event := <-watcher:
c.handleEvent(event)
case <-c.stopChan:
return nil
}
}
} | go | 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 {
return err
}
services, err := store.FindServices(readTx, store.All)
if err != nil {
return err
}
networks, err := store.FindNetworks(readTx, store.All)
if err != nil {
return err
}
secrets, err := store.FindSecrets(readTx, store.All)
if err != nil {
return err
}
configs, err := store.FindConfigs(readTx, store.All)
if err != nil {
return err
}
for _, obj := range nodes {
c.handleEvent(obj.EventCreate())
}
for _, obj := range tasks {
c.handleEvent(obj.EventCreate())
}
for _, obj := range services {
c.handleEvent(obj.EventCreate())
}
for _, obj := range networks {
c.handleEvent(obj.EventCreate())
}
for _, obj := range secrets {
c.handleEvent(obj.EventCreate())
}
for _, obj := range configs {
c.handleEvent(obj.EventCreate())
}
return nil
})
if err != nil {
return err
}
defer cancel()
for {
select {
case event := <-watcher:
c.handleEvent(event)
case <-c.stopChan:
return nil
}
}
} | [
"func",
"(",
"c",
"*",
"Collector",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"defer",
"close",
"(",
"c",
".",
"doneChan",
")",
"\n",
"watcher",
",",
"cancel",
",",
"err",
":=",
"store",
".",
"ViewAndWatch",
"(",
"c",
".... | // Run contains the collector event loop | [
"Run",
"contains",
"the",
"collector",
"event",
"loop"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/metrics/collector.go#L61-L124 | train |
docker/swarmkit | manager/metrics/collector.go | handleEvent | 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.handleSecretsEvent(event)
case api.EventConfig:
c.handleConfigsEvent(event)
}
} | go | 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.handleSecretsEvent(event)
case api.EventConfig:
c.handleConfigsEvent(event)
}
} | [
"func",
"(",
"c",
"*",
"Collector",
")",
"handleEvent",
"(",
"event",
"events",
".",
"Event",
")",
"{",
"switch",
"event",
".",
"(",
"type",
")",
"{",
"case",
"api",
".",
"EventNode",
":",
"c",
".",
"handleNodeEvent",
"(",
"event",
")",
"\n",
"case",... | // handleEvent handles a single incoming cluster event. | [
"handleEvent",
"handles",
"a",
"single",
"incoming",
"cluster",
"event",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/metrics/collector.go#L151-L166 | train |
docker/swarmkit | manager/controlapi/task.go | GetTask | 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)
})
if task == nil {
return nil, status.Errorf(codes.NotFound, "task %s not found", request.TaskID)
}
return &api.GetTaskResponse{
Task: task,
}, nil
} | go | 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)
})
if task == nil {
return nil, status.Errorf(codes.NotFound, "task %s not found", request.TaskID)
}
return &api.GetTaskResponse{
Task: task,
}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"GetTask",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"GetTaskRequest",
")",
"(",
"*",
"api",
".",
"GetTaskResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"TaskID",
"==",
"\"... | // GetTask returns a Task given a TaskID.
// - Returns `InvalidArgument` if TaskID is not provided.
// - Returns `NotFound` if the Task is not found. | [
"GetTask",
"returns",
"a",
"Task",
"given",
"a",
"TaskID",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"TaskID",
"is",
"not",
"provided",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Task",
"is",
"not",
"found",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/task.go#L17-L32 | train |
docker/swarmkit | manager/controlapi/task.go | RemoveTask | 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)
})
if err != nil {
if err == store.ErrNotExist {
return nil, status.Errorf(codes.NotFound, "task %s not found", request.TaskID)
}
return nil, err
}
return &api.RemoveTaskResponse{}, nil
} | go | 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)
})
if err != nil {
if err == store.ErrNotExist {
return nil, status.Errorf(codes.NotFound, "task %s not found", request.TaskID)
}
return nil, err
}
return &api.RemoveTaskResponse{}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"RemoveTask",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"RemoveTaskRequest",
")",
"(",
"*",
"api",
".",
"RemoveTaskResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"TaskID",
"=... | // RemoveTask removes a Task referenced by TaskID.
// - Returns `InvalidArgument` if TaskID is not provided.
// - Returns `NotFound` if the Task is not found.
// - Returns an error if the deletion fails. | [
"RemoveTask",
"removes",
"a",
"Task",
"referenced",
"by",
"TaskID",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"TaskID",
"is",
"not",
"provided",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Task",
"is",
"not",
"found",
".",
"-",
"Returns",
"an",
"err... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/task.go#L38-L53 | train |
docker/swarmkit | manager/orchestrator/update/updater.go | NewSupervisor | func NewSupervisor(store *store.MemoryStore, restartSupervisor *restart.Supervisor) *Supervisor {
return &Supervisor{
store: store,
updates: make(map[string]*Updater),
restarts: restartSupervisor,
}
} | go | func NewSupervisor(store *store.MemoryStore, restartSupervisor *restart.Supervisor) *Supervisor {
return &Supervisor{
store: store,
updates: make(map[string]*Updater),
restarts: restartSupervisor,
}
} | [
"func",
"NewSupervisor",
"(",
"store",
"*",
"store",
".",
"MemoryStore",
",",
"restartSupervisor",
"*",
"restart",
".",
"Supervisor",
")",
"*",
"Supervisor",
"{",
"return",
"&",
"Supervisor",
"{",
"store",
":",
"store",
",",
"updates",
":",
"make",
"(",
"m... | // NewSupervisor creates a new UpdateSupervisor. | [
"NewSupervisor",
"creates",
"a",
"new",
"UpdateSupervisor",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/orchestrator/update/updater.go#L34-L40 | train |
docker/swarmkit | manager/orchestrator/update/updater.go | CancelAll | func (u *Supervisor) CancelAll() {
u.l.Lock()
defer u.l.Unlock()
for _, update := range u.updates {
update.Cancel()
}
} | go | func (u *Supervisor) CancelAll() {
u.l.Lock()
defer u.l.Unlock()
for _, update := range u.updates {
update.Cancel()
}
} | [
"func",
"(",
"u",
"*",
"Supervisor",
")",
"CancelAll",
"(",
")",
"{",
"u",
".",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"u",
".",
"l",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"update",
":=",
"range",
"u",
".",
"updates",
"{",
"upda... | // CancelAll cancels all current updates. | [
"CancelAll",
"cancels",
"all",
"current",
"updates",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/orchestrator/update/updater.go#L76-L83 | train |
docker/swarmkit | manager/orchestrator/update/updater.go | NewUpdater | 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(),
updatedTasks: make(map[string]time.Time),
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
}
} | go | 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(),
updatedTasks: make(map[string]time.Time),
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
}
} | [
"func",
"NewUpdater",
"(",
"store",
"*",
"store",
".",
"MemoryStore",
",",
"restartSupervisor",
"*",
"restart",
".",
"Supervisor",
",",
"cluster",
"*",
"api",
".",
"Cluster",
",",
"newService",
"*",
"api",
".",
"Service",
")",
"*",
"Updater",
"{",
"return"... | // NewUpdater creates a new Updater. | [
"NewUpdater",
"creates",
"a",
"new",
"Updater",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/orchestrator/update/updater.go#L104-L115 | train |
docker/swarmkit | manager/orchestrator/update/updater.go | removeOldTasks | 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) error {
t := store.GetTask(tx, original.ID)
if t == nil {
return fmt.Errorf("task %s not found while trying to shut it down", original.ID)
}
if t.DesiredState > api.TaskStateRunning {
return fmt.Errorf("task %s was already shut down when reached by updater", original.ID)
}
t.DesiredState = api.TaskStateShutdown
return store.UpdateTask(tx, t)
})
if err != nil {
lastErr = err
} else {
removedTask = original
}
}
if removedTask == nil {
return nil, lastErr
}
return removedTask, nil
} | go | 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) error {
t := store.GetTask(tx, original.ID)
if t == nil {
return fmt.Errorf("task %s not found while trying to shut it down", original.ID)
}
if t.DesiredState > api.TaskStateRunning {
return fmt.Errorf("task %s was already shut down when reached by updater", original.ID)
}
t.DesiredState = api.TaskStateShutdown
return store.UpdateTask(tx, t)
})
if err != nil {
lastErr = err
} else {
removedTask = original
}
}
if removedTask == nil {
return nil, lastErr
}
return removedTask, nil
} | [
"func",
"(",
"u",
"*",
"Updater",
")",
"removeOldTasks",
"(",
"ctx",
"context",
".",
"Context",
",",
"batch",
"*",
"store",
".",
"Batch",
",",
"removeTasks",
"[",
"]",
"*",
"api",
".",
"Task",
")",
"(",
"*",
"api",
".",
"Task",
",",
"error",
")",
... | // removeOldTasks shuts down the given tasks and returns one of the tasks that
// was shut down, or an error. | [
"removeOldTasks",
"shuts",
"down",
"the",
"given",
"tasks",
"and",
"returns",
"one",
"of",
"the",
"tasks",
"that",
"was",
"shut",
"down",
"or",
"an",
"error",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/orchestrator/update/updater.go#L496-L527 | train |
docker/swarmkit | agent/task.go | Update | 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 | 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()
}
} | [
"func",
"(",
"tm",
"*",
"taskManager",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"task",
"*",
"api",
".",
"Task",
")",
"error",
"{",
"select",
"{",
"case",
"tm",
".",
"updateq",
"<-",
"task",
":",
"return",
"nil",
"\n",
"case",
"<-... | // Update the task data. | [
"Update",
"the",
"task",
"data",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/task.go#L43-L52 | train |
docker/swarmkit | agent/task.go | Close | func (tm *taskManager) Close() error {
tm.shutdownOnce.Do(func() {
close(tm.shutdown)
})
<-tm.closed
return nil
} | go | func (tm *taskManager) Close() error {
tm.shutdownOnce.Do(func() {
close(tm.shutdown)
})
<-tm.closed
return nil
} | [
"func",
"(",
"tm",
"*",
"taskManager",
")",
"Close",
"(",
")",
"error",
"{",
"tm",
".",
"shutdownOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"tm",
".",
"shutdown",
")",
"\n",
"}",
")",
"\n",
"<-",
"tm",
".",
"closed",
"\n",
"ret... | // Close shuts down the task manager, blocking until it is closed. | [
"Close",
"shuts",
"down",
"the",
"task",
"manager",
"blocking",
"until",
"it",
"is",
"closed",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/task.go#L55-L63 | train |
docker/swarmkit | api/genericresource/parse.go | Parse | 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])
val := strings.TrimSpace(kva[1])
tokens[key] = append(tokens[key], val)
}
var rs []*api.GenericResource
for k, v := range tokens {
if u, ok := isDiscreteResource(v); ok {
if u < 0 {
return nil, newParseError("cannot ask for"+
" negative resource %s", k)
}
rs = append(rs, NewDiscrete(k, u))
continue
}
if allNamedResources(v) {
rs = append(rs, NewSet(k, v...)...)
continue
}
return nil, newParseError("mixed discrete and named resources"+
" in expression '%s=%s'", k, v)
}
return rs, nil
} | go | 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])
val := strings.TrimSpace(kva[1])
tokens[key] = append(tokens[key], val)
}
var rs []*api.GenericResource
for k, v := range tokens {
if u, ok := isDiscreteResource(v); ok {
if u < 0 {
return nil, newParseError("cannot ask for"+
" negative resource %s", k)
}
rs = append(rs, NewDiscrete(k, u))
continue
}
if allNamedResources(v) {
rs = append(rs, NewSet(k, v...)...)
continue
}
return nil, newParseError("mixed discrete and named resources"+
" in expression '%s=%s'", k, v)
}
return rs, nil
} | [
"func",
"Parse",
"(",
"cmds",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"api",
".",
"GenericResource",
",",
"error",
")",
"{",
"tokens",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"term",
":... | // Parse parses a table of GenericResource resources | [
"Parse",
"parses",
"a",
"table",
"of",
"GenericResource",
"resources"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/api/genericresource/parse.go#L56-L94 | train |
docker/swarmkit | agent/exec/dockerapi/controller.go | newController | 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: adapter,
closed: make(chan struct{}),
}, nil
} | go | 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: adapter,
closed: make(chan struct{}),
}, nil
} | [
"func",
"newController",
"(",
"client",
"engineapi",
".",
"APIClient",
",",
"nodeDescription",
"*",
"api",
".",
"NodeDescription",
",",
"task",
"*",
"api",
".",
"Task",
",",
"secrets",
"exec",
".",
"SecretGetter",
")",
"(",
"exec",
".",
"Controller",
",",
... | // newController returns a docker exec controller for the provided task. | [
"newController",
"returns",
"a",
"docker",
"exec",
"controller",
"for",
"the",
"provided",
"task",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/dockerapi/controller.go#L44-L55 | train |
docker/swarmkit | agent/exec/dockerapi/controller.go | Update | 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 | 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
} | [
"func",
"(",
"r",
"*",
"controller",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"t",
"*",
"api",
".",
"Task",
")",
"error",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Warnf",
"(",
"\"task updates not yet supported\"",
")",
"\n",
"re... | // Update takes a recent task update and applies it to the container. | [
"Update",
"takes",
"a",
"recent",
"task",
"update",
"and",
"applies",
"it",
"to",
"the",
"container",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/dockerapi/controller.go#L84-L90 | train |
docker/swarmkit | agent/exec/dockerapi/controller.go | Prepare | 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 err := r.adapter.createVolumes(ctx); err != nil {
return err
}
if r.pulled == nil {
// Launches a re-entrant pull operation associated with controller,
// dissociating the context from the caller's context. Allows pull
// operation to be re-entrant on calls to prepare, resuming from the
// same point after cancellation.
var pctx context.Context
r.pulled = make(chan struct{})
pctx, r.cancelPull = context.WithCancel(context.Background()) // TODO(stevvooe): Bind a context to the entire controller.
go func() {
defer close(r.pulled)
r.pullErr = r.adapter.pullImage(pctx)
}()
}
select {
case <-ctx.Done():
return ctx.Err()
case <-r.pulled:
if r.pullErr != nil {
// NOTE(stevvooe): We always try to pull the image to make sure we have
// the most up to date version. This will return an error, but we only
// log it. If the image truly doesn't exist, the create below will
// error out.
//
// This gives us some nice behavior where we use up to date versions of
// mutable tags, but will still run if the old image is available but a
// registry is down.
//
// If you don't want this behavior, lock down your image to an
// immutable tag or digest.
log.G(ctx).WithError(r.pullErr).Error("pulling image failed")
}
}
if err := r.adapter.create(ctx); err != nil {
if isContainerCreateNameConflict(err) {
if _, err := r.adapter.inspect(ctx); err != nil {
return err
}
// container is already created. success!
return exec.ErrTaskPrepared
}
return err
}
return nil
} | go | 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 err := r.adapter.createVolumes(ctx); err != nil {
return err
}
if r.pulled == nil {
// Launches a re-entrant pull operation associated with controller,
// dissociating the context from the caller's context. Allows pull
// operation to be re-entrant on calls to prepare, resuming from the
// same point after cancellation.
var pctx context.Context
r.pulled = make(chan struct{})
pctx, r.cancelPull = context.WithCancel(context.Background()) // TODO(stevvooe): Bind a context to the entire controller.
go func() {
defer close(r.pulled)
r.pullErr = r.adapter.pullImage(pctx)
}()
}
select {
case <-ctx.Done():
return ctx.Err()
case <-r.pulled:
if r.pullErr != nil {
// NOTE(stevvooe): We always try to pull the image to make sure we have
// the most up to date version. This will return an error, but we only
// log it. If the image truly doesn't exist, the create below will
// error out.
//
// This gives us some nice behavior where we use up to date versions of
// mutable tags, but will still run if the old image is available but a
// registry is down.
//
// If you don't want this behavior, lock down your image to an
// immutable tag or digest.
log.G(ctx).WithError(r.pullErr).Error("pulling image failed")
}
}
if err := r.adapter.create(ctx); err != nil {
if isContainerCreateNameConflict(err) {
if _, err := r.adapter.inspect(ctx); err != nil {
return err
}
// container is already created. success!
return exec.ErrTaskPrepared
}
return err
}
return nil
} | [
"func",
"(",
"r",
"*",
"controller",
")",
"Prepare",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"err",
":=",
"r",
".",
"checkClosed",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":="... | // Prepare creates a container and ensures the image is pulled.
//
// If the container has already be created, exec.ErrTaskPrepared is returned. | [
"Prepare",
"creates",
"a",
"container",
"and",
"ensures",
"the",
"image",
"is",
"pulled",
".",
"If",
"the",
"container",
"has",
"already",
"be",
"created",
"exec",
".",
"ErrTaskPrepared",
"is",
"returned",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/dockerapi/controller.go#L95-L160 | train |
docker/swarmkit | api/deepcopy/copy.go | Copy | 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)
*dst = *src
case *time.Duration:
src := src.(*time.Duration)
*dst = *src
case *types.Timestamp:
src := src.(*types.Timestamp)
*dst = *src
case *types.BoolValue:
src := src.(*types.BoolValue)
*dst = *src
case *types.Int64Value:
src := src.(*types.Int64Value)
*dst = *src
case CopierFrom:
dst.CopyFrom(src)
default:
panic(fmt.Sprintf("Copy for %T not implemented", dst))
}
} | go | 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)
*dst = *src
case *time.Duration:
src := src.(*time.Duration)
*dst = *src
case *types.Timestamp:
src := src.(*types.Timestamp)
*dst = *src
case *types.BoolValue:
src := src.(*types.BoolValue)
*dst = *src
case *types.Int64Value:
src := src.(*types.Int64Value)
*dst = *src
case CopierFrom:
dst.CopyFrom(src)
default:
panic(fmt.Sprintf("Copy for %T not implemented", dst))
}
} | [
"func",
"Copy",
"(",
"dst",
",",
"src",
"interface",
"{",
"}",
")",
"{",
"switch",
"dst",
":=",
"dst",
".",
"(",
"type",
")",
"{",
"case",
"*",
"types",
".",
"Any",
":",
"src",
":=",
"src",
".",
"(",
"*",
"types",
".",
"Any",
")",
"\n",
"dst"... | // Copy copies src into dst. dst and src must have the same type.
//
// If the type has a copy function defined, it will be used.
//
// Default implementations for builtin types and well known protobuf types may
// be provided.
//
// If the copy cannot be performed, this function will panic. Make sure to test
// types that use this function. | [
"Copy",
"copies",
"src",
"into",
"dst",
".",
"dst",
"and",
"src",
"must",
"have",
"the",
"same",
"type",
".",
"If",
"the",
"type",
"has",
"a",
"copy",
"function",
"defined",
"it",
"will",
"be",
"used",
".",
"Default",
"implementations",
"for",
"builtin",... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/api/deepcopy/copy.go#L27-L59 | train |
docker/swarmkit | cmd/swarmctl/network/common.go | GetNetwork | 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.ListNetworks(ctx,
&api.ListNetworksRequest{
Filters: &api.ListNetworksRequest_Filters{
Names: []string{input},
},
},
)
if err != nil {
return nil, err
}
if len(rl.Networks) == 0 {
return nil, fmt.Errorf("network %s not found", input)
}
if l := len(rl.Networks); l > 1 {
return nil, fmt.Errorf("network %s is ambiguous (%d matches found)", input, l)
}
return rl.Networks[0], nil
}
return rg.Network, nil
} | go | 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.ListNetworks(ctx,
&api.ListNetworksRequest{
Filters: &api.ListNetworksRequest_Filters{
Names: []string{input},
},
},
)
if err != nil {
return nil, err
}
if len(rl.Networks) == 0 {
return nil, fmt.Errorf("network %s not found", input)
}
if l := len(rl.Networks); l > 1 {
return nil, fmt.Errorf("network %s is ambiguous (%d matches found)", input, l)
}
return rl.Networks[0], nil
}
return rg.Network, nil
} | [
"func",
"GetNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"api",
".",
"ControlClient",
",",
"input",
"string",
")",
"(",
"*",
"api",
".",
"Network",
",",
"error",
")",
"{",
"rg",
",",
"err",
":=",
"c",
".",
"GetNetwork",
"(",
"ctx",
",... | // GetNetwork tries to query for a network as an ID and if it can't be
// found tries to query as a name. If the name query returns exactly
// one entry then it is returned to the caller. Otherwise an error is
// returned. | [
"GetNetwork",
"tries",
"to",
"query",
"for",
"a",
"network",
"as",
"an",
"ID",
"and",
"if",
"it",
"can",
"t",
"be",
"found",
"tries",
"to",
"query",
"as",
"a",
"name",
".",
"If",
"the",
"name",
"query",
"returns",
"exactly",
"one",
"entry",
"then",
"... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarmctl/network/common.go#L14-L42 | train |
docker/swarmkit | cmd/swarmctl/network/common.go | ResolveServiceNetworks | 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 err != nil {
return err
}
networks = append(networks, &api.NetworkAttachmentConfig{
Target: n.ID,
})
}
spec.Task.Networks = networks
return nil
} | go | 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 err != nil {
return err
}
networks = append(networks, &api.NetworkAttachmentConfig{
Target: n.ID,
})
}
spec.Task.Networks = networks
return nil
} | [
"func",
"ResolveServiceNetworks",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"api",
".",
"ControlClient",
",",
"spec",
"*",
"api",
".",
"ServiceSpec",
")",
"error",
"{",
"if",
"len",
"(",
"spec",
".",
"Task",
".",
"Networks",
")",
"==",
"0",
"{",... | // ResolveServiceNetworks takes a service spec and resolves network names to network IDs. | [
"ResolveServiceNetworks",
"takes",
"a",
"service",
"spec",
"and",
"resolves",
"network",
"names",
"to",
"network",
"IDs",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/cmd/swarmctl/network/common.go#L45-L63 | train |
docker/swarmkit | agent/helpers.go | runctx | 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 | 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():
}
} | [
"func",
"runctx",
"(",
"ctx",
"context",
".",
"Context",
",",
"closed",
"chan",
"struct",
"{",
"}",
",",
"errs",
"chan",
"error",
",",
"fn",
"func",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
")",
"{",
"select",
"{",
"case",
"errs",
"<-",
... | // runctx blocks until the function exits, closed is closed, or the context is
// cancelled. Call as part of go statement. | [
"runctx",
"blocks",
"until",
"the",
"function",
"exits",
"closed",
"is",
"closed",
"or",
"the",
"context",
"is",
"cancelled",
".",
"Call",
"as",
"part",
"of",
"go",
"statement",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/helpers.go#L7-L13 | train |
docker/swarmkit | manager/state/store/tasks.go | CreateTask | func CreateTask(tx Tx, t *api.Task) error {
return tx.create(tableTask, t)
} | go | func CreateTask(tx Tx, t *api.Task) error {
return tx.create(tableTask, t)
} | [
"func",
"CreateTask",
"(",
"tx",
"Tx",
",",
"t",
"*",
"api",
".",
"Task",
")",
"error",
"{",
"return",
"tx",
".",
"create",
"(",
"tableTask",
",",
"t",
")",
"\n",
"}"
] | // CreateTask adds a new task to the store.
// Returns ErrExist if the ID is already taken. | [
"CreateTask",
"adds",
"a",
"new",
"task",
"to",
"the",
"store",
".",
"Returns",
"ErrExist",
"if",
"the",
"ID",
"is",
"already",
"taken",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/tasks.go#L111-L113 | train |
docker/swarmkit | manager/state/store/tasks.go | UpdateTask | func UpdateTask(tx Tx, t *api.Task) error {
return tx.update(tableTask, t)
} | go | func UpdateTask(tx Tx, t *api.Task) error {
return tx.update(tableTask, t)
} | [
"func",
"UpdateTask",
"(",
"tx",
"Tx",
",",
"t",
"*",
"api",
".",
"Task",
")",
"error",
"{",
"return",
"tx",
".",
"update",
"(",
"tableTask",
",",
"t",
")",
"\n",
"}"
] | // UpdateTask updates an existing task in the store.
// Returns ErrNotExist if the node doesn't exist. | [
"UpdateTask",
"updates",
"an",
"existing",
"task",
"in",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"node",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/tasks.go#L117-L119 | train |
docker/swarmkit | manager/state/store/tasks.go | DeleteTask | func DeleteTask(tx Tx, id string) error {
return tx.delete(tableTask, id)
} | go | func DeleteTask(tx Tx, id string) error {
return tx.delete(tableTask, id)
} | [
"func",
"DeleteTask",
"(",
"tx",
"Tx",
",",
"id",
"string",
")",
"error",
"{",
"return",
"tx",
".",
"delete",
"(",
"tableTask",
",",
"id",
")",
"\n",
"}"
] | // DeleteTask removes a task from the store.
// Returns ErrNotExist if the task doesn't exist. | [
"DeleteTask",
"removes",
"a",
"task",
"from",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"task",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/tasks.go#L123-L125 | train |
docker/swarmkit | manager/state/store/tasks.go | GetTask | func GetTask(tx ReadTx, id string) *api.Task {
t := tx.get(tableTask, id)
if t == nil {
return nil
}
return t.(*api.Task)
} | go | func GetTask(tx ReadTx, id string) *api.Task {
t := tx.get(tableTask, id)
if t == nil {
return nil
}
return t.(*api.Task)
} | [
"func",
"GetTask",
"(",
"tx",
"ReadTx",
",",
"id",
"string",
")",
"*",
"api",
".",
"Task",
"{",
"t",
":=",
"tx",
".",
"get",
"(",
"tableTask",
",",
"id",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"t",
... | // GetTask looks up a task by ID.
// Returns nil if the task doesn't exist. | [
"GetTask",
"looks",
"up",
"a",
"task",
"by",
"ID",
".",
"Returns",
"nil",
"if",
"the",
"task",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/tasks.go#L129-L135 | train |
docker/swarmkit | manager/state/store/tasks.go | FindTasks | 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:
return nil
default:
return ErrInvalidFindBy
}
}
taskList := []*api.Task{}
appendResult := func(o api.StoreObject) {
taskList = append(taskList, o.(*api.Task))
}
err := tx.find(tableTask, by, checkType, appendResult)
return taskList, err
} | go | 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:
return nil
default:
return ErrInvalidFindBy
}
}
taskList := []*api.Task{}
appendResult := func(o api.StoreObject) {
taskList = append(taskList, o.(*api.Task))
}
err := tx.find(tableTask, by, checkType, appendResult)
return taskList, err
} | [
"func",
"FindTasks",
"(",
"tx",
"ReadTx",
",",
"by",
"By",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Task",
",",
"error",
")",
"{",
"checkType",
":=",
"func",
"(",
"by",
"By",
")",
"error",
"{",
"switch",
"by",
".",
"(",
"type",
")",
"{",
"case",
... | // FindTasks selects a set of tasks and returns them. | [
"FindTasks",
"selects",
"a",
"set",
"of",
"tasks",
"and",
"returns",
"them",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/tasks.go#L138-L155 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.