protected void tightMarshalCachedObject2( OpenWireFormat wireFormat, DataStructure o, DataOutput dataOut, BooleanStream bs) throws IOException { if (wireFormat.isCacheEnabled()) { Short index = wireFormat.getMarshallCacheIndex(o); if (bs.readBoolean()) { dataOut.writeShort(index.shortValue()); wireFormat.tightMarshalNestedObject2(o, dataOut, bs); } else { dataOut.writeShort(index.shortValue()); } } else { wireFormat.tightMarshalNestedObject2(o, dataOut, bs); } }
protected int tightMarshalThrowable1(OpenWireFormat wireFormat, Throwable o, BooleanStream bs) throws IOException { if (o == null) { bs.writeBoolean(false); return 0; } else { int rc = 0; bs.writeBoolean(true); rc += tightMarshalString1(o.getClass().getName(), bs); rc += tightMarshalString1(o.getMessage(), bs); if (wireFormat.isStackTraceEnabled()) { rc += 2; StackTraceElement[] stackTrace = o.getStackTrace(); for (int i = 0; i < stackTrace.length; i++) { StackTraceElement element = stackTrace[i]; rc += tightMarshalString1(element.getClassName(), bs); rc += tightMarshalString1(element.getMethodName(), bs); rc += tightMarshalString1(element.getFileName(), bs); rc += 4; } rc += tightMarshalThrowable1(wireFormat, o.getCause(), bs); } return rc; } }
protected DataStructure looseUnmarsalCachedObject(OpenWireFormat wireFormat, DataInput dataIn) throws IOException { if (wireFormat.isCacheEnabled()) { if (dataIn.readBoolean()) { short index = dataIn.readShort(); DataStructure object = wireFormat.looseUnmarshalNestedObject(dataIn); wireFormat.setInUnmarshallCache(index, object); return object; } else { short index = dataIn.readShort(); return wireFormat.getFromUnmarshallCache(index); } } else { return wireFormat.looseUnmarshalNestedObject(dataIn); } }
protected void looseMarshalCachedObject( OpenWireFormat wireFormat, DataStructure o, DataOutput dataOut) throws IOException { if (wireFormat.isCacheEnabled()) { Short index = wireFormat.getMarshallCacheIndex(o); dataOut.writeBoolean(index == null); if (index == null) { index = wireFormat.addToMarshallCache(o); dataOut.writeShort(index.shortValue()); wireFormat.looseMarshalNestedObject(o, dataOut); } else { dataOut.writeShort(index.shortValue()); } } else { wireFormat.looseMarshalNestedObject(o, dataOut); } }
protected int tightMarshalCachedObject1( OpenWireFormat wireFormat, DataStructure o, BooleanStream bs) throws IOException { if (wireFormat.isCacheEnabled()) { Short index = wireFormat.getMarshallCacheIndex(o); bs.writeBoolean(index == null); if (index == null) { int rc = wireFormat.tightMarshalNestedObject1(o, bs); wireFormat.addToMarshallCache(o); return 2 + rc; } else { return 2; } } else { return wireFormat.tightMarshalNestedObject1(o, bs); } }
public void physicalSend(Command command) throws IOException { try { ByteSequence bytes = wireFormat.marshal(command); ActiveMQBuffer buffer = OpenWireUtil.toActiveMQBuffer(bytes); synchronized (sendLock) { getTransportConnection().write(buffer, false, false); } } catch (IOException e) { throw e; } catch (Throwable t) { ActiveMQServerLogger.LOGGER.error("error sending", t); } }
protected Throwable looseUnmarsalThrowable(OpenWireFormat wireFormat, DataInput dataIn) throws IOException { if (dataIn.readBoolean()) { String clazz = looseUnmarshalString(dataIn); String message = looseUnmarshalString(dataIn); Throwable o = createThrowable(clazz, message); if (wireFormat.isStackTraceEnabled()) { if (STACK_TRACE_ELEMENT_CONSTRUCTOR != null) { StackTraceElement ss[] = new StackTraceElement[dataIn.readShort()]; for (int i = 0; i < ss.length; i++) { try { ss[i] = (StackTraceElement) STACK_TRACE_ELEMENT_CONSTRUCTOR.newInstance( new Object[] { looseUnmarshalString(dataIn), looseUnmarshalString(dataIn), looseUnmarshalString(dataIn), Integer.valueOf(dataIn.readInt()) }); } catch (IOException e) { throw e; } catch (Throwable e) { } } o.setStackTrace(ss); } else { short size = dataIn.readShort(); for (int i = 0; i < size; i++) { looseUnmarshalString(dataIn); looseUnmarshalString(dataIn); looseUnmarshalString(dataIn); dataIn.readInt(); } } o.initCause(looseUnmarsalThrowable(wireFormat, dataIn)); } return o; } else { return null; } }
protected void looseMarshalThrowable(OpenWireFormat wireFormat, Throwable o, DataOutput dataOut) throws IOException { dataOut.writeBoolean(o != null); if (o != null) { looseMarshalString(o.getClass().getName(), dataOut); looseMarshalString(o.getMessage(), dataOut); if (wireFormat.isStackTraceEnabled()) { StackTraceElement[] stackTrace = o.getStackTrace(); dataOut.writeShort(stackTrace.length); for (int i = 0; i < stackTrace.length; i++) { StackTraceElement element = stackTrace[i]; looseMarshalString(element.getClassName(), dataOut); looseMarshalString(element.getMethodName(), dataOut); looseMarshalString(element.getFileName(), dataOut); dataOut.writeInt(element.getLineNumber()); } looseMarshalThrowable(wireFormat, o.getCause(), dataOut); } } }
protected void tightMarshalThrowable2( OpenWireFormat wireFormat, Throwable o, DataOutput dataOut, BooleanStream bs) throws IOException { if (bs.readBoolean()) { tightMarshalString2(o.getClass().getName(), dataOut, bs); tightMarshalString2(o.getMessage(), dataOut, bs); if (wireFormat.isStackTraceEnabled()) { StackTraceElement[] stackTrace = o.getStackTrace(); dataOut.writeShort(stackTrace.length); for (int i = 0; i < stackTrace.length; i++) { StackTraceElement element = stackTrace[i]; tightMarshalString2(element.getClassName(), dataOut, bs); tightMarshalString2(element.getMethodName(), dataOut, bs); tightMarshalString2(element.getFileName(), dataOut, bs); dataOut.writeInt(element.getLineNumber()); } tightMarshalThrowable2(wireFormat, o.getCause(), dataOut, bs); } } }
@Override public void bufferReceived(Object connectionID, ActiveMQBuffer buffer) { try { dataReceived = true; Command command = (Command) wireFormat.unmarshal(buffer); boolean responseRequired = command.isResponseRequired(); int commandId = command.getCommandId(); // the connection handles pings, negotiations directly. // and delegate all other commands to manager. if (command.getClass() == KeepAliveInfo.class) { KeepAliveInfo info = (KeepAliveInfo) command; info.setResponseRequired(false); // if we don't respond to KeepAlive commands then the client will think the server is dead // and timeout // for some reason KeepAliveInfo.isResponseRequired() is always false protocolManager.sendReply(this, info); } else if (command.getClass() == WireFormatInfo.class) { // amq here starts a read/write monitor thread (detect ttl?) negotiate((WireFormatInfo) command); } else if (command.getClass() == ConnectionInfo.class || command.getClass() == ConsumerInfo.class || command.getClass() == RemoveInfo.class || command.getClass() == SessionInfo.class || command.getClass() == ProducerInfo.class || ActiveMQMessage.class.isAssignableFrom(command.getClass()) || command.getClass() == MessageAck.class || command.getClass() == TransactionInfo.class || command.getClass() == DestinationInfo.class || command.getClass() == ShutdownInfo.class || command.getClass() == RemoveSubscriptionInfo.class) { Response response = null; if (pendingStop) { response = new ExceptionResponse(this.stopError); } else { response = ((Command) command).visit(this); if (response instanceof ExceptionResponse) { if (!responseRequired) { Throwable cause = ((ExceptionResponse) response).getException(); serviceException(cause); response = null; } } } if (responseRequired) { if (response == null) { response = new Response(); } } // The context may have been flagged so that the response is not // sent. if (context != null) { if (context.isDontSendReponse()) { context.setDontSendReponse(false); response = null; } } if (response != null && !protocolManager.isStopping()) { response.setCorrelationId(commandId); dispatchSync(response); } } else { // note!!! wait for negotiation (e.g. use a countdown latch) // before handling any other commands this.protocolManager.handleCommand(this, command); } } catch (IOException e) { ActiveMQServerLogger.LOGGER.error("error decoding", e); } catch (Throwable t) { ActiveMQServerLogger.LOGGER.error("error decoding", t); } }
@Override public Response processAddConnection(ConnectionInfo info) throws Exception { WireFormatInfo wireFormatInfo = wireFormat.getPreferedWireFormatInfo(); // Older clients should have been defaulting this field to true.. but // they were not. if (wireFormatInfo != null && wireFormatInfo.getVersion() <= 2) { info.setClientMaster(true); } state = new ConnectionState(info); context = new AMQConnectionContext(); state.reset(info); this.faultTolerantConnection = info.isFaultTolerant(); // Setup the context. String clientId = info.getClientId(); context.setBroker(protocolManager); context.setClientId(clientId); context.setClientMaster(info.isClientMaster()); context.setConnection(this); context.setConnectionId(info.getConnectionId()); // for now we pass the manager as the connector and see what happens // it should be related to activemq's Acceptor context.setConnector(this.acceptorUsed); context.setMessageAuthorizationPolicy(getMessageAuthorizationPolicy()); context.setNetworkConnection(networkConnection); context.setFaultTolerant(faultTolerantConnection); context.setTransactions(new ConcurrentHashMap<TransactionId, AMQTransaction>()); context.setUserName(info.getUserName()); context.setWireFormatInfo(wireFormatInfo); context.setReconnect(info.isFailoverReconnect()); this.manageable = info.isManageable(); context.setConnectionState(state); if (info.getClientIp() == null) { info.setClientIp(getRemoteAddress()); } try { protocolManager.addConnection(context, info); } catch (Exception e) { if (e instanceof SecurityException) { // close this down - in case the peer of this transport doesn't play // nice delayedStop(2000, "Failed with SecurityException: " + e.getLocalizedMessage(), e); } Response resp = new ExceptionResponse(e); return resp; } if (info.isManageable()) { // send ConnectionCommand ConnectionControl command = this.acceptorUsed.getConnectionControl(); command.setFaultTolerant(protocolManager.isFaultTolerantConfiguration()); if (info.isFailoverReconnect()) { command.setRebalanceConnection(false); } dispatchAsync(command); } return null; }
protected DataStructure tightUnmarsalNestedObject( OpenWireFormat wireFormat, DataInput dataIn, BooleanStream bs) throws IOException { return wireFormat.tightUnmarshalNestedObject(dataIn, bs); }
protected int tightMarshalNestedObject1( OpenWireFormat wireFormat, DataStructure o, BooleanStream bs) throws IOException { return wireFormat.tightMarshalNestedObject1(o, bs); }
protected void looseMarshalNestedObject( OpenWireFormat wireFormat, DataStructure o, DataOutput dataOut) throws IOException { wireFormat.looseMarshalNestedObject(o, dataOut); }
protected DataStructure looseUnmarsalNestedObject(OpenWireFormat wireFormat, DataInput dataIn) throws IOException { return wireFormat.looseUnmarshalNestedObject(dataIn); }
protected void tightMarshalNestedObject2( OpenWireFormat wireFormat, DataStructure o, DataOutput dataOut, BooleanStream bs) throws IOException { wireFormat.tightMarshalNestedObject2(o, dataOut, bs); }
// throw a WireFormatInfo to the peer public void init() { WireFormatInfo info = wireFormat.getPreferedWireFormatInfo(); protocolManager.send(this, info); }