package io.grpc.internal;
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.google.common.base.Supplier;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.grpc.Attributes;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ChannelLogger;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.ClientInterceptors;
import io.grpc.ClientStreamTracer;
import io.grpc.CompressorRegistry;
import io.grpc.ConnectivityState;
import io.grpc.ConnectivityStateInfo;
import io.grpc.Context;
import io.grpc.DecompressorRegistry;
import io.grpc.EquivalentAddressGroup;
import io.grpc.InternalChannelz;
import io.grpc.InternalInstrumented;
import io.grpc.InternalLogId;
import io.grpc.LoadBalancer;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.NameResolver;
import io.grpc.NameResolverRegistry;
import io.grpc.ProxyDetector;
import io.grpc.Status;
import io.grpc.SynchronizationContext;
import io.grpc.internal.AutoConfiguredLoadBalancerFactory;
import io.grpc.internal.BackoffPolicy;
import io.grpc.internal.CallTracer;
import io.grpc.internal.ClientCallImpl;
import io.grpc.internal.InternalSubchannel;
import io.grpc.internal.ManagedClientTransport;
import io.grpc.internal.RetriableStream;
import java.lang.Thread;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import javax.annotation.Nullable;
/* access modifiers changed from: package-private */
public final class ManagedChannelImpl extends ManagedChannel implements InternalInstrumented<InternalChannelz.ChannelStats> {
private static final ServiceConfigHolder EMPTY_SERVICE_CONFIG = new ServiceConfigHolder(Collections.emptyMap(), ManagedChannelServiceConfig.empty());
static final long IDLE_TIMEOUT_MILLIS_DISABLE = -1;
static final Status SHUTDOWN_NOW_STATUS = Status.UNAVAILABLE.withDescription("Channel shutdownNow invoked");
static final Status SHUTDOWN_STATUS = Status.UNAVAILABLE.withDescription("Channel shutdown invoked");
static final long SUBCHANNEL_SHUTDOWN_DELAY_SECONDS = 5;
static final Status SUBCHANNEL_SHUTDOWN_STATUS = Status.UNAVAILABLE.withDescription("Subchannel shutdown invoked");
static final Pattern URI_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9+.-]*:/.*");
static final Logger logger = Logger.getLogger(ManagedChannelImpl.class.getName());
private final BackoffPolicy.Provider backoffPolicyProvider;
private final ExecutorHolder balancerRpcExecutorHolder;
private final ObjectPool<? extends Executor> balancerRpcExecutorPool;
private final CallTracer.Factory callTracerFactory;
private final long channelBufferLimit;
private final RetriableStream.ChannelBufferMeter channelBufferUsed;
private final CallTracer channelCallTracer;
private final ChannelLogger channelLogger;
private final ConnectivityStateManager channelStateManager = new ConnectivityStateManager();
private final ChannelTracer channelTracer;
private final InternalChannelz channelz;
private final CompressorRegistry compressorRegistry;
private final DecompressorRegistry decompressorRegistry;
@Nullable
private final ServiceConfigHolder defaultServiceConfig;
private final DelayedClientTransport delayedTransport;
private final ManagedClientTransport.Listener delayedTransportListener;
private final Executor executor;
private final ObjectPool<? extends Executor> executorPool;
private boolean fullStreamDecompression;
private final long idleTimeoutMillis;
private final Rescheduler idleTimer;
final InUseStateAggregator<Object> inUseStateAggregator;
private final Channel interceptorChannel;
private ResolutionState lastResolutionState;
private ServiceConfigHolder lastServiceConfig;
@Nullable
private LbHelperImpl lbHelper;
private final AutoConfiguredLoadBalancerFactory loadBalancerFactory;
private final InternalLogId logId;
private final boolean lookUpServiceConfig;
private final int maxTraceEvents;
private NameResolver nameResolver;
private final NameResolver.Args nameResolverArgs;
@Nullable
private BackoffPolicy nameResolverBackoffPolicy;
private final NameResolver.Factory nameResolverFactory;
private final NameResolverRegistry nameResolverRegistry;
private boolean nameResolverStarted;
private final ExecutorHolder offloadExecutorHolder;
private final Set<OobChannel> oobChannels;
private boolean panicMode;
private final long perRpcBufferLimit;
private final boolean retryEnabled;
private final RestrictedScheduledExecutor scheduledExecutor;
@Nullable
private SynchronizationContext.ScheduledHandle scheduledNameResolverRefresh;
private final ServiceConfigInterceptor serviceConfigInterceptor;
private boolean serviceConfigUpdated;
private final AtomicBoolean shutdown;
private boolean shutdownNowed;
private final Supplier<Stopwatch> stopwatchSupplier;
@Nullable
private volatile LoadBalancer.SubchannelPicker subchannelPicker;
private final Set<InternalSubchannel> subchannels = new HashSet(16, 0.75f);
final SynchronizationContext syncContext = new SynchronizationContext(new Thread.UncaughtExceptionHandler() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1 */
public void uncaughtException(Thread thread, Throwable th) {
Logger logger = ManagedChannelImpl.logger;
Level level = Level.SEVERE;
logger.log(level, "[" + ManagedChannelImpl.this.getLogId() + "] Uncaught exception in the SynchronizationContext. Panic!", th);
ManagedChannelImpl.this.panic(th);
}
});
private final String target;
private volatile boolean terminated;
private final CountDownLatch terminatedLatch;
private volatile boolean terminating;
private final TimeProvider timeProvider;
private final ClientTransportFactory transportFactory;
private final ClientCallImpl.ClientTransportProvider transportProvider;
private final UncommittedRetriableStreamsRegistry uncommittedRetriableStreamsRegistry;
@Nullable
private final String userAgent;
/* access modifiers changed from: package-private */
public enum ResolutionState {
NO_RESOLUTION,
SUCCESS,
ERROR
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void maybeShutdownNowSubchannels() {
if (this.shutdownNowed) {
for (InternalSubchannel internalSubchannel : this.subchannels) {
internalSubchannel.shutdownNow(SHUTDOWN_NOW_STATUS);
}
for (OobChannel oobChannel : this.oobChannels) {
oobChannel.getInternalSubchannel().shutdownNow(SHUTDOWN_NOW_STATUS);
}
}
}
@Override // io.grpc.InternalInstrumented
public ListenableFuture<InternalChannelz.ChannelStats> getStats() {
final SettableFuture create = SettableFuture.create();
this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1StatsFetcher */
public void run() {
InternalChannelz.ChannelStats.Builder builder = new InternalChannelz.ChannelStats.Builder();
ManagedChannelImpl.this.channelCallTracer.updateBuilder(builder);
ManagedChannelImpl.this.channelTracer.updateBuilder(builder);
builder.setTarget(ManagedChannelImpl.this.target).setState(ManagedChannelImpl.this.channelStateManager.getState());
ArrayList arrayList = new ArrayList();
arrayList.addAll(ManagedChannelImpl.this.subchannels);
arrayList.addAll(ManagedChannelImpl.this.oobChannels);
builder.setSubchannels(arrayList);
create.set(builder.build());
}
});
return create;
}
@Override // io.grpc.InternalWithLogId
public InternalLogId getLogId() {
return this.logId;
}
private class IdleModeTimer implements Runnable {
private IdleModeTimer() {
}
public void run() {
ManagedChannelImpl.this.enterIdleMode();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void shutdownNameResolverAndLoadBalancer(boolean z) {
this.syncContext.throwIfNotInThisSynchronizationContext();
if (z) {
Preconditions.checkState(this.nameResolverStarted, "nameResolver is not started");
Preconditions.checkState(this.lbHelper != null, "lbHelper is null");
}
if (this.nameResolver != null) {
cancelNameResolverBackoff();
this.nameResolver.shutdown();
this.nameResolverStarted = false;
if (z) {
this.nameResolver = getNameResolver(this.target, this.nameResolverFactory, this.nameResolverArgs);
} else {
this.nameResolver = null;
}
}
LbHelperImpl lbHelperImpl = this.lbHelper;
if (lbHelperImpl != null) {
lbHelperImpl.lb.shutdown();
this.lbHelper = null;
}
this.subchannelPicker = null;
}
/* access modifiers changed from: package-private */
public void exitIdleMode() {
this.syncContext.throwIfNotInThisSynchronizationContext();
if (!this.shutdown.get() && !this.panicMode) {
if (this.inUseStateAggregator.isInUse()) {
cancelIdleTimer(false);
} else {
rescheduleIdleTimer();
}
if (this.lbHelper == null) {
this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Exiting idle mode");
LbHelperImpl lbHelperImpl = new LbHelperImpl();
lbHelperImpl.lb = this.loadBalancerFactory.newLoadBalancer(lbHelperImpl);
this.lbHelper = lbHelperImpl;
this.nameResolver.start((NameResolver.Listener2) new NameResolverListener(lbHelperImpl, this.nameResolver));
this.nameResolverStarted = true;
}
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void enterIdleMode() {
shutdownNameResolverAndLoadBalancer(true);
this.delayedTransport.reprocess(null);
this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Entering IDLE state");
this.channelStateManager.gotoState(ConnectivityState.IDLE);
if (this.inUseStateAggregator.isInUse()) {
exitIdleMode();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void cancelIdleTimer(boolean z) {
this.idleTimer.cancel(z);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void rescheduleIdleTimer() {
long j = this.idleTimeoutMillis;
if (j != -1) {
this.idleTimer.reschedule(j, TimeUnit.MILLISECONDS);
}
}
/* access modifiers changed from: package-private */
public class DelayedNameResolverRefresh implements Runnable {
DelayedNameResolverRefresh() {
}
public void run() {
ManagedChannelImpl.this.scheduledNameResolverRefresh = null;
ManagedChannelImpl.this.refreshNameResolution();
}
}
private void cancelNameResolverBackoff() {
this.syncContext.throwIfNotInThisSynchronizationContext();
SynchronizationContext.ScheduledHandle scheduledHandle = this.scheduledNameResolverRefresh;
if (scheduledHandle != null) {
scheduledHandle.cancel();
this.scheduledNameResolverRefresh = null;
this.nameResolverBackoffPolicy = null;
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void refreshAndResetNameResolution() {
this.syncContext.throwIfNotInThisSynchronizationContext();
cancelNameResolverBackoff();
refreshNameResolution();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void refreshNameResolution() {
this.syncContext.throwIfNotInThisSynchronizationContext();
if (this.nameResolverStarted) {
this.nameResolver.refresh();
}
}
private final class ChannelTransportProvider implements ClientCallImpl.ClientTransportProvider {
private ChannelTransportProvider() {
}
@Override // io.grpc.internal.ClientCallImpl.ClientTransportProvider
public ClientTransport get(LoadBalancer.PickSubchannelArgs pickSubchannelArgs) {
LoadBalancer.SubchannelPicker subchannelPicker = ManagedChannelImpl.this.subchannelPicker;
if (ManagedChannelImpl.this.shutdown.get()) {
return ManagedChannelImpl.this.delayedTransport;
}
if (subchannelPicker == null) {
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.ChannelTransportProvider.AnonymousClass1ExitIdleModeForTransport */
public void run() {
ManagedChannelImpl.this.exitIdleMode();
}
});
return ManagedChannelImpl.this.delayedTransport;
}
ClientTransport transportFromPickResult = GrpcUtil.getTransportFromPickResult(subchannelPicker.pickSubchannel(pickSubchannelArgs), pickSubchannelArgs.getCallOptions().isWaitForReady());
if (transportFromPickResult != null) {
return transportFromPickResult;
}
return ManagedChannelImpl.this.delayedTransport;
}
@Override // io.grpc.internal.ClientCallImpl.ClientTransportProvider
public <ReqT> ClientStream newRetriableStream(MethodDescriptor<ReqT, ?> methodDescriptor, CallOptions callOptions, Metadata metadata, Context context) {
Preconditions.checkState(ManagedChannelImpl.this.retryEnabled, "retry should be enabled");
return new RetriableStream<ReqT>(methodDescriptor, metadata, callOptions, ManagedChannelImpl.this.lastServiceConfig.managedChannelServiceConfig.getRetryThrottling(), context) {
/* class io.grpc.internal.ManagedChannelImpl.ChannelTransportProvider.AnonymousClass1RetryStream */
final /* synthetic */ CallOptions val$callOptions;
final /* synthetic */ Context val$context;
final /* synthetic */ Metadata val$headers;
final /* synthetic */ MethodDescriptor val$method;
final /* synthetic */ RetriableStream.Throttle val$throttle;
/* JADX WARN: Incorrect args count in method signature: ()V */
{
this.val$method = r17;
this.val$headers = r18;
this.val$callOptions = r19;
this.val$throttle = r20;
this.val$context = r21;
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.RetriableStream
public Status prestart() {
return ManagedChannelImpl.this.uncommittedRetriableStreamsRegistry.add(this);
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.RetriableStream
public void postCommit() {
ManagedChannelImpl.this.uncommittedRetriableStreamsRegistry.remove(this);
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.RetriableStream
public ClientStream newSubstream(ClientStreamTracer.Factory factory, Metadata metadata) {
CallOptions withStreamTracerFactory = this.val$callOptions.withStreamTracerFactory(factory);
ClientTransport clientTransport = ChannelTransportProvider.this.get(new PickSubchannelArgsImpl(this.val$method, metadata, withStreamTracerFactory));
Context attach = this.val$context.attach();
try {
return clientTransport.newStream(this.val$method, metadata, withStreamTracerFactory);
} finally {
this.val$context.detach(attach);
}
}
};
}
}
ManagedChannelImpl(AbstractManagedChannelImplBuilder<?> abstractManagedChannelImplBuilder, ClientTransportFactory clientTransportFactory, BackoffPolicy.Provider provider, ObjectPool<? extends Executor> objectPool, Supplier<Stopwatch> supplier, List<ClientInterceptor> list, final TimeProvider timeProvider2) {
boolean z = true;
this.oobChannels = new HashSet(1, 0.75f);
this.uncommittedRetriableStreamsRegistry = new UncommittedRetriableStreamsRegistry();
this.shutdown = new AtomicBoolean(false);
this.terminatedLatch = new CountDownLatch(1);
this.lastResolutionState = ResolutionState.NO_RESOLUTION;
this.lastServiceConfig = EMPTY_SERVICE_CONFIG;
this.serviceConfigUpdated = false;
this.channelBufferUsed = new RetriableStream.ChannelBufferMeter();
this.delayedTransportListener = new DelayedTransportListener();
this.inUseStateAggregator = new IdleModeStateAggregator();
this.transportProvider = new ChannelTransportProvider();
String str = (String) Preconditions.checkNotNull(abstractManagedChannelImplBuilder.target, "target");
this.target = str;
this.logId = InternalLogId.allocate("Channel", str);
this.timeProvider = (TimeProvider) Preconditions.checkNotNull(timeProvider2, "timeProvider");
ObjectPool<? extends Executor> objectPool2 = (ObjectPool) Preconditions.checkNotNull(abstractManagedChannelImplBuilder.executorPool, "executorPool");
this.executorPool = objectPool2;
Executor executor2 = (Executor) Preconditions.checkNotNull(objectPool2.getObject(), "executor");
this.executor = executor2;
CallCredentialsApplyingTransportFactory callCredentialsApplyingTransportFactory = new CallCredentialsApplyingTransportFactory(clientTransportFactory, executor2);
this.transportFactory = callCredentialsApplyingTransportFactory;
this.scheduledExecutor = new RestrictedScheduledExecutor(callCredentialsApplyingTransportFactory.getScheduledExecutorService());
this.maxTraceEvents = abstractManagedChannelImplBuilder.maxTraceEvents;
InternalLogId internalLogId = this.logId;
int i = abstractManagedChannelImplBuilder.maxTraceEvents;
long currentTimeNanos = timeProvider2.currentTimeNanos();
ChannelTracer channelTracer2 = new ChannelTracer(internalLogId, i, currentTimeNanos, "Channel for '" + this.target + "'");
this.channelTracer = channelTracer2;
this.channelLogger = new ChannelLoggerImpl(channelTracer2, timeProvider2);
this.nameResolverFactory = abstractManagedChannelImplBuilder.getNameResolverFactory();
ProxyDetector proxyDetector = abstractManagedChannelImplBuilder.proxyDetector != null ? abstractManagedChannelImplBuilder.proxyDetector : GrpcUtil.DEFAULT_PROXY_DETECTOR;
this.retryEnabled = abstractManagedChannelImplBuilder.retryEnabled && !abstractManagedChannelImplBuilder.temporarilyDisableRetry;
this.loadBalancerFactory = new AutoConfiguredLoadBalancerFactory(abstractManagedChannelImplBuilder.defaultLbPolicy);
this.offloadExecutorHolder = new ExecutorHolder((ObjectPool) Preconditions.checkNotNull(abstractManagedChannelImplBuilder.offloadExecutorPool, "offloadExecutorPool"));
this.nameResolverRegistry = abstractManagedChannelImplBuilder.nameResolverRegistry;
ScParser scParser = new ScParser(this.retryEnabled, abstractManagedChannelImplBuilder.maxRetryAttempts, abstractManagedChannelImplBuilder.maxHedgedAttempts, this.loadBalancerFactory, this.channelLogger);
NameResolver.Args build = NameResolver.Args.newBuilder().setDefaultPort(abstractManagedChannelImplBuilder.getDefaultPort()).setProxyDetector(proxyDetector).setSynchronizationContext(this.syncContext).setScheduledExecutorService(this.scheduledExecutor).setServiceConfigParser(scParser).setChannelLogger(this.channelLogger).setOffloadExecutor(new Executor() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass2 */
public void execute(Runnable runnable) {
ManagedChannelImpl.this.offloadExecutorHolder.getExecutor().execute(runnable);
}
}).build();
this.nameResolverArgs = build;
this.nameResolver = getNameResolver(this.target, this.nameResolverFactory, build);
this.balancerRpcExecutorPool = (ObjectPool) Preconditions.checkNotNull(objectPool, "balancerRpcExecutorPool");
this.balancerRpcExecutorHolder = new ExecutorHolder(objectPool);
DelayedClientTransport delayedClientTransport = new DelayedClientTransport(this.executor, this.syncContext);
this.delayedTransport = delayedClientTransport;
delayedClientTransport.start(this.delayedTransportListener);
this.backoffPolicyProvider = provider;
this.serviceConfigInterceptor = new ServiceConfigInterceptor(this.retryEnabled);
if (abstractManagedChannelImplBuilder.defaultServiceConfig != null) {
NameResolver.ConfigOrError parseServiceConfig = scParser.parseServiceConfig(abstractManagedChannelImplBuilder.defaultServiceConfig);
Preconditions.checkState(parseServiceConfig.getError() == null, "Default config is invalid: %s", parseServiceConfig.getError());
ServiceConfigHolder serviceConfigHolder = new ServiceConfigHolder(abstractManagedChannelImplBuilder.defaultServiceConfig, (ManagedChannelServiceConfig) parseServiceConfig.getConfig());
this.defaultServiceConfig = serviceConfigHolder;
this.lastServiceConfig = serviceConfigHolder;
} else {
this.defaultServiceConfig = null;
}
this.lookUpServiceConfig = abstractManagedChannelImplBuilder.lookUpServiceConfig;
Channel intercept = ClientInterceptors.intercept(new RealChannel(this.nameResolver.getServiceAuthority()), this.serviceConfigInterceptor);
this.interceptorChannel = ClientInterceptors.intercept(abstractManagedChannelImplBuilder.binlog != null ? abstractManagedChannelImplBuilder.binlog.wrapChannel(intercept) : intercept, list);
this.stopwatchSupplier = (Supplier) Preconditions.checkNotNull(supplier, "stopwatchSupplier");
if (abstractManagedChannelImplBuilder.idleTimeoutMillis == -1) {
this.idleTimeoutMillis = abstractManagedChannelImplBuilder.idleTimeoutMillis;
} else {
Preconditions.checkArgument(abstractManagedChannelImplBuilder.idleTimeoutMillis < AbstractManagedChannelImplBuilder.IDLE_MODE_MIN_TIMEOUT_MILLIS ? false : z, "invalid idleTimeoutMillis %s", abstractManagedChannelImplBuilder.idleTimeoutMillis);
this.idleTimeoutMillis = abstractManagedChannelImplBuilder.idleTimeoutMillis;
}
this.idleTimer = new Rescheduler(new IdleModeTimer(), this.syncContext, this.transportFactory.getScheduledExecutorService(), supplier.get());
this.fullStreamDecompression = abstractManagedChannelImplBuilder.fullStreamDecompression;
this.decompressorRegistry = (DecompressorRegistry) Preconditions.checkNotNull(abstractManagedChannelImplBuilder.decompressorRegistry, "decompressorRegistry");
this.compressorRegistry = (CompressorRegistry) Preconditions.checkNotNull(abstractManagedChannelImplBuilder.compressorRegistry, "compressorRegistry");
this.userAgent = abstractManagedChannelImplBuilder.userAgent;
this.channelBufferLimit = abstractManagedChannelImplBuilder.retryBufferSize;
this.perRpcBufferLimit = abstractManagedChannelImplBuilder.perRpcBufferLimit;
AnonymousClass1ChannelCallTracerFactory r2 = new CallTracer.Factory() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1ChannelCallTracerFactory */
@Override // io.grpc.internal.CallTracer.Factory
public CallTracer create() {
return new CallTracer(timeProvider2);
}
};
this.callTracerFactory = r2;
this.channelCallTracer = r2.create();
InternalChannelz internalChannelz = (InternalChannelz) Preconditions.checkNotNull(abstractManagedChannelImplBuilder.channelz);
this.channelz = internalChannelz;
internalChannelz.addRootChannel(this);
if (!this.lookUpServiceConfig) {
if (this.defaultServiceConfig != null) {
this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Service config look-up disabled, using default service config");
}
handleServiceConfigUpdate();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void handleServiceConfigUpdate() {
this.serviceConfigUpdated = true;
this.serviceConfigInterceptor.handleUpdate(this.lastServiceConfig.managedChannelServiceConfig);
}
static NameResolver getNameResolver(String str, NameResolver.Factory factory, NameResolver.Args args) {
URI uri;
NameResolver newNameResolver;
StringBuilder sb = new StringBuilder();
try {
uri = new URI(str);
} catch (URISyntaxException e) {
sb.append(e.getMessage());
uri = null;
}
if (uri != null && (newNameResolver = factory.newNameResolver(uri, args)) != null) {
return newNameResolver;
}
String str2 = "";
if (!URI_PATTERN.matcher(str).matches()) {
try {
NameResolver newNameResolver2 = factory.newNameResolver(new URI(factory.getDefaultScheme(), str2, "/" + str, null), args);
if (newNameResolver2 != null) {
return newNameResolver2;
}
} catch (URISyntaxException e2) {
throw new IllegalArgumentException(e2);
}
}
Object[] objArr = new Object[2];
objArr[0] = str;
if (sb.length() > 0) {
str2 = " (" + ((Object) sb) + ")";
}
objArr[1] = str2;
throw new IllegalArgumentException(String.format("cannot find a NameResolver for %s%s", objArr));
}
@Override // io.grpc.ManagedChannel
public ManagedChannelImpl shutdown() {
this.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "shutdown() called");
if (!this.shutdown.compareAndSet(false, true)) {
return this;
}
this.syncContext.executeLater(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1Shutdown */
public void run() {
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Entering SHUTDOWN state");
ManagedChannelImpl.this.channelStateManager.gotoState(ConnectivityState.SHUTDOWN);
}
});
this.uncommittedRetriableStreamsRegistry.onShutdown(SHUTDOWN_STATUS);
this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1CancelIdleTimer */
public void run() {
ManagedChannelImpl.this.cancelIdleTimer(true);
}
});
return this;
}
@Override // io.grpc.ManagedChannel
public ManagedChannelImpl shutdownNow() {
this.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "shutdownNow() called");
shutdown();
this.uncommittedRetriableStreamsRegistry.onShutdownNow(SHUTDOWN_NOW_STATUS);
this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1ShutdownNow */
public void run() {
if (!ManagedChannelImpl.this.shutdownNowed) {
ManagedChannelImpl.this.shutdownNowed = true;
ManagedChannelImpl.this.maybeShutdownNowSubchannels();
}
}
});
return this;
}
/* access modifiers changed from: package-private */
public void panic(final Throwable th) {
if (!this.panicMode) {
this.panicMode = true;
cancelIdleTimer(true);
shutdownNameResolverAndLoadBalancer(false);
updateSubchannelPicker(new LoadBalancer.SubchannelPicker() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1PanicSubchannelPicker */
private final LoadBalancer.PickResult panicPickResult = LoadBalancer.PickResult.withDrop(Status.INTERNAL.withDescription("Panic! This is a bug!").withCause(th));
@Override // io.grpc.LoadBalancer.SubchannelPicker
public LoadBalancer.PickResult pickSubchannel(LoadBalancer.PickSubchannelArgs pickSubchannelArgs) {
return this.panicPickResult;
}
public String toString() {
return MoreObjects.toStringHelper((Class<?>) AnonymousClass1PanicSubchannelPicker.class).add("panicPickResult", this.panicPickResult).toString();
}
});
this.channelLogger.log(ChannelLogger.ChannelLogLevel.ERROR, "PANIC! Entering TRANSIENT_FAILURE");
this.channelStateManager.gotoState(ConnectivityState.TRANSIENT_FAILURE);
}
}
/* access modifiers changed from: package-private */
public boolean isInPanicMode() {
return this.panicMode;
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void updateSubchannelPicker(LoadBalancer.SubchannelPicker subchannelPicker2) {
this.subchannelPicker = subchannelPicker2;
this.delayedTransport.reprocess(subchannelPicker2);
}
@Override // io.grpc.ManagedChannel
public boolean isShutdown() {
return this.shutdown.get();
}
@Override // io.grpc.ManagedChannel
public boolean awaitTermination(long j, TimeUnit timeUnit) throws InterruptedException {
return this.terminatedLatch.await(j, timeUnit);
}
@Override // io.grpc.ManagedChannel
public boolean isTerminated() {
return this.terminated;
}
@Override // io.grpc.Channel
public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
return this.interceptorChannel.newCall(methodDescriptor, callOptions);
}
@Override // io.grpc.Channel
public String authority() {
return this.interceptorChannel.authority();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private Executor getCallExecutor(CallOptions callOptions) {
Executor executor2 = callOptions.getExecutor();
return executor2 == null ? this.executor : executor2;
}
private class RealChannel extends Channel {
private final String authority;
private RealChannel(String str) {
this.authority = (String) Preconditions.checkNotNull(str, "authority");
}
@Override // io.grpc.Channel
public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
return new ClientCallImpl(methodDescriptor, ManagedChannelImpl.this.getCallExecutor(callOptions), callOptions, ManagedChannelImpl.this.transportProvider, ManagedChannelImpl.this.terminated ? null : ManagedChannelImpl.this.transportFactory.getScheduledExecutorService(), ManagedChannelImpl.this.channelCallTracer, ManagedChannelImpl.this.retryEnabled).setFullStreamDecompression(ManagedChannelImpl.this.fullStreamDecompression).setDecompressorRegistry(ManagedChannelImpl.this.decompressorRegistry).setCompressorRegistry(ManagedChannelImpl.this.compressorRegistry);
}
@Override // io.grpc.Channel
public String authority() {
return this.authority;
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void maybeTerminateChannel() {
if (!this.terminated && this.shutdown.get() && this.subchannels.isEmpty() && this.oobChannels.isEmpty()) {
this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Terminated");
this.channelz.removeRootChannel(this);
this.executorPool.returnObject(this.executor);
this.balancerRpcExecutorHolder.release();
this.offloadExecutorHolder.release();
this.transportFactory.close();
this.terminated = true;
this.terminatedLatch.countDown();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void handleInternalSubchannelState(ConnectivityStateInfo connectivityStateInfo) {
if (connectivityStateInfo.getState() == ConnectivityState.TRANSIENT_FAILURE || connectivityStateInfo.getState() == ConnectivityState.IDLE) {
refreshAndResetNameResolution();
}
}
@Override // io.grpc.ManagedChannel
public ConnectivityState getState(boolean z) {
ConnectivityState state = this.channelStateManager.getState();
if (z && state == ConnectivityState.IDLE) {
this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1RequestConnection */
public void run() {
ManagedChannelImpl.this.exitIdleMode();
if (ManagedChannelImpl.this.subchannelPicker != null) {
ManagedChannelImpl.this.subchannelPicker.requestConnection();
}
if (ManagedChannelImpl.this.lbHelper != null) {
ManagedChannelImpl.this.lbHelper.lb.requestConnection();
}
}
});
}
return state;
}
@Override // io.grpc.ManagedChannel
public void notifyWhenStateChanged(final ConnectivityState connectivityState, final Runnable runnable) {
this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1NotifyStateChanged */
public void run() {
ManagedChannelImpl.this.channelStateManager.notifyWhenStateChanged(runnable, ManagedChannelImpl.this.executor, connectivityState);
}
});
}
@Override // io.grpc.ManagedChannel
public void resetConnectBackoff() {
this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1ResetConnectBackoff */
public void run() {
if (!ManagedChannelImpl.this.shutdown.get()) {
if (ManagedChannelImpl.this.scheduledNameResolverRefresh != null && ManagedChannelImpl.this.scheduledNameResolverRefresh.isPending()) {
Preconditions.checkState(ManagedChannelImpl.this.nameResolverStarted, "name resolver must be started");
ManagedChannelImpl.this.refreshAndResetNameResolution();
}
for (InternalSubchannel internalSubchannel : ManagedChannelImpl.this.subchannels) {
internalSubchannel.resetConnectBackoff();
}
for (OobChannel oobChannel : ManagedChannelImpl.this.oobChannels) {
oobChannel.resetConnectBackoff();
}
}
}
});
}
@Override // io.grpc.ManagedChannel
public void enterIdle() {
this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.AnonymousClass1PrepareToLoseNetworkRunnable */
public void run() {
if (!ManagedChannelImpl.this.shutdown.get() && ManagedChannelImpl.this.lbHelper != null) {
ManagedChannelImpl.this.cancelIdleTimer(false);
ManagedChannelImpl.this.enterIdleMode();
}
}
});
}
/* access modifiers changed from: private */
public final class UncommittedRetriableStreamsRegistry {
final Object lock;
Status shutdownStatus;
Collection<ClientStream> uncommittedRetriableStreams;
private UncommittedRetriableStreamsRegistry() {
this.lock = new Object();
this.uncommittedRetriableStreams = new HashSet();
}
/* access modifiers changed from: package-private */
/* JADX WARNING: Code restructure failed: missing block: B:10:0x0014, code lost:
r2.this$0.delayedTransport.shutdown(r3);
*/
/* JADX WARNING: Code restructure failed: missing block: B:14:?, code lost:
return;
*/
/* JADX WARNING: Code restructure failed: missing block: B:15:?, code lost:
return;
*/
/* JADX WARNING: Code restructure failed: missing block: B:9:0x0012, code lost:
if (r1 == false) goto L_?;
*/
public void onShutdown(Status status) {
synchronized (this.lock) {
if (this.shutdownStatus == null) {
this.shutdownStatus = status;
boolean isEmpty = this.uncommittedRetriableStreams.isEmpty();
}
}
}
/* access modifiers changed from: package-private */
public void onShutdownNow(Status status) {
ArrayList<ClientStream> arrayList;
onShutdown(status);
synchronized (this.lock) {
arrayList = new ArrayList(this.uncommittedRetriableStreams);
}
for (ClientStream clientStream : arrayList) {
clientStream.cancel(status);
}
ManagedChannelImpl.this.delayedTransport.shutdownNow(status);
}
/* access modifiers changed from: package-private */
@Nullable
public Status add(RetriableStream<?> retriableStream) {
synchronized (this.lock) {
if (this.shutdownStatus != null) {
return this.shutdownStatus;
}
this.uncommittedRetriableStreams.add(retriableStream);
return null;
}
}
/* access modifiers changed from: package-private */
public void remove(RetriableStream<?> retriableStream) {
Status status;
synchronized (this.lock) {
this.uncommittedRetriableStreams.remove(retriableStream);
if (this.uncommittedRetriableStreams.isEmpty()) {
status = this.shutdownStatus;
this.uncommittedRetriableStreams = new HashSet();
} else {
status = null;
}
}
if (status != null) {
ManagedChannelImpl.this.delayedTransport.shutdown(status);
}
}
}
/* access modifiers changed from: private */
public class LbHelperImpl extends LoadBalancer.Helper {
AutoConfiguredLoadBalancerFactory.AutoConfiguredLoadBalancer lb;
private LbHelperImpl() {
}
@Override // io.grpc.LoadBalancer.Helper
@Deprecated
public AbstractSubchannel createSubchannel(List<EquivalentAddressGroup> list, Attributes attributes) {
ManagedChannelImpl.this.logWarningIfNotInSyncContext("createSubchannel()");
Preconditions.checkNotNull(list, "addressGroups");
Preconditions.checkNotNull(attributes, "attrs");
final SubchannelImpl createSubchannelInternal = createSubchannelInternal(LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(list).setAttributes(attributes).build());
createSubchannelInternal.internalStart(new LoadBalancer.SubchannelStateListener() {
/* class io.grpc.internal.ManagedChannelImpl.LbHelperImpl.AnonymousClass1 */
@Override // io.grpc.LoadBalancer.SubchannelStateListener
public void onSubchannelState(ConnectivityStateInfo connectivityStateInfo) {
LbHelperImpl lbHelperImpl = LbHelperImpl.this;
if (lbHelperImpl == ManagedChannelImpl.this.lbHelper) {
LbHelperImpl.this.lb.handleSubchannelState(createSubchannelInternal, connectivityStateInfo);
}
}
});
return createSubchannelInternal;
}
@Override // io.grpc.LoadBalancer.Helper
public AbstractSubchannel createSubchannel(LoadBalancer.CreateSubchannelArgs createSubchannelArgs) {
ManagedChannelImpl.this.syncContext.throwIfNotInThisSynchronizationContext();
return createSubchannelInternal(createSubchannelArgs);
}
private SubchannelImpl createSubchannelInternal(LoadBalancer.CreateSubchannelArgs createSubchannelArgs) {
Preconditions.checkState(!ManagedChannelImpl.this.terminated, "Channel is terminated");
return new SubchannelImpl(createSubchannelArgs, this);
}
@Override // io.grpc.LoadBalancer.Helper
public void updateBalancingState(final ConnectivityState connectivityState, final LoadBalancer.SubchannelPicker subchannelPicker) {
Preconditions.checkNotNull(connectivityState, "newState");
Preconditions.checkNotNull(subchannelPicker, "newPicker");
ManagedChannelImpl.this.logWarningIfNotInSyncContext("updateBalancingState()");
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.LbHelperImpl.AnonymousClass1UpdateBalancingState */
public void run() {
LbHelperImpl lbHelperImpl = LbHelperImpl.this;
if (lbHelperImpl == ManagedChannelImpl.this.lbHelper) {
ManagedChannelImpl.this.updateSubchannelPicker(subchannelPicker);
if (connectivityState != ConnectivityState.SHUTDOWN) {
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Entering {0} state with picker: {1}", connectivityState, subchannelPicker);
ManagedChannelImpl.this.channelStateManager.gotoState(connectivityState);
}
}
}
});
}
@Override // io.grpc.LoadBalancer.Helper
public void refreshNameResolution() {
ManagedChannelImpl.this.logWarningIfNotInSyncContext("refreshNameResolution()");
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.LbHelperImpl.AnonymousClass1LoadBalancerRefreshNameResolution */
public void run() {
ManagedChannelImpl.this.refreshAndResetNameResolution();
}
});
}
@Override // io.grpc.LoadBalancer.Helper
@Deprecated
public void updateSubchannelAddresses(LoadBalancer.Subchannel subchannel, List<EquivalentAddressGroup> list) {
Preconditions.checkArgument(subchannel instanceof SubchannelImpl, "subchannel must have been returned from createSubchannel");
ManagedChannelImpl.this.logWarningIfNotInSyncContext("updateSubchannelAddresses()");
((InternalSubchannel) subchannel.getInternalSubchannel()).updateAddresses(list);
}
@Override // io.grpc.LoadBalancer.Helper
public ManagedChannel createOobChannel(EquivalentAddressGroup equivalentAddressGroup, String str) {
Preconditions.checkState(!ManagedChannelImpl.this.terminated, "Channel is terminated");
long currentTimeNanos = ManagedChannelImpl.this.timeProvider.currentTimeNanos();
InternalLogId allocate = InternalLogId.allocate("OobChannel", (String) null);
InternalLogId allocate2 = InternalLogId.allocate("Subchannel-OOB", str);
int i = ManagedChannelImpl.this.maxTraceEvents;
ChannelTracer channelTracer = new ChannelTracer(allocate, i, currentTimeNanos, "OobChannel for " + equivalentAddressGroup);
final OobChannel oobChannel = new OobChannel(str, ManagedChannelImpl.this.balancerRpcExecutorPool, ManagedChannelImpl.this.transportFactory.getScheduledExecutorService(), ManagedChannelImpl.this.syncContext, ManagedChannelImpl.this.callTracerFactory.create(), channelTracer, ManagedChannelImpl.this.channelz, ManagedChannelImpl.this.timeProvider);
ManagedChannelImpl.this.channelTracer.reportEvent(new InternalChannelz.ChannelTrace.Event.Builder().setDescription("Child OobChannel created").setSeverity(InternalChannelz.ChannelTrace.Event.Severity.CT_INFO).setTimestampNanos(currentTimeNanos).setChannelRef(oobChannel).build());
int i2 = ManagedChannelImpl.this.maxTraceEvents;
ChannelTracer channelTracer2 = new ChannelTracer(allocate2, i2, currentTimeNanos, "Subchannel for " + equivalentAddressGroup);
InternalSubchannel internalSubchannel = new InternalSubchannel(Collections.singletonList(equivalentAddressGroup), str, ManagedChannelImpl.this.userAgent, ManagedChannelImpl.this.backoffPolicyProvider, ManagedChannelImpl.this.transportFactory, ManagedChannelImpl.this.transportFactory.getScheduledExecutorService(), ManagedChannelImpl.this.stopwatchSupplier, ManagedChannelImpl.this.syncContext, new InternalSubchannel.Callback() {
/* class io.grpc.internal.ManagedChannelImpl.LbHelperImpl.AnonymousClass1ManagedOobChannelCallback */
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.InternalSubchannel.Callback
public void onTerminated(InternalSubchannel internalSubchannel) {
ManagedChannelImpl.this.oobChannels.remove(oobChannel);
ManagedChannelImpl.this.channelz.removeSubchannel(internalSubchannel);
oobChannel.handleSubchannelTerminated();
ManagedChannelImpl.this.maybeTerminateChannel();
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.InternalSubchannel.Callback
public void onStateChange(InternalSubchannel internalSubchannel, ConnectivityStateInfo connectivityStateInfo) {
ManagedChannelImpl.this.handleInternalSubchannelState(connectivityStateInfo);
oobChannel.handleSubchannelStateChange(connectivityStateInfo);
}
}, ManagedChannelImpl.this.channelz, ManagedChannelImpl.this.callTracerFactory.create(), channelTracer2, allocate2, new ChannelLoggerImpl(channelTracer2, ManagedChannelImpl.this.timeProvider));
channelTracer.reportEvent(new InternalChannelz.ChannelTrace.Event.Builder().setDescription("Child Subchannel created").setSeverity(InternalChannelz.ChannelTrace.Event.Severity.CT_INFO).setTimestampNanos(currentTimeNanos).setSubchannelRef(internalSubchannel).build());
ManagedChannelImpl.this.channelz.addSubchannel(oobChannel);
ManagedChannelImpl.this.channelz.addSubchannel(internalSubchannel);
oobChannel.setSubchannel(internalSubchannel);
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.LbHelperImpl.AnonymousClass1AddOobChannel */
public void run() {
if (ManagedChannelImpl.this.terminating) {
oobChannel.shutdown();
}
if (!ManagedChannelImpl.this.terminated) {
ManagedChannelImpl.this.oobChannels.add(oobChannel);
}
}
});
return oobChannel;
}
@Override // io.grpc.LoadBalancer.Helper
public void updateOobChannelAddresses(ManagedChannel managedChannel, EquivalentAddressGroup equivalentAddressGroup) {
Preconditions.checkArgument(managedChannel instanceof OobChannel, "channel must have been returned from createOobChannel");
((OobChannel) managedChannel).updateAddresses(equivalentAddressGroup);
}
@Override // io.grpc.LoadBalancer.Helper
public String getAuthority() {
return ManagedChannelImpl.this.authority();
}
@Override // io.grpc.LoadBalancer.Helper
@Deprecated
public NameResolver.Factory getNameResolverFactory() {
return ManagedChannelImpl.this.nameResolverFactory;
}
@Override // io.grpc.LoadBalancer.Helper
public SynchronizationContext getSynchronizationContext() {
return ManagedChannelImpl.this.syncContext;
}
@Override // io.grpc.LoadBalancer.Helper
public ScheduledExecutorService getScheduledExecutorService() {
return ManagedChannelImpl.this.scheduledExecutor;
}
@Override // io.grpc.LoadBalancer.Helper
public ChannelLogger getChannelLogger() {
return ManagedChannelImpl.this.channelLogger;
}
@Override // io.grpc.LoadBalancer.Helper
public NameResolver.Args getNameResolverArgs() {
return ManagedChannelImpl.this.nameResolverArgs;
}
@Override // io.grpc.LoadBalancer.Helper
public NameResolverRegistry getNameResolverRegistry() {
return ManagedChannelImpl.this.nameResolverRegistry;
}
}
/* access modifiers changed from: private */
public final class NameResolverListener extends NameResolver.Listener2 {
final LbHelperImpl helper;
final NameResolver resolver;
NameResolverListener(LbHelperImpl lbHelperImpl, NameResolver nameResolver) {
this.helper = (LbHelperImpl) Preconditions.checkNotNull(lbHelperImpl, "helperImpl");
this.resolver = (NameResolver) Preconditions.checkNotNull(nameResolver, "resolver");
}
@Override // io.grpc.NameResolver.Listener2
public void onResult(final NameResolver.ResolutionResult resolutionResult) {
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.NameResolverListener.AnonymousClass1NamesResolved */
public void run() {
Status status;
ServiceConfigHolder serviceConfigHolder;
List<EquivalentAddressGroup> addresses = resolutionResult.getAddresses();
Attributes attributes = resolutionResult.getAttributes();
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "Resolved address: {0}, config={1}", addresses, attributes);
ResolutionState resolutionState = ManagedChannelImpl.this.lastResolutionState;
if (ManagedChannelImpl.this.lastResolutionState != ResolutionState.SUCCESS) {
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Address resolved: {0}", addresses);
ManagedChannelImpl.this.lastResolutionState = ResolutionState.SUCCESS;
}
ServiceConfigHolder serviceConfigHolder2 = null;
ManagedChannelImpl.this.nameResolverBackoffPolicy = null;
NameResolver.ConfigOrError serviceConfig = resolutionResult.getServiceConfig();
if (serviceConfig != null) {
Map map = (Map) resolutionResult.getAttributes().get(GrpcAttributes.NAME_RESOLVER_SERVICE_CONFIG);
if (serviceConfig.getConfig() != null) {
serviceConfigHolder2 = new ServiceConfigHolder(map, (ManagedChannelServiceConfig) serviceConfig.getConfig());
}
status = serviceConfig.getError();
} else {
status = null;
}
if (!ManagedChannelImpl.this.lookUpServiceConfig) {
if (serviceConfigHolder2 != null) {
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Service config from name resolver discarded by channel settings");
}
serviceConfigHolder = ManagedChannelImpl.this.defaultServiceConfig == null ? ManagedChannelImpl.EMPTY_SERVICE_CONFIG : ManagedChannelImpl.this.defaultServiceConfig;
attributes = attributes.toBuilder().discard(GrpcAttributes.NAME_RESOLVER_SERVICE_CONFIG).build();
} else {
if (serviceConfigHolder2 != null) {
serviceConfigHolder = serviceConfigHolder2;
} else if (ManagedChannelImpl.this.defaultServiceConfig != null) {
serviceConfigHolder = ManagedChannelImpl.this.defaultServiceConfig;
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Received no service config, using default service config");
} else if (status == null) {
serviceConfigHolder = ManagedChannelImpl.EMPTY_SERVICE_CONFIG;
} else if (!ManagedChannelImpl.this.serviceConfigUpdated) {
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Fallback to error due to invalid first service config without default config");
NameResolverListener.this.onError(serviceConfig.getError());
return;
} else {
serviceConfigHolder = ManagedChannelImpl.this.lastServiceConfig;
}
if (!serviceConfigHolder.equals(ManagedChannelImpl.this.lastServiceConfig)) {
ChannelLogger channelLogger = ManagedChannelImpl.this.channelLogger;
ChannelLogger.ChannelLogLevel channelLogLevel = ChannelLogger.ChannelLogLevel.INFO;
Object[] objArr = new Object[1];
objArr[0] = serviceConfigHolder == ManagedChannelImpl.EMPTY_SERVICE_CONFIG ? " to empty" : "";
channelLogger.log(channelLogLevel, "Service config changed{0}", objArr);
ManagedChannelImpl.this.lastServiceConfig = serviceConfigHolder;
}
try {
ManagedChannelImpl.this.handleServiceConfigUpdate();
} catch (RuntimeException e) {
ManagedChannelImpl.logger.log(Level.WARNING, "[" + ManagedChannelImpl.this.getLogId() + "] Unexpected exception from parsing service config", (Throwable) e);
}
}
if (NameResolverListener.this.helper == ManagedChannelImpl.this.lbHelper) {
if (serviceConfigHolder != serviceConfigHolder2) {
attributes = attributes.toBuilder().set(GrpcAttributes.NAME_RESOLVER_SERVICE_CONFIG, serviceConfigHolder.rawServiceConfig).build();
}
Status tryHandleResolvedAddresses = NameResolverListener.this.helper.lb.tryHandleResolvedAddresses(LoadBalancer.ResolvedAddresses.newBuilder().setAddresses(addresses).setAttributes(attributes).setLoadBalancingPolicyConfig(serviceConfigHolder.managedChannelServiceConfig.getLoadBalancingConfig()).build());
if (tryHandleResolvedAddresses.isOk()) {
return;
}
if (!addresses.isEmpty() || resolutionState != ResolutionState.SUCCESS) {
NameResolverListener.this.handleErrorInSyncContext(tryHandleResolvedAddresses.augmentDescription(NameResolverListener.this.resolver + " was used"));
return;
}
NameResolverListener.this.scheduleExponentialBackOffInSyncContext();
}
}
});
}
@Override // io.grpc.NameResolver.Listener2, io.grpc.NameResolver.Listener
public void onError(final Status status) {
Preconditions.checkArgument(!status.isOk(), "the error status must not be OK");
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.NameResolverListener.AnonymousClass1NameResolverErrorHandler */
public void run() {
NameResolverListener.this.handleErrorInSyncContext(status);
}
});
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void handleErrorInSyncContext(Status status) {
ManagedChannelImpl.logger.log(Level.WARNING, "[{0}] Failed to resolve name. status={1}", new Object[]{ManagedChannelImpl.this.getLogId(), status});
if (ManagedChannelImpl.this.lastResolutionState != ResolutionState.ERROR) {
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.WARNING, "Failed to resolve name: {0}", status);
ManagedChannelImpl.this.lastResolutionState = ResolutionState.ERROR;
}
if (this.helper == ManagedChannelImpl.this.lbHelper) {
this.helper.lb.handleNameResolutionError(status);
scheduleExponentialBackOffInSyncContext();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void scheduleExponentialBackOffInSyncContext() {
if (ManagedChannelImpl.this.scheduledNameResolverRefresh == null || !ManagedChannelImpl.this.scheduledNameResolverRefresh.isPending()) {
if (ManagedChannelImpl.this.nameResolverBackoffPolicy == null) {
ManagedChannelImpl managedChannelImpl = ManagedChannelImpl.this;
managedChannelImpl.nameResolverBackoffPolicy = managedChannelImpl.backoffPolicyProvider.get();
}
long nextBackoffNanos = ManagedChannelImpl.this.nameResolverBackoffPolicy.nextBackoffNanos();
ManagedChannelImpl.this.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "Scheduling DNS resolution backoff for {0} ns", Long.valueOf(nextBackoffNanos));
ManagedChannelImpl managedChannelImpl2 = ManagedChannelImpl.this;
managedChannelImpl2.scheduledNameResolverRefresh = managedChannelImpl2.syncContext.schedule(new DelayedNameResolverRefresh(), nextBackoffNanos, TimeUnit.NANOSECONDS, ManagedChannelImpl.this.transportFactory.getScheduledExecutorService());
}
}
}
/* access modifiers changed from: private */
public final class SubchannelImpl extends AbstractSubchannel {
final LoadBalancer.CreateSubchannelArgs args;
SynchronizationContext.ScheduledHandle delayedShutdownTask;
final LbHelperImpl helper;
LoadBalancer.SubchannelStateListener listener;
boolean shutdown;
boolean started;
InternalSubchannel subchannel;
final InternalLogId subchannelLogId;
final ChannelLoggerImpl subchannelLogger;
final ChannelTracer subchannelTracer;
SubchannelImpl(LoadBalancer.CreateSubchannelArgs createSubchannelArgs, LbHelperImpl lbHelperImpl) {
this.args = (LoadBalancer.CreateSubchannelArgs) Preconditions.checkNotNull(createSubchannelArgs, "args");
this.helper = (LbHelperImpl) Preconditions.checkNotNull(lbHelperImpl, "helper");
this.subchannelLogId = InternalLogId.allocate("Subchannel", ManagedChannelImpl.this.authority());
InternalLogId internalLogId = this.subchannelLogId;
int i = ManagedChannelImpl.this.maxTraceEvents;
long currentTimeNanos = ManagedChannelImpl.this.timeProvider.currentTimeNanos();
ChannelTracer channelTracer = new ChannelTracer(internalLogId, i, currentTimeNanos, "Subchannel for " + createSubchannelArgs.getAddresses());
this.subchannelTracer = channelTracer;
this.subchannelLogger = new ChannelLoggerImpl(channelTracer, ManagedChannelImpl.this.timeProvider);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void internalStart(final LoadBalancer.SubchannelStateListener subchannelStateListener) {
Preconditions.checkState(!this.started, "already started");
Preconditions.checkState(!this.shutdown, "already shutdown");
this.started = true;
this.listener = subchannelStateListener;
if (ManagedChannelImpl.this.terminating) {
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.SubchannelImpl.AnonymousClass1 */
public void run() {
subchannelStateListener.onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.SHUTDOWN));
}
});
return;
}
final InternalSubchannel internalSubchannel = new InternalSubchannel(this.args.getAddresses(), ManagedChannelImpl.this.authority(), ManagedChannelImpl.this.userAgent, ManagedChannelImpl.this.backoffPolicyProvider, ManagedChannelImpl.this.transportFactory, ManagedChannelImpl.this.transportFactory.getScheduledExecutorService(), ManagedChannelImpl.this.stopwatchSupplier, ManagedChannelImpl.this.syncContext, new InternalSubchannel.Callback() {
/* class io.grpc.internal.ManagedChannelImpl.SubchannelImpl.AnonymousClass1ManagedInternalSubchannelCallback */
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.InternalSubchannel.Callback
public void onTerminated(InternalSubchannel internalSubchannel) {
ManagedChannelImpl.this.subchannels.remove(internalSubchannel);
ManagedChannelImpl.this.channelz.removeSubchannel(internalSubchannel);
ManagedChannelImpl.this.maybeTerminateChannel();
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.InternalSubchannel.Callback
public void onStateChange(InternalSubchannel internalSubchannel, ConnectivityStateInfo connectivityStateInfo) {
ManagedChannelImpl.this.handleInternalSubchannelState(connectivityStateInfo);
Preconditions.checkState(subchannelStateListener != null, "listener is null");
subchannelStateListener.onSubchannelState(connectivityStateInfo);
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.InternalSubchannel.Callback
public void onInUse(InternalSubchannel internalSubchannel) {
ManagedChannelImpl.this.inUseStateAggregator.updateObjectInUse(internalSubchannel, true);
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.InternalSubchannel.Callback
public void onNotInUse(InternalSubchannel internalSubchannel) {
ManagedChannelImpl.this.inUseStateAggregator.updateObjectInUse(internalSubchannel, false);
}
}, ManagedChannelImpl.this.channelz, ManagedChannelImpl.this.callTracerFactory.create(), this.subchannelTracer, this.subchannelLogId, this.subchannelLogger);
ManagedChannelImpl.this.channelTracer.reportEvent(new InternalChannelz.ChannelTrace.Event.Builder().setDescription("Child Subchannel started").setSeverity(InternalChannelz.ChannelTrace.Event.Severity.CT_INFO).setTimestampNanos(ManagedChannelImpl.this.timeProvider.currentTimeNanos()).setSubchannelRef(internalSubchannel).build());
this.subchannel = internalSubchannel;
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.SubchannelImpl.AnonymousClass2 */
public void run() {
ManagedChannelImpl.this.channelz.addSubchannel(internalSubchannel);
ManagedChannelImpl.this.subchannels.add(internalSubchannel);
}
});
}
@Override // io.grpc.LoadBalancer.Subchannel
public void start(LoadBalancer.SubchannelStateListener subchannelStateListener) {
ManagedChannelImpl.this.syncContext.throwIfNotInThisSynchronizationContext();
internalStart(subchannelStateListener);
}
/* access modifiers changed from: package-private */
@Override // io.grpc.internal.AbstractSubchannel
public InternalInstrumented<InternalChannelz.ChannelStats> getInstrumentedInternalSubchannel() {
Preconditions.checkState(this.started, "not started");
return this.subchannel;
}
@Override // io.grpc.LoadBalancer.Subchannel
public void shutdown() {
ManagedChannelImpl.this.logWarningIfNotInSyncContext("Subchannel.shutdown()");
ManagedChannelImpl.this.syncContext.execute(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.SubchannelImpl.AnonymousClass3 */
public void run() {
SubchannelImpl.this.internalShutdown();
}
});
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void internalShutdown() {
SynchronizationContext.ScheduledHandle scheduledHandle;
ManagedChannelImpl.this.syncContext.throwIfNotInThisSynchronizationContext();
if (this.subchannel == null) {
this.shutdown = true;
return;
}
if (!this.shutdown) {
this.shutdown = true;
} else if (ManagedChannelImpl.this.terminating && (scheduledHandle = this.delayedShutdownTask) != null) {
scheduledHandle.cancel();
this.delayedShutdownTask = null;
} else {
return;
}
if (!ManagedChannelImpl.this.terminating) {
this.delayedShutdownTask = ManagedChannelImpl.this.syncContext.schedule(new LogExceptionRunnable(new Runnable() {
/* class io.grpc.internal.ManagedChannelImpl.SubchannelImpl.AnonymousClass1ShutdownSubchannel */
public void run() {
SubchannelImpl.this.subchannel.shutdown(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_STATUS);
}
}), 5, TimeUnit.SECONDS, ManagedChannelImpl.this.transportFactory.getScheduledExecutorService());
} else {
this.subchannel.shutdown(ManagedChannelImpl.SHUTDOWN_STATUS);
}
}
@Override // io.grpc.LoadBalancer.Subchannel
public void requestConnection() {
ManagedChannelImpl.this.logWarningIfNotInSyncContext("Subchannel.requestConnection()");
Preconditions.checkState(this.started, "not started");
this.subchannel.obtainActiveTransport();
}
@Override // io.grpc.LoadBalancer.Subchannel
public List<EquivalentAddressGroup> getAllAddresses() {
ManagedChannelImpl.this.logWarningIfNotInSyncContext("Subchannel.getAllAddresses()");
Preconditions.checkState(this.started, "not started");
return this.subchannel.getAddressGroups();
}
@Override // io.grpc.LoadBalancer.Subchannel
public Attributes getAttributes() {
return this.args.getAttributes();
}
public String toString() {
return this.subchannelLogId.toString();
}
@Override // io.grpc.LoadBalancer.Subchannel
public Channel asChannel() {
Preconditions.checkState(this.started, "not started");
return new SubchannelChannel(this.subchannel, ManagedChannelImpl.this.balancerRpcExecutorHolder.getExecutor(), ManagedChannelImpl.this.transportFactory.getScheduledExecutorService(), ManagedChannelImpl.this.callTracerFactory.create());
}
@Override // io.grpc.LoadBalancer.Subchannel
public Object getInternalSubchannel() {
Preconditions.checkState(this.started, "Subchannel is not started");
return this.subchannel;
}
@Override // io.grpc.LoadBalancer.Subchannel
public ChannelLogger getChannelLogger() {
return this.subchannelLogger;
}
@Override // io.grpc.LoadBalancer.Subchannel
public void updateAddresses(List<EquivalentAddressGroup> list) {
ManagedChannelImpl.this.syncContext.throwIfNotInThisSynchronizationContext();
this.subchannel.updateAddresses(list);
}
}
public String toString() {
return MoreObjects.toStringHelper(this).add("logId", this.logId.getId()).add("target", this.target).toString();
}
private final class DelayedTransportListener implements ManagedClientTransport.Listener {
@Override // io.grpc.internal.ManagedClientTransport.Listener
public void transportReady() {
}
private DelayedTransportListener() {
}
@Override // io.grpc.internal.ManagedClientTransport.Listener
public void transportShutdown(Status status) {
Preconditions.checkState(ManagedChannelImpl.this.shutdown.get(), "Channel must have been shut down");
}
@Override // io.grpc.internal.ManagedClientTransport.Listener
public void transportInUse(boolean z) {
ManagedChannelImpl.this.inUseStateAggregator.updateObjectInUse(ManagedChannelImpl.this.delayedTransport, z);
}
@Override // io.grpc.internal.ManagedClientTransport.Listener
public void transportTerminated() {
Preconditions.checkState(ManagedChannelImpl.this.shutdown.get(), "Channel must have been shut down");
ManagedChannelImpl.this.terminating = true;
ManagedChannelImpl.this.shutdownNameResolverAndLoadBalancer(false);
ManagedChannelImpl.this.maybeShutdownNowSubchannels();
ManagedChannelImpl.this.maybeTerminateChannel();
}
}
private final class IdleModeStateAggregator extends InUseStateAggregator<Object> {
private IdleModeStateAggregator() {
}
/* access modifiers changed from: protected */
@Override // io.grpc.internal.InUseStateAggregator
public void handleInUse() {
ManagedChannelImpl.this.exitIdleMode();
}
/* access modifiers changed from: protected */
@Override // io.grpc.internal.InUseStateAggregator
public void handleNotInUse() {
if (!ManagedChannelImpl.this.shutdown.get()) {
ManagedChannelImpl.this.rescheduleIdleTimer();
}
}
}
/* access modifiers changed from: private */
public static final class ExecutorHolder {
private Executor executor;
private final ObjectPool<? extends Executor> pool;
ExecutorHolder(ObjectPool<? extends Executor> objectPool) {
this.pool = (ObjectPool) Preconditions.checkNotNull(objectPool, "executorPool");
}
/* access modifiers changed from: package-private */
public synchronized Executor getExecutor() {
if (this.executor == null) {
this.executor = (Executor) Preconditions.checkNotNull(this.pool.getObject(), "%s.getObject()", this.executor);
}
return this.executor;
}
/* access modifiers changed from: package-private */
public synchronized void release() {
if (this.executor != null) {
this.executor = (Executor) this.pool.returnObject(this.executor);
}
}
}
/* access modifiers changed from: private */
public static final class RestrictedScheduledExecutor implements ScheduledExecutorService {
final ScheduledExecutorService delegate;
private RestrictedScheduledExecutor(ScheduledExecutorService scheduledExecutorService) {
this.delegate = (ScheduledExecutorService) Preconditions.checkNotNull(scheduledExecutorService, "delegate");
}
@Override // java.util.concurrent.ScheduledExecutorService
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long j, TimeUnit timeUnit) {
return this.delegate.schedule(callable, j, timeUnit);
}
@Override // java.util.concurrent.ScheduledExecutorService
public ScheduledFuture<?> schedule(Runnable runnable, long j, TimeUnit timeUnit) {
return this.delegate.schedule(runnable, j, timeUnit);
}
@Override // java.util.concurrent.ScheduledExecutorService
public ScheduledFuture<?> scheduleAtFixedRate(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
return this.delegate.scheduleAtFixedRate(runnable, j, j2, timeUnit);
}
@Override // java.util.concurrent.ScheduledExecutorService
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
return this.delegate.scheduleWithFixedDelay(runnable, j, j2, timeUnit);
}
@Override // java.util.concurrent.ExecutorService
public boolean awaitTermination(long j, TimeUnit timeUnit) throws InterruptedException {
return this.delegate.awaitTermination(j, timeUnit);
}
@Override // java.util.concurrent.ExecutorService
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> collection) throws InterruptedException {
return this.delegate.invokeAll(collection);
}
@Override // java.util.concurrent.ExecutorService
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> collection, long j, TimeUnit timeUnit) throws InterruptedException {
return this.delegate.invokeAll(collection, j, timeUnit);
}
@Override // java.util.concurrent.ExecutorService
public <T> T invokeAny(Collection<? extends Callable<T>> collection) throws InterruptedException, ExecutionException {
return (T) this.delegate.invokeAny(collection);
}
@Override // java.util.concurrent.ExecutorService
public <T> T invokeAny(Collection<? extends Callable<T>> collection, long j, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
return (T) this.delegate.invokeAny(collection, j, timeUnit);
}
public boolean isShutdown() {
return this.delegate.isShutdown();
}
public boolean isTerminated() {
return this.delegate.isTerminated();
}
public void shutdown() {
throw new UnsupportedOperationException("Restricted: shutdown() is not allowed");
}
@Override // java.util.concurrent.ExecutorService
public List<Runnable> shutdownNow() {
throw new UnsupportedOperationException("Restricted: shutdownNow() is not allowed");
}
@Override // java.util.concurrent.ExecutorService
public <T> Future<T> submit(Callable<T> callable) {
return this.delegate.submit(callable);
}
@Override // java.util.concurrent.ExecutorService
public Future<?> submit(Runnable runnable) {
return this.delegate.submit(runnable);
}
@Override // java.util.concurrent.ExecutorService
public <T> Future<T> submit(Runnable runnable, T t) {
return this.delegate.submit(runnable, t);
}
public void execute(Runnable runnable) {
this.delegate.execute(runnable);
}
}
static final class ScParser extends NameResolver.ServiceConfigParser {
private final AutoConfiguredLoadBalancerFactory autoLoadBalancerFactory;
private final ChannelLogger channelLogger;
private final int maxHedgedAttemptsLimit;
private final int maxRetryAttemptsLimit;
private final boolean retryEnabled;
ScParser(boolean z, int i, int i2, AutoConfiguredLoadBalancerFactory autoConfiguredLoadBalancerFactory, ChannelLogger channelLogger2) {
this.retryEnabled = z;
this.maxRetryAttemptsLimit = i;
this.maxHedgedAttemptsLimit = i2;
this.autoLoadBalancerFactory = (AutoConfiguredLoadBalancerFactory) Preconditions.checkNotNull(autoConfiguredLoadBalancerFactory, "autoLoadBalancerFactory");
this.channelLogger = (ChannelLogger) Preconditions.checkNotNull(channelLogger2, "channelLogger");
}
@Override // io.grpc.NameResolver.ServiceConfigParser
public NameResolver.ConfigOrError parseServiceConfig(Map<String, ?> map) {
Object obj;
try {
NameResolver.ConfigOrError parseLoadBalancerPolicy = this.autoLoadBalancerFactory.parseLoadBalancerPolicy(map, this.channelLogger);
if (parseLoadBalancerPolicy == null) {
obj = null;
} else if (parseLoadBalancerPolicy.getError() != null) {
return NameResolver.ConfigOrError.fromError(parseLoadBalancerPolicy.getError());
} else {
obj = parseLoadBalancerPolicy.getConfig();
}
return NameResolver.ConfigOrError.fromConfig(ManagedChannelServiceConfig.fromServiceConfig(map, this.retryEnabled, this.maxRetryAttemptsLimit, this.maxHedgedAttemptsLimit, obj));
} catch (RuntimeException e) {
return NameResolver.ConfigOrError.fromError(Status.UNKNOWN.withDescription("failed to parse service config").withCause(e));
}
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void logWarningIfNotInSyncContext(String str) {
try {
this.syncContext.throwIfNotInThisSynchronizationContext();
} catch (IllegalStateException e) {
Logger logger2 = logger;
Level level = Level.WARNING;
logger2.log(level, str + " should be called from SynchronizationContext. This warning will become an exception in a future release. See https://github.com/grpc/grpc-java/issues/5015 for more details", (Throwable) e);
}
}
/* access modifiers changed from: private */
public static final class ServiceConfigHolder {
ManagedChannelServiceConfig managedChannelServiceConfig;
Map<String, ?> rawServiceConfig;
ServiceConfigHolder(Map<String, ?> map, ManagedChannelServiceConfig managedChannelServiceConfig2) {
this.rawServiceConfig = (Map) Preconditions.checkNotNull(map, "rawServiceConfig");
this.managedChannelServiceConfig = (ManagedChannelServiceConfig) Preconditions.checkNotNull(managedChannelServiceConfig2, "managedChannelServiceConfig");
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
ServiceConfigHolder serviceConfigHolder = (ServiceConfigHolder) obj;
if (!Objects.equal(this.rawServiceConfig, serviceConfigHolder.rawServiceConfig) || !Objects.equal(this.managedChannelServiceConfig, serviceConfigHolder.managedChannelServiceConfig)) {
return false;
}
return true;
}
public int hashCode() {
return Objects.hashCode(this.rawServiceConfig, this.managedChannelServiceConfig);
}
public String toString() {
return MoreObjects.toStringHelper(this).add("rawServiceConfig", this.rawServiceConfig).add("managedChannelServiceConfig", this.managedChannelServiceConfig).toString();
}
}
}