what-the-bank/sources/io/grpc/internal/DelayedClientCall.java

578 lines
21 KiB
Java

package io.grpc.internal;
import com.google.android.gms.common.internal.ServiceSpecificExtraArgs;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import io.grpc.Attributes;
import io.grpc.ClientCall;
import io.grpc.Context;
import io.grpc.Deadline;
import io.grpc.Metadata;
import io.grpc.Status;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
/* loaded from: classes6.dex */
public class DelayedClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
static final boolean $assertionsDisabled = false;
private final Executor callExecutor;
private final Context context;
private DelayedListener<RespT> delayedListener;
private Status error;
private final ScheduledFuture<?> initialDeadlineMonitor;
private ClientCall.Listener<RespT> listener;
private volatile boolean passThrough;
private List<Runnable> pendingRunnables = new ArrayList();
private ClientCall<ReqT, RespT> realCall;
private static final Logger logger = Logger.getLogger(DelayedClientCall.class.getName());
private static final ClientCall<Object, Object> NOOP_CALL = new ClientCall<Object, Object>() { // from class: io.grpc.internal.DelayedClientCall.7
@Override // io.grpc.ClientCall
public void cancel(String str, Throwable th) {
}
@Override // io.grpc.ClientCall
public void halfClose() {
}
@Override // io.grpc.ClientCall
public boolean isReady() {
return false;
}
@Override // io.grpc.ClientCall
public void request(int i) {
}
@Override // io.grpc.ClientCall
public void sendMessage(Object obj) {
}
@Override // io.grpc.ClientCall
public void start(ClientCall.Listener<Object> listener, Metadata metadata) {
}
};
/* JADX INFO: Access modifiers changed from: protected */
public void callCancelled() {
}
/* JADX INFO: Access modifiers changed from: protected */
public DelayedClientCall(Executor executor, ScheduledExecutorService scheduledExecutorService, Deadline deadline) {
this.callExecutor = (Executor) Preconditions.checkNotNull(executor, "callExecutor");
Preconditions.checkNotNull(scheduledExecutorService, "scheduler");
this.context = Context.current();
this.initialDeadlineMonitor = scheduleDeadlineIfNeeded(scheduledExecutorService, deadline);
}
private ScheduledFuture<?> scheduleDeadlineIfNeeded(ScheduledExecutorService scheduledExecutorService, Deadline deadline) {
Deadline deadline2 = this.context.getDeadline();
if (deadline == null && deadline2 == null) {
return null;
}
long min = deadline != null ? Math.min(Long.MAX_VALUE, deadline.timeRemaining(TimeUnit.NANOSECONDS)) : Long.MAX_VALUE;
if (deadline2 != null && deadline2.timeRemaining(TimeUnit.NANOSECONDS) < min) {
min = deadline2.timeRemaining(TimeUnit.NANOSECONDS);
Logger logger2 = logger;
if (logger2.isLoggable(Level.FINE)) {
StringBuilder sb = new StringBuilder(String.format("Call timeout set to '%d' ns, due to context deadline.", Long.valueOf(min)));
if (deadline == null) {
sb.append(" Explicit call timeout was not set.");
} else {
sb.append(String.format(" Explicit call timeout was '%d' ns.", Long.valueOf(deadline.timeRemaining(TimeUnit.NANOSECONDS))));
}
logger2.fine(sb.toString());
}
}
long abs = Math.abs(min) / TimeUnit.SECONDS.toNanos(1L);
long abs2 = Math.abs(min);
long nanos = TimeUnit.SECONDS.toNanos(1L);
StringBuilder sb2 = new StringBuilder();
if (min < 0) {
sb2.append("ClientCall started after deadline exceeded. Deadline exceeded after -");
} else {
sb2.append("Deadline exceeded after ");
}
sb2.append(abs);
sb2.append(String.format(Locale.US, ".%09d", Long.valueOf(abs2 % nanos)));
sb2.append("s. ");
return scheduledExecutorService.schedule(new Runnable(this, sb2) { // from class: io.grpc.internal.DelayedClientCall.1DeadlineExceededRunnable
final DelayedClientCall this$0;
final StringBuilder val$buf;
{
this.this$0 = this;
this.val$buf = sb2;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.cancel(Status.DEADLINE_EXCEEDED.withDescription(this.val$buf.toString()), true);
}
}, min, TimeUnit.NANOSECONDS);
}
public final void setCall(ClientCall<ReqT, RespT> clientCall) {
synchronized (this) {
if (this.realCall != null) {
return;
}
setRealCall((ClientCall) Preconditions.checkNotNull(clientCall, "call"));
drainPendingCalls();
}
}
@Override // io.grpc.ClientCall
public final void start(ClientCall.Listener<RespT> listener, Metadata metadata) {
Status status;
boolean z;
Preconditions.checkState(this.listener == null, "already started");
synchronized (this) {
this.listener = (ClientCall.Listener) Preconditions.checkNotNull(listener, ServiceSpecificExtraArgs.CastExtraArgs.LISTENER);
status = this.error;
z = this.passThrough;
if (!z) {
DelayedListener<RespT> delayedListener = new DelayedListener<>(listener);
this.delayedListener = delayedListener;
listener = delayedListener;
}
}
if (status != null) {
this.callExecutor.execute(new CloseListenerRunnable(this, listener, status));
} else if (z) {
this.realCall.start(listener, metadata);
} else {
delayOrExecute(new Runnable(this, listener, metadata) { // from class: io.grpc.internal.DelayedClientCall.1
final DelayedClientCall this$0;
final ClientCall.Listener val$finalListener;
final Metadata val$headers;
{
this.this$0 = this;
this.val$finalListener = listener;
this.val$headers = metadata;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realCall.start(this.val$finalListener, this.val$headers);
}
});
}
}
@Override // io.grpc.ClientCall
public final void cancel(String str, Throwable th) {
Status withDescription;
Status status = Status.CANCELLED;
if (str != null) {
withDescription = status.withDescription(str);
} else {
withDescription = status.withDescription("Call cancelled without message");
}
if (th != null) {
withDescription = withDescription.withCause(th);
}
cancel(withDescription, false);
}
/* JADX INFO: Access modifiers changed from: private */
/* JADX WARN: Multi-variable type inference failed */
public void cancel(Status status, boolean z) {
boolean z2;
ClientCall.Listener<RespT> listener;
synchronized (this) {
if (this.realCall == null) {
setRealCall(NOOP_CALL);
listener = this.listener;
this.error = status;
z2 = false;
} else {
if (z) {
return;
}
z2 = true;
listener = null;
}
if (z2) {
delayOrExecute(new Runnable(this, status) { // from class: io.grpc.internal.DelayedClientCall.2
final DelayedClientCall this$0;
final Status val$status;
{
this.this$0 = this;
this.val$status = status;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realCall.cancel(this.val$status.getDescription(), this.val$status.getCause());
}
});
} else {
if (listener != null) {
this.callExecutor.execute(new CloseListenerRunnable(this, listener, status));
}
drainPendingCalls();
}
callCancelled();
}
}
private void delayOrExecute(Runnable runnable) {
synchronized (this) {
if (!this.passThrough) {
this.pendingRunnables.add(runnable);
} else {
runnable.run();
}
}
}
/* JADX WARN: Code restructure failed: missing block: B:10:0x0031, code lost:
if (r0.hasNext() == false) goto L24;
*/
/* JADX WARN: Code restructure failed: missing block: B:11:0x0033, code lost:
((java.lang.Runnable) r0.next()).run();
*/
/* JADX WARN: Code restructure failed: missing block: B:8:0x0029, code lost:
r0 = r1.iterator();
*/
/* JADX WARN: Multi-variable type inference failed */
/* JADX WARN: Removed duplicated region for block: B:18:0x0019 */
/* JADX WARN: Removed duplicated region for block: B:21:? A[RETURN, SYNTHETIC] */
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
private void drainPendingCalls() {
/*
r3 = this;
java.util.ArrayList r0 = new java.util.ArrayList
r0.<init>()
L5:
monitor-enter(r3)
java.util.List<java.lang.Runnable> r1 = r3.pendingRunnables // Catch: java.lang.Throwable -> L42
boolean r1 = r1.isEmpty() // Catch: java.lang.Throwable -> L42
if (r1 == 0) goto L24
r0 = 0
r3.pendingRunnables = r0 // Catch: java.lang.Throwable -> L42
r0 = 1
r3.passThrough = r0 // Catch: java.lang.Throwable -> L42
io.grpc.internal.DelayedClientCall$DelayedListener<RespT> r0 = r3.delayedListener // Catch: java.lang.Throwable -> L42
monitor-exit(r3)
if (r0 == 0) goto L23
java.util.concurrent.Executor r1 = r3.callExecutor
io.grpc.internal.DelayedClientCall$1DrainListenerRunnable r2 = new io.grpc.internal.DelayedClientCall$1DrainListenerRunnable
r2.<init>(r3, r0)
r1.execute(r2)
L23:
return
L24:
java.util.List<java.lang.Runnable> r1 = r3.pendingRunnables // Catch: java.lang.Throwable -> L42
r3.pendingRunnables = r0 // Catch: java.lang.Throwable -> L42
monitor-exit(r3)
java.util.Iterator r0 = r1.iterator()
L2d:
boolean r2 = r0.hasNext()
if (r2 == 0) goto L3d
java.lang.Object r2 = r0.next()
java.lang.Runnable r2 = (java.lang.Runnable) r2
r2.run()
goto L2d
L3d:
r1.clear()
r0 = r1
goto L5
L42:
r0 = move-exception
monitor-exit(r3)
throw r0
*/
throw new UnsupportedOperationException("Method not decompiled: io.grpc.internal.DelayedClientCall.drainPendingCalls():void");
}
private void setRealCall(ClientCall<ReqT, RespT> clientCall) {
ClientCall<ReqT, RespT> clientCall2 = this.realCall;
Preconditions.checkState(clientCall2 == null, "realCall already set to %s", clientCall2);
ScheduledFuture<?> scheduledFuture = this.initialDeadlineMonitor;
if (scheduledFuture != null) {
scheduledFuture.cancel(false);
}
this.realCall = clientCall;
}
@Override // io.grpc.ClientCall
public final void sendMessage(ReqT reqt) {
if (this.passThrough) {
this.realCall.sendMessage(reqt);
} else {
delayOrExecute(new Runnable(this, reqt) { // from class: io.grpc.internal.DelayedClientCall.3
final DelayedClientCall this$0;
final Object val$message;
{
this.this$0 = this;
this.val$message = reqt;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // java.lang.Runnable
public void run() {
this.this$0.realCall.sendMessage(this.val$message);
}
});
}
}
@Override // io.grpc.ClientCall
public final void setMessageCompression(boolean z) {
if (this.passThrough) {
this.realCall.setMessageCompression(z);
} else {
delayOrExecute(new Runnable(this, z) { // from class: io.grpc.internal.DelayedClientCall.4
final DelayedClientCall this$0;
final boolean val$enable;
{
this.this$0 = this;
this.val$enable = z;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realCall.setMessageCompression(this.val$enable);
}
});
}
}
@Override // io.grpc.ClientCall
public final void request(int i) {
if (this.passThrough) {
this.realCall.request(i);
} else {
delayOrExecute(new Runnable(this, i) { // from class: io.grpc.internal.DelayedClientCall.5
final DelayedClientCall this$0;
final int val$numMessages;
{
this.this$0 = this;
this.val$numMessages = i;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realCall.request(this.val$numMessages);
}
});
}
}
@Override // io.grpc.ClientCall
public final void halfClose() {
delayOrExecute(new Runnable(this) { // from class: io.grpc.internal.DelayedClientCall.6
final DelayedClientCall this$0;
{
this.this$0 = this;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realCall.halfClose();
}
});
}
@Override // io.grpc.ClientCall
public final boolean isReady() {
if (this.passThrough) {
return this.realCall.isReady();
}
return false;
}
@Override // io.grpc.ClientCall
public final Attributes getAttributes() {
ClientCall<ReqT, RespT> clientCall;
synchronized (this) {
clientCall = this.realCall;
}
if (clientCall != null) {
return clientCall.getAttributes();
}
return Attributes.EMPTY;
}
public String toString() {
return MoreObjects.toStringHelper(this).add("realCall", this.realCall).toString();
}
/* JADX INFO: Access modifiers changed from: package-private */
/* loaded from: classes6.dex */
public final class CloseListenerRunnable extends ContextRunnable {
final ClientCall.Listener<RespT> listener;
final Status status;
final DelayedClientCall this$0;
/* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
CloseListenerRunnable(DelayedClientCall delayedClientCall, ClientCall.Listener<RespT> listener, Status status) {
super(delayedClientCall.context);
this.this$0 = delayedClientCall;
this.listener = listener;
this.status = status;
}
@Override // io.grpc.internal.ContextRunnable
public final void runInContext() {
this.listener.onClose(this.status, new Metadata());
}
}
/* JADX INFO: Access modifiers changed from: package-private */
/* loaded from: classes6.dex */
public static final class DelayedListener<RespT> extends ClientCall.Listener<RespT> {
static final boolean $assertionsDisabled = false;
private volatile boolean passThrough;
private List<Runnable> pendingCallbacks = new ArrayList();
private final ClientCall.Listener<RespT> realListener;
public DelayedListener(ClientCall.Listener<RespT> listener) {
this.realListener = listener;
}
private void delayOrExecute(Runnable runnable) {
synchronized (this) {
if (!this.passThrough) {
this.pendingCallbacks.add(runnable);
} else {
runnable.run();
}
}
}
@Override // io.grpc.ClientCall.Listener
public final void onHeaders(Metadata metadata) {
if (this.passThrough) {
this.realListener.onHeaders(metadata);
} else {
delayOrExecute(new Runnable(this, metadata) { // from class: io.grpc.internal.DelayedClientCall.DelayedListener.1
final DelayedListener this$0;
final Metadata val$headers;
{
this.this$0 = this;
this.val$headers = metadata;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realListener.onHeaders(this.val$headers);
}
});
}
}
@Override // io.grpc.ClientCall.Listener
public final void onMessage(RespT respt) {
if (this.passThrough) {
this.realListener.onMessage(respt);
} else {
delayOrExecute(new Runnable(this, respt) { // from class: io.grpc.internal.DelayedClientCall.DelayedListener.2
final DelayedListener this$0;
final Object val$message;
{
this.this$0 = this;
this.val$message = respt;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realListener.onMessage(this.val$message);
}
});
}
}
@Override // io.grpc.ClientCall.Listener
public final void onClose(Status status, Metadata metadata) {
delayOrExecute(new Runnable(this, status, metadata) { // from class: io.grpc.internal.DelayedClientCall.DelayedListener.3
final DelayedListener this$0;
final Status val$status;
final Metadata val$trailers;
{
this.this$0 = this;
this.val$status = status;
this.val$trailers = metadata;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realListener.onClose(this.val$status, this.val$trailers);
}
});
}
@Override // io.grpc.ClientCall.Listener
public final void onReady() {
if (this.passThrough) {
this.realListener.onReady();
} else {
delayOrExecute(new Runnable(this) { // from class: io.grpc.internal.DelayedClientCall.DelayedListener.4
final DelayedListener this$0;
{
this.this$0 = this;
}
@Override // java.lang.Runnable
public void run() {
this.this$0.realListener.onReady();
}
});
}
}
/* JADX WARN: Multi-variable type inference failed */
final void drainPendingCallbacks() {
List list;
List arrayList = new ArrayList();
while (true) {
synchronized (this) {
if (this.pendingCallbacks.isEmpty()) {
this.pendingCallbacks = null;
this.passThrough = true;
return;
} else {
list = this.pendingCallbacks;
this.pendingCallbacks = arrayList;
}
}
Iterator it = list.iterator();
while (it.hasNext()) {
((Runnable) it.next()).run();
}
list.clear();
arrayList = list;
}
}
}
final ClientCall<ReqT, RespT> getRealCall() {
return this.realCall;
}
}