NodeName:   "node-a",
					DriverName: "driver",
					ResourceModel: resourceapi.ResourceModel{
						NamedResources: &resourceapi.NamedResourcesResources{
							Instances: []resourceapi.NamedResourcesInstance{{Name: "one"}, {Name: "two"}},
						},
					},
				},
				&resourceapi.ResourceSlice{
					NodeName:   "node-b",
					DriverName: "driver",
					ResourceModel: resourceapi.ResourceModel{

			`{"version":"v1","entries":[{"DriverName":"meta-test-driver.cdi.k8s.io","ClassName":"class-name","ClaimUID":"067798be-454e-4be4-9047-1aa06aea63f7","ClaimName":"example","Namespace":"default","PodUIDs":{"139cdb46-f989-4f17-9561-ca10cfb509a6":{}},"ResourceHandles":[{"driverName":"test-driver-1.cdi.k8s.io","data":"{\"a\": \"b\"}"},{"driverName":"test-driver-2.cdi.k8s.io","data":"{\"c\": \"d\"}"}],"CDIDevices":{"test-driver-1.cdi.k8s.io...

		}
		if c.classParameters != nil {
			for _, p := range c.classParameters.VendorParameters {
				if p.DriverName == driverName {
					handle.StructuredData.VendorClassParameters = p.Parameters
					break
				}
			}
		}
		for _, request := range c.claimParameters.DriverRequests {
			if request.DriverName == driverName {
				handle.StructuredData.VendorClaimParameters = request.VendorParameters
				break
			}
		}

					DriverName: driverName,
					Allocation: &resourcev1alpha2.AllocationResult{
						ResourceHandles: []resourcev1alpha2.ResourceHandle{
							{Data: "test-data", DriverName: driverName},
						},
					},
				},
			},
			wantErr: true,
		},
		{
			description: "no container actually uses the claim",
			driverName:  driverName,
			pod: &v1.Pod{

func NewMetricsCsi(volumeID string, targetPath string, driverName csiDriverName) volume.MetricsProvider {
	mc := &metricsCsi{volumeID: volumeID, targetPath: targetPath}
	mc.csiClientGetter.driverName = driverName
	return mc
}

func (mc *metricsCsi) GetMetrics() (*volume.Metrics, error) {
	startTime := time.Now()
	defer servermetrics.CollectVolumeStatCalDuration(string(mc.csiClientGetter.driverName), startTime)
	currentTime := metav1.Now()

	c.mutex.Lock()
	defer c.mutex.Unlock()
	if active, ok := c.activePlugins[driverName]; ok {
		active.cancel(errors.New("plugin has unregistered"))
		delete(c.activePlugins, driverName)
		c.queue.Add(driverName)
	}
}

// monitorPlugin calls the plugin to retrieve resource information and caches
// all responses that it gets for processing in the sync method. It keeps

	"k8s.io/kubernetes/pkg/apis/resource"
	"k8s.io/utils/ptr"
)

func testResourceSlice(name, nodeName, driverName string) *resource.ResourceSlice {
	return &resource.ResourceSlice{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},
		NodeName:   nodeName,
		DriverName: driverName,
		ResourceModel: resource.ResourceModel{
			NamedResources: &resource.NamedResourcesResources{},
		},
	}
}

				t.Error("unexpected volumeHandle constructed:", volHandle)
			}
			driverName := rec.Spec.PersistentVolume.Spec.CSI.Driver
			if driverName != tc.originSpec.PersistentVolume.Spec.CSI.Driver {
				t.Error("unexpected driverName constructed:", driverName)
			}

			if rec.Spec.PersistentVolume.Spec.VolumeMode == nil {
				t.Fatalf("Volume mode has not been set.")
			}

		metricsProvider = volume.NewMetricsStatFS(plugin.host.GetPodVolumeDir(
			podUID, utilstrings.EscapeQualifiedName(plugin.driverName), volName))
	} else {
		metricsProvider = &volume.MetricsNil{}
	}

	return &flexVolumeUnmounter{
		flexVolume: &flexVolume{
			driverName:      plugin.driverName,
			execPath:        plugin.getExecutable(),
			mounter:         mounter,
			plugin:          plugin,

// This method is protected by a mutex.
func (s *DriversStore) Get(driverName string) (Driver, bool) {
	s.RLock()
	defer s.RUnlock()

	driver, ok := s.store[driverName]
	return driver, ok
}

// Set lets you save a CSI Driver to the list and give it a specific name.
// This method is protected by a mutex.
func (s *DriversStore) Set(driverName string, driver Driver) {
	s.Lock()
	defer s.Unlock()

	if s.store == nil {