import com.subgraph.orchid.TorConfig; //导入依赖的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.TorConfig; //导入依赖的package包/类
public ConnectionImpl(TorConfig config, SSLSocket socket, Router router, TorInitializationTracker tracker, boolean isDirectoryConnection) {
	this.config = config;
	this.socket = socket;
	this.router = router;
	this.circuitMap = new HashMap<Integer, Circuit>();
	this.readCellsThread = new Thread(createReadCellsRunnable());
	this.readCellsThread.setDaemon(true);
	this.connectionControlCells = new LinkedBlockingQueue<Cell>();
	this.initializationTracker = tracker;
	this.isDirectoryConnection = isDirectoryConnection;
	initializeCurrentCircuitId();
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
static ConnectionHandshake createHandshake(TorConfig config, ConnectionImpl connection, SSLSocket socket) throws ConnectionHandshakeException {
	if(config.getHandshakeV3Enabled() && ConnectionHandshakeV3.sessionSupportsHandshake(socket.getSession())) {
		return new ConnectionHandshakeV3(connection, socket);
	} else if(config.getHandshakeV2Enabled()) {
		return new ConnectionHandshakeV2(connection, socket);
	} else {
		throw new ConnectionHandshakeException("No valid handshake type available for this connection");
	}
		
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
public DirectoryImpl(TorConfig config, DirectoryStore customDirectoryStore) {
	store = (customDirectoryStore == null) ? (new DirectoryStoreImpl(config)) : (customDirectoryStore);
	this.config = config;
	stateFile = new StateFile(store, this);
	microdescriptorCache = createMicrodescriptorCache(store);
	basicDescriptorCache = createBasicDescriptorCache(store);	
	routersByIdentity = new HashMap<HexDigest, RouterImpl>();
	routersByNickname = new HashMap<String, RouterImpl>();
	directoryCaches = new RandomSet<RouterImpl>();
	requiredCertificates = new HashSet<ConsensusDocument.RequiredCertificate>();
	consensusChangedManager = new EventManager();
	random = new TorRandom();
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
DirectoryDownloadTask(TorConfig config, Directory directory, DirectoryDownloader downloader) {
	this.config = config;
	this.directory = directory;
	this.downloader = downloader;
	this.random = new TorRandom();
	this.outstandingDescriptorTasks = new AtomicInteger();
	this.descriptorProcessor = new DescriptorProcessor(config, directory);
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
Bridges(TorConfig config, DirectoryDownloader directoryDownloader) {
	this.config = config;
	this.directoryDownloader = directoryDownloader;
	this.bridgeRouters = new HashSet<BridgeRouterImpl>();
	this.random = new TorRandom();
	this.lock = new Object();
	this.outstandingDownloadTasks = new AtomicInteger();
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
public EntryGuards(TorConfig config, ConnectionCache connectionCache, DirectoryDownloader directoryDownloader, Directory directory) {
	this.config = config;
	this.random = new TorRandom();
	this.nodeChooser = new CircuitNodeChooser(config, directory);
	this.connectionCache = connectionCache;
	this.directory = directory;
	this.pendingProbes = new HashSet<GuardEntry>();
	this.bridges = new Bridges(config, directoryDownloader);
	this.lock = new Object();
	this.executor = Threading.newPool("EntryGuards worker");
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
public HiddenServiceManager(TorConfig config, Directory directory, CircuitManagerImpl circuitManager) {
	this.config = config;
	this.directory = directory;
	this.hiddenServices = new HashMap<String, HiddenService>();
	this.hsDirectories = new HSDirectories(directory);
	this.circuitManager = circuitManager;
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
CircuitCreationTask(TorConfig config, Directory directory, ConnectionCache connectionCache, CircuitPathChooser pathChooser, CircuitManagerImpl circuitManager, TorInitializationTracker initializationTracker) {
	this.config = config;
	this.directory = directory;
	this.connectionCache = connectionCache;
	this.circuitManager = circuitManager;
	this.initializationTracker = initializationTracker;
	this.pathChooser = pathChooser;
	this.executor = Threading.newPool("CircuitCreationTask worker");
	this.buildHandler = createCircuitBuildHandler();
	this.internalBuildHandler = createInternalCircuitBuildHandler();
	this.predictor = new CircuitPredictor();
	this.lastNewCircuit = new AtomicLong();
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
TorConfigNodeFilter(TorConfig config) {
	this.filters = new HashMap<String, ConfigNodeFilter>();
	addFilter(filters, EXCLUDE_NODES_FILTER, config.getExcludeNodes());
	addFilter(filters, EXCLUDE_EXIT_NODES_FILTER, config.getExcludeExitNodes());
	addFilter(filters, ENTRY_NODES_FILTER, config.getEntryNodes());
	addFilter(filters, EXIT_NODES_FILTER, config.getExitNodes());
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
private ConfigVar getAnnotationForVariable(String varName) {
	final String getName = "get"+ varName;
	for(Method m: TorConfig.class.getDeclaredMethods()) {
		if(getName.equals(m.getName())) {
			return m.getAnnotation(TorConfig.ConfigVar.class);
		}
	}
	return null;
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
private TorConfig.AutoBoolValue parseAutoBool(String value) {
	if("auto".equalsIgnoreCase(value)) {
		return AutoBoolValue.AUTO;
	} else if("true".equalsIgnoreCase(value)) {
		return AutoBoolValue.TRUE;
	} else if("false".equalsIgnoreCase(value)) {
		return AutoBoolValue.FALSE;
	} else {
		throw new IllegalArgumentException("Could not parse AutoBool value "+ value);
	}
}
 

import com.subgraph.orchid.TorConfig; //导入依赖的package包/类
public EntryGuards(TorConfig config, ConnectionCache connectionCache, DirectoryDownloader directoryDownloader, Directory directory) {
	this.config = config;
	this.random = new TorRandom();
	this.nodeChooser = new CircuitNodeChooser(config, directory);
	this.connectionCache = connectionCache;
	this.directory = directory;
	this.pendingProbes = new HashSet<GuardEntry>();
	this.bridges = new Bridges(config, directoryDownloader);
	this.lock = new Object();
	this.executor = Executors.newCachedThreadPool();
}