From 6784b79e337fbe172eb09659088bbba0db03bd8d Mon Sep 17 00:00:00 2001 From: Luiz Aoqui Date: Mon, 7 Mar 2022 18:19:39 -0500 Subject: [PATCH] use named value to indicate reverse sorting --- helper/raftutil/fsm.go | 38 +++++------ nomad/acl_endpoint.go | 3 +- nomad/alloc_endpoint.go | 5 +- nomad/core_sched.go | 2 +- nomad/deployment_endpoint.go | 5 +- .../deploymentwatcher/deployments_watcher.go | 6 +- nomad/drainer_int_test.go | 14 ++-- nomad/eval_endpoint.go | 5 +- nomad/fsm.go | 16 ++--- nomad/search_endpoint.go | 22 +++---- nomad/state/state_store.go | 64 ++++++++++++------- nomad/state/state_store_test.go | 12 ++-- 12 files changed, 108 insertions(+), 84 deletions(-) diff --git a/helper/raftutil/fsm.go b/helper/raftutil/fsm.go index 7217481350a3..cad222f2e182 100644 --- a/helper/raftutil/fsm.go +++ b/helper/raftutil/fsm.go @@ -185,28 +185,28 @@ func (f *FSMHelper) StateAsMap() map[string][]interface{} { } // StateAsMap returns a json-able representation of the state -func StateAsMap(state *state.StateStore) map[string][]interface{} { +func StateAsMap(store *state.StateStore) map[string][]interface{} { result := map[string][]interface{}{ - "ACLPolicies": toArray(state.ACLPolicies(nil)), - "ACLTokens": toArray(state.ACLTokens(nil, false)), - "Allocs": toArray(state.Allocs(nil, false)), - "CSIPlugins": toArray(state.CSIPlugins(nil)), - "CSIVolumes": toArray(state.CSIVolumes(nil)), - "Deployments": toArray(state.Deployments(nil, false)), - "Evals": toArray(state.Evals(nil, false)), - "Indexes": toArray(state.Indexes()), - "JobSummaries": toArray(state.JobSummaries(nil)), - "JobVersions": toArray(state.JobVersions(nil)), - "Jobs": toArray(state.Jobs(nil)), - "Nodes": toArray(state.Nodes(nil)), - "PeriodicLaunches": toArray(state.PeriodicLaunches(nil)), - "SITokenAccessors": toArray(state.SITokenAccessors(nil)), - "ScalingEvents": toArray(state.ScalingEvents(nil)), - "ScalingPolicies": toArray(state.ScalingPolicies(nil)), - "VaultAccessors": toArray(state.VaultAccessors(nil)), + "ACLPolicies": toArray(store.ACLPolicies(nil)), + "ACLTokens": toArray(store.ACLTokens(nil, state.SortDefault)), + "Allocs": toArray(store.Allocs(nil, state.SortDefault)), + "CSIPlugins": toArray(store.CSIPlugins(nil)), + "CSIVolumes": toArray(store.CSIVolumes(nil)), + "Deployments": toArray(store.Deployments(nil, state.SortDefault)), + "Evals": toArray(store.Evals(nil, state.SortDefault)), + "Indexes": toArray(store.Indexes()), + "JobSummaries": toArray(store.JobSummaries(nil)), + "JobVersions": toArray(store.JobVersions(nil)), + "Jobs": toArray(store.Jobs(nil)), + "Nodes": toArray(store.Nodes(nil)), + "PeriodicLaunches": toArray(store.PeriodicLaunches(nil)), + "SITokenAccessors": toArray(store.SITokenAccessors(nil)), + "ScalingEvents": toArray(store.ScalingEvents(nil)), + "ScalingPolicies": toArray(store.ScalingPolicies(nil)), + "VaultAccessors": toArray(store.VaultAccessors(nil)), } - insertEnterpriseState(result, state) + insertEnterpriseState(result, store) return result diff --git a/nomad/acl_endpoint.go b/nomad/acl_endpoint.go index 243c44f0ddce..8f303195270f 100644 --- a/nomad/acl_endpoint.go +++ b/nomad/acl_endpoint.go @@ -654,6 +654,7 @@ func (a *ACL) ListTokens(args *structs.ACLTokenListRequest, reply *structs.ACLTo } // Setup the blocking query + sort := state.SortOption(args.Reverse) opts := blockingOptions{ queryOpts: &args.QueryOptions, queryMeta: &reply.QueryMeta, @@ -674,7 +675,7 @@ func (a *ACL) ListTokens(args *structs.ACLTokenListRequest, reply *structs.ACLTo WithID: true, } } else { - iter, err = state.ACLTokens(ws, args.Reverse) + iter, err = state.ACLTokens(ws, sort) opts = paginator.StructsTokenizerOptions{ WithCreateIndex: true, WithID: true, diff --git a/nomad/alloc_endpoint.go b/nomad/alloc_endpoint.go index babec0508d81..65b0ea4b7211 100644 --- a/nomad/alloc_endpoint.go +++ b/nomad/alloc_endpoint.go @@ -60,6 +60,7 @@ func (a *Alloc) List(args *structs.AllocListRequest, reply *structs.AllocListRes } // Setup the blocking query + sort := state.SortOption(args.Reverse) opts := blockingOptions{ queryOpts: &args.QueryOptions, queryMeta: &reply.QueryMeta, @@ -84,13 +85,13 @@ func (a *Alloc) List(args *structs.AllocListRequest, reply *structs.AllocListRes WithID: true, } } else if namespace != structs.AllNamespacesSentinel { - iter, err = state.AllocsByNamespaceOrdered(ws, namespace, args.Reverse) + iter, err = state.AllocsByNamespaceOrdered(ws, namespace, sort) opts = paginator.StructsTokenizerOptions{ WithCreateIndex: true, WithID: true, } } else { - iter, err = state.Allocs(ws, args.Reverse) + iter, err = state.Allocs(ws, sort) opts = paginator.StructsTokenizerOptions{ WithCreateIndex: true, WithID: true, diff --git a/nomad/core_sched.go b/nomad/core_sched.go index e4dbaf82ab69..1819847c7d40 100644 --- a/nomad/core_sched.go +++ b/nomad/core_sched.go @@ -545,7 +545,7 @@ func (c *CoreScheduler) nodeReap(eval *structs.Evaluation, nodeIDs []string) err func (c *CoreScheduler) deploymentGC(eval *structs.Evaluation) error { // Iterate over the deployments ws := memdb.NewWatchSet() - iter, err := c.snap.Deployments(ws, false) + iter, err := c.snap.Deployments(ws, state.SortDefault) if err != nil { return err } diff --git a/nomad/deployment_endpoint.go b/nomad/deployment_endpoint.go index 06ae0e03464f..d0217f424efb 100644 --- a/nomad/deployment_endpoint.go +++ b/nomad/deployment_endpoint.go @@ -403,6 +403,7 @@ func (d *Deployment) List(args *structs.DeploymentListRequest, reply *structs.De } // Setup the blocking query + sort := state.SortOption(args.Reverse) opts := blockingOptions{ queryOpts: &args.QueryOptions, queryMeta: &reply.QueryMeta, @@ -418,13 +419,13 @@ func (d *Deployment) List(args *structs.DeploymentListRequest, reply *structs.De WithID: true, } } else if namespace != structs.AllNamespacesSentinel { - iter, err = store.DeploymentsByNamespaceOrdered(ws, namespace, args.Reverse) + iter, err = store.DeploymentsByNamespaceOrdered(ws, namespace, sort) opts = paginator.StructsTokenizerOptions{ WithCreateIndex: true, WithID: true, } } else { - iter, err = store.Deployments(ws, args.Reverse) + iter, err = store.Deployments(ws, sort) opts = paginator.StructsTokenizerOptions{ WithCreateIndex: true, WithID: true, diff --git a/nomad/deploymentwatcher/deployments_watcher.go b/nomad/deploymentwatcher/deployments_watcher.go index 8743f2b1274a..56617430fde2 100644 --- a/nomad/deploymentwatcher/deployments_watcher.go +++ b/nomad/deploymentwatcher/deployments_watcher.go @@ -202,9 +202,9 @@ func (w *Watcher) getDeploys(ctx context.Context, minIndex uint64) ([]*structs.D } // getDeploysImpl retrieves all deployments from the passed state store. -func (w *Watcher) getDeploysImpl(ws memdb.WatchSet, state *state.StateStore) (interface{}, uint64, error) { +func (w *Watcher) getDeploysImpl(ws memdb.WatchSet, store *state.StateStore) (interface{}, uint64, error) { - iter, err := state.Deployments(ws, false) + iter, err := store.Deployments(ws, state.SortDefault) if err != nil { return nil, 0, err } @@ -220,7 +220,7 @@ func (w *Watcher) getDeploysImpl(ws memdb.WatchSet, state *state.StateStore) (in } // Use the last index that affected the deployment table - index, err := state.Index("deployment") + index, err := store.Index("deployment") if err != nil { return nil, 0, err } diff --git a/nomad/drainer_int_test.go b/nomad/drainer_int_test.go index 8ee7a980b019..cb8aca2ea9be 100644 --- a/nomad/drainer_int_test.go +++ b/nomad/drainer_int_test.go @@ -931,9 +931,9 @@ func TestDrainer_MultipleNSes_ServiceOnly(t *testing.T) { } // Wait for the two allocations to be placed - state := s1.State() + store := s1.State() testutil.WaitForResult(func() (bool, error) { - iter, err := state.Allocs(nil, false) + iter, err := store.Allocs(nil, state.SortDefault) if err != nil { return false, err } @@ -974,11 +974,11 @@ func TestDrainer_MultipleNSes_ServiceOnly(t *testing.T) { errCh := make(chan error, 2) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - go allocPromoter(errCh, ctx, state, codec, n1.ID, s1.logger) - go allocPromoter(errCh, ctx, state, codec, n2.ID, s1.logger) + go allocPromoter(errCh, ctx, store, codec, n1.ID, s1.logger) + go allocPromoter(errCh, ctx, store, codec, n2.ID, s1.logger) testutil.WaitForResult(func() (bool, error) { - allocs, err := state.AllocsByNode(nil, n2.ID) + allocs, err := store.AllocsByNode(nil, n2.ID) if err != nil { return false, err } @@ -992,7 +992,7 @@ func TestDrainer_MultipleNSes_ServiceOnly(t *testing.T) { if err := checkAllocPromoter(errCh); err != nil { return false, err } - node, err := state.NodeByID(nil, n1.ID) + node, err := store.NodeByID(nil, n1.ID) if err != nil { return false, err } @@ -1002,7 +1002,7 @@ func TestDrainer_MultipleNSes_ServiceOnly(t *testing.T) { }) // Check we got the right events - node, err := state.NodeByID(nil, n1.ID) + node, err := store.NodeByID(nil, n1.ID) require.NoError(err) // sometimes test gets a duplicate node drain complete event require.GreaterOrEqualf(len(node.Events), 3, "unexpected number of events: %v", node.Events) diff --git a/nomad/eval_endpoint.go b/nomad/eval_endpoint.go index 88b024122940..daec216d282f 100644 --- a/nomad/eval_endpoint.go +++ b/nomad/eval_endpoint.go @@ -408,6 +408,7 @@ func (e *Eval) List(args *structs.EvalListRequest, reply *structs.EvalListRespon } // Setup the blocking query + sort := state.SortOption(args.Reverse) opts := blockingOptions{ queryOpts: &args.QueryOptions, queryMeta: &reply.QueryMeta, @@ -423,13 +424,13 @@ func (e *Eval) List(args *structs.EvalListRequest, reply *structs.EvalListRespon WithID: true, } } else if namespace != structs.AllNamespacesSentinel { - iter, err = store.EvalsByNamespaceOrdered(ws, namespace, args.Reverse) + iter, err = store.EvalsByNamespaceOrdered(ws, namespace, sort) opts = paginator.StructsTokenizerOptions{ WithCreateIndex: true, WithID: true, } } else { - iter, err = store.Evals(ws, args.Reverse) + iter, err = store.Evals(ws, sort) opts = paginator.StructsTokenizerOptions{ WithCreateIndex: true, WithID: true, diff --git a/nomad/fsm.go b/nomad/fsm.go index 18569f006653..70f1b0f0e66d 100644 --- a/nomad/fsm.go +++ b/nomad/fsm.go @@ -1704,16 +1704,16 @@ func (n *nomadFSM) Restore(old io.ReadCloser) error { // failLeakedDeployments is used to fail deployments that do not have a job. // This state is a broken invariant that should not occur since 0.8.X. -func (n *nomadFSM) failLeakedDeployments(state *state.StateStore) error { +func (n *nomadFSM) failLeakedDeployments(store *state.StateStore) error { // Scan for deployments that are referencing a job that no longer exists. // This could happen if multiple deployments were created for a given job // and thus the older deployment leaks and then the job is removed. - iter, err := state.Deployments(nil, false) + iter, err := store.Deployments(nil, state.SortDefault) if err != nil { return fmt.Errorf("failed to query deployments: %v", err) } - dindex, err := state.Index("deployment") + dindex, err := store.Index("deployment") if err != nil { return fmt.Errorf("couldn't fetch index of deployments table: %v", err) } @@ -1733,7 +1733,7 @@ func (n *nomadFSM) failLeakedDeployments(state *state.StateStore) error { } // Find the job - job, err := state.JobByID(nil, d.Namespace, d.JobID) + job, err := store.JobByID(nil, d.Namespace, d.JobID) if err != nil { return fmt.Errorf("failed to lookup job %s from deployment %q: %v", d.JobID, d.ID, err) } @@ -1747,7 +1747,7 @@ func (n *nomadFSM) failLeakedDeployments(state *state.StateStore) error { failed := d.Copy() failed.Status = structs.DeploymentStatusCancelled failed.StatusDescription = structs.DeploymentStatusDescriptionStoppedJob - if err := state.UpsertDeployment(dindex, failed); err != nil { + if err := store.UpsertDeployment(dindex, failed); err != nil { return fmt.Errorf("failed to mark leaked deployment %q as failed: %v", failed.ID, err) } } @@ -2099,7 +2099,7 @@ func (s *nomadSnapshot) persistAllocs(sink raft.SnapshotSink, encoder *codec.Encoder) error { // Get all the allocations ws := memdb.NewWatchSet() - allocs, err := s.snap.Allocs(ws, false) + allocs, err := s.snap.Allocs(ws, state.SortDefault) if err != nil { return err } @@ -2250,7 +2250,7 @@ func (s *nomadSnapshot) persistDeployments(sink raft.SnapshotSink, encoder *codec.Encoder) error { // Get all the jobs ws := memdb.NewWatchSet() - deployments, err := s.snap.Deployments(ws, false) + deployments, err := s.snap.Deployments(ws, state.SortDefault) if err != nil { return err } @@ -2306,7 +2306,7 @@ func (s *nomadSnapshot) persistACLTokens(sink raft.SnapshotSink, encoder *codec.Encoder) error { // Get all the policies ws := memdb.NewWatchSet() - tokens, err := s.snap.ACLTokens(ws, false) + tokens, err := s.snap.ACLTokens(ws, state.SortDefault) if err != nil { return err } diff --git a/nomad/search_endpoint.go b/nomad/search_endpoint.go index 4e8313f8b2e4..73cfb47e2edb 100644 --- a/nomad/search_endpoint.go +++ b/nomad/search_endpoint.go @@ -394,42 +394,42 @@ func wildcard(namespace string) bool { return namespace == structs.AllNamespacesSentinel } -func getFuzzyResourceIterator(context structs.Context, aclObj *acl.ACL, namespace string, ws memdb.WatchSet, state *state.StateStore) (memdb.ResultIterator, error) { +func getFuzzyResourceIterator(context structs.Context, aclObj *acl.ACL, namespace string, ws memdb.WatchSet, store *state.StateStore) (memdb.ResultIterator, error) { switch context { case structs.Jobs: if wildcard(namespace) { - iter, err := state.Jobs(ws) + iter, err := store.Jobs(ws) return nsCapIterFilter(iter, err, aclObj) } - return state.JobsByNamespace(ws, namespace) + return store.JobsByNamespace(ws, namespace) case structs.Allocs: if wildcard(namespace) { - iter, err := state.Allocs(ws, false) + iter, err := store.Allocs(ws, state.SortDefault) return nsCapIterFilter(iter, err, aclObj) } - return state.AllocsByNamespace(ws, namespace) + return store.AllocsByNamespace(ws, namespace) case structs.Nodes: if wildcard(namespace) { - iter, err := state.Nodes(ws) + iter, err := store.Nodes(ws) return nsCapIterFilter(iter, err, aclObj) } - return state.Nodes(ws) + return store.Nodes(ws) case structs.Plugins: if wildcard(namespace) { - iter, err := state.CSIPlugins(ws) + iter, err := store.CSIPlugins(ws) return nsCapIterFilter(iter, err, aclObj) } - return state.CSIPlugins(ws) + return store.CSIPlugins(ws) case structs.Namespaces: - iter, err := state.Namespaces(ws) + iter, err := store.Namespaces(ws) return nsCapIterFilter(iter, err, aclObj) default: - return getEnterpriseFuzzyResourceIter(context, aclObj, namespace, ws, state) + return getEnterpriseFuzzyResourceIter(context, aclObj, namespace, ws, store) } } diff --git a/nomad/state/state_store.go b/nomad/state/state_store.go index 0111f87ce9f9..af1b37ed3eef 100644 --- a/nomad/state/state_store.go +++ b/nomad/state/state_store.go @@ -22,6 +22,19 @@ import ( // This can be a read or write transaction. type Txn = *txn +// SortOption represents how results can be sorted. +type SortOption bool + +const ( + // SortDefault indicates that the result should be returned using the + // default go-memdb ResultIterator order. + SortDefault SortOption = true + + // SortReverse indicates that the result should be returned using the + // reversed go-memdb ResultIterator order. + SortReverse SortOption = false +) + const ( // NodeRegisterEventReregistered is the message used when the node becomes // reregistered. @@ -544,15 +557,16 @@ func (s *StateStore) upsertDeploymentImpl(index uint64, deployment *structs.Depl return nil } -func (s *StateStore) Deployments(ws memdb.WatchSet, reverse bool) (memdb.ResultIterator, error) { +func (s *StateStore) Deployments(ws memdb.WatchSet, sort SortOption) (memdb.ResultIterator, error) { txn := s.db.ReadTxn() var it memdb.ResultIterator var err error - if reverse { + switch sort { + case SortReverse: it, err = txn.GetReverse("deployment", "create") - } else { + default: it, err = txn.Get("deployment", "create") } @@ -578,7 +592,7 @@ func (s *StateStore) DeploymentsByNamespace(ws memdb.WatchSet, namespace string) return iter, nil } -func (s *StateStore) DeploymentsByNamespaceOrdered(ws memdb.WatchSet, namespace string, reverse bool) (memdb.ResultIterator, error) { +func (s *StateStore) DeploymentsByNamespaceOrdered(ws memdb.WatchSet, namespace string, sort SortOption) (memdb.ResultIterator, error) { txn := s.db.ReadTxn() var ( @@ -587,9 +601,10 @@ func (s *StateStore) DeploymentsByNamespaceOrdered(ws memdb.WatchSet, namespace exact = terminate(namespace) ) - if reverse { + switch sort { + case SortReverse: it, err = txn.GetReverse("deployment", "namespace_create_prefix", exact) - } else { + default: it, err = txn.Get("deployment", "namespace_create_prefix", exact) } @@ -3215,16 +3230,17 @@ func (s *StateStore) EvalsByJob(ws memdb.WatchSet, namespace, jobID string) ([]* } // Evals returns an iterator over all the evaluations in ascending or descending -// order of CreationIndex as determined by the ascending parameter. -func (s *StateStore) Evals(ws memdb.WatchSet, reverse bool) (memdb.ResultIterator, error) { +// order of CreationIndex as determined by the reverse parameter. +func (s *StateStore) Evals(ws memdb.WatchSet, sort SortOption) (memdb.ResultIterator, error) { txn := s.db.ReadTxn() var it memdb.ResultIterator var err error - if reverse { + switch sort { + case SortReverse: it, err = txn.GetReverse("evals", "create") - } else { + default: it, err = txn.Get("evals", "create") } @@ -3254,7 +3270,7 @@ func (s *StateStore) EvalsByNamespace(ws memdb.WatchSet, namespace string) (memd return it, nil } -func (s *StateStore) EvalsByNamespaceOrdered(ws memdb.WatchSet, namespace string, reverse bool) (memdb.ResultIterator, error) { +func (s *StateStore) EvalsByNamespaceOrdered(ws memdb.WatchSet, namespace string, sort SortOption) (memdb.ResultIterator, error) { txn := s.db.ReadTxn() var ( @@ -3263,9 +3279,10 @@ func (s *StateStore) EvalsByNamespaceOrdered(ws memdb.WatchSet, namespace string exact = terminate(namespace) ) - if reverse { + switch sort { + case SortReverse: it, err = txn.GetReverse("evals", "namespace_create_prefix", exact) - } else { + default: it, err = txn.Get("evals", "namespace_create_prefix", exact) } @@ -3798,15 +3815,16 @@ func (s *StateStore) AllocsByDeployment(ws memdb.WatchSet, deploymentID string) } // Allocs returns an iterator over all the evaluations. -func (s *StateStore) Allocs(ws memdb.WatchSet, reverse bool) (memdb.ResultIterator, error) { +func (s *StateStore) Allocs(ws memdb.WatchSet, sort SortOption) (memdb.ResultIterator, error) { txn := s.db.ReadTxn() var it memdb.ResultIterator var err error - if reverse { + switch sort { + case SortReverse: it, err = txn.GetReverse("allocs", "create") - } else { + default: it, err = txn.Get("allocs", "create") } @@ -3819,7 +3837,7 @@ func (s *StateStore) Allocs(ws memdb.WatchSet, reverse bool) (memdb.ResultIterat return it, nil } -func (s *StateStore) AllocsByNamespaceOrdered(ws memdb.WatchSet, namespace string, reverse bool) (memdb.ResultIterator, error) { +func (s *StateStore) AllocsByNamespaceOrdered(ws memdb.WatchSet, namespace string, sort SortOption) (memdb.ResultIterator, error) { txn := s.db.ReadTxn() var ( @@ -3828,9 +3846,10 @@ func (s *StateStore) AllocsByNamespaceOrdered(ws memdb.WatchSet, namespace strin exact = terminate(namespace) ) - if reverse { + switch sort { + case SortReverse: it, err = txn.GetReverse("allocs", "namespace_create_prefix", exact) - } else { + default: it, err = txn.Get("allocs", "namespace_create_prefix", exact) } @@ -5526,15 +5545,16 @@ func (s *StateStore) ACLTokenByAccessorIDPrefix(ws memdb.WatchSet, prefix string } // ACLTokens returns an iterator over all the tokens -func (s *StateStore) ACLTokens(ws memdb.WatchSet, reverse bool) (memdb.ResultIterator, error) { +func (s *StateStore) ACLTokens(ws memdb.WatchSet, sort SortOption) (memdb.ResultIterator, error) { txn := s.db.ReadTxn() var iter memdb.ResultIterator var err error - if reverse { + switch sort { + case SortReverse: iter, err = txn.GetReverse("acl_token", "create") - } else { + default: iter, err = txn.Get("acl_token", "create") } if err != nil { diff --git a/nomad/state/state_store_test.go b/nomad/state/state_store_test.go index f76046e14939..b2a73acbb4f7 100644 --- a/nomad/state/state_store_test.go +++ b/nomad/state/state_store_test.go @@ -670,7 +670,7 @@ func TestStateStore_Deployments(t *testing.T) { } ws := memdb.NewWatchSet() - it, err := state.Deployments(ws, false) + it, err := state.Deployments(ws, SortDefault) require.NoError(t, err) var out []*structs.Deployment @@ -5424,7 +5424,7 @@ func TestStateStore_Allocs(t *testing.T) { } ws := memdb.NewWatchSet() - iter, err := state.Allocs(ws, false) + iter, err := state.Allocs(ws, SortDefault) if err != nil { t.Fatalf("err: %v", err) } @@ -5472,7 +5472,7 @@ func TestStateStore_Allocs_PrevAlloc(t *testing.T) { require.Nil(err) ws := memdb.NewWatchSet() - iter, err := state.Allocs(ws, false) + iter, err := state.Allocs(ws, SortDefault) require.Nil(err) var out []*structs.Allocation @@ -7500,7 +7500,7 @@ func TestStateStore_BootstrapACLTokens(t *testing.T) { t.Fatalf("expected error") } - iter, err := state.ACLTokens(nil, false) + iter, err := state.ACLTokens(nil, SortDefault) if err != nil { t.Fatalf("err: %v", err) } @@ -7594,7 +7594,7 @@ func TestStateStore_UpsertACLTokens(t *testing.T) { assert.Equal(t, nil, err) assert.Equal(t, tk2, out) - iter, err := state.ACLTokens(ws, false) + iter, err := state.ACLTokens(ws, SortDefault) if err != nil { t.Fatalf("err: %v", err) } @@ -7661,7 +7661,7 @@ func TestStateStore_DeleteACLTokens(t *testing.T) { t.Fatalf("bad: %#v", out) } - iter, err := state.ACLTokens(ws, false) + iter, err := state.ACLTokens(ws, SortDefault) if err != nil { t.Fatalf("err: %v", err) }