func buildFilters(by func(string) store.By, values []string) store.By { filters := make([]store.By, 0, len(values)) for _, v := range values { filters = append(filters, by(v)) } return store.Or(filters...) }
// ListSecrets returns a `ListSecretResponse` with a list all non-internal `Secret`s being // managed, or all secrets matching any name in `ListSecretsRequest.Names`, any // name prefix in `ListSecretsRequest.NamePrefixes`, any id in // `ListSecretsRequest.SecretIDs`, or any id prefix in `ListSecretsRequest.IDPrefixes`. // - Returns an error if listing fails. func (s *Server) ListSecrets(ctx context.Context, request *api.ListSecretsRequest) (*api.ListSecretsResponse, error) { var ( secrets []*api.Secret respSecrets []*api.Secret err error byFilters []store.By by store.By labels map[string]string ) // return all secrets that match either any of the names or any of the name prefixes (why would you give both?) if request.Filters != nil { for _, name := range request.Filters.Names { byFilters = append(byFilters, store.ByName(name)) } for _, prefix := range request.Filters.NamePrefixes { byFilters = append(byFilters, store.ByNamePrefix(prefix)) } for _, prefix := range request.Filters.IDPrefixes { byFilters = append(byFilters, store.ByIDPrefix(prefix)) } labels = request.Filters.Labels } switch len(byFilters) { case 0: by = store.All case 1: by = byFilters[0] default: by = store.Or(byFilters...) } s.store.View(func(tx store.ReadTx) { secrets, err = store.FindSecrets(tx, by) }) if err != nil { return nil, err } // strip secret data from the secret, filter by label, and filter out all internal secrets for _, secret := range secrets { if secret.Internal || !filterMatchLabels(secret.Spec.Annotations.Labels, labels) { continue } secret.Spec.Data = nil // clean the actual secret data so it's never returned respSecrets = append(respSecrets, secret) } return &api.ListSecretsResponse{Secrets: respSecrets}, nil }
// ListNodes returns a list of all nodes. func (s *Server) ListNodes(ctx context.Context, request *api.ListNodesRequest) (*api.ListNodesResponse, error) { var ( nodes []*api.Node err error ) s.store.View(func(tx store.ReadTx) { switch { case request.Filters != nil && len(request.Filters.Names) > 0: nodes, err = store.FindNodes(tx, buildFilters(store.ByName, request.Filters.Names)) case request.Filters != nil && len(request.Filters.NamePrefixes) > 0: nodes, err = store.FindNodes(tx, buildFilters(store.ByNamePrefix, request.Filters.NamePrefixes)) case request.Filters != nil && len(request.Filters.IDPrefixes) > 0: nodes, err = store.FindNodes(tx, buildFilters(store.ByIDPrefix, request.Filters.IDPrefixes)) case request.Filters != nil && len(request.Filters.Roles) > 0: filters := make([]store.By, 0, len(request.Filters.Roles)) for _, v := range request.Filters.Roles { filters = append(filters, store.ByRole(v)) } nodes, err = store.FindNodes(tx, store.Or(filters...)) case request.Filters != nil && len(request.Filters.Memberships) > 0: filters := make([]store.By, 0, len(request.Filters.Memberships)) for _, v := range request.Filters.Memberships { filters = append(filters, store.ByMembership(v)) } nodes, err = store.FindNodes(tx, store.Or(filters...)) default: nodes, err = store.FindNodes(tx, store.All) } }) if err != nil { return nil, err } if request.Filters != nil { nodes = filterNodes(nodes, func(e *api.Node) bool { if len(request.Filters.Names) == 0 { return true } if e.Description == nil { return false } return filterContains(e.Description.Hostname, request.Filters.Names) }, func(e *api.Node) bool { if len(request.Filters.NamePrefixes) == 0 { return true } if e.Description == nil { return false } return filterContainsPrefix(e.Description.Hostname, request.Filters.NamePrefixes) }, func(e *api.Node) bool { return filterContainsPrefix(e.ID, request.Filters.IDPrefixes) }, func(e *api.Node) bool { if len(request.Filters.Labels) == 0 { return true } if e.Description == nil { return false } return filterMatchLabels(e.Description.Engine.Labels, request.Filters.Labels) }, func(e *api.Node) bool { if len(request.Filters.Roles) == 0 { return true } for _, c := range request.Filters.Roles { if c == e.Spec.Role { return true } } return false }, func(e *api.Node) bool { if len(request.Filters.Memberships) == 0 { return true } for _, c := range request.Filters.Memberships { if c == e.Spec.Membership { return true } } return false }, ) } // Add in manager information on nodes that are managers if s.raft != nil { memberlist := s.raft.GetMemberlist() for _, node := range nodes { for _, member := range memberlist { if member.NodeID == node.ID { node.ManagerStatus = &api.ManagerStatus{ RaftID: member.RaftID, Addr: member.Addr, Leader: member.Status.Leader, Reachability: member.Status.Reachability, } break } } } } return &api.ListNodesResponse{ Nodes: nodes, }, nil }
// ListTasks returns a list of all tasks. func (s *Server) ListTasks(ctx context.Context, request *api.ListTasksRequest) (*api.ListTasksResponse, error) { var ( tasks []*api.Task err error ) s.store.View(func(tx store.ReadTx) { switch { case request.Filters != nil && len(request.Filters.Names) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByName, request.Filters.Names)) case request.Filters != nil && len(request.Filters.NamePrefixes) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByNamePrefix, request.Filters.NamePrefixes)) case request.Filters != nil && len(request.Filters.IDPrefixes) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByIDPrefix, request.Filters.IDPrefixes)) case request.Filters != nil && len(request.Filters.ServiceIDs) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByServiceID, request.Filters.ServiceIDs)) case request.Filters != nil && len(request.Filters.NodeIDs) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByNodeID, request.Filters.NodeIDs)) case request.Filters != nil && len(request.Filters.DesiredStates) > 0: filters := make([]store.By, 0, len(request.Filters.DesiredStates)) for _, v := range request.Filters.DesiredStates { filters = append(filters, store.ByDesiredState(v)) } tasks, err = store.FindTasks(tx, store.Or(filters...)) default: tasks, err = store.FindTasks(tx, store.All) } }) if err != nil { return nil, err } if request.Filters != nil { tasks = filterTasks(tasks, func(e *api.Task) bool { return filterContains(naming.Task(e), request.Filters.Names) }, func(e *api.Task) bool { return filterContainsPrefix(naming.Task(e), request.Filters.NamePrefixes) }, func(e *api.Task) bool { return filterContainsPrefix(e.ID, request.Filters.IDPrefixes) }, func(e *api.Task) bool { return filterMatchLabels(e.ServiceAnnotations.Labels, request.Filters.Labels) }, func(e *api.Task) bool { return filterContains(e.ServiceID, request.Filters.ServiceIDs) }, func(e *api.Task) bool { return filterContains(e.NodeID, request.Filters.NodeIDs) }, func(e *api.Task) bool { if len(request.Filters.DesiredStates) == 0 { return true } for _, c := range request.Filters.DesiredStates { if c == e.DesiredState { return true } } return false }, ) } return &api.ListTasksResponse{ Tasks: tasks, }, nil }
// ListTasks returns a list of all tasks. func (s *Server) ListTasks(ctx context.Context, request *api.ListTasksRequest) (*api.ListTasksResponse, error) { var ( tasks []*api.Task err error ) s.store.View(func(tx store.ReadTx) { switch { case request.Filters != nil && len(request.Filters.Names) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByName, request.Filters.Names)) case request.Filters != nil && len(request.Filters.NamePrefixes) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByNamePrefix, request.Filters.NamePrefixes)) case request.Filters != nil && len(request.Filters.IDPrefixes) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByIDPrefix, request.Filters.IDPrefixes)) case request.Filters != nil && len(request.Filters.ServiceIDs) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByServiceID, request.Filters.ServiceIDs)) case request.Filters != nil && len(request.Filters.NodeIDs) > 0: tasks, err = store.FindTasks(tx, buildFilters(store.ByNodeID, request.Filters.NodeIDs)) case request.Filters != nil && len(request.Filters.DesiredStates) > 0: filters := make([]store.By, 0, len(request.Filters.DesiredStates)) for _, v := range request.Filters.DesiredStates { filters = append(filters, store.ByDesiredState(v)) } tasks, err = store.FindTasks(tx, store.Or(filters...)) default: tasks, err = store.FindTasks(tx, store.All) } }) if err != nil { return nil, err } if request.Filters != nil { tasks = filterTasks(tasks, func(e *api.Task) bool { name := e.Annotations.Name if name == "" { // If Task name is not assigned then calculated name is used like before. // This might be removed in the future. name = fmt.Sprintf("%v.%v.%v", e.ServiceAnnotations.Name, e.Slot, e.ID) } return filterContains(name, request.Filters.Names) }, func(e *api.Task) bool { name := e.Annotations.Name if name == "" { // If Task name is not assigned then calculated name is used like before // This might be removed in the future. name = fmt.Sprintf("%v.%v.%v", e.ServiceAnnotations.Name, e.Slot, e.ID) } return filterContainsPrefix(name, request.Filters.NamePrefixes) }, func(e *api.Task) bool { return filterContainsPrefix(e.ID, request.Filters.IDPrefixes) }, func(e *api.Task) bool { return filterMatchLabels(e.ServiceAnnotations.Labels, request.Filters.Labels) }, func(e *api.Task) bool { return filterContains(e.ServiceID, request.Filters.ServiceIDs) }, func(e *api.Task) bool { return filterContains(e.NodeID, request.Filters.NodeIDs) }, func(e *api.Task) bool { if len(request.Filters.DesiredStates) == 0 { return true } for _, c := range request.Filters.DesiredStates { if c == e.DesiredState { return true } } return false }, ) } return &api.ListTasksResponse{ Tasks: tasks, }, nil }