"github.com/minio/minio/internal/grid"
	xhttp "github.com/minio/minio/internal/http"
	"github.com/minio/minio/internal/rest"
)

// globalGrid is the global grid manager.
var globalGrid atomic.Pointer[grid.Manager]

// globalLockGrid is the global lock grid manager.
var globalLockGrid atomic.Pointer[grid.Manager]

// globalGridStart is a channel that will block startup of grid connections until closed.

    <glob pattern="*.kmz"/>
  </mime-type>
  <mime-type type="application/vnd.grafeq">
    <glob pattern="*.gqf"/>
    <glob pattern="*.gqs"/>
  </mime-type>
  <mime-type type="application/vnd.gridmp"/>
  <mime-type type="application/vnd.groove-account">
    <glob pattern="*.gac"/>
  </mime-type>
  <mime-type type="application/vnd.groove-help">
    <glob pattern="*.ghf"/>
  </mime-type>

	reloadPoolMetaRPC              = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerReloadPoolMeta, grid.NewMSS, grid.NewNoPayload)
	reloadSiteReplicationConfigRPC = grid.NewSingleHandler[*grid.MSS, grid.NoPayload](grid.HandlerReloadSiteReplicationConfig, grid.NewMSS, grid.NewNoPayload)

	storageReadVersionRPC      = grid.NewSingleHandler[*grid.MSS, *FileInfo](grid.HandlerReadVersion, grid.NewMSS, func() *FileInfo { return &FileInfo{} })

	var opts WalkDirOptions
	_, err := opts.UnmarshalMsg(payload)
	if err != nil {
		return grid.NewRemoteErr(err)
	}

	if !s.checkID(opts.DiskID) {
		return grid.NewRemoteErr(errDiskNotFound)
	}

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()
	return grid.NewRemoteErr(s.getStorage().WalkDir(ctx, opts, grid.WriterToChannel(ctx, out)))

	lockRPCUnlock      = newLockHandler(grid.HandlerLockUnlock)
	lockRPCRLock       = newLockHandler(grid.HandlerLockRLock)
	lockRPCRUnlock     = newLockHandler(grid.HandlerLockRUnlock)
)

func newLockHandler(h grid.HandlerID) *grid.SingleHandler[*dsync.LockArgs, *dsync.LockResp] {
	return grid.NewSingleHandler[*dsync.LockArgs, *dsync.LockResp](h, func() *dsync.LockArgs {
		return &dsync.LockArgs{}
	}, func() *dsync.LockResp {

	r = &http.Request{
		Proto:  "HTTP/1.1",
		Method: http.MethodGet,
		URL:    &url.URL{Path: grid.RoutePath},
	}
	if !guessIsRPCReq(r) {
		t.Fatal("Grid RPC path not detected")
	}
	r = &http.Request{
		Proto:  "HTTP/1.1",
		Method: http.MethodGet,
		URL:    &url.URL{Path: grid.RouteLockPath},
	}
	if !guessIsRPCReq(r) {
		t.Fatal("Grid RPC path not detected")
	}
}

var isHTTPHeaderSizeTooLargeTests = []struct {

					bugLogIf(ctx, err, "event: Encode failed")
					continue
				}
				mergeCh <- append(grid.GetByteBuffer()[:0], buf.Bytes()...)
			case <-ctx.Done():
				grid.PutByteBuffer(buf.Bytes())
				return
			}
		}
	}()
	peers, _ := newPeerRestClients(globalEndpoints)
	err := globalHTTPListen.Subscribe(mask, localCh, ctx.Done(), func(ev event.Event) bool {

}

// Returns a peer S3 client.
func newPeerS3Client(node Node) peerS3Client {
	var gridConn atomic.Pointer[grid.Connection]

	return &remotePeerS3Client{
		node: node,
		gridConn: func() *grid.Connection {
			// Lazy initialization of grid connection.
			// When we create this peer client, the grid connection is likely not yet initialized.
			if node.GridHost == "" {

	logger.LogIf(ctx, "authZ", err, errKind...)
}

func peersLogIf(ctx context.Context, err error, errKind ...any) {
	if !errors.Is(err, grid.ErrDisconnected) {
		logger.LogIf(ctx, "peers", err, errKind...)
	}
}

func peersLogAlwaysIf(ctx context.Context, err error, errKind ...any) {
	if !errors.Is(err, grid.ErrDisconnected) {
		logger.LogAlwaysIf(ctx, "peers", err, errKind...)
	}
}