SpeedCash v6.5.1482 - GracefulSwitchLoadBalancer.java 源代码

package io.grpc.util;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import io.grpc.ConnectivityState;
import io.grpc.ConnectivityStateInfo;
import io.grpc.ExperimentalApi;
import io.grpc.LoadBalancer;
import io.grpc.Status;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;

@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5999")
@NotThreadSafe
public final class GracefulSwitchLoadBalancer extends ForwardingLoadBalancer {

    @VisibleForTesting
    public static final LoadBalancer.SubchannelPicker k = new c();
    public final LoadBalancer b;
    public final LoadBalancer.Helper c;

    @Nullable
    public LoadBalancer.Factory d;
    public LoadBalancer e;

    @Nullable
    public LoadBalancer.Factory f;
    public LoadBalancer g;
    public ConnectivityState h;
    public LoadBalancer.SubchannelPicker i;
    public boolean j;

    public class a extends LoadBalancer {

        public class C0020a extends LoadBalancer.SubchannelPicker {
            public final Status a;

            public C0020a(Status status) {
                this.a = status;
            }

            public LoadBalancer.PickResult pickSubchannel(LoadBalancer.PickSubchannelArgs pickSubchannelArgs) {
                return LoadBalancer.PickResult.withError(this.a);
            }

            public String toString() {
                return MoreObjects.toStringHelper(C0020a.class).add("error", this.a).toString();
            }
        }

        public a() {
        }

        public void handleNameResolutionError(Status status) {
            GracefulSwitchLoadBalancer.this.c.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, new C0020a(status));
        }

        public void handleResolvedAddresses(LoadBalancer.ResolvedAddresses resolvedAddresses) {
            throw new IllegalStateException("GracefulSwitchLoadBalancer must switch to a load balancing policy before handling ResolvedAddresses");
        }

        public void shutdown() {
        }
    }

    public class b extends ForwardingLoadBalancerHelper {
        public LoadBalancer a;

        public b() {
        }

        @Override
        public LoadBalancer.Helper delegate() {
            return GracefulSwitchLoadBalancer.this.c;
        }

        @Override
        public void updateBalancingState(ConnectivityState connectivityState, LoadBalancer.SubchannelPicker subchannelPicker) {
            if (this.a == GracefulSwitchLoadBalancer.this.g) {
                Preconditions.checkState(GracefulSwitchLoadBalancer.this.j, "there's pending lb while current lb has been out of READY");
                GracefulSwitchLoadBalancer.this.h = connectivityState;
                GracefulSwitchLoadBalancer.this.i = subchannelPicker;
                if (connectivityState == ConnectivityState.READY) {
                    GracefulSwitchLoadBalancer.this.j();
                    return;
                }
                return;
            }
            if (this.a == GracefulSwitchLoadBalancer.this.e) {
                GracefulSwitchLoadBalancer.this.j = connectivityState == ConnectivityState.READY;
                if (GracefulSwitchLoadBalancer.this.j || GracefulSwitchLoadBalancer.this.g == GracefulSwitchLoadBalancer.this.b) {
                    GracefulSwitchLoadBalancer.this.c.updateBalancingState(connectivityState, subchannelPicker);
                } else {
                    GracefulSwitchLoadBalancer.this.j();
                }
            }
        }
    }

    public class c extends LoadBalancer.SubchannelPicker {
        public LoadBalancer.PickResult pickSubchannel(LoadBalancer.PickSubchannelArgs pickSubchannelArgs) {
            return LoadBalancer.PickResult.withNoResult();
        }

        public String toString() {
            return "BUFFER_PICKER";
        }
    }

    public GracefulSwitchLoadBalancer(LoadBalancer.Helper helper) {
        a aVar = new a();
        this.b = aVar;
        this.e = aVar;
        this.g = aVar;
        this.c = (LoadBalancer.Helper) Preconditions.checkNotNull(helper, "helper");
    }

    @Override
    public LoadBalancer delegate() {
        LoadBalancer loadBalancer = this.g;
        return loadBalancer == this.b ? this.e : loadBalancer;
    }

    @Override
    @Deprecated
    public void handleSubchannelState(LoadBalancer.Subchannel subchannel, ConnectivityStateInfo connectivityStateInfo) {
        throw new UnsupportedOperationException("handleSubchannelState() is not supported by " + GracefulSwitchLoadBalancer.class.getName());
    }

    public final void j() {
        this.c.updateBalancingState(this.h, this.i);
        this.e.shutdown();
        this.e = this.g;
        this.d = this.f;
        this.g = this.b;
        this.f = null;
    }

    @Override
    public void shutdown() {
        this.g.shutdown();
        this.e.shutdown();
    }

    public void switchTo(LoadBalancer.Factory factory) {
        Preconditions.checkNotNull(factory, "newBalancerFactory");
        if (factory.equals(this.f)) {
            return;
        }
        this.g.shutdown();
        this.g = this.b;
        this.f = null;
        this.h = ConnectivityState.CONNECTING;
        this.i = k;
        if (factory.equals(this.d)) {
            return;
        }
        b bVar = new b();
        LoadBalancer newLoadBalancer = factory.newLoadBalancer(bVar);
        bVar.a = newLoadBalancer;
        this.g = newLoadBalancer;
        this.f = factory;
        if (this.j) {
            return;
        }
        j();
    }
}