import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
Stream getStream() throws OpenFailedException, TimeoutException, StreamConnectFailedException, InterruptedException {
	synchronized(requestCompletionLock) {
		switch(completionStatus) {
		case NOT_COMPLETED:
			throw new IllegalStateException("Request not completed");
		case EXIT_FAILURE:
			throw new OpenFailedException("Failure at exit node");
		case TIMEOUT:
			throw new TimeoutException();
		case STREAM_OPEN_FAILURE:
			throw new StreamConnectFailedException(streamOpenFailReason);
		case INTERRUPTED:
			throw new InterruptedException();
		case SUCCESS:
			return stream;
		default:
			throw new IllegalStateException("Unknown completion status");
		}
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
private void waitForRelayConnected(long timeout) throws InterruptedException, TimeoutException, StreamConnectFailedException {
	final long start = System.currentTimeMillis();
	long elapsed = 0;
	synchronized(waitConnectLock) {
		while(!relayConnectedReceived) {

			if(relayEndReceived) {
				throw new StreamConnectFailedException(relayEndReason);
			}

			if(elapsed >= timeout) {
				throw new TimeoutException();
			}

			waitConnectLock.wait(timeout - elapsed);
			
			elapsed = System.currentTimeMillis() - start;
		}
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
private Stream openDirectoryStream(int purpose) throws InterruptedException, TimeoutException, StreamConnectFailedException {
	final int requestEventCode = purposeToEventCode(purpose, false);
	final int loadingEventCode = purposeToEventCode(purpose, true);
	
	notifyInitialization(requestEventCode);

	final Stream stream = circuit.openDirectoryStream(OPEN_DIRECTORY_STREAM_TIMEOUT, true);
	notifyInitialization(loadingEventCode);
	return stream;
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
protected Stream processStreamOpenException(Exception e) throws InterruptedException, TimeoutException, StreamConnectFailedException {
	if(e instanceof InterruptedException) {
		throw (InterruptedException) e;
	} else if(e instanceof TimeoutException) {
		throw(TimeoutException) e;
	} else if(e instanceof StreamConnectFailedException) {
		throw(StreamConnectFailedException) e;
	} else {
		throw new IllegalStateException();
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
public Stream openDirectoryStream(long timeout, boolean autoclose) throws InterruptedException, TimeoutException, StreamConnectFailedException {
	if(type != InternalType.HS_DIRECTORY) {
		throw new IllegalStateException("Cannot open directory stream on internal circuit with type "+ type);
	}
	final StreamImpl stream = createNewStream();
	try {
		stream.openDirectory(timeout);
		return stream;
	} catch (Exception e) {
		removeStream(stream);
		return processStreamOpenException(e);
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
public Stream openStream(int port, long timeout) 
		throws InterruptedException, TimeoutException, StreamConnectFailedException {
	if(type != InternalType.HS_CIRCUIT) {
		throw new IllegalStateException("Cannot open stream to hidden service from internal circuit type "+ type);
	}
	final StreamImpl stream = createNewStream();
	try {
		stream.openExit("", port, timeout);
		return stream;
	} catch (Exception e) {
		removeStream(stream);
		return processStreamOpenException(e);
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
public Stream openExitStream(String target, int port, long timeout) throws InterruptedException, TimeoutException, StreamConnectFailedException {
	final StreamImpl stream = createNewStream();
	try {
		stream.openExit(target, port, timeout);
		return stream;
	} catch (Exception e) {
		removeStream(stream);
		return processStreamOpenException(e);
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
public Stream openDirectoryStream(long timeout, boolean autoclose) throws InterruptedException, TimeoutException, StreamConnectFailedException {
	final StreamImpl stream = createNewStream(autoclose);
	try {
		stream.openDirectory(timeout);
		return stream;
	} catch (Exception e) {
		removeStream(stream);
		return processStreamOpenException(e);
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
void openExit(String target, int port, long timeout) throws InterruptedException, TimeoutException, StreamConnectFailedException {
	streamTarget = target + ":"+ port;
	final RelayCell cell = new RelayCellImpl(circuit.getFinalCircuitNode(), circuit.getCircuitId(), streamId, RelayCell.RELAY_BEGIN);
	cell.putString(target + ":"+ port);
	circuit.sendRelayCellToFinalNode(cell);
	waitForRelayConnected(timeout);
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
private Stream tryOpenExitStream() throws InterruptedException, TimeoutException, StreamConnectFailedException {
	if(exitRequest.isAddressTarget()) {
		return circuit.openExitStream(exitRequest.getAddress(), exitRequest.getPort(), exitRequest.getStreamTimeout());
	} else {
		return circuit.openExitStream(exitRequest.getHostname(), exitRequest.getPort(), exitRequest.getStreamTimeout());
	}
}
 

import com.subgraph.orchid.StreamConnectFailedException; //导入依赖的package包/类
public Stream getStreamTo(String onion, int port) throws OpenFailedException, InterruptedException, TimeoutException {
	final HiddenService hs = getHiddenServiceForOnion(onion);
	final HiddenServiceCircuit circuit = getCircuitTo(hs);
	
	try {
		return circuit.openStream(port, HS_STREAM_TIMEOUT);
	} catch (StreamConnectFailedException e) {
		throw new OpenFailedException("Failed to open stream to hidden service "+ hs.getOnionAddressForLogging() + " reason "+ e.getReason());
	}
}