public static boolean buffersEqual(Buffer b1, Buffer b2) { if (b1.length() != b2.length()) return false; for (int i = 0; i < b1.length(); i++) { if (b1.getByte(i) != b2.getByte(i)) return false; } return true; }
/** * Appends the specified {@code Buffer} to the end of the Buffer. The buffer will expand as * necessary to accomodate any bytes written. * * <p>Returns a reference to {@code this} so multiple operations can be appended together. */ public Buffer appendBuffer(Buffer buff) { ChannelBuffer cb = buff.getChannelBuffer(); buffer.writeBytes(buff.getChannelBuffer()); cb.readerIndex( 0); // Need to reset readerindex since Netty write modifies readerIndex of source! return this; }
@Test public void testGetBytes() throws Exception { byte[] bytes = TestUtils.generateRandomByteArray(100); Buffer b = new Buffer(bytes); assertTrue(TestUtils.byteArraysEqual(bytes, b.getBytes())); }
private void testSetFloat(Buffer buff) throws Exception { for (int i = 0; i < numSets; i++) { buff.setFloat(i * 4, (float) i); } for (int i = 0; i < numSets; i++) { assertEquals((float) i, buff.getFloat(i * 4)); } }
private void testSetShort(Buffer buff) throws Exception { for (int i = 0; i < numSets; i++) { buff.setShort(i * 2, (short) i); } for (int i = 0; i < numSets; i++) { assertEquals(i, buff.getShort(i * 2)); } }
private void testSetLong(Buffer buff) throws Exception { for (int i = 0; i < numSets; i++) { buff.setLong(i * 8, i); } for (int i = 0; i < numSets; i++) { assertEquals(i, buff.getLong(i * 8)); } }
private void testSetByte(Buffer buff) throws Exception { for (int i = 0; i < numSets; i++) { buff.setByte(i, (byte) i); } for (int i = 0; i < numSets; i++) { assertEquals(i, buff.getByte(i)); } }
private void testSetDouble(Buffer buff) throws Exception { for (int i = 0; i < numSets; i++) { buff.setDouble(i * 8, (double) i); } for (int i = 0; i < numSets; i++) { assertEquals((double) i, buff.getDouble(i * 8)); } }
@Test public void testToString() throws Exception { String str = TestUtils.randomUnicodeString(100); Buffer buff = new Buffer(str); assertEquals(str, buff.toString()); // TODO toString with encoding }
private void manualEncodeVertxMessageBody(ActiveMQBuffer bodyBuffer, Object body, int type) { switch (type) { case VertxConstants.TYPE_BOOLEAN: bodyBuffer.writeBoolean(((Boolean) body)); break; case VertxConstants.TYPE_BUFFER: Buffer buff = (Buffer) body; int len = buff.length(); bodyBuffer.writeInt(len); bodyBuffer.writeBytes(((Buffer) body).getBytes()); break; case VertxConstants.TYPE_BYTEARRAY: byte[] bytes = (byte[]) body; bodyBuffer.writeInt(bytes.length); bodyBuffer.writeBytes(bytes); break; case VertxConstants.TYPE_BYTE: bodyBuffer.writeByte((byte) body); break; case VertxConstants.TYPE_CHARACTER: bodyBuffer.writeChar((Character) body); break; case VertxConstants.TYPE_DOUBLE: bodyBuffer.writeDouble((double) body); break; case VertxConstants.TYPE_FLOAT: bodyBuffer.writeFloat((Float) body); break; case VertxConstants.TYPE_INT: bodyBuffer.writeInt((Integer) body); break; case VertxConstants.TYPE_LONG: bodyBuffer.writeLong((Long) body); break; case VertxConstants.TYPE_SHORT: bodyBuffer.writeShort((Short) body); break; case VertxConstants.TYPE_STRING: case VertxConstants.TYPE_PING: bodyBuffer.writeString((String) body); break; case VertxConstants.TYPE_JSON_OBJECT: bodyBuffer.writeString(((JsonObject) body).encode()); break; case VertxConstants.TYPE_JSON_ARRAY: bodyBuffer.writeString(((JsonArray) body).encode()); break; case VertxConstants.TYPE_REPLY_FAILURE: ReplyException except = (ReplyException) body; bodyBuffer.writeInt(except.failureType().toInt()); bodyBuffer.writeInt(except.failureCode()); bodyBuffer.writeString(except.getMessage()); break; default: throw new IllegalArgumentException("Invalid body type: " + type); } }
@Test public void testGetByte() throws Exception { int bytesLen = 100; byte[] bytes = TestUtils.generateRandomByteArray(bytesLen); Buffer b = new Buffer(bytes); for (int i = 0; i < bytesLen; i++) { assertEquals(bytes[i], b.getByte(i)); } }
@Test public void testGetBytes2() throws Exception { byte[] bytes = TestUtils.generateRandomByteArray(100); Buffer b = new Buffer(bytes); byte[] sub = new byte[bytes.length / 2]; System.arraycopy(bytes, bytes.length / 4, sub, 0, bytes.length / 2); assertTrue( TestUtils.byteArraysEqual( sub, b.getBytes(bytes.length / 4, bytes.length / 4 + bytes.length / 2))); }
@Test public void testAppendString1() throws Exception { String str = TestUtils.randomUnicodeString(100); byte[] sb = str.getBytes("UTF-8"); Buffer b = new Buffer(); b.appendString(str); assertEquals(b.length(), sb.length); assertTrue(str.equals(b.toString("UTF-8"))); }
@Test public void testGetLong() throws Exception { int numLongs = 100; Buffer b = new Buffer(numLongs * 8); for (int i = 0; i < numLongs; i++) { b.setLong(i * 8, i); } for (int i = 0; i < numLongs; i++) { assertEquals(i, b.getLong(i * 8)); } }
private void testSetBytesString(Buffer buff) throws Exception { String str = TestUtils.randomUnicodeString(100); buff.setString(50, str); byte[] b1 = buff.getBytes(50, buff.length()); String str2 = new String(b1, "UTF-8"); assertEquals(str, str2); // TODO setString with encoding }
@Test public void testGetShort() throws Exception { int numShorts = 100; Buffer b = new Buffer(numShorts * 2); for (short i = 0; i < numShorts; i++) { b.setShort(i * 2, i); } for (short i = 0; i < numShorts; i++) { assertEquals(i, b.getShort(i * 2)); } }
@Test public void testGetDouble() throws Exception { int numDoubles = 100; Buffer b = new Buffer(numDoubles * 8); for (int i = 0; i < numDoubles; i++) { b.setDouble(i * 8, i); } for (int i = 0; i < numDoubles; i++) { assertEquals((double) i, b.getDouble(i * 8)); } }
private void testSetBytesBuffer(Buffer buff) throws Exception { Buffer b = TestUtils.generateRandomBuffer(100); buff.setBuffer(50, b); byte[] b2 = buff.getBytes(50, 150); assertTrue(TestUtils.buffersEqual(b, new Buffer(b2))); byte[] b3 = TestUtils.generateRandomByteArray(100); buff.setBytes(50, b3); byte[] b4 = buff.getBytes(50, 150); assertTrue(TestUtils.buffersEqual(new Buffer(b3), new Buffer(b4))); }
@Test public void testCopy() throws Exception { Buffer buff = TestUtils.generateRandomBuffer(100); assertTrue(TestUtils.buffersEqual(buff, buff.copy())); Buffer copy = buff.getBuffer(0, buff.length()); assertTrue(TestUtils.buffersEqual(buff, copy)); // Make sure they don't share underlying buffer buff.setInt(0, 1); assertTrue(!TestUtils.buffersEqual(buff, copy)); }
@Test public void testGetFloat() throws Exception { int numFloats = 100; Buffer b = new Buffer(numFloats * 4); for (int i = 0; i < numFloats; i++) { b.setFloat(i * 4, i); } for (int i = 0; i < numFloats; i++) { assertEquals((float) i, b.getFloat(i * 4)); } }
@Test public void testhandleOne() { final EventManager eventManager = mock(EventManager.class); final PostParams postParams = new PostParams(eventManager); final Buffer buff = new Buffer(); buff.appendString("param1=value1"); postParams.handle(buff); final ArgumentCaptor<HashMap> arguments = ArgumentCaptor.forClass(HashMap.class); verify(eventManager, only()).run(arguments.capture()); assertEquals(1, arguments.getValue().entrySet().size()); assertEquals("value1", arguments.getValue().get("param1")); }
Icon(Buffer buffer) { headers = new HashMap<>(); body = buffer; headers.put("content-type", "image/x-icon"); headers.put("content-length", buffer.length()); try { MessageDigest md = MessageDigest.getInstance("MD5"); headers.put("etag", "\"" + Utils.base64(md.digest(buffer.getBytes())) + "\""); } catch (NoSuchAlgorithmException e) { // ignore } headers.put("cache-control", "public, max-age=" + (maxAge / 1000)); }
public void fillInRequest(HttpClientRequest req, String hostHeader) throws Exception { req.headers().put(HttpHeaders.Names.CONNECTION, "Upgrade"); req.headers().put(HttpHeaders.Names.UPGRADE, "WebSocket"); req.headers().put(HttpHeaders.Names.HOST, hostHeader); req.headers().put(HttpHeaders.Names.SEC_WEBSOCKET_KEY1, this.challenge.getKey1String()); req.headers().put(HttpHeaders.Names.SEC_WEBSOCKET_KEY2, this.challenge.getKey2String()); Buffer buff = new Buffer(6); buff.appendBytes(challenge.getKey3()); buff.appendByte((byte) '\r'); buff.appendByte((byte) '\n'); req.write(buff); }
@Override public void onData(Buffer input) { // Create our own copy since we will process later. final ByteBuffer source = ByteBuffer.wrap(input.getBytes()); serializer.execute( new Runnable() { @Override public void run() { LOG.trace("Received from Broker {} bytes:", source.remaining()); do { ByteBuffer buffer = protonTransport.getInputBuffer(); int limit = Math.min(buffer.remaining(), source.remaining()); ByteBuffer duplicate = source.duplicate(); duplicate.limit(source.position() + limit); buffer.put(duplicate); protonTransport.processInput(); source.position(source.position() + limit); } while (source.hasRemaining()); // Process the state changes from the latest data and then answer back // any pending updates to the Broker. processUpdates(); pumpToProtonTransport(); } }); }
public void onComplete(HttpClientResponse response, final CompletionHandler<Void> doneHandler) { final Buffer buff = Buffer.create(16); response.dataHandler( new Handler<Buffer>() { public void handle(Buffer data) { buff.appendBuffer(data); } }); response.endHandler( new SimpleHandler() { public void handle() { byte[] bytes = buff.getBytes(); SimpleFuture<Void> fut = new SimpleFuture<>(); try { if (challenge.verify(bytes)) { fut.setResult(null); } else { fut.setException(new Exception("Invalid websocket handshake response")); } } catch (Exception e) { fut.setException(e); } doneHandler.handle(fut); } }); }
/** * Same as {@link #end()} but writes some data to the request body before ending. If the request * is not chunked and no other data has been written then the Content-Length header will be * automatically set */ public void end(Buffer chunk) { if (!chunked && contentLength == 0) { contentLength = chunk.length(); request.setHeader(HttpHeaders.Names.CONTENT_LENGTH, String.valueOf(contentLength)); } write(chunk); end(); }
private void hecPost(String bodyContent) throws Exception { Buffer buff = new Buffer(); buff.appendString(bodyContent); HttpClientRequest request = client.post( "/services/collector", new Handler<HttpClientResponse>() { public void handle(HttpClientResponse resp) { if (resp.statusCode() != 200) logger.error("Got a response: " + resp.statusCode()); } }); request.headers().set("Authorization", "Splunk " + token); request.headers().set("Content-Length", String.valueOf(bodyContent.length())); request.write(buff); request.end(); }
@Override public void handle(Buffer body) { String query = body.getString(0, body.length()); if (Strings.isNullOrEmpty(query) || query.equals("{}")) { replyHandler.replyForError(null); return; } // object.putString("req-id",requestId); Action action = new Action(); action.setId(requestId); action.setCategory(StringConstants.ACTION); action.setLabel(IManagerConstants.PUT_ENC_OBJECT); action.setOwnerId(com.getId()); action.setComponentType("webservice"); action.setTriggered(""); action.setTriggers(new JsonArray()); JsonObject object = new JsonObject(query); action.setData(object); action.setDestination(StringConstants.IMANAGERQUEUE); action.setStatus(ActionStatus.PENDING.toString()); com.sendRequestTo(StringConstants.IMANAGERQUEUE, action.asJsonObject(), replyHandler); }
private void parseConfigAndStart(final Buffer buffer) { final JsonObject config = new JsonObject(buffer.toString()); container.deployModule( METRICS_MODULE, config.getObject("metrics"), ar -> { if (ar.succeeded()) { container .logger() .fatal("Deployed: " + METRICS_MODULE + " with id: " + ar.result(), ar.cause()); start(config); } else { container.logger().fatal("Failed to deploy: " + METRICS_MODULE, ar.cause()); } }); }
@Test public void testAppendBytes() throws Exception { int bytesLen = 100; byte[] bytes = TestUtils.generateRandomByteArray(bytesLen); Buffer b = new Buffer(); b.appendBytes(bytes); assertEquals(b.length(), bytes.length); assertTrue(TestUtils.byteArraysEqual(bytes, b.getBytes())); b.appendBytes(bytes); assertEquals(b.length(), 2 * bytes.length); }