public static ChannelWriter openHTTPPayload( HTTPUtilResponse that, Pipe<ServerResponseSchema> output, long activeChannelId, int activeSequenceNo) { HTTPUtilResponse.holdEmptyBlock(that, activeChannelId, activeSequenceNo, output); return Pipe.openOutputStream(output); }
/** * Writes decimal as ASCII to specified Pipe * @param readDecimalExponent int exponent -63 to +64 where the point goes * @param readDecimalMantissa long actual value for the number * @param outputRing Pipe to write to * @param <S> MessageSchema to write to */ public static <S extends MessageSchema<S>> void addDecimalAsASCII( int readDecimalExponent, long readDecimalMantissa, Pipe<S> outputRing) { DataOutputBlobWriter<S> out = outputRing.openOutputStream(outputRing); Appendables.appendDecimalValue(out, readDecimalMantissa, (byte)readDecimalExponent); DataOutputBlobWriter.closeLowLevelField(out); }
/** * Writes decimal as ASCII to specified Pipe * @param readDecimalExponent int exponent -63 to +64 where the point goes * @param readDecimalMantissa long actual value for the number * @param outputRing Pipe to write to * @param <S> MessageSchema to write to */ public static <S extends MessageSchema<S>> void addDecimalAsASCII( int readDecimalExponent, long readDecimalMantissa, Pipe<S> outputRing) { DataOutputBlobWriter<S> out = outputRing.openOutputStream(outputRing); Appendables.appendDecimalValue(out, readDecimalMantissa, (byte)readDecimalExponent); DataOutputBlobWriter.closeLowLevelField(out); }
/** * Writes decimal as ASCII to specified Pipe * @param readDecimalExponent int exponent -63 to +64 where the point goes * @param readDecimalMantissa long actual value for the number * @param outputRing Pipe to write to * @param <S> MessageSchema to write to */ public static <S extends MessageSchema<S>> void addDecimalAsASCII( int readDecimalExponent, long readDecimalMantissa, Pipe<S> outputRing) { DataOutputBlobWriter<S> out = outputRing.openOutputStream(outputRing); Appendables.appendDecimalValue(out, readDecimalMantissa, (byte)readDecimalExponent); DataOutputBlobWriter.closeLowLevelField(out); }
/** * Open the message for writing * @return returns the ChannelWriter or null if there is no room to write. */ public ChannelWriter beginWrite() { if (Pipe.hasRoomForWrite(pipe)) { Pipe.markHead(pipe); Pipe.addMsgIdx(pipe, RawDataSchema.MSG_CHUNKEDSTREAM_1); isWriting = true; return Pipe.openOutputStream(pipe); } return null; }
/** * Open the message for writing * @return returns the ChannelWriter or null if there is no room to write. */ public ChannelWriter beginWrite() { if (Pipe.hasRoomForWrite(pipe)) { Pipe.markHead(pipe); Pipe.addMsgIdx(pipe, RawDataSchema.MSG_CHUNKEDSTREAM_1); isWriting = true; return Pipe.openOutputStream(pipe); } return null; }
/** * Open the message for writing * @return returns the ChannelWriter or null if there is no room to write. */ public ChannelWriter beginWrite() { if (Pipe.hasRoomForWrite(pipe)) { Pipe.markHead(pipe); Pipe.addMsgIdx(pipe, RawDataSchema.MSG_CHUNKEDSTREAM_1); isWriting = true; return Pipe.openOutputStream(pipe); } return null; }
private void sendOrderedResults(int totalBuckets, long totalSum) { int size = Pipe.addMsgIdx(output, ProbabilitySchema.MSG_SELECTION_1); Pipe.addLongValue(totalSum, output); Pipe.addIntValue(totalBuckets, output); DataOutputBlobWriter<ProbabilitySchema> writer = Pipe.openOutputStream(output); for(int c=0;c<totalBuckets;c++) { writer.writePackedLong(sortWorkspace[c][0]); //count for this writer.writePackedLong(sortWorkspace[c][1]); //index location for this } DataOutputBlobWriter.closeLowLevelField(writer); Pipe.confirmLowLevelWrite(output, size); Pipe.publishWrites(output); }
private void processFoundRevision(int i, final int stateIdx, Pipe<NetResponseSchema> targetPipe, long ccId, HTTPClientConnection cc, int startingLength1) { clearConnectionStateData(i); //because we have started written the response we MUST do extra cleanup later. Pipe.addMsgIdx(targetPipe, NetResponseSchema.MSG_RESPONSE_101); Pipe.addLongValue(ccId, targetPipe); // NetResponseSchema.MSG_RESPONSE_101_FIELD_CONNECTIONID_1, ccId); Pipe.addIntValue(cc.sessionId, targetPipe); Pipe.addIntValue(ServerCoordinator.BEGIN_RESPONSE_MASK, targetPipe);//flags, init to zero, will set later if required positionMemoData[stateIdx]++;//state change is key DataOutputBlobWriter<NetResponseSchema> openOutputStream = Pipe.openOutputStream(targetPipe); DataOutputBlobWriter.tryClearIntBackData(openOutputStream, cc.totalSizeOfIndexes()); //NOTE: this is always first and not indexed... TrieParserReader.writeCapturedShort(trieReader, 0, openOutputStream); //status code runningHeaderBytes[i] = startingLength1 - trieReader.sourceLen; }
DataOutputBlobWriter<RawDataSchema> outputStream = Pipe.openOutputStream(t); inputStream.readInto(outputStream, toCopyLength); DataOutputBlobWriter.closeLowLevelField(outputStream);
boolean publishOnPrivateTopic(int token, Writable writable) { //this is a private topic Pipe<MessagePrivate> output = publishPrivateTopics.getPipe(token); if (Pipe.hasRoomForWrite(output)) { int size = Pipe.addMsgIdx(output, MessagePrivate.MSG_PUBLISH_1); DataOutputBlobWriter<MessagePrivate> writer = Pipe.openOutputStream(output); writable.write(writer); DataOutputBlobWriter.closeLowLevelField(writer); Pipe.confirmLowLevelWrite(output, size); Pipe.publishWrites(output); return true; } else { //Pipe<MessagePrivate> output = publishPrivateTopics.getPipe(token); logPrivateTopicTooShort(token, output); return false; } }
FailableWrite publishFailableOnPrivateTopic(int token, FailableWritable writable) { //this is a private topic Pipe<MessagePrivate> output = publishPrivateTopics.getPipe(token); if (Pipe.hasRoomForWrite(output)) { DataOutputBlobWriter<MessagePrivate> writer = Pipe.openOutputStream(output); FailableWrite result = writable.write(writer); if (result == FailableWrite.Cancel) { output.closeBlobFieldWrite(); } else { int size = Pipe.addMsgIdx(output, MessagePrivate.MSG_PUBLISH_1); DataOutputBlobWriter.closeLowLevelField(writer); Pipe.confirmLowLevelWrite(output, size); Pipe.publishWrites(output); } return result; } else { return FailableWrite.Retry; } }
private void requestPing(long now, long connectionId, Pipe<NetPayloadSchema> server) { Pipe.presumeRoomForWrite(server); int size = Pipe.addMsgIdx(server, NetPayloadSchema.MSG_PLAIN_210); Pipe.addLongValue(connectionId, server); Pipe.addLongValue(now, server); Pipe.addLongValue(0, server); //always use zero for client requests DataOutputBlobWriter<NetPayloadSchema> output = Pipe.openOutputStream(server); output.writeByte(0xC0); output.writeByte(0x00); output.closeLowLevelField(); Pipe.confirmLowLevelWrite(server, size); Pipe.publishWrites(server); //logger.info("wrote block of {}",len2); }
int tokenForPrivateTopic(TopicWritable topic) { if (null==publishPrivateTopics) { return -1; } if (null==tempTopicPipe) { tempTopicPipe = RawDataSchema.instance.newPipe(2, maxDynamicTopicLength); tempTopicPipe.initBuffers(); } int size = Pipe.addMsgIdx(tempTopicPipe, RawDataSchema.MSG_CHUNKEDSTREAM_1); DataOutputBlobWriter<RawDataSchema> output = Pipe.openOutputStream(tempTopicPipe); topic.write(output); DataOutputBlobWriter.closeLowLevelField(output); Pipe.confirmLowLevelWrite(tempTopicPipe, size); Pipe.publishWrites(tempTopicPipe); Pipe.takeMsgIdx(tempTopicPipe); int token = publishPrivateTopics.getToken(tempTopicPipe); Pipe.confirmLowLevelRead(tempTopicPipe, size); Pipe.releaseReadLock(tempTopicPipe); return token; }
DataOutputBlobWriter<?> logStr = Pipe.openOutputStream(outLog); Pipe.outputStream(output).replicate(logStr, outPos, outLen); outLog.closeBlobFieldWrite();
ChannelWriter outStream = Pipe.openOutputStream(output);
Pipe.addIntValue(channelIdLow, localOutput); Pipe.addIntValue(sequence, localOutput); DataOutputBlobWriter<ServerResponseSchema> writer = Pipe.openOutputStream(localOutput);
Pipe.addIntValue(channelIdLow, localOutput); Pipe.addIntValue(sequence, localOutput); DataOutputBlobWriter<ServerResponseSchema> writer = Pipe.openOutputStream(localOutput);
private void batchMessages(Pipe<RawDataSchema> output, int esitmate) { if ((!messageOpen) || (Pipe.outputStream(output).remaining() < (esitmate+(1<<12))) ) { if (messageOpen) { //add to end of each file, when there is room. if (Pipe.outputStream(output).remaining()>(1<<12)) { Pipe.outputStream(output).append("\n"); etr.report(Pipe.outputStream(output)); } DataOutputBlobWriter.closeLowLevelField(Pipe.outputStream(output)); Pipe.confirmLowLevelWrite(output, Pipe.sizeOf(output, RawDataSchema.MSG_CHUNKEDSTREAM_1)); Pipe.publishWrites(output); messageOpen=false; } Pipe.addMsgIdx(output, RawDataSchema.MSG_CHUNKEDSTREAM_1); Pipe.openOutputStream(output); messageOpen=true; } }
DataOutputBlobWriter<RawDataSchema> writer = Pipe.openOutputStream(target);