@Override protected void processAck(Message msg, String opName) throws Exception { final int msgType = msg.getMessageType(); if (msgType == MessageType.REPLY) { return; } else { Part part = msg.getPart(0); if (msgType == MessageType.EXCEPTION) { Throwable t = (Throwable) part.getObject(); if (t instanceof CommitConflictException || t instanceof SynchronizationCommitConflictException) { throw (GemFireException) t; } } super.processAck(msg, opName); } }
protected void writeReply(Message origMsg, ServerConnection servConn, boolean entryNotFound, VersionTag tag) throws IOException { Message replyMsg = servConn.getReplyMessage(); servConn.getCache().getCancelCriterion().checkCancelInProgress(null); replyMsg.setMessageType(MessageType.REPLY); replyMsg.setNumberOfParts(2); replyMsg.setTransactionId(origMsg.getTransactionId()); replyMsg.addBytesPart(okBytes()); replyMsg.addIntPart(entryNotFound ? 1 : 0); replyMsg.send(servConn); if (logger.isTraceEnabled()) { logger.trace("{}: rpl tx: {} parts={}", servConn.getName(), origMsg.getTransactionId(), replyMsg.getNumberOfParts()); } }
protected static void writeErrorResponse(Message origMsg, int messageType, ServerConnection serverConnection) throws IOException { Message errorMsg = serverConnection.getErrorResponseMessage(); errorMsg.setMessageType(messageType); errorMsg.setNumberOfParts(1); errorMsg.setTransactionId(origMsg.getTransactionId()); errorMsg.addStringPart( "Invalid data received. Please see the cache server log file for additional details."); errorMsg.send(serverConnection); }
protected Message getGFEMessage() throws IOException { Message message = new Message(1, Version.CURRENT); message.setMessageType(MessageType.CLIENT_MARKER); message.setTransactionId(0); message.addObjPart(this.eventId); return message; }
public void addStringOrObjPart(Object o) { if (o instanceof String || o == null) { addStringPart((String) o); } else { // Note even if o is a byte[] we need to serialize it. // This could be cleaned up but it would require C client code to change. serializeAndAddPart(o, false); } }
protected static void writeResponseWithFunctionAttribute(byte[] data, Message origMsg, ServerConnection serverConnection) throws IOException { Message responseMsg = serverConnection.getResponseMessage(); responseMsg.setMessageType(MessageType.RESPONSE); responseMsg.setTransactionId(origMsg.getTransactionId()); responseMsg.setNumberOfParts(1); responseMsg.addBytesPart(data); serverConnection.getCache().getCancelCriterion().checkCancelInProgress(null); responseMsg.send(serverConnection); origMsg.clearParts(); }
@Test public void numberOfPartsIsAdjusted() { int numParts = this.message.getNumberOfParts(); this.message.setNumberOfParts(2 * numParts + 1); assertEquals(2 * numParts + 1, this.message.getNumberOfParts()); this.message.addBytesPart(new byte[1]); this.message.addIntPart(2); this.message.addLongPart(3); this.message.addObjPart("4"); this.message.addStringPart("5"); assertEquals(5, this.message.getNextPartNumber()); }
@Override public void cmdExecute(final Message clientMessage, final ServerConnection serverConnection, final SecurityService securityService, long start) throws IOException, ClassNotFoundException { serverConnection.setAsTrue(REQUIRES_RESPONSE); if (logger.isDebugEnabled()) { logger.debug("{}: Received get pdx id for enum request ({} parts) from {}", serverConnection.getName(), clientMessage.getNumberOfParts(), serverConnection.getSocketString()); } EnumInfo enumInfo = (EnumInfo) clientMessage.getPart(0).getObject(); int enumId = clientMessage.getPart(1).getInt(); try { InternalCache cache = serverConnection.getCache(); TypeRegistry registry = cache.getPdxRegistry(); registry.addRemoteEnum(enumId, enumInfo); } catch (Exception e) { writeException(clientMessage, e, false, serverConnection); serverConnection.setAsTrue(RESPONDED); return; } writeReply(clientMessage, serverConnection); serverConnection.setAsTrue(RESPONDED); } }
if (logger.isDebugEnabled()) { logger.debug("{}: Received get pdx enum by id request ({} parts) from {}", serverConnection.getName(), clientMessage.getNumberOfParts(), serverConnection.getSocketString()); int enumId = clientMessage.getPart(0).getInt(); responseMsg.setMessageType(MessageType.RESPONSE); responseMsg.setNumberOfParts(1); responseMsg.setTransactionId(clientMessage.getTransactionId()); responseMsg.addObjPart(result); responseMsg.send(serverConnection); serverConnection.setAsTrue(RESPONDED);
private static void writeContainsKeyResponse(boolean containsKey, Message origMsg, ServerConnection servConn) throws IOException { Message responseMsg = servConn.getResponseMessage(); responseMsg.setMessageType(MessageType.RESPONSE); responseMsg.setNumberOfParts(1); responseMsg.setTransactionId(origMsg.getTransactionId()); responseMsg.addObjPart(containsKey ? Boolean.TRUE : Boolean.FALSE); responseMsg.send(servConn); }
Object args = executor.getArguments(); MemberMappedArgument memberMappedArg = executor.getMemberMappedArgument(); getMessage().clear(); addBytes(this.hasResult); getMessage().addStringPart(this.regionName); if (executor.isFnSerializationReqd()) { getMessage().addStringOrObjPart(function); } else { getMessage().addStringOrObjPart(functionId); getMessage().addObjPart(args); getMessage().addObjPart(memberMappedArg); byte flags = ExecuteFunctionHelper.createFlags(executeOnBucketSet, isReExecute); getMessage().addBytesPart(new byte[] {flags}); getMessage().addIntPart(routingObjects.size()); for (Object key : routingObjects) { getMessage().addStringOrObjPart(key); getMessage().addIntPart(removedNodes.size()); for (Object nodes : removedNodes) { getMessage().addStringOrObjPart(nodes);
clientMessage.receiveWithHeaderReadTimeout(headerReadTimeout); if (clientMessage.getMessageType() == MessageType.SERVER_TO_CLIENT_PING) { if (isDebugEnabled) { logger.debug("{}: Received ping", this); boolean isCreateOrUpdate = clientMessage.getMessageType() == MessageType.LOCAL_CREATE || clientMessage.getMessageType() == MessageType.LOCAL_UPDATE; if (isCreateOrUpdate) { isDeltaSent = (Boolean) clientMessage.getPart(2).getObject(); int numberOfParts = clientMessage.getNumberOfParts(); Part eid = clientMessage.getPart(numberOfParts - 1); if (clientMessage.getMessageType() != MessageType.REGISTER_INSTANTIATORS && clientMessage.getMessageType() != MessageType.REGISTER_DATASERIALIZERS) { if (this.qManager.getState().verifyIfDuplicate(eventId, !(this.isDurableClient || isDeltaSent))) { switch (clientMessage.getMessageType()) { case MessageType.LOCAL_CREATE: case MessageType.LOCAL_UPDATE: default: logger.warn("{}: Received an unsupported message (type={})", new Object[] {this, MessageType.getString(clientMessage.getMessageType())}); break; clientMessage.clear();
private void writeReply(Message msg, ServerConnection servConn, int batchId, int numberOfEvents) throws IOException { Message replyMsg = servConn.getResponseMessage(); replyMsg.setMessageType(MessageType.REPLY); replyMsg.setTransactionId(msg.getTransactionId()); replyMsg.setNumberOfParts(2); replyMsg.addIntPart(batchId); replyMsg.addIntPart(numberOfEvents); replyMsg.setTransactionId(msg.getTransactionId()); replyMsg.send(servConn); servConn.setAsTrue(Command.RESPONDED); if (logger.isDebugEnabled()) { logger.debug("{}: rpl tx: {} batchId {} numberOfEvents: {}", servConn.getName(), msg.getTransactionId(), batchId, numberOfEvents); } }
@Override protected String[] getGroups(Message msg) throws IOException, ClassNotFoundException { String[] groups = null; Part messagePart = msg.getPart(4); if (messagePart != null) { groups = (String[]) messagePart.getObject(); } return groups; }
/** * @throws org.apache.geode.SerializationException if serialization fails */ public ClearOpImpl(String region, EventID eventId, Object callbackArg) { super(MessageType.CLEAR_REGION, callbackArg != null ? 3 : 2); getMessage().addStringPart(region); getMessage().addBytesPart(eventId.calcBytes()); if (callbackArg != null) { getMessage().addObjPart(callbackArg); } }
/** * @throws org.apache.geode.SerializationException if serialization fails */ public QueryOpImpl(String queryPredicate, Object[] queryParams) { super(MessageType.QUERY_WITH_PARAMETERS, 2 + queryParams.length); getMessage().addStringPart(queryPredicate); getMessage().addIntPart(queryParams.length); for (Object param : queryParams) { getMessage().addObjPart(param); } }
try { switch (msg.getMessageType()) { case MessageType.REPLY: Part part0 = msg.getPart(0); if (part0.isBytes() && part0.getLength() == 1 && part0.getSerializedForm()[0] == 0) { int numEvents = msg.getPart(1).getInt(); ack = new GatewayAck(batchId, numEvents); break; case MessageType.EXCEPTION: part0 = msg.getPart(0); logger.debug( "We got an exception from the GatewayReceiver. MessageType : {} obj :{}", msg.getMessageType(), obj); default: throw new InternalGemFireError(String.format("Unknown message type %s", Integer.valueOf(msg.getMessageType()))); msg.clear();
@Test public void oldSecurityShouldSucceedIfAuthorized() throws Exception { when(this.securityService.isClientSecurityRequired()).thenReturn(true); when(this.securityService.isIntegratedSecurity()).thenReturn(false); this.put61.cmdExecute(this.message, this.serverConnection, this.securityService, 0); ArgumentCaptor<byte[]> argument = ArgumentCaptor.forClass(byte[].class); verify(this.replyMessage).addBytesPart(argument.capture()); assertThat(argument.getValue()).isEqualTo(OK_BYTES); verify(this.authzRequest).putAuthorize(eq(REGION_NAME), eq(KEY), eq(null), eq(true), eq(CALLBACK_ARG)); verify(this.replyMessage).send(this.serverConnection); }
/** * @throws org.apache.geode.SerializationException if serialization fails */ public AddPdxEnumOpImpl(int id, EnumInfo ei) { super(MessageType.ADD_PDX_ENUM, 2); getMessage().addObjPart(ei); getMessage().addIntPart(id); }
/** * @throws org.apache.geode.SerializationException if serialization fails */ public ContainsKeyOpImpl(String region, Object key, MODE mode) { super(MessageType.CONTAINS_KEY, 3); getMessage().addStringPart(region); getMessage().addStringOrObjPart(key); getMessage().addIntPart(mode.ordinal()); this.region = region; this.key = key; this.mode = mode; }