protected Object readCommand() throws IOException { return wireFormat.unmarshal(dataIn); }
public void oneway(Object command) throws IOException { next.oneway((Command) remoteWireFormat.unmarshal(localWireFormat.marshal(command))); }
@Override public void recover(TransactionRecoveryListener listener) throws IOException { for (Map.Entry<TransactionId, ArrayList<Operation>> entry : preparedTransactions.entrySet()) { XATransactionId xid = (XATransactionId)entry.getKey(); ArrayList<Message> messageList = new ArrayList<Message>(); ArrayList<MessageAck> ackList = new ArrayList<MessageAck>(); for (Operation op : entry.getValue()) { if( op.getClass() == AddOpperation.class ) { AddOpperation addOp = (AddOpperation)op; Message msg = (Message)wireFormat.unmarshal( new DataInputStream(addOp.getCommand().getMessage().newInput()) ); messageList.add(msg); } else { RemoveOpperation rmOp = (RemoveOpperation)op; MessageAck ack = (MessageAck)wireFormat.unmarshal( new DataInputStream(rmOp.getCommand().getAck().newInput()) ); ackList.add(ack); } } Message[] addedMessages = new Message[messageList.size()]; MessageAck[] acks = new MessageAck[ackList.size()]; messageList.toArray(addedMessages); ackList.toArray(acks); listener.recover(xid, addedMessages, acks); } } @Override
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { if (listener.hasSpace()) { Message msg = (Message) wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); } else { if (LOG.isTraceEnabled()) { LOG.trace("Message recovery limit reached for MessageRecoveryListener"); } return false; } }
@Override public synchronized void recover(TransactionRecoveryListener listener) throws IOException { for (Map.Entry<TransactionId, List<Operation>> entry : theStore.preparedTransactions.entrySet()) { XATransactionId xid = (XATransactionId) entry.getKey(); ArrayList<Message> messageList = new ArrayList<Message>(); ArrayList<MessageAck> ackList = new ArrayList<MessageAck>(); for (Operation op : entry.getValue()) { if (op.getClass() == MessageDatabase.AddOperation.class) { MessageDatabase.AddOperation addOp = (MessageDatabase.AddOperation) op; Message msg = (Message) wireFormat().unmarshal(new DataInputStream(addOp.getCommand().getMessage() .newInput())); messageList.add(msg); } else { MessageDatabase.RemoveOperation rmOp = (MessageDatabase.RemoveOperation) op; Buffer ackb = rmOp.getCommand().getAck(); MessageAck ack = (MessageAck) wireFormat().unmarshal(new DataInputStream(ackb.newInput())); ackList.add(ack); } } Message[] addedMessages = new Message[messageList.size()]; MessageAck[] acks = new MessageAck[ackList.size()]; messageList.toArray(addedMessages); ackList.toArray(acks); xid.setPreparedAcks(ackList); theStore.trackRecoveredAcks(ackList); listener.recover(xid, addedMessages, acks); } }
protected Message getMessage(ByteSequence bs) throws IOException { org.apache.activemq.util.ByteSequence packet = new org.apache.activemq.util.ByteSequence(bs.getData(), bs .getOffset(), bs.getLength()); return (Message) this.wireFormat.unmarshal(packet); }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); }
currentBuffer.flip(); Object command = wireFormat.unmarshal(new DataInputStream(new NIOInputStream(currentBuffer))); doConsume(command);
@Override public Message getMessage(MessageId identity) throws IOException { final String key = identity.toProducerKey(); // Hopefully one day the page file supports concurrent read operations... but for now we must // externally synchronize... ByteSequence data; synchronized(indexMutex) { data = pageFile.tx().execute(new Transaction.CallableClosure<ByteSequence, IOException>(){ @Override public ByteSequence execute(Transaction tx) throws IOException { StoredDestination sd = getStoredDestination(dest, tx); Long sequence = sd.messageIdIndex.get(tx, key); if( sequence ==null ) { return null; } return sd.orderIndex.get(tx, sequence).data; } }); } if( data == null ) { return null; } Message msg = (Message)wireFormat.unmarshal( data ); return msg; }
/** * @param location * @return * @throws IOException */ public DataStructure readCommand(RecordLocation location) throws IOException { try { Packet packet = journal.read(location); return (DataStructure)wireFormat.unmarshal(toByteSequence(packet)); } catch (InvalidRecordLocationException e) { throw createReadException(location, e); } catch (IOException e) { throw createReadException(location, e); } }
public void onCommand(Object command) { try { getTransportListener().onCommand((Command)localWireFormat.unmarshal(remoteWireFormat.marshal(command))); } catch (IOException e) { getTransportListener().onException(e); } }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { if (delegate.hasSpace() && recoveredCount < maxMessages) { Message msg = (Message) wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); lastRecovered.recovered = sequenceId; if (delegate.recoverMessage(msg)) { recoveredCount++; return true; } } return false; }
throw new IOException("Could not load journal record, null message content at location: " + location); Message msg = (Message) wireFormat.unmarshal(new DataInputStream(addMessage.getMessage().newInput())); return msg; } catch (Throwable t) {
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); msg.getMessageId().setFutureOrSequenceLong(sequenceId); msg.getMessageId().setEntryLocator(sequenceId); listener.recoverMessage(msg); trackLastRecovered(sequenceId, msg.getPriority()); return true; }
@Override public Message getMessage(MessageId messageId) throws IOException { // Get a connection and pull the message out of the DB TransactionContext c = persistenceAdapter.getTransactionContext(); try { byte data[] = adapter.doGetMessage(c, messageId); if (data == null) { return null; } Message answer = (Message)wireFormat.unmarshal(new ByteSequence(data)); return answer; } catch (IOException e) { throw IOExceptionSupport.create("Failed to broker message: " + messageId + " in container: " + e, e); } catch (SQLException e) { JDBCPersistenceAdapter.log("JDBC Failure: ", e); throw IOExceptionSupport.create("Failed to broker message: " + messageId + " in container: " + e, e); } finally { c.close(); } }
public void recoverAdd(long id, byte[] messageBytes) throws IOException { final Message message = (Message) ((JDBCPersistenceAdapter)persistenceAdapter).getWireFormat().unmarshal(new ByteSequence(messageBytes)); message.getMessageId().setFutureOrSequenceLong(id); message.getMessageId().setEntryLocator(id); Tx tx = getPreparedTx(message.getTransactionId()); tx.add(new CommitAddOutcome(null, message)); }
@Override public long getLastMessageBrokerSequenceId() throws IOException { TransactionContext c = getTransactionContext(); try { long seq = getAdapter().doGetLastMessageStoreSequenceId(c); sequenceGenerator.setLastSequenceId(seq); long brokerSeq = 0; if (seq != 0) { byte[] msg = getAdapter().doGetMessageById(c, seq); if (msg != null) { Message last = (Message)wireFormat.unmarshal(new ByteSequence(msg)); brokerSeq = last.getMessageId().getBrokerSequenceId(); } else { LOG.warn("Broker sequence id wasn't recovered properly, possible duplicates!"); } } return brokerSeq; } catch (SQLException e) { JDBCPersistenceAdapter.log("JDBC Failure: ", e); throw IOExceptionSupport.create("Failed to get last broker message id: " + e, e); } finally { c.close(); } }
public void recoverAck(long id, byte[] xid, byte[] message) throws IOException { final Message msg = (Message) ((JDBCPersistenceAdapter)persistenceAdapter).getWireFormat().unmarshal(new ByteSequence(message)); msg.getMessageId().setFutureOrSequenceLong(id); msg.getMessageId().setEntryLocator(id); Tx tx = getPreparedTx(new XATransactionId(xid)); final MessageAck ack = new MessageAck(msg, MessageAck.STANDARD_ACK_TYPE, 1); tx.add(new RecoveredRemoveMessageCommand() { MessageStore messageStore = null; @Override public MessageAck getMessageAck() { return ack; } @Override public void run(ConnectionContext context) throws IOException { ((JDBCPersistenceAdapter)persistenceAdapter).commitRemove(context, ack); } public Message getMessage() { return msg; } @Override public void setMessageStore(MessageStore messageStore) { this.messageStore = messageStore; } @Override public MessageStore getMessageStore() { return messageStore; } }); }
org.apache.activemq.util.ByteSequence packet = new org.apache.activemq.util.ByteSequence(job.getData(), job.getOffset(), job.getLength()); try { Message messageSend = (Message) wireFormat.unmarshal(packet); messageSend.setOriginalTransactionId(null); Object repeatValue = messageSend.getProperty(ScheduledMessage.AMQ_SCHEDULED_REPEAT);
Message msg = (Message) this.wireFormat.unmarshal(packet); msg.setOriginalTransactionId(null); msg.setPersistent(false);