private static MQTTConfigImpl buildMQTTBridge(GraphManager gm, CharSequence host, int port, CharSequence clientId, int maxInFlight, int maxMessageLength, PipeConfigManager localPCM, long rate) { ClientCoordinator.registerDomain(host); if (maxInFlight>(1<<15)) { throw new UnsupportedOperationException("Does not suppport more than "+(1<<15)+" in flight"); } if (maxMessageLength>(256*(1<<20))) { throw new UnsupportedOperationException("Specification does not support values larger than 256M"); } localPCM.ensureSize(MessageSubscription.class, maxInFlight, maxMessageLength); MQTTConfigImpl mqttBridge = new MQTTConfigImpl(host, port, clientId, gm, rate, (short)maxInFlight, maxMessageLength); mqttBridge.beginDeclarations(); return mqttBridge; }
TLSCertificates tlsCertificates) { ClientCoordinator ccm = new ClientCoordinator(connectionsInBits, maxPartialResponses, tlsCertificates, gm.recordTypeData);
assert(activeConnection.hostId == ClientCoordinator.lookupHostId(host, READER)); int hostId = null!=activeConnection? activeConnection.hostId : ClientCoordinator.lookupHostId(host, READER); long liveConnectionId = ClientCoordinator.lookup(hostId, hostPort, sessionId); activeConnection = ClientCoordinator.openConnection(ccm, hostId, hostPort, sessionId, responsePipeIdx, toBroker, liveConnectionId,
/** * * @param host String arg specifying host * @param port int arg specifying port number * @param sessionId int arg specifying the sessionId, this is internal an private * @param extractor optional JSON extractor */ private ClientHostPortInstance(String host, int port, int sessionId, JSONExtractorCompleted extractor, long callTimeoutNS) { this.host = host; this.port = port; if (port<=0 || port>65535) { throw new UnsupportedOperationException("Invalid port "+port+" must be postive and <= 65535"); } if (sessionId<=0) { throw new UnsupportedOperationException("SessionId must be postive and greater than zero. found: "+sessionId); } this.sessionId = sessionId; this.hostBytes = host.getBytes(); this.extractor = extractor; this.hostId = ClientCoordinator.registerDomain(host); //TODO: this static is bad plus we need to reg the chpis ClientCoordinator.setSessionTimeoutNS(sessionId, callTimeoutNS); }
cc.registerForUse(ccm.selector(), handshakeBegin, ccm.isTLS); BaseConnection con = ccm.lookupConnectionById(cc.id);
long connectionId, AbstractClientConnectionFactory ccf) { assert(hostId>=0) : "bad hostId"; assert(null!=ClientCoordinator.registeredDomain(hostId)) : "bad hostId"; connectionId = ccm.lookupInsertPosition(); (pipeIdx = findAPipeWithRoom(outputs, (int)Math.abs(connectionId%outputs.length)))<0) { return reportNoNewConnectionsAvail(ccm, connectionId); long timeoutNS = ClientCoordinator.lookupSessionTimeoutNS(sessionId); int structureId = structureId(sessionId, ccm.typeData); logger.warn("\nUnable to open connection to {}:{}",ClientCoordinator.registeredDomain(hostId),port, ex); connectionId = Long.MIN_VALUE; return null; long key = computePortSessionKey(cc.port, cc.sessionId); LongLongHashTable table = conTables[cc.hostId]; return doRegister(ccm, outputs, cc);
connectionId = ClientCoordinator.lookup(hostId, port, sessionId); activeConnection = (ClientConnection) ccm.connectionObjForConnectionId(connectionId, false); assert(null!=ClientCoordinator.registeredDomain(Pipe.peekInt(requestPipe, 3))) : "bad hostId"; assert( Pipe.peekInt(requestPipe, 2)!=0) : "sessionId must not be zero, MsgId:"+Pipe.peekInt(requestPipe); activeConnection = ClientCoordinator.openConnection(ccm,
if (-1 == connectionId) { connectionId = ClientCoordinator.lookup(s.hostId(), s.port(), s.sessionId); newConnection = true; ClientCoordinator ccm = this.builder.getClientCoordinator(); ClientConnection conObj = (ClientConnection)ccm.connectionObjForConnectionId(connectionId, true); ClientConnection conObjPrev = (ClientConnection)ccm.connectionObjForConnectionId(prevConnectionId, true); System.out.println("Con: "+conObjPrev.id+" registered:"+conObjPrev.isRegistered()+" valid:"+conObjPrev.isValid()+" Outstanding:" + Appendables.appendNearestTimeUnit(new StringBuilder(), conObjPrev.outstandingCallTime(System.nanoTime()))+" atIdx: "+prevConnectionId System.out.println("SCAN NOW"); ClientAbandonConnectionScanner.showScan = true; ClientAbandonConnectionScanner slow = this.builder.getClientCoordinator().scanForSlowConnections(); ClientAbandonConnectionScanner.showScan = false; System.out.println("SCAN FINISHED");
ClientConnection cc = (ClientConnection)clientCoord.lookupConnectionById(connectionId); connectionId = clientCoord.lookup(clientCoord.lookupHostId(hostBytes, 0, hostBytes.length, Integer.MAX_VALUE), port, userId); Pipe.addIntValue(port, outputs[outputIdx]); int hostId = ClientCoordinator.lookupHostId(hostBytes, 0, hostBytes.length, Integer.MAX_VALUE); Pipe.addIntValue(hostId, outputs[outputIdx]);
assert((msgCommandChannel.initFeatures & MsgCommandChannel.NET_REQUESTER)!=0) : "must turn on NET_REQUESTER to use this method"; session.setConnectionId(ClientCoordinator.lookup( session.hostId, session.port,
GraphManager.addNota(gm, GraphManager.DOT_BACKGROUND, BACKGROUND_COLOR, idGenStage); ClientCoordinator ccm = new ClientCoordinator(connectionsInBits, maxPartialResponses, tlsCertificates, gm.recordTypeData); ccm.setStageNotaProcessor(new PronghornStageProcessor() {
cc = (HTTPClientConnection)ccm.connectionObjForConnectionId(ccId, alsoReturnDisconnected); targetPipe = output[i]; cc = (HTTPClientConnection)ccm.lookupConnectionById(ccId); if (null==cc) { //skip data the connection was closed
private boolean writeEncrypted(boolean didWork, int i, Pipe<NetPayloadSchema> pipe) { long chnl = Pipe.peekLong(pipe, 0xF&NetPayloadSchema.MSG_ENCRYPTED_200_FIELD_CONNECTIONID_201); ClientConnection cc = (ClientConnection)ccm.lookupConnectionById(chnl); if (null==cc) {//closed or we can not get it yet, just push back till later. return false; } final int msgIdx = Pipe.takeMsgIdx(pipe); final long channelId = Pipe.takeLong(pipe); assert(chnl==channelId); final long arrivalTime = Pipe.takeLong(pipe); int meta = Pipe.takeByteArrayMetaData(pipe); //for string and byte array int len = Pipe.takeByteArrayLength(pipe); if (showWrites) { logger.info("/////\n/// has connection "+((cc!=null)&&cc.isValid())+" channelId "+channelId+" write encrypted length:"+len); } didWork = wrapupUpEncryptedToSingleWrite(didWork, i, pipe, msgIdx, channelId, meta, len, cc); return didWork; }
private boolean writeDisconnect(Pipe<NetPayloadSchema> pipe) { long chnl = Pipe.peekLong(pipe, 0xF&NetPayloadSchema.MSG_DISCONNECT_203_FIELD_CONNECTIONID_201); ClientConnection cc = (ClientConnection)ccm.lookupConnectionById(chnl); int msgIdx = Pipe.takeMsgIdx(pipe); long channelId = Pipe.takeLong(pipe); assert(chnl==channelId); if (cc!=null) { if (cc.isValid()) { //only begin disconnect if not already disconnected cc.beginDisconnect();//do not close or we will not get any response } else { //already closed so remove value ccm.removeConnection(channelId); } } else { //already closed so remove value ccm.removeConnection(channelId);//already closed so remove if possible } Pipe.confirmLowLevelRead(pipe, Pipe.sizeOf(pipe, msgIdx)); Pipe.releaseReadLock(pipe); return true; }
public ClientConnection connection(int idx, ClientCoordinator ccm, Pipe<NetPayloadSchema>[] outputs) { ClientConnection result = ClientCoordinator.openConnection( ccm, members[idx].hostId, members[idx].port, members[idx].sessionId, ClientHostPortInstance.getTargetResponsePipeIdx(members[idx]), outputs, members[idx].getConnectionId(), BasicClientConnectionFactory.instance); members[idx].setConnectionId(result.getId()); return result; }
Selector selector = coordinator.selector(); ClientAbandonConnectionScanner slowConnections = coordinator.scanForSlowConnections(); ClientConnection abandonded = slowConnections.leadingCandidate(); if (null!=abandonded) {
public static int lookupHostId(byte[] hostBytes) { return lookupHostId(hostBytes, 0, hostBytes.length, Integer.MAX_VALUE); }
ClientCoordinator.structureId(httpSessions[j].sessionId, builder.gm.recordTypeData));
assert(null!=session); session.setConnectionId(ClientCoordinator.lookup( session.hostId, session.port,
private boolean writePlain(boolean didWork, int i, Pipe<NetPayloadSchema> pipe) { long chnl = Pipe.peekLong(pipe, 0xF&NetPayloadSchema.MSG_PLAIN_210_FIELD_CONNECTIONID_201); ClientConnection cc = (ClientConnection)ccm.lookupConnectionById(chnl); if (null==cc) { return false;