Refine search
protected static String printPayload(Message msg, final StringBuilder sb) { byte[] payload=msg.getRawBuffer(); int print_max=Math.min(msg.getLength(), 50); for(int i=msg.getOffset(); i < print_max; i++) { byte ch=payload[i]; sb.append((char)ch); } return null; } }
/** * Message contains a Command. Execute it against *this* object and return result. */ @Override public Object handle(Message req) { if (isValid(req)) { try { ReplicableCommand command = (ReplicableCommand) req_marshaller.objectFromByteBuffer(req.getBuffer(), req.getOffset(), req.getLength()); Object execResult = executeCommand(command, req); if (log.isTraceEnabled()) log.trace("Command : " + command + " executed, result is: " + execResult); return execResult; } catch (Throwable x) { if (trace) log.trace("Problems invoking command.", x); return x; } } else { return null; } }
protected Message _decrypt(final Cipher cipher, Message msg) throws Exception { if(msg.getLength() == 0) return msg; byte[] decrypted_msg; if(cipher == null) decrypted_msg=code(msg.getRawBuffer(), msg.getOffset(), msg.getLength(), true); else try { decrypted_msg=cipher.doFinal(msg.getRawBuffer(), msg.getOffset(), msg.getLength()); } catch(BadPaddingException | IllegalBlockSizeException e) { // if any exception is thrown, this cipher object may need to be reset before it can be used again. cipher.init(Cipher.DECRYPT_MODE, secret_key); throw e; } return msg.setBuffer(decrypted_msg); }
public void receive(Message msg) { try { TotOrderRequest req=new TotOrderRequest(); ByteBuffer buf=ByteBuffer.wrap(msg.getRawBuffer(), msg.getOffset(), msg.getLength()); req.init(buf); processRequest(req); } catch(Exception e) { System.err.println(e); } }
public void receive(Message msg) { byte[] buf=msg.getRawBuffer(); byte type=buf[msg.getOffset()]; switch(type) { case START: ByteBuffer tmp=ByteBuffer.wrap(buf, 1+msg.getOffset(), Global.LONG_SIZE); num_msgs=(int)tmp.getLong(); print=num_msgs / 10; current_value.set(0); total_bytes.set(0); start=System.currentTimeMillis(); break; case DATA: long new_val=current_value.incrementAndGet(); total_bytes.addAndGet(msg.getLength() - Global.INT_SIZE); if(print > 0 && new_val % print == 0) System.out.println("received " + new_val); if(new_val >= num_msgs) { long time=System.currentTimeMillis() - start; double msgs_sec=(current_value.get() / (time / 1000.0)); double throughput=total_bytes.get() / (time / 1000.0); System.out.println(String.format("\nreceived %d messages in %d ms (%.2f msgs/sec), throughput=%s", current_value.get(), time, msgs_sec, Util.printBytes(throughput))); break; } break; default: System.err.println("Type " + type + " is invalid"); } }
/** * Assembles all the fragments into one buffer. Takes all Messages, and combines their buffers into one * buffer. * This method does not check if the fragmentation is complete (use {@link #isComplete()} to verify * before calling this method) * @return the complete message in one buffer * */ protected Message assembleMessage() { Message retval; byte[] combined_buffer, tmp; int combined_length=0, length, offset; int index=0; for(Message fragment: fragments) combined_length+=fragment.getLength(); combined_buffer=new byte[combined_length]; retval=fragments[0].copy(false); // doesn't copy the payload, but copies the headers for(int i=0; i < fragments.length; i++) { Message fragment=fragments[i]; fragments[i]=null; // help garbage collection a bit tmp=fragment.getRawBuffer(); length=fragment.getLength(); offset=fragment.getOffset(); System.arraycopy(tmp, offset, combined_buffer, index, length); index+=length; } retval.setBuffer(combined_buffer); return retval; }
public void receive(Message msg) { byte[] buf=msg.getRawBuffer(); byte type=buf[msg.getOffset()]; switch(type) { case START: ByteBuffer tmp=ByteBuffer.wrap(buf, 1+msg.getOffset(), Global.LONG_SIZE); num_msgs=(int)tmp.getLong(); print=num_msgs / 10; current_value.set(0); total_bytes.set(0); start=System.currentTimeMillis(); break; case DATA: long new_val=current_value.incrementAndGet(); total_bytes.addAndGet(msg.getLength() - Global.INT_SIZE); if(print > 0 && new_val % print == 0) System.out.println("received " + new_val); if(new_val >= num_msgs) { long time=System.currentTimeMillis() - start; double msgs_sec=(current_value.get() / (time / 1000.0)); double throughput=total_bytes.get() / (time / 1000.0); System.out.println(String.format("\nreceived %d messages in %d ms (%.2f msgs/sec), throughput=%s", current_value.get(), time, msgs_sec, Util.printBytes(throughput))); break; } break; default: System.err.println("Type " + type + " is invalid"); } }
public void receive(Message msg) { byte[] buf=msg.getRawBuffer(); byte type=buf[msg.getOffset()]; switch(type) { case START: ByteBuffer tmp=ByteBuffer.wrap(buf, 1+msg.getOffset(), Global.LONG_SIZE); num_msgs=(int)tmp.getLong(); print=num_msgs / 10; current_value.set(0); total_bytes.set(0); start=System.currentTimeMillis(); break; case DATA: long new_val=current_value.incrementAndGet(); total_bytes.addAndGet(msg.getLength() - Global.INT_SIZE); if(print > 0 && new_val % print == 0) System.out.println("received " + new_val); if(new_val >= num_msgs) { long time=System.currentTimeMillis() - start; double msgs_sec=(current_value.get() / (time / 1000.0)); double throughput=total_bytes.get() / (time / 1000.0); System.out.println(String.format("\nreceived %d messages in %d ms (%.2f msgs/sec), throughput=%s", current_value.get(), time, msgs_sec, Util.printBytes(throughput))); break; } break; default: System.err.println("Type " + type + " is invalid"); } }
public void receive(Message msg) { if(receiver == null) return; try { receiver.receive(msg.src(), msg.getRawBuffer(), msg.getOffset(), msg.getLength()); } catch(Throwable t) { log.error("failed delivering message", t); } }
protected void encryptAndSend(Message msg) throws Exception { EncryptHeader hdr=new EncryptHeader(EncryptHeader.ENCRYPT, symVersion()); // copy neeeded because same message (object) may be retransmitted -> prevent double encryption Message msgEncrypted=msg.copy(false).putHeader(this.id, hdr); if(msg.getLength() > 0) msgEncrypted.setBuffer(code(msg.getRawBuffer(),msg.getOffset(),msg.getLength(),false)); else { // length is 0 byte[] payload=msg.getRawBuffer(); if(payload != null) // we don't encrypt empty buffers (https://issues.jboss.org/browse/JGRP-2153) msgEncrypted.setBuffer(payload, msg.getOffset(), msg.getLength()); } down_prot.down(msgEncrypted); }
public void receive(Message msg) { if(msg == null || msg.getLength() == 0) { log.error("DrawApplet.run(): msg or msg.buffer is null !"); return; } instream=new DataInputStream(new ByteArrayInputStream(msg.getRawBuffer(), msg.getOffset(), msg.getLength())); int r=0; try { r=instream.readInt(); if(r == -13) { clearPanel(); return; } int g=instream.readInt(); int b=instream.readInt(); int my_x=instream.readInt(); int my_y=instream.readInt(); if(graphics != null) { graphics.setColor(new Color(r, g, b)); graphics.fillOval(my_x, my_y, 10, 10); graphics.setColor(default_color); } } catch(Exception ex) { ex.printStackTrace(); } } });
public void receive(MessageBatch batch) { if(receiver == null) return; for(Message msg: batch) { try { receiver.receive(msg.src(), msg.getRawBuffer(), msg.getOffset(), msg.getLength()); } catch(Throwable t) { log.error("failed delivering message from batch", t); } } }
protected Object handleUpEvent(Message msg, RelayHeader hdr) { switch(hdr.type) { case DISSEMINATE: Message copy=msg.copy(); if(hdr.original_sender != null) copy.setSrc(hdr.original_sender); return up_prot.up(copy); case FORWARD: if(is_coord) forward(msg.getRawBuffer(), msg.getOffset(), msg.getLength()); break; case VIEW: return installView(msg.getRawBuffer(), msg.getOffset(), msg.getLength()); case BROADCAST_VIEW: break; default: throw new IllegalArgumentException(hdr.type + " is not a valid type"); } return null; }
private Callable<Object> read(Message message) throws Exception { try (DataInputStream input = new DataInputStream(new ByteArrayInputStream(message.getRawBuffer(), message.getOffset(), message.getLength()))) { int version = IndexSerializer.VARIABLE.readInt(input); try (Unmarshaller unmarshaller = this.marshallingContext.createUnmarshaller(version)) { unmarshaller.start(Marshalling.createByteInput(input)); Object clientId = unmarshaller.readObject(); Optional<Object> context = this.contexts.get(clientId); if (context == null) return () -> NoSuchService.INSTANCE; @SuppressWarnings("unchecked") Command<Object, Object> command = (Command<Object, Object>) unmarshaller.readObject(); // Wrap execution result in an Optional, since command execution might return null ExceptionSupplier<Optional<Object>, Exception> task = () -> Optional.ofNullable(command.execute(context.orElse(null))); return () -> this.executor.execute(task).orElse(Optional.of(NoSuchService.INSTANCE)).orElse(null); } } }
/** Returns a new message as a result of uncompressing msg, or null if msg couldn't be uncompressed */ protected Message uncompress(Message msg, int original_size) { byte[] compressed_payload=msg.getRawBuffer(); if(compressed_payload != null && compressed_payload.length > 0) { byte[] uncompressed_payload=new byte[original_size]; Inflater inflater=null; try { inflater=inflater_pool.take(); inflater.reset(); inflater.setInput(compressed_payload, msg.getOffset(), msg.getLength()); try { inflater.inflate(uncompressed_payload); // we need to copy: https://jira.jboss.org/jira/browse/JGRP-867 return msg.copy(false).setBuffer(uncompressed_payload); } catch(DataFormatException e) { log.error(Util.getMessage("CompressionFailure"), e); } } catch(InterruptedException e) { Thread.currentThread().interrupt(); // set the interrupt bit again, so caller can handle it } finally { if(inflater != null) inflater_pool.offer(inflater); } } return null; }
/** Adds a fragment to the full message */ public Message set(Message frag_msg, Frag3Header hdr) { lock.lock(); try { if(buffer == null) buffer=new byte[hdr.original_length]; if(hdr.frag_id == 0) { // the first fragment creates the message, copy the headers but not the buffer msg=frag_msg.copy(false); } if(received.set(hdr.frag_id)) { // if not yet added: copy the fragment's buffer into msg.buffer at the correct offset int frag_length=frag_msg.getLength(); int offset=hdr.offset; System.arraycopy(frag_msg.getRawBuffer(), frag_msg.getOffset(), buffer, offset, frag_length); if(isComplete()) return assembleMessage(); } return null; } finally { lock.unlock(); } }
protected void dispatch(final Message msg, final Header hdr) { switch(hdr.type) { case Header.REQ: handleRequest(msg, hdr); break; case Header.RSP: case Header.EXC_RSP: Request req=requests.get(hdr.req_id); if(req != null) handleResponse(req, msg.src(), msg.getRawBuffer(), msg.getOffset(), msg.getLength(), hdr.type == Header.EXC_RSP); break; default: log.error(Util.getMessage("HeaderSTypeIsNeitherREQNorRSP")); break; } }
HashMap<String, String> hdrs=new HashMap<>(); hdrs.put("sender", msg.getSrc().toString()); sendToClients(hdrs, msg.getRawBuffer(), msg.getOffset(), msg.getLength()); sendToClients(hdr.headers, msg.getRawBuffer(), msg.getOffset(), msg.getLength()); break; case ENDPOINT:
public Object up(Message msg) { StableHeader hdr=msg.getHeader(this.id); if(hdr == null) { handleRegularMessage(msg); return up_prot.up(msg); } handleUpEvent(hdr, msg.getSrc(), readDigest(msg.getRawBuffer(), msg.getOffset(), msg.getLength())); return null; // don't pass STABLE or STABILITY messages up the stack }
public void receive(Message msg) { byte[] buf=msg.getRawBuffer(); if(buf == null) { System.err.printf("%s: received null buffer from %s, headers: %s\n", channel.getAddress(), msg.src(), msg.printHeaders()); return; } try { DrawCommand comm=Util.streamableFromByteBuffer(DrawCommand::new, buf, msg.getOffset(), msg.getLength()); switch(comm.mode) { case DrawCommand.DRAW: if(panel != null) panel.drawPoint(comm); break; case DrawCommand.CLEAR: clearPanel(); break; default: System.err.println("***** received invalid draw command " + comm.mode); break; } } catch(Exception e) { e.printStackTrace(); } }