return newETCD3ProberMonitor(c)
	default:
		return nil, fmt.Errorf("unknown storage type: %s", c.Type)
	}
}

// Prober is an interface that defines the Probe function for doing etcd readiness/liveness checks.
type Prober interface {
	Probe(ctx context.Context) error
	Close() error

	"k8s.io/klog/v2"
	"k8s.io/kubernetes/pkg/probe"
)

// Prober is an interface that defines the Probe function for doing GRPC readiness/liveness/startup checks.
type Prober interface {
	Probe(host, service string, port int, timeout time.Duration) (probe.Result, string, error)
}

type grpcProber struct {
}

// New Prober for execute grpc probe
func New() Prober {
	return grpcProber{}
}

)

var _ ready.Prober = &probe{}

type probe struct {
	sync.RWMutex
	bootstrapPath string
	bootstrap     *grpcxds.Bootstrap
}

// NewProbe returns a probe that checks if a valid bootstrap file can be loaded once.
// If that bootstrap file has a file_watcher cert provider, we also ensure those certs exist.
func NewProbe(bootstrapPath string) ready.Prober {
	return &probe{bootstrapPath: bootstrapPath}
}

	).(*manager)
	// Don't actually execute probes.
	m.prober.exec = fakeExecProber{probe.Success, nil}
	return m
}

func newTestWorker(m *manager, probeType probeType, probeSpec v1.Probe) *worker {
	pod := getTestPod()
	setTestProbe(pod, probeType, probeSpec)
	return newWorker(m, probeType, pod, pod.Spec.Containers[0])
}

type fakeExecProber struct {
	result probe.Result
	err    error
}

	Check() error
}

var _ Prober = &Probe{}

// Check executes the probe and returns an error if the probe fails.
func (p *Probe) Check() error {
	// First, check that Envoy has received a configuration update from Pilot.
	if err := p.checkConfigStatus(); err != nil {
		return err
	}
	return p.isEnvoyReady()
}

// checkConfigStatus checks to make sure initial configs have been received from Pilot.

		host string
		port int

		expectedStatus probe.Result
		expectedError  error
	}{
		// A connection is made and probing would succeed
		{tHost, tPort, probe.Success, nil},
		// No connection can be made and probing would fail
		{tHost, -1, probe.Failure, nil},
	}

	prober := New()
	for i, tt := range tests {
		status, _, err := prober.Probe(tt.host, tt.port, 1*time.Second)
		if status != tt.expectedStatus {

	if err != nil {
		t.Fatalf("error creating temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	plugMgr := volume.VolumePluginMgr{}
	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost(t, tmpDir, nil, nil))
	plug, err := plugMgr.FindPluginByName("kubernetes.io/nfs")
	if err != nil {
		t.Fatal("Can't find the plugin by name")
	}

	"k8s.io/apimachinery/pkg/util/sets"
)

// FakeManager simulates a prober.Manager for testing.
type FakeManager struct{}

// Unused methods below.

// AddPod simulates adding a Pod.
func (FakeManager) AddPod(_ *v1.Pod) {}

// RemovePod simulates removing a Pod.
func (FakeManager) RemovePod(_ *v1.Pod) {}

// Simulated stopping liveness and startup probes.
func (FakeManager) StopLivenessAndStartup(_ *v1.Pod) {}

		err              error
	}{
		// Ok
		{probe.Success, false, true, "OK", "OK", nil},
		// Ok
		{probe.Success, false, true, "OK", "OK", &fakeExitError{true, 0}},
		// Ok - truncated output
		{probe.Success, false, true, elevenKilobyte, tenKilobyte, nil},
		// Run returns error
		{probe.Unknown, true, true, "", "", fmt.Errorf("test error")},
		// Unhealthy
		{probe.Failure, false, true, "Fail", "", &fakeExitError{true, 1}},

	api "k8s.io/kubernetes/pkg/apis/core"
	"k8s.io/kubernetes/pkg/probe"
)

type fakeHttpProber struct {
	result probe.Result
	body   string
	err    error
}

func (f *fakeHttpProber) Probe(*http.Request, time.Duration) (probe.Result, string, error) {
	return f.result, f.body, f.err
}

type testResponse struct {
	result probe.Result
	data   string
	err    error
}