lastDriveStatsRefresh time.Time
)

// PeerResourceMetrics represents the resource metrics
// retrieved from a peer, along with errors if any
type PeerResourceMetrics struct {
	Metrics map[MetricSubsystem]ResourceMetrics
	Errors  []string
}

// ResourceMetrics is a map of unique key identifying
// a resource metric (e.g. reads_per_sec_{node}_{drive})
// to its data
type ResourceMetrics map[string]ResourceMetric

    }

    /**
     * Create a managed resource wrapper
     *
     * @param <T> resource type
     * @param resource the resource to wrap
     * @return managed resource
     */
    public <T extends AutoCloseable> ManagedResource<T> manage(T resource) {
        String resourceId = registerResource(resource);
        return new ManagedResource<>(resource, resourceId, this);
    }

    /**

        // Then
        assertNotNull(resource1, "First resource should be created");
        assertNotNull(resource2, "Second resource should be created");
        assertNotNull(pipe1, "First pipe should be created");
        assertNotNull(pipe2, "Second pipe should be created");

        assertNotSame(resource1, resource2, "Different resources should be different instances");

	}

	// No locks held on the all resources, so claim write
	// lock on all resources at once.
	now := UTCNow()
	for i, resource := range args.Resources {
		l.lockMap[resource] = []lockRequesterInfo{
			{
				Name:            resource,
				Writer:          true,
				Source:          args.Source,
				Owner:           args.Owner,
				UID:             args.UID,
				Timestamp:       now.UnixNano(),

        assertTrue(iterator.hasNext());
        assertSame(resource, iterator.next());

        assertTrue(iterator.hasNext());
        assertSame(resource, iterator.next());

        assertTrue(iterator.hasNext());
        assertSame(resource, iterator.next());

        assertFalse(iterator.hasNext());
        assertNull(iterator.next());

        verify(resource, never()).close();
    }

    @Test

            assertTrue(resource.exists(), "Resource should exist");
            assertTrue(resource.isFile(), "Should be a file");
            assertTrue(resource.canWrite(), "Should be writable");

            // Should be able to perform file operations
            assertDoesNotThrow(() -> {
                resource.setReadOnly();
                resource.setReadWrite();
                resource.setAttributes(0x20);

		locksHeld[resource] = []lockRequesterInfo{lri}
	}

	// Add a few concurrent read locks to the mix
	for i := range 50 {
		resource := fmt.Sprintf("bucket/get-object-%d", i)
		lri := lockRequesterInfo{
			Name:   resource,
			UID:    mustGetUUID(),
			Owner:  owners[i%len(owners)],
			Quorum: 2,
		}
		lris = append(lris, lri)
		locksHeld[resource] = append(locksHeld[resource], lri)

     */
    boolean exists() throws CIFSException;

    /**
     * Fetch a child resource
     *
     * @param name the name of the child resource to resolve
     * @return the child resource
     * @throws CIFSException if an error occurs accessing the resource
     */
    SmbResource resolve(String name) throws CIFSException;

    /**
     * Get the file index
     *

		},
		{
			name:   "create key as user set policy to non matching resource want success",
			method: http.MethodPost,
			path:   kmsAdminKeyCreate,
			query:  map[string]string{"key-id": "third-new-test-key"},
			asRoot: false,

			// Admin actions ignore Resources
			policy: `{"Effect": "Allow",
				"Action": ["admin:KMSCreateKey"],
				"Resource": ["arn:minio:kms:::this-is-disregarded"] }`,

			t.Fatalf("Test %d: %s: Unable to marshal response body %s", i+1, instanceType, rec.Body.String())
		}
		if errorResponse.Resource != testCase.errorResponse.Resource {
			t.Errorf("Test %d: %s: Expected the error resource to be `%s`, but instead found `%s`", i+1, instanceType, testCase.errorResponse.Resource, errorResponse.Resource)
		}
		if errorResponse.Message != testCase.errorResponse.Message {