protected ServerConnection(SSLEngine engine, SocketChannel socketChannel, long id, ServerCoordinator coordinator) { super(engine, socketChannel, id, true); this.scs = coordinator.connectionStruct(); assert(coordinator.connectionStruct() != null) : "server side connections require struct"; //TODO: build queues. // this.scs.inFlightCount(), this.scs.inFlightPayloadSize() }
serverSocketChannel.socket().setSoTimeout(0); endPoint = bindAddressPort(coordinator.host(), coordinator.port()); logger.warn("\n{} Unable to open {} due to {}",coordinator.serviceName(),coordinator.port(),se.getMessage()); coordinator.shutdown(); throw new RuntimeException(se);//server can not run at this point so we must have a hard stop logger.warn("\n{} Already in use {}:{}",coordinator.serviceName(),coordinator.host(), coordinator.port()); coordinator.shutdown(); throw new RuntimeException(se);//server can not run at this point so we must have a hard stop } catch (IOException e) { if (e.getMessage().contains("Unresolved address")) { logger.warn("\n{} Unresolved host address http"+(coordinator.isTLS?"s":""),coordinator.serviceName()); coordinator.shutdown(); throw new RuntimeException(e);//server can not run at this point so we must have a hard stop
public static void buildOrderingSupers(GraphManager graphManager, ServerCoordinator coordinator, Pipe<ServerResponseSchema>[][] fromModule, Pipe<HTTPLogResponseSchema>[] log, Pipe<NetPayloadSchema>[][] perTrackFromSuper) { int track = fromModule.length; while (--track>=0) { OrderSupervisorStage wrapSuper = new OrderSupervisorStage(graphManager, fromModule[track], log[track], perTrackFromSuper[track], coordinator);//ensure order coordinator.processNota(graphManager, wrapSuper); } }
public ProxyRequestToBackEndStage(GraphManager graphManager, Pipe<HTTPRequestSchema>[] inputPipes, Pipe<ConnectionData>[] connectionId, Pipe<ClientHTTPRequestSchema>[] clientRequests, ServerCoordinator serverCoordinator) { super(graphManager, inputPipes, join(clientRequests,connectionId)); this.inputPipes = inputPipes; this.connectionId = connectionId; this.clientRequests = clientRequests; assert(inputPipes.length == connectionId.length); assert(inputPipes.length == clientRequests.length); this.targetHost = serverCoordinator.host(); this.targetPort = serverCoordinator.port(); this.spec = serverCoordinator.spec; assert(targetHost!=null); ClientCoordinator.registerDomain(targetHost); }
System.out.println(); System.out.append(coordinator.serviceName()).append(" is now ready on http"); if (coordinator.isTLS) { System.out.append("s"); System.out.append("://").append(host).append("/").append(coordinator.defaultPath()).append("\n"); System.out.append(coordinator.serviceName()) .append(" max connections: ") ,coordinator.channelBitsSize).append("\n"); System.out.append(coordinator.serviceName()) .append(" max concurrent inputs: ") ,coordinator.maxConcurrentInputs).append("\n"); System.out.append(coordinator.serviceName()) .append(" concurrent tracks: ") ,coordinator.moduleParallelism()).append("\n"); System.out.append(coordinator.serviceName()) .append(" max concurrent outputs: ") ,coordinator.maxConcurrentOutputs).append("\n");
int spaceForEchos = serverCoord.connectionStruct().inFlightPayloadSize(); serverCoord.processNota(gm, newConStage);
this.channelBitsSize = coordinator.channelBitsSize; this.isTLS = coordinator.isTLS; this.socketHolder = ServerCoordinator.getSocketChannelHolder(coordinator); this.conStruct = coordinator.connectionStruct(); this.spec = coordinator.spec;
ServiceObjectHolder<ServerConnection> holder = ServerCoordinator.getSocketChannelHolder(coordinator); Selector sel = coordinator.getSelector(); if (sel!=null) { try { ServerCoordinator.selectorKeyContext(coordinator, channelId));
final int trackCount = coordinator.moduleParallelism(); final HTTPRouterStageConfig routerConfig = new HTTPRouterStageConfig(httpSpec, coordinator.connectionStruct());
coordinator.moduleParallelism(), encryptedIncomingGroup); coordinator.processNota(graphManager, newConStage);
ServerCoordinator serverCoord = new ServerCoordinator(tlsCertificates, bindHost, port, scs, false, "Telemetry Server","", serverConfig); serverCoord.setStageNotaProcessor(new PronghornStageProcessor() {
@Override public ServerCoordinator buildServerCoordinator() { finalizeDeclareConnections(); return new ServerCoordinator( getCertificates(), bindHost(), bindPort(), connectionStruct(), requireClientAuth(), serviceName(), defaultHostPath(), buildServerConfig()); }
boolean webSocketUpgraded = ServerCoordinator.isWebSocketUpgraded(coordinator, channel); if (!webSocketUpgraded) { return parseHTTPAvail(this, idx, channel, false); Pipe<NetPayloadSchema> selectedInput = inputs[idx]; final int totalAvail = inputLengths[idx]; final int pipeIdx = ServerCoordinator.getWebSocketPipeIdx(coordinator, channel); final Pipe<HTTPRequestSchema> outputPipe = outputs[pipeIdx]; if (!Pipe.hasRoomForWrite(outputPipe) ) {
Pipe<HTTPLogResponseSchema>[] logRes) { if (coordinator.isLogFilesEnabled()) { LogFileConfig logFileConfig = coordinator.getLogFilesConfig();
Pipe.releaseReadLock(input[idx]); assert(Pipe.contentRemaining(input[idx])>=0); ServiceObjectHolder<ServerConnection> socketHolder = ServerCoordinator.getSocketChannelHolder(coordinator); int pipeIdx = Pipe.takeInt(input[idx]); ServerCoordinator.setUpgradePipe(coordinator,
ServiceObjectHolder<ServerConnection> socketHolder = ServerCoordinator.getSocketChannelHolder(coordinator);
r.pcmIn,r.pcmOut); serverCoord = new ServerCoordinator( config.getCertificates(), config.bindHost(),
private static void buildSocketWriters(GraphManager graphManager, ServerCoordinator coordinator, int socketWriters, Pipe<NetPayloadSchema>[] toWiterPipes) { /////////////// //all the writer stages /////////////// Pipe[][] req = Pipe.splitPipes(socketWriters, toWiterPipes); int w = socketWriters; while (--w>=0) { ServerSocketWriterStage writerStage = new ServerSocketWriterStage(graphManager, coordinator, req[w]); //pump bytes out GraphManager.addNota(graphManager, GraphManager.DOT_RANK_NAME, "SocketWriter", writerStage); coordinator.processNota(graphManager, writerStage); } }
this.connectionStruct().inFlightPayloadSize());
private static void buildSocketReaderGroups(final GraphManager graphManager, final ServerCoordinator coordinator, final Pipe<NetPayloadSchema>[] encryptedIncomingGroup, Pipe<ReleaseSchema>[] acks, int groups) { Pipe[][] in = Pipe.splitPipes(groups, encryptedIncomingGroup); Pipe[][] out = Pipe.splitPipes(groups, acks); for(int x=0; x<groups; x++) { ServerSocketReaderStage readerStage = new ServerSocketReaderStage(graphManager, out[(groups-x)-1], in[x], coordinator); GraphManager.addNota(graphManager, GraphManager.DOT_RANK_NAME, "SocketReader", readerStage); coordinator.processNota(graphManager, readerStage); } }