import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
public GuardEntry createGuardEntryFor(Router router) {
	final GuardEntryImpl entry = new GuardEntryImpl(directory, this, router.getNickname(), router.getIdentityHash().toString());
	final String version = Tor.getImplementation() + "-" + Tor.getVersion();
	entry.setVersion(version);
	
	/* 
	 * "Choose expiry time smudged over the last month."
	 * 
	 * See add_an_entry_guard() in entrynodes.c 
	 */
	final long createTime = (new Date()).getTime() - (random.nextInt(3600 * 24 * 30) * 1000L);
	entry.setCreatedTime(new Date(createTime));
	return entry;
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private void addGuardEntry(GuardEntry entry, boolean writeFile) {
	synchronized(guardEntries) {
		if(guardEntries.contains(entry)) {
			return;
		}
		final GuardEntryImpl impl = (GuardEntryImpl) entry;
		guardEntries.add(impl);
		synchronized (impl) {
			impl.setAddedFlag();
			if(writeFile) {
				writeFile();
			}
		}
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的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.GuardEntry; //导入依赖的package包/类
void probeConnectionSucceeded(GuardEntry entry) {
	synchronized (lock) {
		pendingProbes.remove(entry);
		if(entry.isAdded()) {
			retestProbeSucceeded(entry);
		} else {
			initialProbeSucceeded(entry);
		}
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
void probeConnectionFailed(GuardEntry entry) {
	synchronized (lock) {
		pendingProbes.remove(entry);
		if(entry.isAdded()) {
			retestProbeFailed(entry);
		}
		lock.notifyAll();
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private void retestAllUnreachable() {
	for(GuardEntry e: directory.getGuardEntries()) {
		if(e.getDownSince() != null) {
			launchEntryProbe(e);
		}
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private void testStatusOfAllGuards() {
	for(GuardEntry entry: directory.getGuardEntries()) {
		if(isPermanentlyUnlisted(entry) || isExpired(entry)) {
			directory.removeGuardEntry(entry);
		} else if(needsUnreachableTest(entry)) {
			launchEntryProbe(entry);
		}
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private List<Router> getUsableGuardRouters(Set<Router> excluded) {
	List<Router> usableRouters = new ArrayList<Router>();
	for(GuardEntry entry: directory.getGuardEntries()) {
		addRouterIfUsableAndNotExcluded(entry, excluded, usableRouters);
	}
	return usableRouters;
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private void addRouterIfUsableAndNotExcluded(GuardEntry entry, Set<Router> excluded, List<Router> routers) {
	if(entry.testCurrentlyUsable() && entry.getDownSince() == null) {
		final Router r = entry.getRouterForEntry();
		if(r != null && !excluded.contains(r)) {
			routers.add(r);
		}
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private void addPendingInitialConnections(Set<Router> routerSet) {
	for(GuardEntry entry: pendingProbes) {
		if(!entry.isAdded()) {
			Router r = entry.getRouterForEntry();
			if(r != null) {
				routerSet.add(r);
			}
		}
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private void maybeChooseNew(int usableSize, int minSize, Set<Router> excluded) {
	int sz = usableSize + countPendingInitialProbes();
	while(sz < minSize) {	
		Router newGuard = chooseNewGuard(excluded);
		if(newGuard == null) {
			logger.warning("Need to add entry guards but no suitable guard routers are available");
			return;
		}
		logger.fine("Testing "+ newGuard + " as a new guard since we only have "+ usableSize + " usable guards");
		final GuardEntry entry = directory.createGuardEntryFor(newGuard);
		launchEntryProbe(entry);
		sz += 1;
	}
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private int countPendingInitialProbes() {
	int count = 0;
	for(GuardEntry entry: pendingProbes) {
		if(!entry.isAdded()) {
			count += 1;
		}
	}
	return count;
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private void launchEntryProbe(GuardEntry entry) {
	if(!entry.testCurrentlyUsable() || pendingProbes.contains(entry)) {
		return;
	}
	pendingProbes.add(entry);
	executor.execute(new GuardProbeTask(connectionCache, this, entry));
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private boolean isPermanentlyUnlisted(GuardEntry entry) {
	final Date unlistedSince = entry.getUnlistedSince();
	if(unlistedSince == null || pendingProbes.contains(entry)) {
		return false;
	}
	final Date now = new Date();
	final long unlistedTime = now.getTime() - unlistedSince.getTime();
	return unlistedTime > THIRTY_DAYS; 
}
 

import com.subgraph.orchid.GuardEntry; //导入依赖的package包/类
private boolean needsUnreachableTest(GuardEntry entry) {
	final Date downSince = entry.getDownSince();
	if(downSince == null || !entry.testCurrentlyUsable()) {
		return false;
	}
	final Date now = new Date();
	final Date lastConnect = entry.getLastConnectAttempt();
	final long timeDown = now.getTime() - downSince.getTime();
	final long timeSinceLastRetest = (lastConnect == null) ? timeDown : (now.getTime() - lastConnect.getTime());
	
	return timeSinceLastRetest > getRetestInterval(timeDown);
}