import com.subgraph.orchid.InternalCircuit; //导入依赖的package包/类
public CircuitManagerImpl(TorConfig config, DirectoryDownloaderImpl directoryDownloader, Directory directory, ConnectionCache connectionCache, TorInitializationTracker initializationTracker) {
	this.config = config;
	this.directory = directory;
	this.connectionCache = connectionCache;
	this.pathChooser = CircuitPathChooser.create(config, directory);
	if(config.getUseEntryGuards() || config.getUseBridges()) {
		this.pathChooser.enableEntryGuards(new EntryGuards(config, connectionCache, directoryDownloader, directory));
	}
	this.pendingExitStreams = new PendingExitStreams(config);
	this.circuitCreationTask = new CircuitCreationTask(config, directory, connectionCache, pathChooser, this, initializationTracker);
	this.activeCircuits = new HashSet<CircuitImpl>();
	this.cleanInternalCircuits = new LinkedList<InternalCircuit>();
	this.random = new TorRandom();
	
	this.initializationTracker = initializationTracker;
	this.hiddenServiceManager = new HiddenServiceManager(config, directory, this);
	
	directoryDownloader.setCircuitManager(this);
}
 

import com.subgraph.orchid.InternalCircuit; //导入依赖的package包/类
public InternalCircuit getCleanInternalCircuit() throws InterruptedException {
	synchronized(cleanInternalCircuits) {
		try {
			requestedInternalCircuitCount += 1;
			while(cleanInternalCircuits.isEmpty()) {
				cleanInternalCircuits.wait();
			}
			return cleanInternalCircuits.remove();
		} finally {
			requestedInternalCircuitCount -= 1;
		}
	}
}
 

import com.subgraph.orchid.InternalCircuit; //导入依赖的package包/类
void addCleanInternalCircuit(InternalCircuit circuit) {
	synchronized(cleanInternalCircuits) {
		pendingInternalCircuitCount -= 1;
		cleanInternalCircuits.add(circuit);
		cleanInternalCircuits.notifyAll();
	}
}
 

import com.subgraph.orchid.InternalCircuit; //导入依赖的package包/类
public InternalCircuit openInternalCircuitTo(List<Router> path) throws OpenFailedException {
	final InternalCircuit circuit = CircuitImpl.createInternalCircuitTo(this, path);
	if(!tryOpenCircuit(circuit, false, false)) {
		throw new OpenFailedException("Could not create internal circuit for path");
	}
	return circuit;
}
 

import com.subgraph.orchid.InternalCircuit; //导入依赖的package包/类
public HiddenServiceCircuit call() throws Exception {
	
	logger.fine("Opening rendezvous circuit for "+ logServiceName());
	
	final InternalCircuit rendezvous = circuitManager.getCleanInternalCircuit();
	logger.fine("Establishing rendezvous for "+ logServiceName());
	RendezvousProcessor rp = new RendezvousProcessor(rendezvous);
	if(!rp.establishRendezvous()) {
		rendezvous.markForClose();
		return null;
	}
	logger.fine("Opening introduction circuit for "+ logServiceName());
	final IntroductionProcessor introductionProcessor = openIntroduction();
	if(introductionProcessor == null) {
		logger.info("Failed to open connection to any introduction point");
		rendezvous.markForClose();
		return null;
	}
	logger.fine("Sending introduce cell for "+ logServiceName());
	final TorTapKeyAgreement kex = new TorTapKeyAgreement();
	final boolean icResult = introductionProcessor.sendIntroduce(introductionProcessor.getServiceKey(), kex.getPublicKeyBytes(), rp.getCookie(), rp.getRendezvousRouter());
	introductionProcessor.markCircuitForClose();
	if(!icResult) {
		rendezvous.markForClose();
		return null;
	}
	logger.fine("Processing RV2 for "+ logServiceName());
	HiddenServiceCircuit hsc = rp.processRendezvous2(kex);
	if(hsc == null) {
		rendezvous.markForClose();
	}

	logger.fine("Rendezvous circuit opened for "+ logServiceName());
	
	return hsc;
}
 

import com.subgraph.orchid.InternalCircuit; //导入依赖的package包/类
static InternalCircuit createInternalCircuitTo(CircuitManagerImpl circuitManager, List<Router> prechosenPath) {
	return new InternalCircuitImpl(circuitManager, prechosenPath);
}
 

import com.subgraph.orchid.InternalCircuit; //导入依赖的package包/类
protected RendezvousProcessor(InternalCircuit circuit) {
	this.circuit = circuit;
	this.cookie = random.getBytes(RENDEZVOUS_COOKIE_LEN);
}