import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
public boolean canHandleExitTo(ExitTarget target) {
	synchronized(failedExitRequests) {
		if(failedExitRequests.contains(target)) {
			return false;
		}
	}
	
	if(isMarkedForClose()) {
		return false;
	}

	if(target.isAddressTarget()) {
		return exitRouter.exitPolicyAccepts(target.getAddress(), target.getPort());
	} else {
		return exitRouter.exitPolicyAccepts(target.getPort());
	}
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private void buildCircuitIfNeeded() {
	if (connectionCache.isClosed()) {
		logger.warning("Not building circuits, because connection cache is closed");
		return;
	}

	final List<StreamExitRequest> pendingExitStreams = circuitManager.getPendingExitStreams();
	final List<PredictedPortTarget> predictedPorts = predictor.getPredictedPortTargets();
	final List<ExitTarget> exitTargets = new ArrayList<ExitTarget>();
	for(StreamExitRequest streamRequest: pendingExitStreams) {
		if(!streamRequest.isReserved() && countCircuitsSupportingTarget(streamRequest, false) == 0) {
			exitTargets.add(streamRequest);
		}
	}
	for(PredictedPortTarget ppt: predictedPorts) {
		if(countCircuitsSupportingTarget(ppt, true) < 2) {
			exitTargets.add(ppt);
		}
	}
	buildCircuitToHandleExitTargets(exitTargets);
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private void buildCircuitIfNeeded() {
	final List<StreamExitRequest> pendingExitStreams = circuitManager.getPendingExitStreams();
	final List<PredictedPortTarget> predictedPorts = predictor.getPredictedPortTargets();
	final List<ExitTarget> exitTargets = new ArrayList<ExitTarget>();
	for(StreamExitRequest streamRequest: pendingExitStreams) {
		if(!streamRequest.isReserved() && countCircuitsSupportingTarget(streamRequest, false) == 0) {
			exitTargets.add(streamRequest);
		}
	}
	for(PredictedPortTarget ppt: predictedPorts) {
		if(countCircuitsSupportingTarget(ppt, true) < 2) {
			exitTargets.add(ppt);
		}
	}
	buildCircuitToHandleExitTargets(exitTargets);
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private int countCircuitsSupportingTarget(final ExitTarget target, final boolean needClean) {
	final CircuitFilter filter = new CircuitFilter() {
		public boolean filter(Circuit circuit) {
			if(!(circuit instanceof ExitCircuit)) {
				return false;
			}
			final ExitCircuit ec = (ExitCircuit) circuit;
			final boolean pendingOrConnected = circuit.isPending() || circuit.isConnected();
			final boolean isCleanIfNeeded = !(needClean && !circuit.isClean());
			return pendingOrConnected && isCleanIfNeeded && ec.canHandleExitTo(target);
		}
	};
	return circuitManager.getCircuitsByFilter(filter).size();
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private void buildCircuitToHandleExitTargets(List<ExitTarget> exitTargets) {
	if(exitTargets.isEmpty()) {
		return;
	}
	if(!directory.haveMinimumRouterInfo()) 
		return;
	if(circuitManager.getPendingCircuitCount() >= MAX_PENDING_CIRCUITS)
		return;

	if(logger.isLoggable(Level.FINE)) { 
		logger.fine("Building new circuit to handle "+ exitTargets.size() +" pending streams and predicted ports");
	}

	launchBuildTaskForTargets(exitTargets);
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private void launchBuildTaskForTargets(List<ExitTarget> exitTargets) {
	final Router exitRouter = pathChooser.chooseExitNodeForTargets(exitTargets);
	if(exitRouter == null) {
		logger.warning("Failed to select suitable exit node for targets");
		return;
	}
	
	final Circuit circuit = circuitManager.createNewExitCircuit(exitRouter);
	final CircuitCreationRequest request = new CircuitCreationRequest(pathChooser, circuit, buildHandler, false);
	final CircuitBuildTask task = new  CircuitBuildTask(request, connectionCache, circuitManager.isNtorEnabled(), initializationTracker);
	executor.execute(task);
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private List<Router> filterForExitTargets(List<Router> routers, List<ExitTarget> exitTargets) {
	int bestSupport = 0;
	if(exitTargets.isEmpty()) {
		return routers;
	}
	
	final int[] nSupport = new int[routers.size()];
	
	for(int i = 0; i < routers.size(); i++) {
		final Router r = routers.get(i);
		nSupport[i] = countTargetSupport(r, exitTargets);
		if(nSupport[i] > bestSupport) {
			bestSupport = nSupport[i];
		}
	}
	
	if(bestSupport == 0) {
		return routers;
	}

	final List<Router> results = new ArrayList<Router>();
	for(int i = 0; i < routers.size(); i++) {
		if(nSupport[i] == bestSupport) {
			results.add(routers.get(i));
		}
	}
	return results;
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private int countTargetSupport(Router router, List<ExitTarget> targets) {
	int count = 0;
	for(ExitTarget t: targets) {
		if(routerSupportsTarget(router, t)) {
			count += 1;
		}
	}
	return count;
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
private boolean routerSupportsTarget(Router router, ExitTarget target) {
	if(target.isAddressTarget()) {
		return router.exitPolicyAccepts(target.getAddress(), target.getPort());
	} else {
		return router.exitPolicyAccepts(target.getPort());
	}
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
@Override
public InetSocketAddress[] getPeers(long timeoutValue, TimeUnit timeoutUnit) throws PeerDiscoveryException {
    if (hostNames == null)
        throw new PeerDiscoveryException("Unable to find any peers via DNS");

    Set<Router> routers = Sets.newHashSet();
    ArrayList<ExitTarget> dummyTargets = Lists.newArrayList();

    // Collect exit nodes until we have enough
    while (routers.size() < ROUTER_LOOKUP_COUNT) {
        Router router = pathChooser.chooseExitNodeForTargets(dummyTargets);
        routers.add(router);
    }

    try {
        List<Circuit> circuits =
            getCircuits(torClient.getConfig().getCircuitBuildTimeout(), TimeUnit.MILLISECONDS, routers);
        if (circuits.isEmpty())
            throw new PeerDiscoveryException("Failed to open any circuit within " +
                                             String.valueOf(timeoutValue) + " " + timeoutUnit);

        Collection<InetSocketAddress> addresses = lookupAddresses(timeoutValue, timeoutUnit, circuits);

        if (addresses.size() < MINIMUM_ROUTER_COUNT)
            throw new PeerDiscoveryException("Unable to find enough peers via Tor - got " + addresses.size());
        ArrayList<InetSocketAddress> addressList = Lists.newArrayList();
        addressList.addAll(addresses);
        Collections.shuffle(addressList);
        return addressList.toArray(new InetSocketAddress[addressList.size()]);
    } catch (InterruptedException e) {
        throw new PeerDiscoveryException(e);
    }
}
 

import com.subgraph.orchid.data.exitpolicy.ExitTarget; //导入依赖的package包/类
public InetSocketAddress[] getPeers(long timeoutValue, TimeUnit timeoutUnit) throws PeerDiscoveryException {
    if (hostNames == null)
        throw new PeerDiscoveryException("Unable to find any peers via DNS");

    Set<Router> routers = Sets.newHashSet();
    ArrayList<ExitTarget> dummyTargets = Lists.newArrayList();

    // Collect exit nodes until we have enough
    while (routers.size() < MINIMUM_ROUTER_LOOKUP_COUNT) {
        Router router = pathChooser.chooseExitNodeForTargets(dummyTargets);
        routers.add(router);
    }

    try {
        List<Circuit> circuits = getCircuits(timeoutValue, timeoutUnit, routers);

        Collection<InetSocketAddress> addresses = lookupAddresses(timeoutValue, timeoutUnit, circuits);

        if (addresses.size() < MINIMUM_ROUTER_COUNT)
            throw new PeerDiscoveryException("Unable to find enough peers via Tor - got " + addresses.size());
        ArrayList<InetSocketAddress> addressList = Lists.newArrayList();
        addressList.addAll(addresses);
        Collections.shuffle(addressList);
        return addressList.toArray(new InetSocketAddress[addressList.size()]);
    } catch (InterruptedException e) {
        throw new PeerDiscoveryException(e);
    }
}