}

type Prober interface {
	// Check executes the probe and returns an error if the probe fails.
	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()
}

		return err
	}
	if err := prober.initWatcher(); err != nil {
		return err
	}

	return nil
}

// If probeAllNeeded is true, probe all pluginDir
// else probe events in eventsMap
func (prober *flexVolumeProber) Probe() (events []volume.ProbeEvent, err error) {
	if prober.probeAllNeeded {
		prober.testAndSetProbeAllNeeded(false)
		return prober.probeAll()
	}

	return prober.probeMap()
}

			t.Errorf("Failed to find -j MASQUERADE in %s chain", kubePostroutingChain)
		}
		if hasMasqRandomFully != testcase {
			probs := map[bool]string{false: "found", true: "did not find"}
			t.Errorf("%s --random-fully in -j MASQUERADE rule in %s chain for HasRandomFully()=%v", probs[testcase], kubePostroutingChain, testcase)
		}
	}
}

func TestExternalIPsNoEndpoint(t *testing.T) {

	URISchemeHTTP URIScheme = "HTTP"
	// URISchemeHTTPS means that the scheme used will be https://
	URISchemeHTTPS URIScheme = "HTTPS"
)

// HTTPHeader describes a custom header to be used in HTTP probes
type HTTPHeader struct {
	// The header field name
	Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
	// The header field value
	Value string `json:"value" protobuf:"bytes,2,opt,name=value"`
}

      Startup probes run only at the start of the pod. Once the startup probe completes, readiness probes will continue.
      
      By using a startup probe, we can poll for the sidecar to start more aggressively, without polling as aggressively throughout
      the entire pod's lifecycle.
      On average, this improves pod startup time by roughly 1s.
      

  - image: registry.k8s.io/nginx:1.7.9
    name: target
    readinessProbe:
      exec:
        command: ["/bin/sh", "-c", "cat probe"]
    livenessProbe:
      exec:
        command: ["/bin/sh", "-c", "cat probe"]
    startupProbe:
      exec:
        command: ["/bin/sh", "-c", "cat probe"]
  initContainers:
  - image: busybox

apiVersion: release-notes/v2
kind: feature
area: traffic-management
releaseNotes:
  - |

			upstreamLocalAddress = UpstreamLocalAddressIPv6
		}
	}
	probes := make([]ready.Prober, 0)
	if !config.NoEnvoy {
		probes = append(probes, &ready.Probe{
			LocalHostAddr: localhost,
			AdminPort:     config.AdminPort,
			Context:       config.Context,
			NoEnvoy:       config.NoEnvoy,
		})
	}

	if config.GRPCBootstrap != "" {
		probes = append(probes, grpcready.NewProbe(config.GRPCBootstrap))
	}

		// and we don't need to probe the capability.
		probes = probes[:1]
	}
	for i := range probes {
		s, err := sysSocket(syscall.AF_INET6, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
		if err != nil {
			continue
		}
		defer poll.CloseFunc(s)
		syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, probes[i].value)
		sa, err := probes[i].laddr.sockaddr(syscall.AF_INET6)
		if err != nil {

/**
 * A registry of watch probes. A probe serves as a way to prove that a hierarchy Gradle is interested in
 * indeed receives file system events from the operating system.
 * This is to avoid trusting locations where OSs silently not send any events, despite watchers being registered.
 *
 * When the hierarchy is first registered via {@link #registerProbe(File)}, we don't yet create the probe.