#19908

Committed 16 Jul 2025 07:54PM UTC coverage: 88.593% (+0.07%) from 88.528%

Build # #19908

Build Type

push

github

Committed by

ejona86

Commit Message

Revert "xds: Convert CdsLb to XdsDepManager"

This reverts commit 297ab05ef.

b/430347751 shows multiple concerning behaviors in the xDS stack with
the new A74 config update model. XdsDepManager and CdsLB2 still seem to
be working correctly, but the change is exacerbated issues in other
parts of the stack, like RingHashConfig not having equals fixed in
a8de9f07ab.

Revert only for the v1.74.x release, leaving it on master.

Run Details

34647 of 39108 relevant lines covered (88.59%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.59

/../core/src/main/java/io/grpc/internal/RetryingNameResolver.java

/*
 * Copyright 2023 The gRPC Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.grpc.internal;

import com.google.common.annotations.VisibleForTesting;
import io.grpc.NameResolver;
import io.grpc.Status;
import io.grpc.SynchronizationContext;

/**
 * This wrapper class can add retry capability to any polling {@link NameResolver} implementation
 * that supports calling {@link ResolutionResultListener}s with the outcome of each resolution.
 *
 * <p>The {@link NameResolver} used with this
 */
final class RetryingNameResolver extends ForwardingNameResolver {

  private final NameResolver retriedNameResolver;
  private final RetryScheduler retryScheduler;
  private final SynchronizationContext syncContext;


  /**
   * Creates a new {@link RetryingNameResolver}.
   *
   * @param retriedNameResolver A {@link NameResolver} that will have failed attempt retried.
   * @param retryScheduler Used to schedule the retry attempts.
   */
  RetryingNameResolver(NameResolver retriedNameResolver, RetryScheduler retryScheduler,
      SynchronizationContext syncContext) {
    super(retriedNameResolver);
    this.retriedNameResolver = retriedNameResolver;
    this.retryScheduler = retryScheduler;
    this.syncContext = syncContext;
  }

  @Override
  public void start(Listener2 listener) {
    super.start(new RetryingListener(listener));
  }

  @Override
  public void shutdown() {
    super.shutdown();
    retryScheduler.reset();
  }

  /**
   * Used to get the underlying {@link NameResolver} that is getting its failed attempts retried.
   */
  @VisibleForTesting
  NameResolver getRetriedNameResolver() {
    return retriedNameResolver;
  }

  @VisibleForTesting
  class DelayedNameResolverRefresh implements Runnable {
    @Override
    public void run() {
      refresh();
    }
  }

  private class RetryingListener extends Listener2 {
    private Listener2 delegateListener;

    RetryingListener(Listener2 delegateListener) {
      this.delegateListener = delegateListener;
    }

    @Override
    public void onResult(ResolutionResult resolutionResult) {
      syncContext.execute(() -> onResult2(resolutionResult));
    }

    @Override
    public Status onResult2(ResolutionResult resolutionResult) {
      Status status = delegateListener.onResult2(resolutionResult);
      if (status.isOk()) {
        retryScheduler.reset();
      } else {
        retryScheduler.schedule(new DelayedNameResolverRefresh());
      }
      return status;
    }

    @Override
    public void onError(Status error) {
      delegateListener.onError(error);
      syncContext.execute(() -> retryScheduler.schedule(new DelayedNameResolverRefresh()));
    }
  }
}

1	/*
2	* Copyright 2023 The gRPC Authors
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package io.grpc.internal;
18
19	import com.google.common.annotations.VisibleForTesting;
20	import io.grpc.NameResolver;
21	import io.grpc.Status;
22	import io.grpc.SynchronizationContext;
23
24	/**
25	* This wrapper class can add retry capability to any polling {@link NameResolver} implementation
26	* that supports calling {@link ResolutionResultListener}s with the outcome of each resolution.
27	*
28	* <p>The {@link NameResolver} used with this
29	*/
30	final class RetryingNameResolver extends ForwardingNameResolver {
31
32	private final NameResolver retriedNameResolver;
33	private final RetryScheduler retryScheduler;
34	private final SynchronizationContext syncContext;
35
36
37	/**
38	* Creates a new {@link RetryingNameResolver}.
39	*
40	* @param retriedNameResolver A {@link NameResolver} that will have failed attempt retried.
41	* @param retryScheduler Used to schedule the retry attempts.
42	*/
43	RetryingNameResolver(NameResolver retriedNameResolver, RetryScheduler retryScheduler,
44	SynchronizationContext syncContext) {
45	super(retriedNameResolver);	1✔
46	this.retriedNameResolver = retriedNameResolver;	1✔
47	this.retryScheduler = retryScheduler;	1✔
48	this.syncContext = syncContext;	1✔
49	}	1✔
50
51	@Override
52	public void start(Listener2 listener) {
53	super.start(new RetryingListener(listener));	1✔
54	}	1✔
55
56	@Override
57	public void shutdown() {
58	super.shutdown();	1✔
59	retryScheduler.reset();	1✔
60	}	1✔
61
62	/**
63	* Used to get the underlying {@link NameResolver} that is getting its failed attempts retried.
64	*/
65	@VisibleForTesting
66	NameResolver getRetriedNameResolver() {
67	return retriedNameResolver;	1✔
68	}
69
70	@VisibleForTesting
71	class DelayedNameResolverRefresh implements Runnable {	1✔
72	@Override
73	public void run() {
74	refresh();	×
75	}	×
76	}
77
78	private class RetryingListener extends Listener2 {
79	private Listener2 delegateListener;
80
81	RetryingListener(Listener2 delegateListener) {	1✔
82	this.delegateListener = delegateListener;	1✔
83	}	1✔
84
85	@Override
86	public void onResult(ResolutionResult resolutionResult) {
87	syncContext.execute(() -> onResult2(resolutionResult));	1✔
88	}	1✔
89
90	@Override
91	public Status onResult2(ResolutionResult resolutionResult) {
92	Status status = delegateListener.onResult2(resolutionResult);	1✔
93	if (status.isOk()) {	1✔
94	retryScheduler.reset();	1✔
95	} else {
96	retryScheduler.schedule(new DelayedNameResolverRefresh());	1✔
97	}
98	return status;	1✔
99	}
100
101	@Override
102	public void onError(Status error) {
103	delegateListener.onError(error);	1✔
104	syncContext.execute(() -> retryScheduler.schedule(new DelayedNameResolverRefresh()));	1✔
105	}	1✔
106	}
107	}

grpc / grpc-java / #19908

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous