SpeedCash v6.5.1482 - LoadBalancerRegistry.java 源代码

package io.grpc;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import io.grpc.ServiceProviders;
import io.grpc.internal.PickFirstLoadBalancerProvider;
import io.grpc.util.SecretRoundRobinLoadBalancerProvider;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;

@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
@ThreadSafe
public final class LoadBalancerRegistry {
    public static LoadBalancerRegistry d;
    public final LinkedHashSet<LoadBalancerProvider> a = new LinkedHashSet<>();
    public final LinkedHashMap<String, LoadBalancerProvider> b = new LinkedHashMap<>();
    public static final Logger c = Logger.getLogger(LoadBalancerRegistry.class.getName());
    public static final Iterable<Class<?>> e = b();

    public static final class a implements ServiceProviders.PriorityAccessor<LoadBalancerProvider> {
        @Override
        public int getPriority(LoadBalancerProvider loadBalancerProvider) {
            return loadBalancerProvider.getPriority();
        }

        @Override
        public boolean isAvailable(LoadBalancerProvider loadBalancerProvider) {
            return loadBalancerProvider.isAvailable();
        }
    }

    @VisibleForTesting
    public static List<Class<?>> b() {
        ArrayList arrayList = new ArrayList();
        try {
            int i = PickFirstLoadBalancerProvider.b;
            arrayList.add(PickFirstLoadBalancerProvider.class);
        } catch (ClassNotFoundException e2) {
            c.log(Level.WARNING, "Unable to find pick-first LoadBalancer", (Throwable) e2);
        }
        try {
            int i2 = SecretRoundRobinLoadBalancerProvider.Provider.b;
            arrayList.add(SecretRoundRobinLoadBalancerProvider.Provider.class);
        } catch (ClassNotFoundException e3) {
            c.log(Level.FINE, "Unable to find round-robin LoadBalancer", (Throwable) e3);
        }
        return Collections.unmodifiableList(arrayList);
    }

    public static synchronized LoadBalancerRegistry getDefaultRegistry() {
        LoadBalancerRegistry loadBalancerRegistry;
        synchronized (LoadBalancerRegistry.class) {
            if (d == null) {
                List<LoadBalancerProvider> f = ServiceProviders.f(LoadBalancerProvider.class, e, LoadBalancerProvider.class.getClassLoader(), new a());
                d = new LoadBalancerRegistry();
                for (LoadBalancerProvider loadBalancerProvider : f) {
                    c.fine("Service loader found " + loadBalancerProvider);
                    d.a(loadBalancerProvider);
                }
                d.c();
            }
            loadBalancerRegistry = d;
        }
        return loadBalancerRegistry;
    }

    public final synchronized void a(LoadBalancerProvider loadBalancerProvider) {
        Preconditions.checkArgument(loadBalancerProvider.isAvailable(), "isAvailable() returned false");
        this.a.add(loadBalancerProvider);
    }

    public final synchronized void c() {
        this.b.clear();
        Iterator<LoadBalancerProvider> it = this.a.iterator();
        while (it.hasNext()) {
            LoadBalancerProvider next = it.next();
            String policyName = next.getPolicyName();
            LoadBalancerProvider loadBalancerProvider = this.b.get(policyName);
            if (loadBalancerProvider == null || loadBalancerProvider.getPriority() < next.getPriority()) {
                this.b.put(policyName, next);
            }
        }
    }

    public synchronized void deregister(LoadBalancerProvider loadBalancerProvider) {
        this.a.remove(loadBalancerProvider);
        c();
    }

    @Nullable
    public synchronized LoadBalancerProvider getProvider(String str) {
        return this.b.get(Preconditions.checkNotNull(str, "policy"));
    }

    public synchronized void register(LoadBalancerProvider loadBalancerProvider) {
        a(loadBalancerProvider);
        c();
    }
}