Regenerate files according to 1.19.2 formatter

acl/errors.go

@@ -63,7 +63,6 @@ func IsErrPermissionDenied(err error) bool {
 
 // Arguably this should be some sort of union type.
 // The usage of Cause and the rest of the fields is entirely disjoint.
-//
 type PermissionDeniedError struct {
 	Cause string
 

agent/auto-config/auto_config.go

@@ -225,7 +225,7 @@ func (ac *AutoConfig) introToken() (string, error) {
 
 // recordInitialConfiguration is responsible for recording the AutoConfigResponse from
 // the AutoConfig.InitialConfiguration RPC. It is an all-in-one function to do the following
-//   * update the Agent token in the token store
+//   - update the Agent token in the token store
 func (ac *AutoConfig) recordInitialConfiguration(resp *pbautoconf.AutoConfigResponse) error {
 	ac.autoConfigResponse = resp
 

agent/cache-types/connect_ca_leaf.go

@@ -262,10 +262,10 @@ func (c *ConnectCALeaf) rootWatcher(ctx context.Context) {
 //
 // Somewhat arbitrarily the current strategy looks like this:
 //
-//          0                              60%             90%
-//   Issued [------------------------------|===============|!!!!!] Expires
-// 72h TTL: 0                             ~43h            ~65h
-//  1h TTL: 0                              36m             54m
+//	         0                              60%             90%
+//	  Issued [------------------------------|===============|!!!!!] Expires
+//	72h TTL: 0                             ~43h            ~65h
+//	 1h TTL: 0                              36m             54m
 //
 // Where |===| is the soft renewal period where we jitter for the first attempt
 // and |!!!| is the danger zone where we just try immediately.

agent/cache-types/rpc.go

@@ -3,6 +3,7 @@ package cachetype
 // RPC is an interface that an RPC client must implement. This is a helper
 // interface that is implemented by the agent delegate so that Type
 // implementations can request RPC access.
+//
 //go:generate mockery --name RPC --inpackage
 type RPC interface {
 	RPC(method string, args interface{}, reply interface{}) error

agent/cache/request.go

@@ -8,6 +8,7 @@ import (
 //
 // This interface is typically implemented by request structures in
 // the agent/structs package.
+//
 //go:generate mockery --name Request --inpackage
 type Request interface {
 	// CacheInfo returns information used for caching this request.

agent/cache/type.go

@@ -5,6 +5,7 @@ import (
 )
 
 // Type implements the logic to fetch certain types of data.
+//
 //go:generate mockery --name Type --inpackage
 type Type interface {
 	// Fetch fetches a single unique item.

agent/config/file_watcher.go

@@ -47,7 +47,7 @@ type FileWatcherEvent struct {
 	Filenames []string
 }
 
-//NewFileWatcher create a file watcher that will watch all the files/folders from configFiles
+// NewFileWatcher create a file watcher that will watch all the files/folders from configFiles
 // if success a fileWatcher will be returned and a nil error
 // otherwise an error and a nil fileWatcher are returned
 func NewFileWatcher(configFiles []string, logger hclog.Logger) (Watcher, error) {

agent/configentry/config_entry.go

@@ -6,9 +6,12 @@ import (
 )
 
 // KindName is a value type useful for maps. You can use:
-//     map[KindName]Payload
+//
+//	map[KindName]Payload
+//
 // instead of:
-//     map[string]map[string]Payload
+//
+//	map[string]map[string]Payload
 type KindName struct {
 	Kind string
 	Name string

agent/connect/common_names.go

@@ -45,9 +45,10 @@ func CompactUID() (string, error) {
 // specific purpose.
 //
 // Format is:
-//   {provider}-{uniqueID_first8}.{pri|sec}.ca.<trust_domain_first_8>.consul
 //
-//   trust domain is truncated to keep the whole name short
+//	{provider}-{uniqueID_first8}.{pri|sec}.ca.<trust_domain_first_8>.consul
+//
+// trust domain is truncated to keep the whole name short
 func CACN(provider, uniqueID, trustDomain string, primaryDC bool) string {
 	providerSan := invalidDNSNameChars.ReplaceAllString(strings.ToLower(provider), "")
 	typ := "pri"

agent/consul/acl.go

@@ -225,19 +225,19 @@ type ACLResolverSettings struct {
 //   - Resolving roles remotely via an ACL.RoleResolve RPC
 //
 // Remote Resolution:
-//   Remote resolution can be done synchronously or asynchronously depending
-//   on the ACLDownPolicy in the Config passed to the resolver.
 //
-//   When the down policy is set to async-cache and we have already cached values
-//   then go routines will be spawned to perform the RPCs in the background
-//   and then will update the cache with either the positive or negative result.
+//	Remote resolution can be done synchronously or asynchronously depending
+//	on the ACLDownPolicy in the Config passed to the resolver.
 //
-//   When the down policy is set to extend-cache or the token/policy/role is not already
-//   cached then the same go routines are spawned to do the RPCs in the background.
-//   However in this mode channels are created to receive the results of the RPC
-//   and are registered with the resolver. Those channels are immediately read/blocked
-//   upon.
+//	When the down policy is set to async-cache and we have already cached values
+//	then go routines will be spawned to perform the RPCs in the background
+//	and then will update the cache with either the positive or negative result.
 //
+//	When the down policy is set to extend-cache or the token/policy/role is not already
+//	cached then the same go routines are spawned to do the RPCs in the background.
+//	However in this mode channels are created to receive the results of the RPC
+//	and are registered with the resolver. Those channels are immediately read/blocked
+//	upon.
 type ACLResolver struct {
 	config ACLResolverSettings
 	logger hclog.Logger

agent/consul/acl_endpoint.go

@@ -13,8 +13,8 @@ import (
 	"github.com/armon/go-metrics/prometheus"
 	"github.com/hashicorp/go-bexpr"
 	"github.com/hashicorp/go-hclog"
-	memdb "github.com/hashicorp/go-memdb"
-	uuid "github.com/hashicorp/go-uuid"
+	"github.com/hashicorp/go-memdb"
+	"github.com/hashicorp/go-uuid"
 
 	"github.com/hashicorp/consul/acl"
 	"github.com/hashicorp/consul/acl/resolver"
@@ -108,19 +108,18 @@ type ACL struct {
 // fileBootstrapResetIndex retrieves the reset index specified by the administrator from
 // the file on disk.
 //
-// Q: What is the bootstrap reset index?
-// A: If you happen to lose acess to all tokens capable of ACL management you need a way
-//    to get back into your system. This allows an admin to write the current
-//    bootstrap "index" into a special file on disk to override the mechanism preventing
-//    a second token bootstrap. The index will be retrieved by a API call to /v1/acl/bootstrap
-//    When already bootstrapped this API will return the reset index necessary within
-//    the error response. Once set in the file, the bootstrap API can be used again to
-//    get a new token.
-//
-// Q: Why is the reset index not in the config?
-// A: We want to be able to remove the reset index once we have used it. This prevents
-//    accidentally allowing bootstrapping yet again after a snapshot restore.
+//	 Q: What is the bootstrap reset index?
+//	 A: If you happen to lose acess to all tokens capable of ACL management you need a way
+//				   to get back into your system. This allows an admin to write the current
+//				   bootstrap "index" into a special file on disk to override the mechanism preventing
+//				   a second token bootstrap. The index will be retrieved by a API call to /v1/acl/bootstrap
+//				   When already bootstrapped this API will return the reset index necessary within
+//				   the error response. Once set in the file, the bootstrap API can be used again to
+//				   get a new token.
 //
+//	 Q: Why is the reset index not in the config?
+//	 A: We want to be able to remove the reset index once we have used it. This prevents
+//				   accidentally allowing bootstrapping yet again after a snapshot restore.
 func (a *ACL) fileBootstrapResetIndex() uint64 {
 	// Determine the file path to check
 	path := filepath.Join(a.srv.config.DataDir, aclBootstrapReset)

agent/consul/authmethod/kubeauth/testing.go

@@ -27,7 +27,6 @@ import (
 //
 //   - POST /apis/authentication.k8s.io/v1/tokenreviews
 //   - GET  /api/v1/namespaces/<NAMESPACE>/serviceaccounts/<NAME>
-//
 type TestAPIServer struct {
 	srv    *httptest.Server
 	caCert string

agent/consul/helper_test.go

@@ -127,7 +127,7 @@ type clientOrServer interface {
 
 // joinLAN is a convenience function for
 //
-//   member.JoinLAN("127.0.0.1:"+leader.config.SerfLANConfig.MemberlistConfig.BindPort)
+//	member.JoinLAN("127.0.0.1:"+leader.config.SerfLANConfig.MemberlistConfig.BindPort)
 func joinLAN(t *testing.T, member clientOrServer, leader *Server) {
 	t.Helper()
 	joinLANWithOptions(t, member, leader, true)
@@ -184,7 +184,7 @@ func joinLANWithOptions(t *testing.T, member clientOrServer, leader *Server, doM
 
 // joinWAN is a convenience function for
 //
-//   member.JoinWAN("127.0.0.1:"+leader.config.SerfWANConfig.MemberlistConfig.BindPort)
+//	member.JoinWAN("127.0.0.1:"+leader.config.SerfWANConfig.MemberlistConfig.BindPort)
 func joinWAN(t *testing.T, member, leader *Server) {
 	t.Helper()
 	joinWANWithOptions(t, member, leader, true)

agent/consul/rpc.go

@@ -14,9 +14,9 @@ import (
 
 	"github.com/armon/go-metrics"
 	"github.com/armon/go-metrics/prometheus"
-	connlimit "github.com/hashicorp/go-connlimit"
+	"github.com/hashicorp/go-connlimit"
 	"github.com/hashicorp/go-hclog"
-	memdb "github.com/hashicorp/go-memdb"
+	"github.com/hashicorp/go-memdb"
 	"github.com/hashicorp/go-raftchunking"
 	"github.com/hashicorp/memberlist"
 	"github.com/hashicorp/raft"
@@ -992,19 +992,19 @@ type blockingQueryResponseMeta interface {
 //
 // The query function must follow these rules:
 //
-//   1. to access data it must use the passed in state.Store.
-//   2. it must set the responseMeta.Index to an index greater than
-//      opts.GetMinQueryIndex if the results return by the query have changed.
-//   3. any channels added to the memdb.WatchSet must unblock when the results
-//      returned by the query have changed.
+//  1. to access data it must use the passed in state.Store.
+//  2. it must set the responseMeta.Index to an index greater than
+//     opts.GetMinQueryIndex if the results return by the query have changed.
+//  3. any channels added to the memdb.WatchSet must unblock when the results
+//     returned by the query have changed.
 //
 // To ensure optimal performance of the query, the query function should make a
 // best-effort attempt to follow these guidelines:
 //
-//   1. only set responseMeta.Index to an index greater than
-//      opts.GetMinQueryIndex when the results returned by the query have changed.
-//   2. any channels added to the memdb.WatchSet should only unblock when the
-//      results returned by the query have changed.
+//  1. only set responseMeta.Index to an index greater than
+//     opts.GetMinQueryIndex when the results returned by the query have changed.
+//  2. any channels added to the memdb.WatchSet should only unblock when the
+//     results returned by the query have changed.
 func (s *Server) blockingQuery(
 	opts blockingQueryOptions,
 	responseMeta blockingQueryResponseMeta,
@@ -1142,7 +1142,7 @@ func (s *Server) consistentRead() error {
 	defer metrics.MeasureSince([]string{"rpc", "consistentRead"}, time.Now())
 	future := s.raft.VerifyLeader()
 	if err := future.Error(); err != nil {
-		return err //fail fast if leader verification fails
+		return err // fail fast if leader verification fails
 	}
 	// poll consistent read readiness, wait for up to RPCHoldTimeout milliseconds
 	if s.isReadyForConsistentReads() {
@@ -1197,16 +1197,16 @@ func (s *Server) rpcQueryTimeout(queryTimeout time.Duration) time.Duration {
 //
 // Notes:
 //
-//	* The definition of "unauthenticated" here is incomplete, as it doesn't
-//	  account for the fact that operators can modify the anonymous token with
-//	  custom policies, or set namespace default policies. As these scenarios
-//	  are less common and this flag is a best-effort UX improvement, we think
-//	  the trade-off for reduced complexity is acceptable.
+//   - The definition of "unauthenticated" here is incomplete, as it doesn't
+//     account for the fact that operators can modify the anonymous token with
+//     custom policies, or set namespace default policies. As these scenarios
+//     are less common and this flag is a best-effort UX improvement, we think
+//     the trade-off for reduced complexity is acceptable.
 //
-//	* This method assumes that the given token has already been validated (and
-//	  will only check whether it is blank or not). It's a safe assumption because
-//	  ResultsFilteredByACLs is only set to try when applying the already-resolved
-//	  token's policies.
+//   - This method assumes that the given token has already been validated (and
+//     will only check whether it is blank or not). It's a safe assumption because
+//     ResultsFilteredByACLs is only set to try when applying the already-resolved
+//     token's policies.
 func maskResultsFilteredByACLs(token string, meta blockingQueryResponseMeta) {
 	if token == "" {
 		meta.SetResultsFilteredByACLs(false)

agent/consul/rtt_test.go

@@ -73,10 +73,9 @@ func verifyCheckServiceNodeSort(t *testing.T, nodes structs.CheckServiceNodes, e
 //
 // Here's the layout of the nodes:
 //
-//       node3 node2 node5                         node4       node1
-//   |     |     |     |     |     |     |     |     |     |     |
-//   0     1     2     3     4     5     6     7     8     9     10  (ms)
-//
+//	    node3 node2 node5                         node4       node1
+//	|     |     |     |     |     |     |     |     |     |     |
+//	0     1     2     3     4     5     6     7     8     9     10  (ms)
 func seedCoordinates(t *testing.T, codec rpc.ClientCodec, server *Server) {
 	// Register some nodes.
 	for i := 0; i < 5; i++ {

agent/consul/state/catalog.go

@@ -1267,8 +1267,8 @@ func (s *Store) ServicesByNodeMeta(ws memdb.WatchSet, filters map[string]string,
 // The service_last_extinction is set to the last raft index when a service
 // was unregistered (or 0 if no services were ever unregistered). This
 // allows blocking queries to
-//   * return when the last instance of a service is removed
-//   * block until an instance for this service is available, or another
+//   - return when the last instance of a service is removed
+//   - block until an instance for this service is available, or another
 //     service is unregistered.
 func maxIndexForService(tx ReadTxn, serviceName string, serviceExists, checks bool, entMeta *acl.EnterpriseMeta, peerName string) uint64 {
 	idx, _ := maxIndexAndWatchChForService(tx, serviceName, serviceExists, checks, entMeta, peerName)
@@ -1280,8 +1280,8 @@ func maxIndexForService(tx ReadTxn, serviceName string, serviceExists, checks bo
 // index. The service_last_extinction is set to the last raft index when a
 // service was unregistered (or 0 if no services were ever unregistered). This
 // allows blocking queries to
-//   * return when the last instance of a service is removed
-//   * block until an instance for this service is available, or another
+//   - return when the last instance of a service is removed
+//   - block until an instance for this service is available, or another
 //     service is unregistered.
 //
 // It also _may_ return a watch chan to add to a WatchSet. It will only return

agent/consul/state/catalog_oss.go

@@ -54,8 +54,8 @@ func catalogUpdateNodeIndexes(tx WriteTxn, idx uint64, nodeName string, _ *acl.E
 
 // catalogUpdateServicesIndexes upserts the max index for the entire services table with varying levels
 // of granularity (no-op if `idx` is lower than what exists for that index key):
-// 	- all services
-// 	- all services in a specified peer (including internal)
+//   - all services
+//   - all services in a specified peer (including internal)
 func catalogUpdateServicesIndexes(tx WriteTxn, idx uint64, _ *acl.EnterpriseMeta, peerName string) error {
 	// overall services index for snapshot
 	if err := indexUpdateMaxTxn(tx, idx, tableServices); err != nil {
@@ -72,8 +72,8 @@ func catalogUpdateServicesIndexes(tx WriteTxn, idx uint64, _ *acl.EnterpriseMeta
 
 // catalogUpdateServiceKindIndexes upserts the max index for the ServiceKind with varying levels
 // of granularity (no-op if `idx` is lower than what exists for that index key):
-// 	- all services of ServiceKind
-// 	- all services of ServiceKind in a specified peer (including internal)
+//   - all services of ServiceKind
+//   - all services of ServiceKind in a specified peer (including internal)
 func catalogUpdateServiceKindIndexes(tx WriteTxn, idx uint64, kind structs.ServiceKind, _ *acl.EnterpriseMeta, peerName string) error {
 	base := "service_kind." + kind.Normalized()
 	// service-kind index

agent/consul/state/catalog_schema.go

@@ -418,7 +418,7 @@ func indexServiceNameFromHealthCheck(hc *structs.HealthCheck) ([]byte, error) {
 	return b.Bytes(), nil
 }
 
-//  gatewayServicesTableSchema returns a new table schema used to store information
+// gatewayServicesTableSchema returns a new table schema used to store information
 // about services associated with terminating gateways.
 func gatewayServicesTableSchema() *memdb.TableSchema {
 	return &memdb.TableSchema{

agent/consul/state/config_entry_oss.go

@@ -7,7 +7,7 @@ import (
 	"fmt"
 	"strings"
 
-	memdb "github.com/hashicorp/go-memdb"
+	"github.com/hashicorp/go-memdb"
 
 	"github.com/hashicorp/consul/acl"
 	"github.com/hashicorp/consul/agent/configentry"
@@ -65,6 +65,7 @@ func configIntentionsConvertToList(iter memdb.ResultIterator, _ *acl.EnterpriseM
 // found in a list of exported-services config entries. For OSS, namespace is not considered, so a match is one of:
 //   - the service name matches
 //   - the service name is a wildcard
+//
 // This value can be used to filter exported-services config entries for a given service name.
 func getExportedServicesMatchServiceNames(serviceName string, entMeta *acl.EnterpriseMeta) []structs.ServiceName {
 	return []structs.ServiceName{

agent/consul/state/tombstone_gc.go

@@ -16,7 +16,6 @@ import (
 // data is deleted from the KV store, the "latest" row can go backwards if the
 // newest row is removed. The tombstones provide a way to ensure time doesn't
 // move backwards within some interval.
-//
 type TombstoneGC struct {
 	// ttl sets the TTL for tombstones.
 	ttl time.Duration