in dp_check/dp_check.go [1159:1684]
func main() {
flag.Parse()
infoLog.Printf("Running dp_check: service=%s, ipv4_only=%v, ipv6_only=%v, ipv4_and_v6=%v, check_grpclb=%v, check_xds=%v, td_endpoint=%s, xds_expect_fallback_configured=%v\n", *service, *ipv4Only, *ipv6Only, *ipv4AndV6, *checkGrpclb, *checkXds, *trafficDirectorHostname, *xdsExpectFallbackConfigured)
maybeOverrideFlags()
if len(*service) == 0 {
panic("--service not set")
}
var skipIPv6Err error
var skipIPv4Err error
explicitChecks := 0
if *ipv4Only {
skipIPv6Err = fmt.Errorf("skip IPv6 checks because of flag: --ipv4_only")
explicitChecks++
}
if *ipv6Only {
skipIPv4Err = fmt.Errorf("skip IPv4 checks because of flag: --ipv6_only")
explicitChecks++
}
if *ipv4AndV6 {
explicitChecks++
}
if explicitChecks > 1 {
infoLog.Printf("At most one of --ipv4_only, --ipv6_only, or --ipv4_and_v6 can be set. Have --ipv4_only=%v --ipv6_only=%v --ipv4_and_v6=%v.", *ipv4Only, *ipv6Only, *ipv4AndV6)
os.Exit(1)
}
var skipGrpclbErr error
if !*checkGrpclb {
skipGrpclbErr = fmt.Errorf("skip grpclb related checks because --check_grpclb is false")
}
var skipXdsErr error
if !*checkXds {
skipXdsErr = fmt.Errorf("skip xds related checks because --check_xds is false")
}
var balancerHostname string
var balancerPort string
if len(*balancerTargetOverride) > 0 {
infoLog.Printf("--balancer_target_override is non-empty. Will override load balancer target used in load balancer connectivity checks and queries to: %v", *balancerTargetOverride)
var err error
if balancerHostname, balancerPort, err = net.SplitHostPort(*balancerTargetOverride); err != nil {
infoLog.Printf("ERROR: --balancer_target_override was set to %v, but failed to split into host and port: %v", *balancerTargetOverride, err)
os.Exit(1)
}
if net.ParseIP(balancerHostname) != nil {
infoLog.Printf("ERROR: --balancer_target_override was set to %v, but this flag does not support IP literal based addresses, the host must be a DNS hostname", *balancerTargetOverride)
os.Exit(1)
}
}
if *backendAddressOverride != "" {
infoLog.Printf("Flag --backend_address_override is non-empty. Will use it as a backend address, skipping XDS load balancer interactions")
ip, err := parseAddress(*backendAddressOverride)
if err != nil {
infoLog.Printf("ERROR: problem with --backend_address_override=%v - %v", *backendAddressOverride, err)
os.Exit(1)
}
if ip.To4() != nil {
// Override uses IPv4, skip IPv6
if *ipv6Only {
infoLog.Printf("ERROR: --backend_address_override=%v is IPv4, but --ipv6_only is set", *backendAddressOverride)
os.Exit(1)
}
infoLog.Printf("--backend_address_override=%v is IPv4, skipping IPv6 checks", *backendAddressOverride)
skipIPv6Err = fmt.Errorf("skip IPv6 checks because --backend_address_override=%v is IPv4", *backendAddressOverride)
} else {
// Override uses IPv6, skip IPv4
if *ipv4Only {
infoLog.Printf("ERROR: --backend_address_override=%v is IPv6, but --ipv4_only is set", *backendAddressOverride)
os.Exit(1)
}
infoLog.Printf("--backend_address_override=%v is IPv6, skipping IPv4 checks", *backendAddressOverride)
skipIPv4Err = fmt.Errorf("skip IPv4 checks because --backend_address_override=%v is IPv6", *backendAddressOverride)
}
}
if syscall.Getuid() != 0 {
infoLog.Println("Not running as root, some checks may fail.")
}
// Check if dp_check is running on GCP
runCheck("Running on GCP", func() error {
ret, err := isRunningOnGCP()
if err != nil {
return err
}
if !ret {
return fmt.Errorf("dp_check is not running on GCP, this tool will not work as intended")
}
return nil
})
var ipv6FromMetadataServer *net.IP
runCheck("IPv6 address allocated to VM's primary NIC (i.e. DirectPath IPv6 enablement)", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
var err error
ipv6FromMetadataServer, err = fetchIPFromMetadataServer("IPv6")
return err
})
var ipv4FromMetadataServer *net.IP
runCheck("IPv4 address allocated to VM's primary NIC", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
var err error
ipv4FromMetadataServer, err = fetchIPFromMetadataServer("IPv4")
return err
})
// Check if xds bootstrap environment variable is set
runCheck("Xds bootstrap environment variable", func() error {
if skipXdsErr != nil {
return &skipCheckError{err: skipXdsErr}
}
const xdsBootStrapEnvVar = "GRPC_XDS_BOOTSTRAP"
const xdsBootStrapConfigEnvVar = "GRPC_XDS_BOOTSTRAP_CONFIG"
if os.Getenv(xdsBootStrapEnvVar) != "" || os.Getenv(xdsBootStrapConfigEnvVar) != "" {
return fmt.Errorf("DirectPath can not be used with environment variables |%v| or |%v|", xdsBootStrapEnvVar, xdsBootStrapConfigEnvVar)
}
return nil
})
// Check DNS
srvQueriesSucceeded := false
runCheck("Service SRV DNS queries", func() error {
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
infoLog.Printf("Lookup service SRV records with:|net.DefaultResolver.LoookupSRV(context.Background(), \"grpclb\", \"tcp\", \"%v\")|...", *service)
_, srvs, err := net.DefaultResolver.LookupSRV(context.Background(), "grpclb", "tcp", *service)
if err != nil || len(srvs) == 0 {
if ipv6FromMetadataServer == nil {
return fmt.Errorf(`SRV record resolution for _grpclb._tcp.%s failed with error:|%v|.
This is expected (even if %s is a DirectPath-enabled service) because this VM is not DirectPath-enabled`, *service, err, *service)
}
return fmt.Errorf(`SRV record resolution for _grpclb._tcp.%s failed with error:|%v|.
Because this VM is known to be DirectPath-enabled, there are three possible causes:
a) %s is not a DirectPath-enabled service
b) The query was rejected because some attribute(s) of this specific VM (for example the VPC network project number of this VM's primary network interface, the VM project number, or the current region or zone we're running in), are causing this VM to be prevented DirectPath access to %s.
c) Something is broken i.e. there is a serious bug somewhere.
See results of LB query below which may give help in diagnosing which case we fall into.`, *service, err, *service)
}
if len(srvs) != 1 {
return fmt.Errorf("Got %d SRV records:|%v|. This is not necessarily an error but is unexpected", len(srvs), srvs)
}
if strings.Compare(srvs[0].Target, loadBalancerIPv6OnlyDNS) != 0 && strings.Compare(srvs[0].Target, loadBalancerDualstackDNS) != 0 {
return fmt.Errorf("Got SRV record target:|%v|; expected:|%v| or |%v|", srvs[0].Target, loadBalancerIPv6OnlyDNS, loadBalancerDualstackDNS)
}
if len(*balancerTargetOverride) == 0 {
balancerHostname = srvs[0].Target
if balancerHostname == loadBalancerIPv6OnlyDNS && explicitChecks == 0 && !*checkXds {
skipIPv4Err = fmt.Errorf("%v was detected to be an IPv6-only service because it's DirectPath SRV record pointed to: %v, so DirectPath/IPv4 does not need to work from this VM. Set the flag --ipv4_and_v6 if you want to run this check anyways", *service, loadBalancerIPv6OnlyDNS)
}
balancerPort = strconv.Itoa(int(srvs[0].Port))
infoLog.Println("--balancer_target_override is empty. Will use results from SRV record for the load balancer target used in load balancer connectivity checks and queries")
}
infoLog.Printf("Determined load balancer hostname:|%v| and port:|%v|", balancerHostname, balancerPort)
srvQueriesSucceeded = true
return nil
})
if len(balancerHostname) == 0 {
balancerHostname = loadBalancerDualstackDNS
infoLog.Printf("SRV query for _grpclb._tcp.%s failed and --balancer_target_override is unset. Assuming (possible incorrectly) that the load balancer's hostname is %s", *service, balancerHostname)
}
if len(balancerPort) == 0 {
balancerPort = strconv.Itoa(defaultLoadBalancerPort)
infoLog.Printf("SRV query for _grpclb._tcp.%s failed and --balancer_target_override is unset. Assuming (possible incorrectly) that the load balancer's port is %s", *service, balancerPort)
}
var ipv6BalancerIPs []net.IP
runCheck("Load balancer IPv6 DNS queries", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
var err error
infoLog.Printf("Resolve LB IPv6 addrs with:|new(net.Resolver).LookupIP(context.Background(), \"ip6\", \"%v\")|...", balancerHostname)
if ipv6BalancerIPs, err = new(net.Resolver).LookupIP(context.Background(), "ip6", balancerHostname); len(ipv6BalancerIPs) == 0 || err != nil {
return fmt.Errorf(`DNS resolution of load balancer IPv6 addresses failed: %v.
This is unexpected for both IPv6-only and dualstack DirectPath services. Either this VM doesn't have DirectPath access, or there is a bug that may be causing a larger outage`, err)
}
for _, addr := range ipv6BalancerIPs {
infoLog.Printf("Resolved LB IPv6 addr: %v", addr.String())
}
return nil
})
var ipv4BalancerIPs []net.IP
runCheck("Load balancer IPv4 DNS queries", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
var err error
infoLog.Printf("Resolve LB IPv6 addrs with:|new(net.Resolver).LookupIP(context.Background(), \"ip4\", \"%v\")|...", balancerHostname)
ipv4BalancerIPs, err = new(net.Resolver).LookupIP(context.Background(), "ip4", balancerHostname)
// Fail this check if either:
// a) we expect to resolve LB IPv4 endpoints but don't
// b) we don't expect to resolve LB IPv4 endpoint but do
if strings.Compare(balancerHostname, loadBalancerDualstackDNS) == 0 {
if len(ipv4BalancerIPs) == 0 || err != nil {
return fmt.Errorf(`DNS resolution of load balancer IPv4 addresses failed: %v.
This is unexpected for dualstack DirectPath services. Either this VM doesn't have DirectPath access, or there is a bug that may be causing a larger outage`, err)
}
for _, addr := range ipv4BalancerIPs {
infoLog.Printf("Resolved LB IPv4 addr: %v", addr.String())
}
} else {
if len(ipv4BalancerIPs) > 0 {
return fmt.Errorf(`the DNS resolution of load balancer IPv4 addresses succeeded, but %v is not expected
to be a dualstack service because we resolver load balancer hostname:|%v| which does not match the dualstack load balancer hostname:|%v|,
this indicates a possible bug that may be causing a larger outage`, balancerHostname, loadBalancerDualstackDNS, *service)
}
}
return nil
})
var directPathIPv6NetworkInterface *net.Interface
runCheck("Local IPv6 addresses", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
var err error
directPathIPv6NetworkInterface, err = checkLocalIPv6Addresses(ipv6FromMetadataServer)
return err
})
runCheck("Local IPv6 loopback address", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
return checkLocalIPv6LoopbackAddress(ipv6FromMetadataServer)
})
var directPathIPv4NetworkInterface *net.Interface
runCheck("Local IPv4 addresses", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
var err error
directPathIPv4NetworkInterface, err = checkLocalIPv4Addresses(ipv4FromMetadataServer)
return err
})
// Contact LBs
tcpOverIPv6ToLoadBalancersSucceeded := false
runCheck("TCP/IPv6 connectivity to load balancers", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if len(ipv6BalancerIPs) == 0 {
return fmt.Errorf("skipping \"TCP/IPv6 connectivity to load balancers\" because prior DNS resolution of LB IPv6 address failed")
}
addr := net.JoinHostPort(ipv6BalancerIPs[0].String(), balancerPort)
infoLog.Printf("Check TCP/IPv6 connectivity to LB's with:|net.DialTimeout(\"tcp\", \"%v\", time.Second*5)|...", addr)
if _, err := net.DialTimeout("tcp", addr, time.Second*5); err != nil {
return fmt.Errorf("TCP/IPv6 connectivity to the load balancer failed: %v. This may be a transient error specific to the load balancer at %v", err, addr)
}
tcpOverIPv6ToLoadBalancersSucceeded = true
return nil
})
tcpOverIPv4ToLoadBalancersSucceeded := false
runCheck("TCP/IPv4 connectivity to load balancers", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if len(ipv4BalancerIPs) == 0 {
return fmt.Errorf("skipping \"TCP/IPv4 connectivity to load balancers\" because prior DNS resolution of LB IPv4 address failed")
}
addr := net.JoinHostPort(ipv4BalancerIPs[0].String(), balancerPort)
infoLog.Printf("Check TCP/IPv4 connectivity to LB's with:|net.DialTimeout(\"tcp\", \"%v\", time.Second*5)|...", addr)
if _, err := net.DialTimeout("tcp", addr, time.Second*5); err != nil {
return fmt.Errorf("TCP/IPv4 connectivity to the load balancer failed: %v. This may be a transient error specific to the load balancer at %v", err, addr)
}
tcpOverIPv4ToLoadBalancersSucceeded = true
return nil
})
// Resolve backends
var ipv6BackendAddrs []string
runCheck("Discovery of IPv6 backends via load balancers", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if *backendAddressOverride != "" {
ipv6BackendAddrs = []string{*backendAddressOverride}
return &skipCheckError{err: errors.New("skipping discovery of backends via load balancers because --backend_address_override is set")}
}
if !tcpOverIPv6ToLoadBalancersSucceeded {
return fmt.Errorf("skipping discovery of backends via load balancers because TCP connectivity to LBs failed")
}
var err error
ipv6BackendAddrs, err = resolveBackends(net.JoinHostPort(ipv6BalancerIPs[0].String(), balancerPort), balancerHostname, srvQueriesSucceeded)
return err
})
var ipv4BackendAddrs []string
runCheck("Discovery of IPv4 backends via load balancers", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if *backendAddressOverride != "" {
ipv4BackendAddrs = []string{*backendAddressOverride}
return &skipCheckError{err: errors.New("skipping discovery of backends via load balancers because --backend_address_override is set")}
}
if !tcpOverIPv4ToLoadBalancersSucceeded {
return fmt.Errorf("skipping discovery of backends via load balancers because TCP connectivity to LBs failed")
}
var err error
ipv4BackendAddrs, err = resolveBackends(net.JoinHostPort(ipv4BalancerIPs[0].String(), balancerPort), balancerHostname, srvQueriesSucceeded)
return err
})
// Contact backends
tcpConnectivityToIpv6BackendSucceeded := false
runCheck("TCP connectivity to IPv6 backends", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if len(ipv6BackendAddrs) == 0 {
return fmt.Errorf("skipping TCP connectivity to IPv6 backends because discovery of IPv6 backends failed")
}
infoLog.Printf("Check TCP connectivity to IPv6 backends with:|net.DialTimeout(\"tcp\", \"%v\", time.Second*5)|...", ipv6BackendAddrs[0])
if _, err := net.DialTimeout("tcp", ipv6BackendAddrs[0], time.Second*5); err != nil {
return fmt.Errorf("TCP connectivity to backend addr - %v failed: %v", ipv6BackendAddrs[0], err)
}
tcpConnectivityToIpv6BackendSucceeded = true
return nil
})
tcpConnectivityToIpv4BackendSucceeded := false
runCheck("TCP connectivity to IPv4 backends", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if len(ipv4BackendAddrs) == 0 {
return fmt.Errorf("skipping TCP connectivity to IPv4 backends because discovery of IPv4 backends failed")
}
infoLog.Printf("Check TCP connectivity to IPv4 backends with:|net.DialTimeout(\"tcp\", \"%v\", time.Second*5)|...", ipv4BackendAddrs[0])
if _, err := net.DialTimeout("tcp", ipv4BackendAddrs[0], time.Second*5); err != nil {
return fmt.Errorf("TCP connectivity to backend addr - %v failed: %v", ipv4BackendAddrs[0], err)
}
tcpConnectivityToIpv4BackendSucceeded = true
return nil
})
runCheck("Secure connectivity to IPv6 backends", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if !tcpConnectivityToIpv6BackendSucceeded {
return fmt.Errorf("skipping secure connectivity to IPv6 backends because TCP connectivity to IPv6 backends did not succeed")
}
infoLog.Println("Check secure connectivity to IPv6 backends by attempting to complete all handshakes involved in the setup of a gRPC/ALTS connection to", ipv6BackendAddrs[0])
return checkSecureConnectivityToBackend(ipv6BackendAddrs[0])
})
runCheck("Secure connectivity to IPv4 backends", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if skipGrpclbErr != nil {
return &skipCheckError{err: skipGrpclbErr}
}
if !tcpConnectivityToIpv4BackendSucceeded {
return fmt.Errorf("skipping secure connectivity to IPv4 backends because TCP connectivity to IPv4 backends did not succeed")
}
infoLog.Println("Check secure connectivity to IPv4 backends by attempting to complete all handshakes involved in the setup of a gRPC/ALTS connection to", ipv4BackendAddrs[0])
return checkSecureConnectivityToBackend(ipv4BackendAddrs[0])
})
// xds
var xdsIPv6BackendAddrs []string
runCheck("Get IPv6 backend addresses from Traffic Director", func() error {
if skipXdsErr != nil {
return &skipCheckError{err: skipXdsErr}
}
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if *backendAddressOverride != "" {
xdsIPv6BackendAddrs = []string{*backendAddressOverride}
return &skipCheckError{err: errors.New("skipping xds IPv6 backend address discovery because --backend_address_override is set")}
}
var err error
xdsIPv6BackendAddrs, err = getBackendAddrsFromTrafficDirector("IPv6")
return err
})
var xdsIPv4BackendAddrs []string
runCheck("Get IPv4 backend addresses from Traffic Director", func() error {
if skipXdsErr != nil {
return &skipCheckError{err: skipXdsErr}
}
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if *backendAddressOverride != "" {
xdsIPv4BackendAddrs = []string{*backendAddressOverride}
return &skipCheckError{err: errors.New("skipping xds IPv4 backend address discovery because --backend_address_override is set")}
}
var err error
xdsIPv4BackendAddrs, err = getBackendAddrsFromTrafficDirector("IPv4")
return err
})
runCheck("Local IPv6 routes", func() error {
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if directPathIPv6NetworkInterface != nil {
if err := logLocalRoutes(*directPathIPv6NetworkInterface, net.IPv6len); err != nil {
infoLog.Printf("Error logging IPv6 routes on %v: %v", *directPathIPv6NetworkInterface, err)
}
}
var addr string
if len(xdsIPv6BackendAddrs) != 0 {
addr = xdsIPv6BackendAddrs[0]
} else if len(ipv6BackendAddrs) != 0 {
addr = ipv6BackendAddrs[0]
} else {
return fmt.Errorf("skipping local IPv6 routes check b/c we did not discover any IPv6 backends")
}
return checkLocalIPv6Routes(ipv6FromMetadataServer, addr)
})
runCheck("Local IPv4 routes", func() error {
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if directPathIPv4NetworkInterface != nil {
if err := logLocalRoutes(*directPathIPv4NetworkInterface, net.IPv4len); err != nil {
infoLog.Printf("Error logging IPv4 routes on %v: %v", *directPathIPv4NetworkInterface, err)
}
}
var addr string
if len(xdsIPv4BackendAddrs) != 0 {
addr = xdsIPv4BackendAddrs[0]
} else if len(ipv4BackendAddrs) != 0 {
addr = ipv4BackendAddrs[0]
} else {
return fmt.Errorf("skipping local IPv4 routes check b/c we did not discover any IPv4 backends")
}
return checkLocalIPv4Routes(ipv4FromMetadataServer, addr)
})
xdsTCPConnectivityToIpv6BackendSucceeded := false
runCheck("TCP connectivity to IPv6 backends from Traffic Director", func() error {
if skipXdsErr != nil {
return &skipCheckError{err: skipXdsErr}
}
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if len(xdsIPv6BackendAddrs) == 0 {
return fmt.Errorf("skipping TCP connectivity to IPv6 backends because discovery of IPv6 backends failed")
}
infoLog.Printf("Check TCP connectivity to IPv6 backends with:|net.DialTimeout(\"tcp\", \"%v\", time.Second*5)|...", xdsIPv6BackendAddrs[0])
if _, err := net.DialTimeout("tcp", xdsIPv6BackendAddrs[0], time.Second*5); err != nil {
return fmt.Errorf("TCP connectivity to backend addr - %v failed: %v", xdsIPv6BackendAddrs[0], err)
}
xdsTCPConnectivityToIpv6BackendSucceeded = true
return nil
})
xdsTCPConnectivityToIpv4BackendSucceeded := false
runCheck("TCP connectivity to IPv4 backends from Traffic Director", func() error {
if skipXdsErr != nil {
return &skipCheckError{err: skipXdsErr}
}
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if len(xdsIPv4BackendAddrs) == 0 {
return fmt.Errorf("skipping TCP connectivity to IPv4 backends because discovery of IPv4 backends failed")
}
infoLog.Printf("Check TCP connectivity to IPv4 backends with:|net.DialTimeout(\"tcp\", \"%v\", time.Second*5)|...", xdsIPv4BackendAddrs[0])
if _, err := net.DialTimeout("tcp", xdsIPv4BackendAddrs[0], time.Second*5); err != nil {
return fmt.Errorf("TCP connectivity to backend addr - %v failed: %v", xdsIPv4BackendAddrs[0], err)
}
xdsTCPConnectivityToIpv4BackendSucceeded = true
return nil
})
runCheck("Secure connectivity to IPv6 backends from Traffic Director", func() error {
if skipXdsErr != nil {
return &skipCheckError{err: skipXdsErr}
}
if skipIPv6Err != nil {
return &skipCheckError{err: skipIPv6Err}
}
if !xdsTCPConnectivityToIpv6BackendSucceeded {
return fmt.Errorf("skipping secure connectivity to IPv6 backends because TCP connectivity to IPv6 backends did not succeed")
}
infoLog.Println("Check secure connectivity to IPv6 backends by attempting to complete all handshakes involved in the setup of a gRPC/ALTS connection to", xdsIPv6BackendAddrs[0])
return checkSecureConnectivityToBackend(xdsIPv6BackendAddrs[0])
})
runCheck("Secure connectivity to IPv4 backends from Traffic Director", func() error {
if skipXdsErr != nil {
return &skipCheckError{err: skipXdsErr}
}
if skipIPv4Err != nil {
return &skipCheckError{err: skipIPv4Err}
}
if !xdsTCPConnectivityToIpv4BackendSucceeded {
return fmt.Errorf("skipping secure connectivity to IPv4 backends because TCP connectivity to IPv4 backends did not succeed")
}
infoLog.Println("Check secure connectivity to IPv4 backends by attempting to complete all handshakes involved in the setup of a gRPC/ALTS connection to", xdsIPv4BackendAddrs[0])
return checkSecureConnectivityToBackend(xdsIPv4BackendAddrs[0])
})
os.Exit(failureCount)
}