@Override public <A extends Appendable> A appendTo(StructuredReader activeReader, long id, A target) { try { target.append(String.valueOf(java.lang.Float.intBitsToFloat(activeReader.readInt(id)))); } catch (IOException e) { throw new RuntimeException(e); } return target; }
public boolean productUpdate(HTTPRequestReader request) { StructuredReader structured = request.structured(); int idx = structured.readInt(Field.ID); quantity[idx] = structured.readInt(Field.QUANTITY); disabled[idx] = structured.readBoolean(Field.DISABLED); names[idx].setLength(0); structured.readText(Field.NAME, names[idx] ); return responseService.publishHTTPResponse(request, 200); }
/** * Reads text from specified field and calls setupParser for TrieParserReader to consume this data. * @param association Object associated object to find this field * @param target TrieParserReader target */ public boolean readTextAsParserSource(Object association, TrieParserReader target) { ChannelReader textReader = read(association); if (null!=textReader) { DataInputBlobReader.setupParser((DataInputBlobReader<?>)textReader, target, (int) textReader.readShort()); return true; } else { return false; } }
@Override public boolean message(CharSequence topic, ChannelReader payload) { StructuredReader struct = payload.structured(); return responseService.publishHTTPResponse( struct.readLong(Field.CONNECTION), struct.readLong(Field.SEQUENCE), struct.readInt(Field.STATUS), HTTPContentTypeDefaults.JSON, w->{ struct.readText(Field.PAYLOAD, w); }); }
@Override public boolean restRequest(HTTPRequestReader request) { StructuredReader record = request.structured(); int age = record.readInt(Field.PERSON_AGE); isLegal = age>=21; name.setLength(0); record.readText(Field.PERSON_NAME, name); return responseService.publishHTTPResponse(request, 200, HTTPContentTypeDefaults.JSON, w-> { jsonRenderer.render(w, this); }); }
long connectionId = struct.readLong(Field.CONNECTION); long sequenceId = struct.readLong(Field.SEQUENCE); Struct operation = struct.structAssociatedObject(); switch (operation) { case DB_ALL_QUERY: break; case DB_PRODUCT_QUERY: id = struct.readInt(Field.ID); break; case DB_PRODUCT_UPDATE: id = struct.readInt(Field.ID); quantity = struct.readInt(Field.QUANTITY); disabled = struct.readBoolean(Field.DISABLED); name = struct.readText(Field.NAME); break;
@Override public <A extends Appendable> A appendTo(StructuredReader activeReader, long id, A target) { return activeReader.readText(id,target); }
@Override public boolean restRequest(HTTPRequestReader request) { int argInt = request.structured().readInt(Field.MYARG); if (request.structured().isNull(Field.MYARG)) { console.append("Arg is NULL\n "); } else { request.structured().identityVisit(HTTPHeaderDefaults.COOKIE, (id,reader,field)-> {
@Override public boolean restRequest(HTTPRequestReader request) { if (request.structured().isEqual(keyFieldId, PASS1)) { if (channel.publishHTTPResponse(request, 200)) { channel.requestShutdown(); hasFirstKey = true; System.out.println("first key"); return true; } } else if (hasFirstKey && request.structured().isEqual(keyFieldId, PASS2)) { if (channel.publishHTTPResponse(request, 200)) { hasSecondKey = true; System.out.println("second key"); return true; } } else { return channel.publishHTTPResponse(request, 404); } return false; }
@Override public boolean restRequest(HTTPRequestReader request) { int argInt = request.structured().readInt(nameFieldId); Appendables.appendValue(console, "Arg Int: ", argInt, "\n"); request.structured().identityVisit(HTTPHeaderDefaults.COOKIE, (id,reader,field)-> { console.append("COOKIE: "); reader.readUTF(console).append('\n'); }); if (request.isVerbPost()) { request.openPayloadData((reader)->{ console.append("POST: "); reader.readUTFOfLength(reader.available(), console); console.append('\n'); }); } //no body just a 200 ok response. return cmd.publishHTTPResponse(request, 200); }
@Override public <A extends Appendable> A appendTo(StructuredReader activeReader, long id, A target) { try { target.append(String.valueOf(java.lang.Double.longBitsToDouble(activeReader.readLong(id)))); } catch (IOException e) { throw new RuntimeException(e); } return target; }
private int echoHeaders(DataOutputBlobWriter<NetPayloadSchema> outputStream, int len, final int blobMask, byte[] blob, final int bytePosition, ChannelReader reader) { HTTPHeader[] headersToEcho = conStruct.headersToEcho(); if (null!=headersToEcho) { int newLinePos = (bytePosition+len-2); assert(blob[newLinePos&blobMask]=='\r'); assert(blob[(1+newLinePos)&blobMask]=='\n'); if (blob[newLinePos&blobMask]=='\r') { len-=2;//confirm it is \r\n? add assert! DataOutputBlobWriter.write(outputStream, blob, bytePosition, len, blobMask); len = 0;//so the following write will not write a second time. for(int i=0; i<headersToEcho.length; i++) { HTTPHeader header = headersToEcho[i]; if (!reader.structured().isNull(header)) { System.err.println("echo header "+header); spec.writeHeader(outputStream, header, reader.structured().read(header)); } //TODO: confirm works with chunked and not } outputStream.write(BYTES_NEWLINE); } } return len; }
@Override public <A extends Appendable> A appendTo(StructuredReader activeReader, long id, A target) { try { if (activeReader.readBoolean(id)) { target.append("true"); } else { target.append("false"); } } catch (IOException e) { throw new RuntimeException(e); } return target; }
@Override public boolean responseHTTP(HTTPResponseReader reader) { if (reader.isConnectionClosed()) { return responder.closed(); } else { return responder.respondWith(200, !reader.isEndOfResponse(), (headWriter) -> { reader.structured().visit(HTTPHeader.class, (header,r,id)->{ //we are a proxy, our response has its own length, connection and status if (header != HTTPHeaderDefaults.CONTENT_LENGTH && header != HTTPHeaderDefaults.CONNECTION && header != HTTPHeaderDefaults.STATUS ) { headWriter.write(header, reader.getSpec(), r); } }); }, reader.contentType(), (payloadWriter) -> { payloadWriter.write(reader.structured().readPayload()); }); } }
public boolean isNull(Object association) { return isNull( Pipe.structRegistry(DataInputBlobReader.getBackingPipe(channelReader)) .fieldLookupByIdentity(association, DataInputBlobReader.getStructType(channelReader) )); }
if (!reader.hasAttachedObject(fieldIdAssoc)) { long readLong = reader.readLong(fieldIdAssoc) >> 1; //since SocketReaders are always grouped by 2 int targetIdx = (int)(readLong%toBlockingWork.length);
/** * * @return HTTPContentTypeDefaults.UNKNOWN or htc.type */ public HTTPContentType contentType() { if (structured().identityVisit(HTTPHeaderDefaults.CONTENT_TYPE, htc)) { return htc.type(); } else { return HTTPContentTypeDefaults.UNKNOWN; } }
/** * * @param reader FailablePayloadReading arg used to read(this) * @return if (hasRemainingBytes()) return reader.read(this) else false */ public boolean openPayloadDataFailable(FailablePayloadReading reader) { if (hasRemainingBytes()) { return reader.read(this.structured().readPayload());//even when we have zero length... } else { return false; } }