geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From u..@apache.org
Subject [geode] 03/04: Adding SecurityProcessor.java and returning MessageExecutionContext.java
Date Mon, 23 Oct 2017 23:36:25 GMT
This is an automated email from the ASF dual-hosted git repository.

udo pushed a commit to branch feature/GEODE-3705
in repository https://gitbox.apache.org/repos/asf/geode.git

commit f8d6089596b0bd2c09e762b660d522ab133bc49e
Author: kohlmu-pivotal <ukohlmeyer@pivotal.io>
AuthorDate: Fri Oct 20 16:08:56 2017 -0700

    Adding SecurityProcessor.java and returning MessageExecutionContext.java
---
 .../tier/sockets/ClientProtocolMessageHandler.java | 13 ++---
 .../tier/sockets/MessageExecutionContext.java      | 40 ++++++++++----
 .../{protobuf => }/EncodingTypeTranslator.java     |  3 +-
 .../internal/protocol/{protobuf => }/Failure.java  | 20 ++++---
 .../protocol/{protobuf => }/Handshaker.java        |  7 ++-
 .../protocol/{protobuf => }/OperationContext.java  |  3 +-
 .../internal/protocol/ProtobufCachePipeline.java   | 17 ++----
 .../protocol/{protobuf => }/ProtocolErrorCode.java |  2 +-
 .../internal/protocol/{protobuf => }/Result.java   |  7 ++-
 .../internal/protocol/{protobuf => }/Success.java  | 21 +++++---
 .../protocol/operations/OperationHandler.java      |  6 +--
 .../protocol/protobuf/ProtobufOpsProcessor.java    | 62 ++++++++++++----------
 .../protobuf/ProtobufSerializationService.java     |  1 +
 .../protocol/protobuf/ProtobufStreamProcessor.java | 21 +++++---
 .../operations/GetAllRequestOperationHandler.java  | 20 +++----
 .../GetAvailableServersOperationHandler.java       | 12 ++---
 .../GetRegionNamesRequestOperationHandler.java     | 12 ++---
 .../GetRegionRequestOperationHandler.java          | 18 +++----
 .../operations/GetRequestOperationHandler.java     | 28 +++++-----
 .../operations/PutAllRequestOperationHandler.java  | 20 +++----
 .../operations/PutRequestOperationHandler.java     | 22 ++++----
 .../operations/RemoveRequestOperationHandler.java  | 22 ++++----
 .../HandshakerRequestOperationHandler.java         | 23 ++++----
 .../AuthenticationRequestOperationHandler.java     | 57 ++++++++++++++++++++
 .../security/InvalidConfigAuthenticator.java       | 25 +++------
 .../security/ProtobufShiroAuthenticator.java       | 55 ++-----------------
 .../AuthenticationSecurityProcessor.java}          | 19 ++++---
 .../AuthorizationSecurityProcessor.java}           | 19 ++++---
 .../NoAuthenticationSecurityProcessor.java}        | 18 ++++---
 .../utilities/ProtobufResponseUtilities.java       |  4 +-
 .../protobuf/utilities/ProtobufUtilities.java      |  2 +-
 .../registry/OperationContextRegistry.java         | 10 +++-
 .../security/AuthenticationLookupService.java      |  2 +-
 .../internal/protocol/security/Authenticator.java  | 18 ++-----
 .../protocol/security/NoOpAuthenticator.java       |  8 +--
 .../SecurityProcessor.java}                        | 18 +++----
 geode-protobuf/src/main/proto/clientProtocol.proto |  4 +-
 geode-protobuf/src/main/proto/handshake_API.proto  |  5 ++
 .../protocol/AuthenticationIntegrationTest.java    | 17 +++---
 .../protocol/AuthorizationIntegrationTest.java     |  7 ++-
 .../acceptance/LocatorConnectionDUnitTest.java     |  3 +-
 ...TypeToSerializationTypeTranslatorJUnitTest.java |  1 +
 .../internal/protocol/protobuf/HandshakerTest.java | 18 +++----
 .../ProtobufShiroAuthenticatorJUnitTest.java       | 35 ++++++------
 .../protobuf/ProtobufStreamProcessorTest.java      |  6 ++-
 .../protobuf/ProtobufTestExecutionContext.java     |  6 ++-
 .../protocol/protobuf/ProtobufTestUtilities.java   |  2 +-
 .../GetAllRequestOperationHandlerJUnitTest.java    | 13 ++---
 ...tAvailableServersOperationHandlerJUnitTest.java |  4 +-
 ...egionNamesRequestOperationHandlerJUnitTest.java |  9 ++--
 .../GetRegionRequestOperationHandlerJUnitTest.java | 11 ++--
 .../GetRequestOperationHandlerJUnitTest.java       | 19 +++----
 .../PutAllRequestOperationHandlerJUnitTest.java    | 11 ++--
 .../PutRequestOperationHandlerJUnitTest.java       | 17 +++---
 .../RemoveRequestOperationHandlerJUnitTest.java    | 17 +++---
 55 files changed, 461 insertions(+), 399 deletions(-)

diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientProtocolMessageHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientProtocolMessageHandler.java
index 4de279b..c1250e1 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientProtocolMessageHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientProtocolMessageHandler.java
@@ -23,17 +23,18 @@ import org.apache.geode.StatisticsFactory;
 
 
 /**
- * This is an interface that other modules can implement to hook into
- * {@link GenericProtocolServerConnection} to handle messages sent to Geode.
+ * This is an interface that other modules can implement to hook into {@link
+ * GenericProtocolServerConnection} to handle messages sent to Geode.
  *
  * Currently, only one {@link ClientProtocolMessageHandler} at a time can be used in a Geode
- * instance. It gets wired into {@link ServerConnectionFactory} to create all instances of
- * {@link GenericProtocolServerConnection}.
+ * instance. It gets wired into {@link ServerConnectionFactory} to create all instances of {@link
+ * GenericProtocolServerConnection}.
  *
  * Implementors of this interface are expected to be able to be used for any number of connections
  * at a time (stateless except for the statistics).
  */
 public interface ClientProtocolMessageHandler {
-  void receiveMessage(InputStream inputStream, OutputStream outputStream,
-      MessageExecutionContext executionContext) throws IOException;
+  MessageExecutionContext receiveMessage(InputStream inputStream, OutputStream outputStream,
+                                         MessageExecutionContext executionContext)
+      throws IOException;
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/MessageExecutionContext.java b/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/MessageExecutionContext.java
index 0978e41..5c9a5c8 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/MessageExecutionContext.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/cache/tier/sockets/MessageExecutionContext.java
@@ -15,11 +15,16 @@
 
 package org.apache.geode.internal.cache.tier.sockets;
 
+
 import org.apache.geode.annotations.Experimental;
 import org.apache.geode.cache.Cache;
 import org.apache.geode.distributed.Locator;
 import org.apache.geode.distributed.internal.InternalLocator;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.protobuf.security.processors.NoAuthenticationSecurityProcessor;
+import org.apache.geode.internal.protocol.security.Authenticator;
+import org.apache.geode.internal.protocol.security.NoOpAuthenticator;
+import org.apache.geode.internal.protocol.security.SecurityProcessor;
 import org.apache.geode.internal.protocol.statistics.ProtocolClientStatistics;
 import org.apache.geode.internal.protocol.security.Authorizer;
 import org.apache.geode.internal.protocol.security.NoOpAuthorizer;
@@ -29,16 +34,21 @@ public class MessageExecutionContext {
   private Cache cache;
   private Locator locator;
   private final Authorizer authorizer;
-  private final Object authenticatedSubject;
+  private final Object authenticatedToken;
   private final ProtocolClientStatistics statistics;
+  private final SecurityProcessor securityProcessor;
+  private final Authenticator authenticator;
 
 
-  public MessageExecutionContext(Cache cache, Authorizer streamAuthorizer,
-      Object authenticatedSubject, ProtocolClientStatistics statistics) {
+  public MessageExecutionContext(Cache cache, Authenticator authenticator,
+      Authorizer streamAuthorizer, Object authenticatedToken, ProtocolClientStatistics statistics,
+      SecurityProcessor securityProcessor) {
     this.cache = cache;
     this.authorizer = streamAuthorizer;
-    this.authenticatedSubject = authenticatedSubject;
+    this.authenticatedToken = authenticatedToken;
     this.statistics = statistics;
+    this.securityProcessor = securityProcessor;
+    this.authenticator = authenticator;
   }
 
   public MessageExecutionContext(InternalLocator locator, ProtocolClientStatistics statistics) {
@@ -46,14 +56,16 @@ public class MessageExecutionContext {
     // set a no-op authorizer until such time as locators implement authentication
     // and authorization checks
     this.authorizer = new NoOpAuthorizer();
+    this.authenticator = new NoOpAuthenticator();
     this.statistics = statistics;
-    this.authenticatedSubject = new Object();
+    this.authenticatedToken = new Object();
+    this.securityProcessor = new NoAuthenticationSecurityProcessor();
   }
 
   /**
    * Returns the cache associated with this execution
    * <p>
-   *
+   * 
    * @throws InvalidExecutionContextException if there is no cache available
    */
   public Cache getCache() throws InvalidExecutionContextException {
@@ -67,7 +79,7 @@ public class MessageExecutionContext {
   /**
    * Returns the locator associated with this execution
    * <p>
-   *
+   * 
    * @throws InvalidExecutionContextException if there is no locator available
    */
   public Locator getLocator() throws InvalidExecutionContextException {
@@ -86,10 +98,10 @@ public class MessageExecutionContext {
   }
 
   /**
-   * Returns the authentication/authorization subject associated with this execution
+   * Returns the authentication token associated with this execution
    */
-  public Object getSubject() {
-    return authenticatedSubject;
+  public Object getAuthenticationToken() {
+    return authenticatedToken;
   }
 
 
@@ -100,4 +112,12 @@ public class MessageExecutionContext {
   public ProtocolClientStatistics getStatistics() {
     return statistics;
   }
+
+  public Authenticator getAuthenticator() {
+    return authenticator;
+  }
+
+  public SecurityProcessor getSecurityProcessor() {
+    return securityProcessor;
+  }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/EncodingTypeTranslator.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/EncodingTypeTranslator.java
similarity index 96%
rename from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/EncodingTypeTranslator.java
rename to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/EncodingTypeTranslator.java
index 1868ced..5801292 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/EncodingTypeTranslator.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/EncodingTypeTranslator.java
@@ -12,11 +12,12 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol;
 
 import java.util.HashMap;
 
 import org.apache.geode.annotations.Experimental;
+import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.pdx.JSONFormatter;
 import org.apache.geode.pdx.PdxInstance;
 import org.apache.geode.internal.serialization.SerializationType;
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Failure.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Failure.java
similarity index 64%
rename from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Failure.java
rename to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Failure.java
index 6ac73de..cfcd46d 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Failure.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Failure.java
@@ -12,31 +12,39 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol;
 
 import java.util.function.Function;
 
 import org.apache.geode.annotations.Experimental;
+import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 
 @Experimental
-public class Failure<SuccessType> implements Result<SuccessType> {
+public class Failure<SuccessType, ExecutionContext> implements Result<SuccessType, ExecutionContext> {
   private final ClientProtocol.ErrorResponse errorResponse;
+  private final ExecutionContext executionContext;
 
-  public Failure(ClientProtocol.ErrorResponse errorResponse) {
+  public Failure(ClientProtocol.ErrorResponse errorResponse, ExecutionContext executionContext) {
     this.errorResponse = errorResponse;
+    this.executionContext = executionContext;
   }
 
-  public static <T> Failure<T> of(ClientProtocol.ErrorResponse errorResponse) {
-    return new Failure<>(errorResponse);
+  public static <T, V> Failure<T, V> of(ClientProtocol.ErrorResponse errorResponse, V context) {
+    return new Failure<>(errorResponse, context);
   }
 
   @Override
   public <T> T map(Function<SuccessType, T> successFunction,
-      Function<ClientProtocol.ErrorResponse, T> errorFunction) {
+                   Function<ClientProtocol.ErrorResponse, T> errorFunction) {
     return errorFunction.apply(errorResponse);
   }
 
   @Override
+  public ExecutionContext getExecutionContext() {
+    return executionContext;
+  }
+
+  @Override
   public SuccessType getMessage() {
     throw new RuntimeException("This is not a Success result");
   }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Handshaker.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Handshaker.java
similarity index 88%
rename from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Handshaker.java
rename to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Handshaker.java
index 1812f92..1a5bb97 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Handshaker.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Handshaker.java
@@ -13,7 +13,7 @@
  * the License.
  */
 
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -22,8 +22,11 @@ import java.io.OutputStream;
 import org.apache.logging.log4j.Logger;
 
 import org.apache.geode.cache.IncompatibleVersionException;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.logging.LogService;
+import org.apache.geode.internal.protocol.Result;
 import org.apache.geode.internal.protocol.handshaker.ClientProtocolHandshaker;
+import org.apache.geode.internal.protocol.protobuf.HandshakeAPI;
 import org.apache.geode.internal.protocol.protobuf.operations.handshaker.HandshakerRequestOperationHandler;
 
 public class Handshaker implements ClientProtocolHandshaker {
@@ -45,7 +48,7 @@ public class Handshaker implements ClientProtocolHandshaker {
     // At this stage HandshakerRequestOperationHandler is not wired into the
     // ProtobufOpsStreamProcesser.
     // Thus passing in null serializationService and executionContext.
-    Result<HandshakeAPI.HandshakeResponse> result =
+    Result<HandshakeAPI.HandshakeResponse,MessageExecutionContext> result =
         handshakerRequestOperationHandler.process(null, handshakeRequest, null);
 
     HandshakeAPI.HandshakeResponse handshakeResponse = result.getMessage();
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/OperationContext.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/OperationContext.java
similarity index 96%
rename from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/OperationContext.java
rename to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/OperationContext.java
index 12c50aa..d4ca2a0 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/OperationContext.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/OperationContext.java
@@ -13,12 +13,13 @@
  * the License.
  */
 
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol;
 
 import java.util.function.Function;
 
 import org.apache.geode.annotations.Experimental;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
+import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 import org.apache.geode.security.ResourcePermission;
 
 @Experimental
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/ProtobufCachePipeline.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/ProtobufCachePipeline.java
index 3b6d2e5..a7764df 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/ProtobufCachePipeline.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/ProtobufCachePipeline.java
@@ -24,6 +24,7 @@ import org.apache.geode.cache.Cache;
 import org.apache.geode.internal.cache.tier.sockets.ClientProtocolProcessor;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.ProtobufStreamProcessor;
+import org.apache.geode.internal.protocol.protobuf.security.processors.AuthenticationSecurityProcessor;
 import org.apache.geode.internal.protocol.security.Authenticator;
 import org.apache.geode.internal.protocol.security.Authorizer;
 import org.apache.geode.internal.protocol.statistics.ProtocolClientStatistics;
@@ -39,7 +40,7 @@ public final class ProtobufCachePipeline implements ClientProtocolProcessor {
   private final ProtobufStreamProcessor streamProcessor;
   private final Authenticator authenticator;
 
-  private Object authenticatorToken;
+  private MessageExecutionContext messageExecutionContext;
 
   ProtobufCachePipeline(ProtobufStreamProcessor protobufStreamProcessor,
       ProtocolClientStatistics statistics, Cache cache, Authenticator authenticator,
@@ -50,22 +51,14 @@ public final class ProtobufCachePipeline implements ClientProtocolProcessor {
     this.authenticator = authenticator;
     this.authorizer = authorizer;
     this.statistics.clientConnected();
+    this.messageExecutionContext = new MessageExecutionContext(cache, authenticator, authorizer,
+        null, statistics, new AuthenticationSecurityProcessor());
   }
 
   @Override
   public void processMessage(InputStream inputStream, OutputStream outputStream)
       throws IOException {
-    if (authenticatorToken == null) {
-      try {
-        authenticatorToken = authenticator.authenticate(inputStream, outputStream);
-      } catch (AuthenticationFailedException ex) {
-        statistics.incAuthenticationFailures();
-        throw new IOException(ex);
-      }
-    } else {
-      streamProcessor.receiveMessage(inputStream, outputStream,
-          new MessageExecutionContext(cache, authorizer, authenticatorToken, statistics));
-    }
+    messageExecutionContext = streamProcessor.receiveMessage(inputStream, outputStream, messageExecutionContext);
   }
 
   @Override
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtocolErrorCode.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/ProtocolErrorCode.java
similarity index 96%
rename from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtocolErrorCode.java
rename to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/ProtocolErrorCode.java
index 2c895d3..f74f613 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtocolErrorCode.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/ProtocolErrorCode.java
@@ -12,7 +12,7 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol;
 
 public enum ProtocolErrorCode {
   GENERIC_FAILURE(1000),
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Result.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Result.java
similarity index 83%
copy from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Result.java
copy to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Result.java
index bada098..69a5f6f 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Result.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Result.java
@@ -12,17 +12,20 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol;
 
 import java.util.function.Function;
 
 import org.apache.geode.annotations.Experimental;
+import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 
 @Experimental
-public interface Result<SuccessType> {
+public interface Result<SuccessType,ExecutionContext> {
   <T> T map(Function<SuccessType, T> successFunction,
       Function<ClientProtocol.ErrorResponse, T> errorFunction);
 
+  ExecutionContext getExecutionContext();
+
   SuccessType getMessage();
 
   ClientProtocol.ErrorResponse getErrorMessage();
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Success.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Success.java
similarity index 66%
rename from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Success.java
rename to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Success.java
index 224b21c..0a3378e 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Success.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/Success.java
@@ -12,31 +12,40 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol;
 
 import java.util.function.Function;
 
 import org.apache.geode.annotations.Experimental;
+import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 
 @Experimental
-public class Success<SuccessType> implements Result<SuccessType> {
+public class Success<SuccessType, ExecutionContext>
+    implements Result<SuccessType, ExecutionContext> {
   private final SuccessType successResponse;
+  private final ExecutionContext executionContext;
 
-  public Success(SuccessType successResponse) {
+  public Success(SuccessType successResponse, ExecutionContext executionContext) {
     this.successResponse = successResponse;
+    this.executionContext = executionContext;
   }
 
-  public static <T> Success<T> of(T result) {
-    return new Success<>(result);
+  public static <T,V> Success<T,V> of(T result,V context) {
+    return new Success<>(result,context);
   }
 
   @Override
   public <T> T map(Function<SuccessType, T> successFunction,
-      Function<ClientProtocol.ErrorResponse, T> errorFunction) {
+                   Function<ClientProtocol.ErrorResponse, T> errorFunction) {
     return successFunction.apply(successResponse);
   }
 
   @Override
+  public ExecutionContext getExecutionContext() {
+    return executionContext;
+  }
+
+  @Override
   public SuccessType getMessage() {
     return successResponse;
   }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/operations/OperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/operations/OperationHandler.java
index 9d2d482..13ce932 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/operations/OperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/operations/OperationHandler.java
@@ -18,7 +18,7 @@ import org.apache.geode.annotations.Experimental;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.protocol.protobuf.ProtobufOpsProcessor;
-import org.apache.geode.internal.protocol.protobuf.Result;
+import org.apache.geode.internal.protocol.Result;
 import org.apache.geode.internal.serialization.SerializationService;
 
 /**
@@ -33,7 +33,7 @@ public interface OperationHandler<Req, Resp> {
    * Decode the message, deserialize contained values using the serialization service, do the work
    * indicated on the provided cache, and return a response.
    */
-  Result<Resp> process(SerializationService serializationService, Req request,
-      MessageExecutionContext executionContext) throws InvalidExecutionContextException;
+  Result<Resp,MessageExecutionContext> process(SerializationService serializationService, Req request,
+      MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException;
 }
 
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufOpsProcessor.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufOpsProcessor.java
index 4fd1764..59407d6 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufOpsProcessor.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufOpsProcessor.java
@@ -20,12 +20,16 @@ import org.apache.geode.annotations.Experimental;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.logging.LogService;
+import org.apache.geode.internal.protocol.Failure;
+import org.apache.geode.internal.protocol.OperationContext;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.registry.OperationContextRegistry;
-import org.apache.geode.internal.protocol.statistics.ProtocolClientStatistics;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
+import org.apache.geode.internal.protocol.security.SecurityProcessor;
 import org.apache.geode.internal.serialization.SerializationService;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.*;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.*;
 
 /**
  * This handles protobuf requests by determining the operation type of the request and dispatching
@@ -39,42 +43,46 @@ public class ProtobufOpsProcessor {
   private static final Logger logger = LogService.getLogger(ProtobufOpsProcessor.class);
 
   public ProtobufOpsProcessor(SerializationService serializationService,
-      OperationContextRegistry operationContextRegistry) {
+                              OperationContextRegistry operationContextRegistry) {
     this.serializationService = serializationService;
     this.operationContextRegistry = operationContextRegistry;
   }
 
-  public ClientProtocol.Response process(ClientProtocol.Request request,
-      MessageExecutionContext context) {
+  public Result<ClientProtocol.Response, MessageExecutionContext> process(
+      ClientProtocol.Request request,
+      MessageExecutionContext messageExecutionContext) {
     ClientProtocol.Request.RequestAPICase requestType = request.getRequestAPICase();
     logger.debug("Processing request of type {}", requestType);
     OperationContext operationContext = operationContextRegistry.getOperationContext(requestType);
-    ClientProtocol.Response.Builder builder;
     Result result;
-    try {
-      if (context.getAuthorizer().authorize(context.getSubject(),
-          operationContext.getAccessPermissionRequired())) {
-        result = operationContext.getOperationHandler().process(serializationService,
-            operationContext.getFromRequest().apply(request), context);
-      } else {
-        logger.warn("Received unauthorized request");
-        recordAuthorizationViolation(context);
-        result = Failure.of(ProtobufResponseUtilities.makeErrorResponse(AUTHORIZATION_FAILED,
-            "User isn't authorized for this operation."));
-      }
-    } catch (InvalidExecutionContextException exception) {
-      logger.error("Invalid execution context found for operation {}", requestType);
-      result = Failure.of(ProtobufResponseUtilities.makeErrorResponse(UNSUPPORTED_OPERATION,
-          "Invalid execution context found for operation."));
+
+    SecurityProcessor securityProcessor = messageExecutionContext.getSecurityProcessor();
+    if (securityProcessor.validateOperation(request, messageExecutionContext, operationContext)) {
+      result = processOperation(request, messageExecutionContext, requestType, operationContext);
+    } else {
+      logger.warn("Received unauthorized request");
+      messageExecutionContext.getStatistics().incAuthorizationViolations();
+      result = Failure.of(ProtobufResponseUtilities.makeErrorResponse(AUTHORIZATION_FAILED,
+          "User isn't authorized for this operation."), messageExecutionContext);
     }
 
-    builder = (ClientProtocol.Response.Builder) result.map(operationContext.getToResponse(),
-        operationContext.getToErrorResponse());
-    return builder.build();
+    ClientProtocol.Response
+        response =
+        ((ClientProtocol.Response.Builder) result.map(operationContext.getToResponse(),
+            operationContext.getToErrorResponse())).build();
+    return Success.of(response, (MessageExecutionContext) result.getExecutionContext());
   }
 
-  private void recordAuthorizationViolation(MessageExecutionContext context) {
-    ProtocolClientStatistics statistics = context.getStatistics();
-    statistics.incAuthorizationViolations();
+  private Result processOperation(ClientProtocol.Request request, MessageExecutionContext context,
+                                  ClientProtocol.Request.RequestAPICase requestType,
+                                  OperationContext operationContext) {
+    try {
+      return operationContext.getOperationHandler().process(serializationService,
+          operationContext.getFromRequest().apply(request), context);
+    } catch (InvalidExecutionContextException exception) {
+      logger.error("Invalid execution context found for operation {}", requestType);
+      return Failure.of(ProtobufResponseUtilities.makeErrorResponse(UNSUPPORTED_OPERATION,
+          "Invalid execution context found for operation."), context);
+    }
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufSerializationService.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufSerializationService.java
index 8b8dbb3..f7281fd 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufSerializationService.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufSerializationService.java
@@ -15,6 +15,7 @@
 package org.apache.geode.internal.protocol.protobuf;
 
 import org.apache.geode.annotations.Experimental;
+import org.apache.geode.internal.protocol.EncodingTypeTranslator;
 import org.apache.geode.internal.serialization.SerializationService;
 import org.apache.geode.internal.serialization.SerializationType;
 import org.apache.geode.internal.serialization.TypeCodec;
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessor.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessor.java
index 9386ee7..4250e93 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessor.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessor.java
@@ -25,6 +25,7 @@ import org.apache.geode.annotations.Experimental;
 import org.apache.geode.internal.cache.tier.sockets.ClientProtocolMessageHandler;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.logging.LogService;
+import org.apache.geode.internal.protocol.Result;
 import org.apache.geode.internal.protocol.exception.InvalidProtocolMessageException;
 import org.apache.geode.internal.protocol.registry.OperationContextRegistry;
 import org.apache.geode.internal.protocol.protobuf.serializer.ProtobufProtocolSerializer;
@@ -49,17 +50,19 @@ public class ProtobufStreamProcessor implements ClientProtocolMessageHandler {
   }
 
   @Override
-  public void receiveMessage(InputStream inputStream, OutputStream outputStream,
-      MessageExecutionContext executionContext) throws IOException {
+  public MessageExecutionContext receiveMessage(InputStream inputStream, OutputStream outputStream,
+                                                MessageExecutionContext executionContext)
+      throws IOException {
     try {
-      processOneMessage(inputStream, outputStream, executionContext);
+      return processOneMessage(inputStream, outputStream, executionContext);
     } catch (InvalidProtocolMessageException e) {
       throw new IOException(e);
     }
   }
 
-  private void processOneMessage(InputStream inputStream, OutputStream outputStream,
-      MessageExecutionContext executionContext)
+  private MessageExecutionContext processOneMessage(InputStream inputStream,
+                                                    OutputStream outputStream,
+                                                    MessageExecutionContext executionContext)
       throws InvalidProtocolMessageException, IOException {
     ClientProtocol.Message message = protobufProtocolSerializer.deserialize(inputStream);
     if (message == null) {
@@ -71,9 +74,13 @@ public class ProtobufStreamProcessor implements ClientProtocolMessageHandler {
     statistics.messageReceived(message.getSerializedSize());
 
     ClientProtocol.Request request = message.getRequest();
-    ClientProtocol.Response response = protobufOpsProcessor.process(request, executionContext);
-    ClientProtocol.Message responseMessage = ProtobufUtilities.createProtobufResponse(response);
+    Result<ClientProtocol.Response, MessageExecutionContext> result =
+        protobufOpsProcessor.process(request, executionContext);
+    ClientProtocol.Message
+        responseMessage =
+        ProtobufUtilities.createProtobufResponse(result.getMessage());
     statistics.messageSent(responseMessage.getSerializedSize());
     protobufProtocolSerializer.serialize(responseMessage, outputStream);
+    return result.getExecutionContext();
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandler.java
index 2001645..c15a44f 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandler.java
@@ -31,17 +31,17 @@ import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Failure;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Failure;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.SerializationService;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.internal.serialization.registry.exception.CodecNotRegisteredForTypeException;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.*;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.*;
 
 @Experimental
 public class GetAllRequestOperationHandler
@@ -49,15 +49,15 @@ public class GetAllRequestOperationHandler
   private static final Logger logger = LogService.getLogger();
 
   @Override
-  public Result<RegionAPI.GetAllResponse> process(SerializationService serializationService,
-      RegionAPI.GetAllRequest request, MessageExecutionContext executionContext)
+  public Result<RegionAPI.GetAllResponse,MessageExecutionContext> process(SerializationService serializationService,
+      RegionAPI.GetAllRequest request, MessageExecutionContext messageExecutionContext)
       throws InvalidExecutionContextException {
     String regionName = request.getRegionName();
-    Region region = executionContext.getCache().getRegion(regionName);
+    Region region = messageExecutionContext.getCache().getRegion(regionName);
     if (region == null) {
       logger.error("Received GetAll request for non-existing region {}", regionName);
       return Failure
-          .of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND, "Region not found"));
+          .of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND, "Region not found"),messageExecutionContext);
     }
 
     Map<Boolean, List<Object>> resultsCollection = request.getKeyList().stream()
@@ -73,7 +73,7 @@ public class GetAllRequestOperationHandler
       responseBuilder.addFailures((BasicTypes.KeyedError) entry);
     }
 
-    return Success.of(responseBuilder.build());
+    return Success.of(responseBuilder.build(),messageExecutionContext);
   }
 
   private Object processOneMessage(SerializationService serializationService, Region region,
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandler.java
index c8f663f..ec2c917 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandler.java
@@ -25,9 +25,9 @@ import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.Result;
+import org.apache.geode.internal.protocol.Result;
 import org.apache.geode.internal.protocol.protobuf.ServerAPI;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.serialization.SerializationService;
 
 @Experimental
@@ -35,11 +35,11 @@ public class GetAvailableServersOperationHandler implements
     OperationHandler<ServerAPI.GetAvailableServersRequest, ServerAPI.GetAvailableServersResponse> {
 
   @Override
-  public Result<ServerAPI.GetAvailableServersResponse> process(
+  public Result<ServerAPI.GetAvailableServersResponse,MessageExecutionContext> process(
       SerializationService serializationService, ServerAPI.GetAvailableServersRequest request,
-      MessageExecutionContext executionContext) throws InvalidExecutionContextException {
+      MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException {
 
-    InternalLocator internalLocator = (InternalLocator) executionContext.getLocator();
+    InternalLocator internalLocator = (InternalLocator) messageExecutionContext.getLocator();
     ArrayList serversFromSnapshot =
         internalLocator.getServerLocatorAdvisee().getLoadSnapshot().getServers(null);
     if (serversFromSnapshot == null) {
@@ -51,7 +51,7 @@ public class GetAvailableServersOperationHandler implements
         .collect(Collectors.toList());
     ServerAPI.GetAvailableServersResponse.Builder builder =
         ServerAPI.GetAvailableServersResponse.newBuilder().addAllServers(servers);
-    return Success.of(builder.build());
+    return Success.of(builder.build(),messageExecutionContext);
   }
 
   private BasicTypes.Server getServerProtobufMessage(ServerLocation serverLocation) {
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandler.java
index 7ffdcd8..c8e6573 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandler.java
@@ -22,8 +22,8 @@ import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
 import org.apache.geode.internal.serialization.SerializationService;
 
@@ -32,10 +32,10 @@ public class GetRegionNamesRequestOperationHandler
     implements OperationHandler<RegionAPI.GetRegionNamesRequest, RegionAPI.GetRegionNamesResponse> {
 
   @Override
-  public Result<RegionAPI.GetRegionNamesResponse> process(SerializationService serializationService,
-      RegionAPI.GetRegionNamesRequest request, MessageExecutionContext executionContext)
+  public Result<RegionAPI.GetRegionNamesResponse,MessageExecutionContext> process(SerializationService serializationService,
+      RegionAPI.GetRegionNamesRequest request, MessageExecutionContext messageExecutionContext)
       throws InvalidExecutionContextException {
-    Set<Region<?, ?>> regions = executionContext.getCache().rootRegions();
-    return Success.of(ProtobufResponseUtilities.createGetRegionNamesResponse(regions));
+    Set<Region<?, ?>> regions = messageExecutionContext.getCache().rootRegions();
+    return Success.of(ProtobufResponseUtilities.createGetRegionNamesResponse(regions),messageExecutionContext);
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandler.java
index 78d3d5c..032d72c 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandler.java
@@ -23,15 +23,15 @@ import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
-import org.apache.geode.internal.protocol.protobuf.Failure;
+import org.apache.geode.internal.protocol.Failure;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.SerializationService;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.*;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.*;
 
 @Experimental
 public class GetRegionRequestOperationHandler
@@ -39,20 +39,20 @@ public class GetRegionRequestOperationHandler
   private static final Logger logger = LogService.getLogger();
 
   @Override
-  public Result<RegionAPI.GetRegionResponse> process(SerializationService serializationService,
-      RegionAPI.GetRegionRequest request, MessageExecutionContext executionContext)
+  public Result<RegionAPI.GetRegionResponse,MessageExecutionContext> process(SerializationService serializationService,
+      RegionAPI.GetRegionRequest request, MessageExecutionContext messageExecutionContext)
       throws InvalidExecutionContextException {
     String regionName = request.getRegionName();
 
-    Region region = executionContext.getCache().getRegion(regionName);
+    Region region = messageExecutionContext.getCache().getRegion(regionName);
     if (region == null) {
       logger.error("Received GetRegion request for non-existing region {}", regionName);
       return Failure.of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND,
-          "No region exists for name: " + regionName));
+          "No region exists for name: " + regionName),messageExecutionContext);
     }
 
     BasicTypes.Region protoRegion = ProtobufUtilities.createRegionMessageFromRegion(region);
 
-    return Success.of(RegionAPI.GetRegionResponse.newBuilder().setRegion(protoRegion).build());
+    return Success.of(RegionAPI.GetRegionResponse.newBuilder().setRegion(protoRegion).build(),messageExecutionContext);
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandler.java
index e7702b8..0e7c6a2 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandler.java
@@ -23,18 +23,17 @@ import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.Failure;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.Failure;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.SerializationService;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.internal.serialization.registry.exception.CodecNotRegisteredForTypeException;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.*;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.*;
 
 @Experimental
 public class GetRequestOperationHandler
@@ -42,15 +41,17 @@ public class GetRequestOperationHandler
   private static final Logger logger = LogService.getLogger();
 
   @Override
-  public Result<RegionAPI.GetResponse> process(SerializationService serializationService,
-      RegionAPI.GetRequest request, MessageExecutionContext executionContext)
+  public Result<RegionAPI.GetResponse, MessageExecutionContext> process(
+      SerializationService serializationService,
+      RegionAPI.GetRequest request, MessageExecutionContext messageExecutionContext)
       throws InvalidExecutionContextException {
     String regionName = request.getRegionName();
-    Region region = executionContext.getCache().getRegion(regionName);
+    Region region = messageExecutionContext.getCache().getRegion(regionName);
     if (region == null) {
       logger.error("Received Get request for non-existing region {}", regionName);
       return Failure
-          .of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND, "Region not found"));
+          .of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND, "Region not found"),
+              messageExecutionContext);
     }
 
     try {
@@ -58,20 +59,21 @@ public class GetRequestOperationHandler
       Object resultValue = region.get(decodedKey);
 
       if (resultValue == null) {
-        return Success.of(RegionAPI.GetResponse.newBuilder().build());
+        return Success.of(RegionAPI.GetResponse.newBuilder().build(), messageExecutionContext);
       }
 
       BasicTypes.EncodedValue encodedValue =
           ProtobufUtilities.createEncodedValue(serializationService, resultValue);
-      return Success.of(RegionAPI.GetResponse.newBuilder().setResult(encodedValue).build());
+      return Success.of(RegionAPI.GetResponse.newBuilder().setResult(encodedValue).build(),
+          messageExecutionContext);
     } catch (UnsupportedEncodingTypeException ex) {
       logger.error("Received Get request with unsupported encoding: {}", ex);
       return Failure.of(ProtobufResponseUtilities.makeErrorResponse(VALUE_ENCODING_ERROR,
-          "Encoding not supported."));
+          "Encoding not supported."), messageExecutionContext);
     } catch (CodecNotRegisteredForTypeException ex) {
       logger.error("Got codec error when decoding Get request: {}", ex);
       return Failure.of(ProtobufResponseUtilities.makeErrorResponse(VALUE_ENCODING_ERROR,
-          "Codec error in protobuf deserialization."));
+          "Codec error in protobuf deserialization."), messageExecutionContext);
     }
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandler.java
index 300616b..54f9391 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandler.java
@@ -26,18 +26,18 @@ import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.Failure;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.Failure;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.SerializationService;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.internal.serialization.registry.exception.CodecNotRegisteredForTypeException;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.*;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.*;
 
 @Experimental
 public class PutAllRequestOperationHandler
@@ -45,23 +45,23 @@ public class PutAllRequestOperationHandler
   private static final Logger logger = LogManager.getLogger();
 
   @Override
-  public Result<RegionAPI.PutAllResponse> process(SerializationService serializationService,
-      RegionAPI.PutAllRequest putAllRequest, MessageExecutionContext executionContext)
+  public Result<RegionAPI.PutAllResponse,MessageExecutionContext> process(SerializationService serializationService,
+      RegionAPI.PutAllRequest putAllRequest, MessageExecutionContext messageExecutionContext)
       throws InvalidExecutionContextException {
     String regionName = putAllRequest.getRegionName();
-    Region region = executionContext.getCache().getRegion(regionName);
+    Region region = messageExecutionContext.getCache().getRegion(regionName);
 
     if (region == null) {
       logger.error("Received PutAll request for non-existing region {}", regionName);
       return Failure.of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND,
-          "Region passed does not exist: " + regionName));
+          "Region passed does not exist: " + regionName),messageExecutionContext);
     }
 
     RegionAPI.PutAllResponse.Builder builder = RegionAPI.PutAllResponse.newBuilder()
         .addAllFailedKeys(putAllRequest.getEntryList().stream()
             .map((entry) -> singlePut(serializationService, region, entry)).filter(Objects::nonNull)
             .collect(Collectors.toList()));
-    return Success.of(builder.build());
+    return Success.of(builder.build(),messageExecutionContext);
   }
 
   private BasicTypes.KeyedError singlePut(SerializationService serializationService, Region region,
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandler.java
index 81c842d..719fa85 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandler.java
@@ -23,17 +23,17 @@ import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.Failure;
+import org.apache.geode.internal.protocol.Failure;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.SerializationService;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.internal.serialization.registry.exception.CodecNotRegisteredForTypeException;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.*;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.*;
 
 @Experimental
 public class PutRequestOperationHandler
@@ -41,15 +41,15 @@ public class PutRequestOperationHandler
   private static final Logger logger = LogService.getLogger();
 
   @Override
-  public Result<RegionAPI.PutResponse> process(SerializationService serializationService,
-      RegionAPI.PutRequest request, MessageExecutionContext executionContext)
+  public Result<RegionAPI.PutResponse,MessageExecutionContext> process(SerializationService serializationService,
+      RegionAPI.PutRequest request, MessageExecutionContext messageExecutionContext)
       throws InvalidExecutionContextException {
     String regionName = request.getRegionName();
-    Region region = executionContext.getCache().getRegion(regionName);
+    Region region = messageExecutionContext.getCache().getRegion(regionName);
     if (region == null) {
       logger.warn("Received Put request for non-existing region: {}", regionName);
       return Failure.of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND,
-          "Region passed by client did not exist: " + regionName));
+          "Region passed by client did not exist: " + regionName),messageExecutionContext);
     }
 
     try {
@@ -59,16 +59,16 @@ public class PutRequestOperationHandler
       Object decodedKey = ProtobufUtilities.decodeValue(serializationService, entry.getKey());
       try {
         region.put(decodedKey, decodedValue);
-        return Success.of(RegionAPI.PutResponse.newBuilder().build());
+        return Success.of(RegionAPI.PutResponse.newBuilder().build(),messageExecutionContext);
       } catch (ClassCastException ex) {
         logger.error("Received Put request with invalid key type: {}", ex);
         return Failure.of(ProtobufResponseUtilities.makeErrorResponse(CONSTRAINT_VIOLATION,
-            "invalid key or value type for region " + regionName));
+            "invalid key or value type for region " + regionName),messageExecutionContext);
       }
     } catch (UnsupportedEncodingTypeException | CodecNotRegisteredForTypeException ex) {
       logger.error("Got codec error when decoding Put request: {}", ex);
       return Failure
-          .of(ProtobufResponseUtilities.makeErrorResponse(VALUE_ENCODING_ERROR, ex.getMessage()));
+          .of(ProtobufResponseUtilities.makeErrorResponse(VALUE_ENCODING_ERROR, ex.getMessage()),messageExecutionContext);
     }
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandler.java
index 0e3b148..2d401fa 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandler.java
@@ -22,17 +22,17 @@ import org.apache.geode.cache.Region;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
-import org.apache.geode.internal.protocol.protobuf.Failure;
+import org.apache.geode.internal.protocol.Failure;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.SerializationService;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.internal.serialization.registry.exception.CodecNotRegisteredForTypeException;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.*;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.*;
 
 @Experimental
 public class RemoveRequestOperationHandler
@@ -40,32 +40,32 @@ public class RemoveRequestOperationHandler
   private static final Logger logger = LogManager.getLogger();
 
   @Override
-  public Result<RegionAPI.RemoveResponse> process(SerializationService serializationService,
-      RegionAPI.RemoveRequest request, MessageExecutionContext executionContext)
+  public Result<RegionAPI.RemoveResponse,MessageExecutionContext> process(SerializationService serializationService,
+      RegionAPI.RemoveRequest request, MessageExecutionContext messageExecutionContext)
       throws InvalidExecutionContextException {
 
     String regionName = request.getRegionName();
-    Region region = executionContext.getCache().getRegion(regionName);
+    Region region = messageExecutionContext.getCache().getRegion(regionName);
     if (region == null) {
       logger.error("Received Remove request for non-existing region {}", regionName);
       return Failure
-          .of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND, "Region not found"));
+          .of(ProtobufResponseUtilities.makeErrorResponse(REGION_NOT_FOUND, "Region not found"),messageExecutionContext);
     }
 
     try {
       Object decodedKey = ProtobufUtilities.decodeValue(serializationService, request.getKey());
       region.remove(decodedKey);
 
-      return Success.of(RegionAPI.RemoveResponse.newBuilder().build());
+      return Success.of(RegionAPI.RemoveResponse.newBuilder().build(),messageExecutionContext);
     } catch (UnsupportedEncodingTypeException ex) {
       // can be thrown by encoding or decoding.
       logger.error("Received Remove request with unsupported encoding: {}", ex);
       return Failure.of(ProtobufResponseUtilities.makeErrorResponse(VALUE_ENCODING_ERROR,
-          "Encoding not supported: " + ex.getMessage()));
+          "Encoding not supported: " + ex.getMessage()),messageExecutionContext);
     } catch (CodecNotRegisteredForTypeException ex) {
       logger.error("Got codec error when decoding Remove request: {}", ex);
       return Failure.of(ProtobufResponseUtilities.makeErrorResponse(VALUE_ENCODING_ERROR,
-          "Codec error in protobuf deserialization: " + ex.getMessage()));
+          "Codec error in protobuf deserialization: " + ex.getMessage()),messageExecutionContext);
     }
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/handshaker/HandshakerRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/handshaker/HandshakerRequestOperationHandler.java
index b31247b..0b2e3b6 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/handshaker/HandshakerRequestOperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/handshaker/HandshakerRequestOperationHandler.java
@@ -14,24 +14,17 @@
  */
 package org.apache.geode.internal.protocol.protobuf.operations.handshaker;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.CONSTRAINT_VIOLATION;
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.UNSUPPORTED_VERSION;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.UNSUPPORTED_VERSION;
 
 import org.apache.logging.log4j.Logger;
 
-import org.apache.geode.cache.IncompatibleVersionException;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
-import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.protocol.operations.OperationHandler;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.internal.protocol.protobuf.Failure;
 import org.apache.geode.internal.protocol.protobuf.HandshakeAPI;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
-import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufResponseUtilities;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.serialization.SerializationService;
 
 public class HandshakerRequestOperationHandler
@@ -42,8 +35,9 @@ public class HandshakerRequestOperationHandler
       LogService.getLogger(HandshakerRequestOperationHandler.class);
 
   @Override
-  public Result<HandshakeAPI.HandshakeResponse> process(SerializationService serializationService,
-      HandshakeAPI.HandshakeRequest request, MessageExecutionContext executionContext) {
+  public Result<HandshakeAPI.HandshakeResponse, MessageExecutionContext> process(
+      SerializationService serializationService,
+      HandshakeAPI.HandshakeRequest request, MessageExecutionContext messageExecutionContext) {
     HandshakeAPI.Semver version = request.getVersion();
     if (version.getMajor() != MAJOR_VERSION || version.getMinor() < MINOR_VERSION) {
       logger.warn("Version mismatch: incompatible version. Supported version is: " + MAJOR_VERSION
@@ -52,8 +46,9 @@ public class HandshakerRequestOperationHandler
           .setError(BasicTypes.Error.newBuilder().setErrorCode(UNSUPPORTED_VERSION.codeValue)
               .setMessage("Version mismatch: incompatible version. Supported version is: "
                   + MAJOR_VERSION + "." + MINOR_VERSION))
-          .build());
+          .build(), messageExecutionContext);
     }
-    return Success.of(HandshakeAPI.HandshakeResponse.newBuilder().setOk(true).build());
+    return Success.of(HandshakeAPI.HandshakeResponse.newBuilder().setOk(true).build(),
+        messageExecutionContext);
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/security/AuthenticationRequestOperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/security/AuthenticationRequestOperationHandler.java
new file mode 100644
index 0000000..947563f
--- /dev/null
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/operations/security/AuthenticationRequestOperationHandler.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.apache.geode.internal.protocol.protobuf.operations.security;
+
+import java.util.Properties;
+
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
+import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
+import org.apache.geode.internal.protocol.operations.OperationHandler;
+import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
+import org.apache.geode.internal.protocol.protobuf.security.processors.AuthorizationSecurityProcessor;
+import org.apache.geode.internal.protocol.security.Authenticator;
+import org.apache.geode.internal.serialization.SerializationService;
+import org.apache.geode.security.AuthenticationFailedException;
+
+public class AuthenticationRequestOperationHandler implements
+    OperationHandler<AuthenticationAPI.AuthenticationRequest, AuthenticationAPI.AuthenticationResponse> {
+  @Override
+  public Result<AuthenticationAPI.AuthenticationResponse,MessageExecutionContext> process(
+      SerializationService serializationService, AuthenticationAPI.AuthenticationRequest request,
+      MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException {
+    Authenticator authenticator = messageExecutionContext.getAuthenticator();
+    Properties properties = new Properties();
+    properties.putAll(request.getCredentialsMap());
+
+    try {
+      Object authenticationToken = authenticator.authenticate(properties);
+      MessageExecutionContext
+          newMessageExecutionContext =
+          new MessageExecutionContext(messageExecutionContext.getCache(),
+              messageExecutionContext.getAuthenticator(), messageExecutionContext.getAuthorizer(),
+              authenticationToken, messageExecutionContext.getStatistics(),
+              new AuthorizationSecurityProcessor());
+      return Success
+          .of(AuthenticationAPI.AuthenticationResponse.newBuilder().setAuthenticated(true).build(),
+              newMessageExecutionContext);
+    } catch (AuthenticationFailedException e) {
+      return Success
+          .of(AuthenticationAPI.AuthenticationResponse.newBuilder().setAuthenticated(false)
+              .build(), messageExecutionContext);
+    }
+  }
+}
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/InvalidConfigAuthenticator.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/InvalidConfigAuthenticator.java
index e924bc6..409a075 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/InvalidConfigAuthenticator.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/InvalidConfigAuthenticator.java
@@ -21,35 +21,22 @@ import java.io.OutputStream;
 
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 import org.apache.logging.log4j.Logger;
 
 import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.protocol.security.Authenticator;
 import org.apache.geode.internal.security.SecurityService;
+import org.apache.geode.security.AuthenticationFailedException;
 
-public class InvalidConfigAuthenticator implements Authenticator {
+public class InvalidConfigAuthenticator implements Authenticator<Object, Object> {
   private static final Logger logger = LogService.getLogger(InvalidConfigAuthenticator.class);
-  private final SecurityService securityService;
-
-  public InvalidConfigAuthenticator(SecurityService securityService) {
-    this.securityService = securityService;
-  }
 
   @Override
-  public Object authenticate(InputStream inputStream, OutputStream outputStream)
-      throws IOException {
+  public Object authenticate(Object object) throws AuthenticationFailedException {
     logger.warn(
         "Attempting to authenticate incoming protobuf message using legacy security implementation. This is not supported. Failing authentication.");
-
-    ClientProtocol.Message.newBuilder()
-        .setResponse(ClientProtocol.Response.newBuilder()
-            .setErrorResponse(ClientProtocol.ErrorResponse.newBuilder()
-                .setError(BasicTypes.Error.newBuilder()
-                    .setErrorCode(ProtocolErrorCode.AUTHENTICATION_FAILED.codeValue).setMessage(
-                        "Attempting to authenticate incoming protobuf message using legacy security implementation. This is not supported. Failing authentication."))))
-        .build().writeDelimitedTo(outputStream);
-
-    throw new IOException("Protobuf clients not supported with legacy security.");
+    throw new AuthenticationFailedException(
+        "Attempting to authenticate incoming protobuf message using legacy security implementation. This is not supported. Failing authentication.");
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/ProtobufShiroAuthenticator.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/ProtobufShiroAuthenticator.java
index 6d6a497..cdee506 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/ProtobufShiroAuthenticator.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/ProtobufShiroAuthenticator.java
@@ -14,7 +14,7 @@
  */
 package org.apache.geode.internal.protocol.protobuf.security;
 
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.AUTHENTICATION_FAILED;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.AUTHENTICATION_FAILED;
 
 import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
 
@@ -31,9 +31,7 @@ import java.util.Properties;
 
 import org.apache.shiro.subject.Subject;
 
-public class ProtobufShiroAuthenticator implements Authenticator {
-  private static final String UNEXECPTED_REQUEST = "Expected to receive an authentication request";
-
+public class ProtobufShiroAuthenticator implements Authenticator<Properties, Subject> {
   private final SecurityService securityService;
 
   public ProtobufShiroAuthenticator(SecurityService securityService) {
@@ -41,52 +39,7 @@ public class ProtobufShiroAuthenticator implements Authenticator {
   }
 
   @Override
-  public Subject authenticate(InputStream inputStream, OutputStream outputStream)
-      throws IOException, AuthenticationFailedException {
-    ClientProtocol.Message message = ClientProtocol.Message.parseDelimitedFrom(inputStream);
-
-    if (message.getRequest().getRequestAPICase()
-        .getNumber() != ClientProtocol.Request.SIMPLEAUTHENTICATIONREQUEST_FIELD_NUMBER) {
-      failAuth(outputStream);
-    }
-
-    AuthenticationAPI.AuthenticationRequest authenticationRequest =
-        message.getRequest().getSimpleAuthenticationRequest();
-    if (authenticationRequest == null) {
-      failAuth(outputStream);
-    }
-
-    Properties properties = new Properties();
-    properties.putAll(authenticationRequest.getCredentialsMap());
-
-    try {
-      // throws AuthenticationFailedException on failure.
-      Subject authToken = securityService.login(properties);
-
-      sendAuthenticationResponse(outputStream, true);
-      return authToken;
-    } catch (AuthenticationFailedException ex) {
-      sendAuthenticationResponse(outputStream, false);
-      throw ex;
-    }
-  }
-
-  private void sendAuthenticationResponse(OutputStream outputStream, boolean success)
-      throws IOException {
-    ClientProtocol.Message.newBuilder()
-        .setResponse(ClientProtocol.Response.newBuilder().setSimpleAuthenticationResponse(
-            AuthenticationAPI.AuthenticationResponse.newBuilder().setAuthenticated(success)))
-        .build().writeDelimitedTo(outputStream);
-  }
-
-  private void failAuth(OutputStream outputStream) throws IOException {
-    ClientProtocol.Message.newBuilder()
-        .setResponse(ClientProtocol.Response.newBuilder()
-            .setErrorResponse(ClientProtocol.ErrorResponse.newBuilder()
-                .setError(BasicTypes.Error.newBuilder()
-                    .setErrorCode(AUTHENTICATION_FAILED.codeValue).setMessage(UNEXECPTED_REQUEST))))
-        .build().writeDelimitedTo(outputStream);
-
-    throw new IOException(UNEXECPTED_REQUEST);
+  public Subject authenticate(Properties properties) throws AuthenticationFailedException {
+    return securityService.login(properties);
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/AuthenticationSecurityProcessor.java
similarity index 53%
copy from geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
copy to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/AuthenticationSecurityProcessor.java
index 43b1efa..d164222 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/AuthenticationSecurityProcessor.java
@@ -12,16 +12,19 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol.protobuf.security.processors;
 
-import org.apache.geode.cache.Cache;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
-import org.apache.geode.internal.protocol.security.NoOpAuthorizer;
-import org.apache.geode.internal.protocol.statistics.NoOpStatistics;
+import org.apache.geode.internal.protocol.OperationContext;
+import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
+import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
+import org.apache.geode.internal.protocol.security.SecurityProcessor;
 
-public class ProtobufTestExecutionContext {
-  public static MessageExecutionContext getNoAuthExecutionContext(Cache cache) {
-    return new MessageExecutionContext(cache, new NoOpAuthorizer(), new Object(),
-        new NoOpStatistics());
+public class AuthenticationSecurityProcessor implements SecurityProcessor<ClientProtocol.Request> {
+  @Override
+  public boolean validateOperation(ClientProtocol.Request request,
+      MessageExecutionContext messageExecutionContext, OperationContext operationContext) {
+    Object fromRequest = operationContext.getFromRequest().apply(request);
+    return fromRequest instanceof AuthenticationAPI.AuthenticationRequest;
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/AuthorizationSecurityProcessor.java
similarity index 54%
copy from geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
copy to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/AuthorizationSecurityProcessor.java
index 43b1efa..7664e8a 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/AuthorizationSecurityProcessor.java
@@ -12,16 +12,19 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol.protobuf.security.processors;
 
-import org.apache.geode.cache.Cache;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
-import org.apache.geode.internal.protocol.security.NoOpAuthorizer;
-import org.apache.geode.internal.protocol.statistics.NoOpStatistics;
+import org.apache.geode.internal.protocol.OperationContext;
+import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
+import org.apache.geode.internal.protocol.security.SecurityProcessor;
 
-public class ProtobufTestExecutionContext {
-  public static MessageExecutionContext getNoAuthExecutionContext(Cache cache) {
-    return new MessageExecutionContext(cache, new NoOpAuthorizer(), new Object(),
-        new NoOpStatistics());
+public class AuthorizationSecurityProcessor implements SecurityProcessor<ClientProtocol.Request> {
+  @Override
+  public boolean validateOperation(ClientProtocol.Request request,
+      MessageExecutionContext messageExecutionContext, OperationContext operationContext) {
+    return messageExecutionContext.getAuthorizer().authorize(
+        messageExecutionContext.getAuthenticationToken(),
+        operationContext.getAccessPermissionRequired());
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/NoAuthenticationSecurityProcessor.java
similarity index 60%
copy from geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
copy to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/NoAuthenticationSecurityProcessor.java
index 43b1efa..d603b1a 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/security/processors/NoAuthenticationSecurityProcessor.java
@@ -12,16 +12,18 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol.protobuf.security.processors;
 
-import org.apache.geode.cache.Cache;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
-import org.apache.geode.internal.protocol.security.NoOpAuthorizer;
-import org.apache.geode.internal.protocol.statistics.NoOpStatistics;
+import org.apache.geode.internal.protocol.OperationContext;
+import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
+import org.apache.geode.internal.protocol.security.SecurityProcessor;
 
-public class ProtobufTestExecutionContext {
-  public static MessageExecutionContext getNoAuthExecutionContext(Cache cache) {
-    return new MessageExecutionContext(cache, new NoOpAuthorizer(), new Object(),
-        new NoOpStatistics());
+public class NoAuthenticationSecurityProcessor
+    implements SecurityProcessor<ClientProtocol.Request> {
+  @Override
+  public boolean validateOperation(ClientProtocol.Request request,
+      MessageExecutionContext messageExecutionContext, OperationContext operationContext) {
+    return true;
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufResponseUtilities.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufResponseUtilities.java
index 6819d8b..663c31e 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufResponseUtilities.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufResponseUtilities.java
@@ -16,14 +16,12 @@ package org.apache.geode.internal.protocol.protobuf.utilities;
 
 import java.util.Set;
 
-import org.apache.logging.log4j.Logger;
-
 import org.apache.geode.annotations.Experimental;
 import org.apache.geode.cache.Region;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 
 
 /**
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufUtilities.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufUtilities.java
index 320a10c..1053f64 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufUtilities.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/utilities/ProtobufUtilities.java
@@ -21,7 +21,7 @@ import org.apache.geode.cache.Region;
 import org.apache.geode.cache.RegionAttributes;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.internal.protocol.protobuf.EncodingTypeTranslator;
+import org.apache.geode.internal.protocol.EncodingTypeTranslator;
 import org.apache.geode.internal.protocol.protobuf.ProtobufSerializationService;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
 import org.apache.geode.internal.protocol.protobuf.utilities.exception.UnknownProtobufPrimitiveType;
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/registry/OperationContextRegistry.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/registry/OperationContextRegistry.java
index dbf6259..e18a81b 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/registry/OperationContextRegistry.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/registry/OperationContextRegistry.java
@@ -21,7 +21,7 @@ import java.util.concurrent.ConcurrentHashMap;
 import org.apache.geode.annotations.Experimental;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol.Request.RequestAPICase;
-import org.apache.geode.internal.protocol.protobuf.OperationContext;
+import org.apache.geode.internal.protocol.OperationContext;
 import org.apache.geode.internal.protocol.protobuf.operations.GetAllRequestOperationHandler;
 import org.apache.geode.internal.protocol.protobuf.operations.GetAvailableServersOperationHandler;
 import org.apache.geode.internal.protocol.protobuf.operations.GetRegionNamesRequestOperationHandler;
@@ -30,6 +30,7 @@ import org.apache.geode.internal.protocol.protobuf.operations.GetRequestOperatio
 import org.apache.geode.internal.protocol.protobuf.operations.PutAllRequestOperationHandler;
 import org.apache.geode.internal.protocol.protobuf.operations.PutRequestOperationHandler;
 import org.apache.geode.internal.protocol.protobuf.operations.RemoveRequestOperationHandler;
+import org.apache.geode.internal.protocol.protobuf.operations.security.AuthenticationRequestOperationHandler;
 import org.apache.geode.security.ResourcePermission;
 
 @Experimental
@@ -45,6 +46,13 @@ public class OperationContextRegistry {
   }
 
   private void addContexts() {
+    operationContexts.put(RequestAPICase.AUTHENTICATIONREQUEST,
+        new OperationContext<>(ClientProtocol.Request::getAuthenticationRequest,
+            new AuthenticationRequestOperationHandler(),
+            opsResp -> ClientProtocol.Response.newBuilder().setAuthenticationResponse(opsResp),
+            new ResourcePermission(ResourcePermission.Resource.DATA,
+                ResourcePermission.Operation.READ)));
+
     operationContexts.put(RequestAPICase.GETREQUEST,
         new OperationContext<>(ClientProtocol.Request::getGetRequest,
             new GetRequestOperationHandler(),
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/AuthenticationLookupService.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/AuthenticationLookupService.java
index f61a300..5d3f04d 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/AuthenticationLookupService.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/AuthenticationLookupService.java
@@ -26,7 +26,7 @@ public class AuthenticationLookupService {
     }
     if (securityService.isPeerSecurityRequired() || securityService.isClientSecurityRequired()) {
       // Failing authentication...legacy security
-      return new InvalidConfigAuthenticator(securityService);
+      return new InvalidConfigAuthenticator();
     } else {
       // Noop authenticator...no security
       return new NoOpAuthenticator();
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/Authenticator.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/Authenticator.java
index f4234cd..42dd22b 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/Authenticator.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/Authenticator.java
@@ -14,13 +14,7 @@
  */
 package org.apache.geode.internal.protocol.security;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-
-import org.apache.geode.internal.security.SecurityService;
 import org.apache.geode.security.AuthenticationFailedException;
-import org.apache.geode.security.AuthenticationRequiredException;
 
 /**
  * Implementers of this interface do some message passing over a socket to authenticate a client,
@@ -29,14 +23,12 @@ import org.apache.geode.security.AuthenticationRequiredException;
  * If authentication fails, an implementor may continue to wait for another valid authentication
  * exchange.
  */
-public interface Authenticator {
+public interface Authenticator<SecurityProperties, AuthenticationToken> {
   /**
-   *
-   * @param inputStream to read auth messages from.
-   * @param outputStream to send messages to.
+   * @param securityProperties a generic object that is required for authentication dependent on
+   *        implementation
    * @return authenticated principal
-   * @throws IOException if EOF or if invalid input is received.
    */
-  Object authenticate(InputStream inputStream, OutputStream outputStream)
-      throws IOException, AuthenticationFailedException;
+  AuthenticationToken authenticate(SecurityProperties securityProperties)
+      throws AuthenticationFailedException;
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/NoOpAuthenticator.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/NoOpAuthenticator.java
index d4f96e4..9cdeb6e 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/NoOpAuthenticator.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/NoOpAuthenticator.java
@@ -19,16 +19,16 @@ import java.io.InputStream;
 import java.io.OutputStream;
 
 import org.apache.geode.internal.security.SecurityService;
+import org.apache.geode.security.AuthenticationFailedException;
 
 /**
  * An implementation of {@link Authenticator} that doesn't use its parameters and always returns
  * true.
  */
-public class NoOpAuthenticator implements Authenticator {
+public class NoOpAuthenticator implements Authenticator<Object, Object> {
+
   @Override
-  public Object authenticate(InputStream inputStream, OutputStream outputStream)
-      throws IOException {
-    // this method needs to do nothing as it is a pass-through implementation
+  public Object authenticate(Object inputObject) throws AuthenticationFailedException {
     return new Object();
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Result.java b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/SecurityProcessor.java
similarity index 67%
rename from geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Result.java
rename to geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/SecurityProcessor.java
index bada098..40d5e9e 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/protobuf/Result.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/internal/protocol/security/SecurityProcessor.java
@@ -12,18 +12,12 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.apache.geode.internal.protocol.protobuf;
+package org.apache.geode.internal.protocol.security;
 
-import java.util.function.Function;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
+import org.apache.geode.internal.protocol.OperationContext;
 
-import org.apache.geode.annotations.Experimental;
-
-@Experimental
-public interface Result<SuccessType> {
-  <T> T map(Function<SuccessType, T> successFunction,
-      Function<ClientProtocol.ErrorResponse, T> errorFunction);
-
-  SuccessType getMessage();
-
-  ClientProtocol.ErrorResponse getErrorMessage();
+public interface SecurityProcessor<RequestMessage> {
+  boolean validateOperation(RequestMessage request, MessageExecutionContext messageExecutionContext,
+      OperationContext operationContext);
 }
diff --git a/geode-protobuf/src/main/proto/clientProtocol.proto b/geode-protobuf/src/main/proto/clientProtocol.proto
index b4c0f56..4d8b94a 100644
--- a/geode-protobuf/src/main/proto/clientProtocol.proto
+++ b/geode-protobuf/src/main/proto/clientProtocol.proto
@@ -48,7 +48,7 @@ message Request {
         GetRegionNamesRequest getRegionNamesRequest = 43;
         GetRegionRequest getRegionRequest = 44;
 
-        AuthenticationRequest simpleAuthenticationRequest = 100;
+        AuthenticationRequest authenticationRequest = 100;
     }
 }
 
@@ -67,7 +67,7 @@ message Response {
         GetRegionNamesResponse getRegionNamesResponse = 43;
         GetRegionResponse getRegionResponse = 44;
 
-        AuthenticationResponse simpleAuthenticationResponse = 100;
+        AuthenticationResponse authenticationResponse = 100;
     }
 }
 
diff --git a/geode-protobuf/src/main/proto/handshake_API.proto b/geode-protobuf/src/main/proto/handshake_API.proto
index 17f7d40..b11ae03 100644
--- a/geode-protobuf/src/main/proto/handshake_API.proto
+++ b/geode-protobuf/src/main/proto/handshake_API.proto
@@ -31,4 +31,9 @@ message HandshakeRequest {
 message HandshakeResponse {
     bool ok = 1;
     Error error = 2; // only set if not OK.
+}
+
+message Semver{
+    int32 major = 1;
+    int32 minor = 2;
 }
\ No newline at end of file
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthenticationIntegrationTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthenticationIntegrationTest.java
index adbe906..124abbb 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthenticationIntegrationTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthenticationIntegrationTest.java
@@ -15,7 +15,7 @@
 package org.apache.geode.internal.protocol;
 
 import static junit.framework.TestCase.fail;
-import static org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode.AUTHENTICATION_FAILED;
+import static org.apache.geode.internal.protocol.ProtocolErrorCode.AUTHENTICATION_FAILED;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -29,7 +29,6 @@ import java.net.Socket;
 import java.util.Properties;
 import java.util.concurrent.TimeUnit;
 
-import org.apache.geode.internal.protocol.exception.InvalidProtocolMessageException;
 import org.awaitility.Awaitility;
 import org.junit.After;
 import org.junit.Before;
@@ -204,7 +203,7 @@ public class AuthenticationIntegrationTest {
 
     ClientProtocol.Message authenticationRequest = ClientProtocol.Message.newBuilder()
         .setRequest(ClientProtocol.Request.newBuilder()
-            .setSimpleAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
+            .setAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
                 .putCredentials(ResourceConstants.USER_NAME, TEST_USERNAME)
                 .putCredentials(ResourceConstants.PASSWORD, TEST_PASSWORD)))
         .build();
@@ -232,7 +231,7 @@ public class AuthenticationIntegrationTest {
 
     ClientProtocol.Message authenticationRequest = ClientProtocol.Message.newBuilder()
         .setRequest(ClientProtocol.Request.newBuilder()
-            .setSimpleAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()))
+            .setAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()))
         .build();
 
     authenticationRequest.writeDelimitedTo(outputStream);
@@ -249,7 +248,7 @@ public class AuthenticationIntegrationTest {
 
     ClientProtocol.Message authenticationRequest = ClientProtocol.Message.newBuilder()
         .setRequest(ClientProtocol.Request.newBuilder()
-            .setSimpleAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
+            .setAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
                 .putCredentials(ResourceConstants.USER_NAME, TEST_USERNAME)
                 .putCredentials(ResourceConstants.PASSWORD, "wrong password")))
         .build();
@@ -279,7 +278,7 @@ public class AuthenticationIntegrationTest {
 
     ClientProtocol.Message authenticationRequest = ClientProtocol.Message.newBuilder()
         .setRequest(ClientProtocol.Request.newBuilder()
-            .setSimpleAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()))
+            .setAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()))
         .build();
 
     authenticationRequest.writeDelimitedTo(outputStream);
@@ -298,7 +297,7 @@ public class AuthenticationIntegrationTest {
 
     ClientProtocol.Message authenticationRequest = ClientProtocol.Message.newBuilder()
         .setRequest(ClientProtocol.Request.newBuilder()
-            .setSimpleAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()))
+            .setAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()))
         .build();
 
     authenticationRequest.writeDelimitedTo(outputStream);
@@ -332,8 +331,8 @@ public class AuthenticationIntegrationTest {
         ClientProtocol.Message.parseDelimitedFrom(inputStream);
     assertEquals(ClientProtocol.Message.RESPONSE_FIELD_NUMBER,
         authenticationResponseMessage.getMessageTypeCase().getNumber());
-    assertEquals(ClientProtocol.Response.SIMPLEAUTHENTICATIONRESPONSE_FIELD_NUMBER,
+    assertEquals(ClientProtocol.Response.AUTHENTICATIONRESPONSE_FIELD_NUMBER,
         authenticationResponseMessage.getResponse().getResponseAPICase().getNumber());
-    return authenticationResponseMessage.getResponse().getSimpleAuthenticationResponse();
+    return authenticationResponseMessage.getResponse().getAuthenticationResponse();
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthorizationIntegrationTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthorizationIntegrationTest.java
index b41b93c..109e10d 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthorizationIntegrationTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/AuthorizationIntegrationTest.java
@@ -43,7 +43,6 @@ import org.apache.geode.internal.AvailablePortHelper;
 import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 import org.apache.geode.internal.protocol.protobuf.ProtobufSerializationService;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
 import org.apache.geode.internal.protocol.protobuf.serializer.ProtobufProtocolSerializer;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
@@ -116,7 +115,7 @@ public class AuthorizationIntegrationTest {
     when(mockSecurityManager.authorize(same(securityPrincipal), any())).thenReturn(false);
     ClientProtocol.Message authenticationRequest = ClientProtocol.Message.newBuilder()
         .setRequest(ClientProtocol.Request.newBuilder()
-            .setSimpleAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
+            .setAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
                 .putCredentials(ResourceConstants.USER_NAME, TEST_USERNAME)
                 .putCredentials(ResourceConstants.PASSWORD, TEST_PASSWORD)))
         .build();
@@ -125,10 +124,10 @@ public class AuthorizationIntegrationTest {
     ClientProtocol.Message responseMessage = ClientProtocol.Message.parseDelimitedFrom(inputStream);
     assertEquals(ClientProtocol.Message.RESPONSE_FIELD_NUMBER,
         responseMessage.getMessageTypeCase().getNumber());
-    assertEquals(ClientProtocol.Response.SIMPLEAUTHENTICATIONRESPONSE_FIELD_NUMBER,
+    assertEquals(ClientProtocol.Response.AUTHENTICATIONRESPONSE_FIELD_NUMBER,
         responseMessage.getResponse().getResponseAPICase().getNumber());
     AuthenticationAPI.AuthenticationResponse authenticationResponse =
-        responseMessage.getResponse().getSimpleAuthenticationResponse();
+        responseMessage.getResponse().getAuthenticationResponse();
     assertTrue(authenticationResponse.getAuthenticated());
   }
 
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/acceptance/LocatorConnectionDUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/acceptance/LocatorConnectionDUnitTest.java
index 01dac04..3d239b5 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/acceptance/LocatorConnectionDUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/acceptance/LocatorConnectionDUnitTest.java
@@ -37,11 +37,10 @@ import org.apache.geode.distributed.internal.InternalDistributedSystem;
 import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.protocol.exception.InvalidProtocolMessageException;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.ServerAPI;
 import org.apache.geode.internal.protocol.protobuf.serializer.ProtobufProtocolSerializer;
 import org.apache.geode.internal.protocol.protobuf.statistics.ProtobufClientStatisticsImpl;
-import org.apache.geode.internal.protocol.statistics.ProtocolClientStatistics;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.test.dunit.DistributedTestUtils;
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/EncodingTypeToSerializationTypeTranslatorJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/EncodingTypeToSerializationTypeTranslatorJUnitTest.java
index 883b0f6..0a67aff 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/EncodingTypeToSerializationTypeTranslatorJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/EncodingTypeToSerializationTypeTranslatorJUnitTest.java
@@ -19,6 +19,7 @@ import static org.junit.Assert.assertSame;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
+import org.apache.geode.internal.protocol.EncodingTypeTranslator;
 import org.apache.geode.internal.serialization.SerializationType;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.test.junit.categories.UnitTest;
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/HandshakerTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/HandshakerTest.java
index 6eba760..10bfeaf 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/HandshakerTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/HandshakerTest.java
@@ -23,18 +23,15 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.HashMap;
 import java.util.Map;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-import org.apache.geode.cache.IncompatibleVersionException;
+import org.apache.geode.internal.protocol.Handshaker;
 import org.apache.geode.internal.protocol.security.Authenticator;
-import org.apache.geode.internal.protocol.security.Authorizer;
 import org.apache.geode.security.AuthenticationFailedException;
-import org.apache.geode.security.AuthenticationRequiredException;
 import org.apache.geode.test.junit.categories.UnitTest;
 
 @Category(UnitTest.class)
@@ -45,9 +42,9 @@ public class HandshakerTest {
 
   private static class AuthenticatorMock implements Authenticator {
 
+
     @Override
-    public Object authenticate(InputStream inputStream, OutputStream outputStream)
-        throws IOException, AuthenticationFailedException {
+    public Object authenticate(Object o) throws AuthenticationFailedException {
       return null;
     }
   }
@@ -67,8 +64,7 @@ public class HandshakerTest {
   @Test
   public void version1_0IsSupported() throws Exception {
     HandshakeAPI.HandshakeRequest handshakeRequest = HandshakeAPI.HandshakeRequest.newBuilder()
-        .setVersion(HandshakeAPI.Semver.newBuilder().setMajor(1).setMinor(1))
-        .setAuthenticationMode(HandshakeAPI.AuthenticationMode.SIMPLE).build();
+        .setVersion(HandshakeAPI.Semver.newBuilder().setMajor(1).setMinor(1)).build();
 
     ByteArrayInputStream byteArrayInputStream =
         ProtobufTestUtilities.messageToByteArrayInputStream(handshakeRequest);
@@ -85,7 +81,7 @@ public class HandshakerTest {
   public void version2NotSupported() throws Exception {
     HandshakeAPI.HandshakeRequest handshakeRequest = HandshakeAPI.HandshakeRequest.newBuilder()
         .setVersion(HandshakeAPI.Semver.newBuilder().setMajor(2).setMinor(0))
-        .setAuthenticationMode(HandshakeAPI.AuthenticationMode.NONE).build();
+        .build();
 
     ByteArrayInputStream byteArrayInputStream =
         ProtobufTestUtilities.messageToByteArrayInputStream(handshakeRequest);
@@ -99,7 +95,7 @@ public class HandshakerTest {
   public void bogusAuthenticationMode() throws Exception {
     HandshakeAPI.HandshakeRequest handshakeRequest = HandshakeAPI.HandshakeRequest.newBuilder()
         .setVersion(HandshakeAPI.Semver.newBuilder().setMajor(1).setMinor(0))
-        .setAuthenticationModeValue(-1).build();
+        .build();
 
     ByteArrayInputStream byteArrayInputStream =
         ProtobufTestUtilities.messageToByteArrayInputStream(handshakeRequest);
@@ -113,7 +109,7 @@ public class HandshakerTest {
   public void simpleIsSupported() throws Exception {
     HandshakeAPI.HandshakeRequest handshakeRequest = HandshakeAPI.HandshakeRequest.newBuilder()
         .setVersion(HandshakeAPI.Semver.newBuilder().setMajor(1).setMinor(0))
-        .setAuthenticationMode(HandshakeAPI.AuthenticationMode.SIMPLE).build();
+        .build();
 
     ByteArrayInputStream byteArrayInputStream =
         ProtobufTestUtilities.messageToByteArrayInputStream(handshakeRequest);
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufShiroAuthenticatorJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufShiroAuthenticatorJUnitTest.java
index 419d9fe..9b0ea9d 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufShiroAuthenticatorJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufShiroAuthenticatorJUnitTest.java
@@ -16,6 +16,7 @@
 package org.apache.geode.internal.protocol.protobuf;
 
 import static junit.framework.TestCase.fail;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -52,7 +53,7 @@ public class ProtobufShiroAuthenticatorJUnitTest {
   public void setUp() throws IOException {
     ClientProtocol.Message basicAuthenticationRequest = ClientProtocol.Message.newBuilder()
         .setRequest(ClientProtocol.Request.newBuilder()
-            .setSimpleAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
+            .setAuthenticationRequest(AuthenticationAPI.AuthenticationRequest.newBuilder()
                 .putCredentials(ResourceConstants.USER_NAME, TEST_USERNAME)
                 .putCredentials(ResourceConstants.PASSWORD, TEST_PASSWORD)))
         .build();
@@ -75,12 +76,14 @@ public class ProtobufShiroAuthenticatorJUnitTest {
 
   @Test
   public void successfulAuthentication() throws IOException {
-    protobufShiroAuthenticator.authenticate(byteArrayInputStream, byteArrayOutputStream);
 
-    AuthenticationAPI.AuthenticationResponse authenticationResponse =
-        getSimpleAuthenticationResponse(byteArrayOutputStream);
+    Properties properties = new Properties();
+    properties.setProperty(ResourceConstants.USER_NAME, TEST_USERNAME);
+    properties.setProperty(ResourceConstants.PASSWORD, TEST_PASSWORD);
 
-    assertTrue(authenticationResponse.getAuthenticated());
+    Subject authenticate = protobufShiroAuthenticator.authenticate(properties);
+
+    assertNotNull(authenticate);
   }
 
   @Test(expected = AuthenticationFailedException.class)
@@ -88,7 +91,11 @@ public class ProtobufShiroAuthenticatorJUnitTest {
     when(mockSecurityService.login(expectedAuthProperties))
         .thenThrow(new AuthenticationFailedException("BOOM!"));
 
-    protobufShiroAuthenticator.authenticate(byteArrayInputStream, byteArrayOutputStream);
+    Properties properties = new Properties();
+    properties.setProperty(ResourceConstants.USER_NAME, TEST_USERNAME);
+    properties.setProperty(ResourceConstants.PASSWORD, TEST_PASSWORD);
+
+    protobufShiroAuthenticator.authenticate(properties);
   }
 
   @Test
@@ -97,18 +104,12 @@ public class ProtobufShiroAuthenticatorJUnitTest {
     when(mockSecurityService.isClientSecurityRequired()).thenReturn(false);
     when(mockSecurityService.isPeerSecurityRequired()).thenReturn(false);
 
-    protobufShiroAuthenticator.authenticate(byteArrayInputStream, byteArrayOutputStream);
+    Properties properties = new Properties();
+    properties.setProperty(ResourceConstants.USER_NAME, TEST_USERNAME);
+    properties.setProperty(ResourceConstants.PASSWORD, TEST_PASSWORD);
 
-    AuthenticationAPI.AuthenticationResponse authenticationResponse =
-        getSimpleAuthenticationResponse(byteArrayOutputStream);
-
-    assertTrue(authenticationResponse.getAuthenticated());
-  }
+    Subject authenticate = protobufShiroAuthenticator.authenticate(properties);
 
-  private AuthenticationAPI.AuthenticationResponse getSimpleAuthenticationResponse(
-      ByteArrayOutputStream outputStream) throws IOException {
-    ByteArrayInputStream responseStream = new ByteArrayInputStream(outputStream.toByteArray());
-    return ClientProtocol.Message.parseDelimitedFrom(responseStream).getResponse()
-        .getSimpleAuthenticationResponse();
+    assertNotNull(authenticate);
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessorTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessorTest.java
index a9578ff..e4be893 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessorTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufStreamProcessorTest.java
@@ -16,9 +16,12 @@ package org.apache.geode.internal.protocol.protobuf;
 
 import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
+import org.apache.geode.internal.protocol.protobuf.security.processors.NoAuthenticationSecurityProcessor;
+import org.apache.geode.internal.protocol.security.NoOpAuthenticator;
 import org.apache.geode.internal.protocol.security.NoOpAuthorizer;
 import org.apache.geode.internal.protocol.statistics.NoOpStatistics;
 import org.apache.geode.test.junit.categories.UnitTest;
+
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
@@ -40,6 +43,7 @@ public class ProtobufStreamProcessorTest {
     ProtobufStreamProcessor protobufStreamProcessor = new ProtobufStreamProcessor();
     InternalCache mockInternalCache = mock(InternalCache.class);
     protobufStreamProcessor.receiveMessage(inputStream, outputStream, new MessageExecutionContext(
-        mockInternalCache, new NoOpAuthorizer(), new Object(), new NoOpStatistics()));
+        mockInternalCache, new NoOpAuthenticator(), new NoOpAuthorizer(), new Object(),
+        new NoOpStatistics(), new NoAuthenticationSecurityProcessor()));
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
index 43b1efa..1781865 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestExecutionContext.java
@@ -16,12 +16,14 @@ package org.apache.geode.internal.protocol.protobuf;
 
 import org.apache.geode.cache.Cache;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
+import org.apache.geode.internal.protocol.protobuf.security.processors.NoAuthenticationSecurityProcessor;
+import org.apache.geode.internal.protocol.security.NoOpAuthenticator;
 import org.apache.geode.internal.protocol.security.NoOpAuthorizer;
 import org.apache.geode.internal.protocol.statistics.NoOpStatistics;
 
 public class ProtobufTestExecutionContext {
   public static MessageExecutionContext getNoAuthExecutionContext(Cache cache) {
-    return new MessageExecutionContext(cache, new NoOpAuthorizer(), new Object(),
-        new NoOpStatistics());
+    return new MessageExecutionContext(cache, new NoOpAuthenticator(), new NoOpAuthorizer(), new Object(),
+        new NoOpStatistics(), new NoAuthenticationSecurityProcessor());
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestUtilities.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestUtilities.java
index 827599f..9a767fd 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestUtilities.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/ProtobufTestUtilities.java
@@ -55,6 +55,6 @@ public class ProtobufTestUtilities {
       HandshakeAPI.AuthenticationMode authenticationMode) {
     return HandshakeAPI.HandshakeRequest.newBuilder()
         .setVersion(HandshakeAPI.Semver.newBuilder().setMajor(1).setMinor(0))
-        .setAuthenticationMode(authenticationMode).build();
+        .build();
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java
index 86ad5af..40b8a7c 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java
@@ -33,12 +33,13 @@ import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.CacheLoaderException;
 import org.apache.geode.cache.Region;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.ProtobufTestExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
@@ -76,7 +77,7 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
 
   @Test
   public void processReturnsExpectedValuesForValidKeys() throws Exception {
-    Result<RegionAPI.GetAllResponse> result =
+    Result<RegionAPI.GetAllResponse,MessageExecutionContext> result =
         operationHandler.process(serializationServiceStub, generateTestRequest(true, false),
             ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
@@ -97,7 +98,7 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   @Test
   public void processReturnsNoEntriesForNoKeysRequested() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
-    Result<RegionAPI.GetAllResponse> result =
+    Result<RegionAPI.GetAllResponse,MessageExecutionContext> result =
         operationHandler.process(serializationServiceStub, generateTestRequest(false, false),
             ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
@@ -115,7 +116,7 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
         NO_VALUE_PRESENT_FOR_THIS_KEY));
     RegionAPI.GetAllRequest getAllRequest =
         ProtobufRequestUtilities.createGetAllRequest(TEST_REGION, testKeys);
-    Result<RegionAPI.GetAllResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetAllResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         getAllRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Success);
@@ -130,7 +131,7 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   @Test
   public void multipleKeysWhereOneThrows() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
-    Result<RegionAPI.GetAllResponse> result =
+    Result<RegionAPI.GetAllResponse,MessageExecutionContext> result =
         operationHandler.process(serializationServiceStub, generateTestRequest(true, true),
             ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandlerJUnitTest.java
index 393fab8..418191d 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetAvailableServersOperationHandlerJUnitTest.java
@@ -21,10 +21,10 @@ import org.apache.geode.distributed.internal.ServerLocator;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.Result;
+import org.apache.geode.internal.protocol.Result;
 import org.apache.geode.internal.protocol.protobuf.ServerAPI;
 import org.apache.geode.internal.protocol.protobuf.ServerAPI.GetAvailableServersResponse;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.statistics.NoOpStatistics;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.test.junit.categories.UnitTest;
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java
index 3c0c913..ba42f63 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java
@@ -29,10 +29,11 @@ import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.Cache;
 import org.apache.geode.cache.Region;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.internal.serialization.registry.exception.CodecNotRegisteredForTypeException;
@@ -63,7 +64,7 @@ public class GetRegionNamesRequestOperationHandlerJUnitTest extends OperationHan
   @Test
   public void processReturnsCacheRegions() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
-    Result<RegionAPI.GetRegionNamesResponse> result = operationHandler.process(
+    Result<RegionAPI.GetRegionNamesResponse,MessageExecutionContext> result = operationHandler.process(
         serializationServiceStub, ProtobufRequestUtilities.createGetRegionNamesRequest(),
         getNoAuthExecutionContext(cacheStub));
     Assert.assertTrue(result instanceof Success);
@@ -87,7 +88,7 @@ public class GetRegionNamesRequestOperationHandlerJUnitTest extends OperationHan
     Cache emptyCache = mock(Cache.class);;
     when(emptyCache.rootRegions())
         .thenReturn(Collections.unmodifiableSet(new HashSet<Region<String, String>>()));
-    Result<RegionAPI.GetRegionNamesResponse> result = operationHandler.process(
+    Result<RegionAPI.GetRegionNamesResponse,MessageExecutionContext> result = operationHandler.process(
         serializationServiceStub, ProtobufRequestUtilities.createGetRegionNamesRequest(),
         getNoAuthExecutionContext(emptyCache));
     Assert.assertTrue(result instanceof Success);
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java
index 2e7979c..f2aebb5 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java
@@ -31,13 +31,14 @@ import org.apache.geode.cache.DataPolicy;
 import org.apache.geode.cache.Region;
 import org.apache.geode.cache.RegionAttributes;
 import org.apache.geode.cache.Scope;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.protocol.MessageUtil;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.internal.protocol.protobuf.Failure;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.Failure;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
+import org.apache.geode.internal.protocol.Result;
 import org.apache.geode.test.junit.categories.UnitTest;
 
 @Category(UnitTest.class)
@@ -69,7 +70,7 @@ public class GetRegionRequestOperationHandlerJUnitTest extends OperationHandlerJ
     when(regionAttributesStub.getScope()).thenReturn(Scope.DISTRIBUTED_ACK);
 
 
-    Result<RegionAPI.GetRegionResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetRegionResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         MessageUtil.makeGetRegionRequest(TEST_REGION1), getNoAuthExecutionContext(cacheStub));
     RegionAPI.GetRegionResponse response = result.getMessage();
     BasicTypes.Region region = response.getRegion();
@@ -92,7 +93,7 @@ public class GetRegionRequestOperationHandlerJUnitTest extends OperationHandlerJ
     when(emptyCache.rootRegions())
         .thenReturn(Collections.unmodifiableSet(new HashSet<Region<String, String>>()));
     String unknownRegionName = "UNKNOWN_REGION";
-    Result<RegionAPI.GetRegionResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetRegionResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         MessageUtil.makeGetRegionRequest(unknownRegionName), getNoAuthExecutionContext(emptyCache));
     Assert.assertTrue(result instanceof Failure);
     Assert.assertEquals(ProtocolErrorCode.REGION_NOT_FOUND.codeValue,
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java
index 8064475..f3e80bf 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java
@@ -25,13 +25,14 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.Region;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.Failure;
+import org.apache.geode.internal.protocol.Failure;
 import org.apache.geode.internal.protocol.protobuf.ProtobufTestExecutionContext;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
@@ -66,7 +67,7 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   @Test
   public void processReturnsTheEncodedValueFromTheRegion() throws Exception {
     RegionAPI.GetRequest getRequest = generateTestRequest(false, false, false);
-    Result<RegionAPI.GetResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         getRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     Assert.assertTrue(result instanceof Success);
@@ -79,7 +80,7 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   @Test
   public void processReturnsUnsucessfulResponseForInvalidRegion() throws Exception {
     RegionAPI.GetRequest getRequest = generateTestRequest(true, false, false);
-    Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetResponse,MessageExecutionContext> response = operationHandler.process(serializationServiceStub,
         getRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     Assert.assertTrue(response instanceof Failure);
@@ -90,7 +91,7 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   @Test
   public void processReturnsKeyNotFoundWhenKeyIsNotFound() throws Exception {
     RegionAPI.GetRequest getRequest = generateTestRequest(false, true, false);
-    Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetResponse,MessageExecutionContext> response = operationHandler.process(serializationServiceStub,
         getRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     Assert.assertTrue(response instanceof Success);
@@ -99,7 +100,7 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   @Test
   public void processReturnsLookupFailureWhenKeyFoundWithNoValue() throws Exception {
     RegionAPI.GetRequest getRequest = generateTestRequest(false, false, true);
-    Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetResponse,MessageExecutionContext> response = operationHandler.process(serializationServiceStub,
         getRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     Assert.assertTrue(response instanceof Success);
@@ -118,7 +119,7 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
         .setCustomEncodedValue(customEncodedValueBuilder).build();
     RegionAPI.GetRequest getRequest =
         ProtobufRequestUtilities.createGetRequest(TEST_REGION, encodedKey).getGetRequest();
-    Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.GetResponse,MessageExecutionContext> response = operationHandler.process(serializationServiceStub,
         getRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     Assert.assertTrue(response instanceof Failure);
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java
index 9e1d7a5..9e3e406 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java
@@ -31,10 +31,11 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.Region;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
@@ -70,7 +71,7 @@ public class PutAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   public void processInsertsMultipleValidEntriesInCache() throws Exception {
     PutAllRequestOperationHandler operationHandler = new PutAllRequestOperationHandler();
 
-    Result<RegionAPI.PutAllResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.PutAllResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         generateTestRequest(false, true), getNoAuthExecutionContext(cacheStub));
 
     Assert.assertTrue(result instanceof Success);
@@ -84,7 +85,7 @@ public class PutAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   public void processWithInvalidEntrySucceedsAndReturnsFailedKey() throws Exception {
     PutAllRequestOperationHandler operationHandler = new PutAllRequestOperationHandler();
 
-    Result<RegionAPI.PutAllResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.PutAllResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         generateTestRequest(true, true), getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Success);
@@ -103,7 +104,7 @@ public class PutAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   public void processWithNoEntriesPasses() throws Exception {
     PutAllRequestOperationHandler operationHandler = new PutAllRequestOperationHandler();
 
-    Result<RegionAPI.PutAllResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.PutAllResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         generateTestRequest(false, false), getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Success);
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java
index b90982c..4dec3f0 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java
@@ -29,13 +29,14 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.Region;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.Failure;
+import org.apache.geode.internal.protocol.Failure;
 import org.apache.geode.internal.protocol.protobuf.ProtobufTestExecutionContext;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
@@ -62,7 +63,7 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   @Test
   public void test_puttingTheEncodedEntryIntoRegion() throws Exception {
     PutRequestOperationHandler operationHandler = new PutRequestOperationHandler();
-    Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.PutResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         generateTestRequest(), ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Success);
@@ -91,7 +92,7 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
     BasicTypes.Entry testEntry = ProtobufUtilities.createEntry(encodedKey, testValue);
     RegionAPI.PutRequest putRequest =
         ProtobufRequestUtilities.createPutRequest(TEST_REGION, testEntry).getPutRequest();
-    Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.PutResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         putRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Failure);
@@ -103,7 +104,7 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   public void test_RegionNotFound() throws Exception {
     when(cacheStub.getRegion(TEST_REGION)).thenReturn(null);
     PutRequestOperationHandler operationHandler = new PutRequestOperationHandler();
-    Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.PutResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         generateTestRequest(), ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Failure);
@@ -116,7 +117,7 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
     when(regionMock.put(any(), any())).thenThrow(ClassCastException.class);
 
     PutRequestOperationHandler operationHandler = new PutRequestOperationHandler();
-    Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.PutResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         generateTestRequest(), ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Failure);
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java
index 5bfad23..e5166d0 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java
@@ -27,14 +27,15 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.Region;
+import org.apache.geode.internal.cache.tier.sockets.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.internal.protocol.protobuf.Failure;
+import org.apache.geode.internal.protocol.Failure;
 import org.apache.geode.internal.protocol.protobuf.ProtobufTestExecutionContext;
-import org.apache.geode.internal.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.internal.protocol.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.internal.protocol.protobuf.Result;
-import org.apache.geode.internal.protocol.protobuf.Success;
+import org.apache.geode.internal.protocol.Result;
+import org.apache.geode.internal.protocol.Success;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.internal.protocol.protobuf.utilities.ProtobufUtilities;
 import org.apache.geode.internal.serialization.exception.UnsupportedEncodingTypeException;
@@ -67,7 +68,7 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   @Test
   public void processValidKeyRemovesTheEntryAndReturnSuccess() throws Exception {
     RegionAPI.RemoveRequest removeRequest = generateTestRequest(false, false).getRemoveRequest();
-    Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.RemoveResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         removeRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Success);
@@ -77,7 +78,7 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   @Test
   public void processReturnsUnsucessfulResponseForInvalidRegion() throws Exception {
     RegionAPI.RemoveRequest removeRequest = generateTestRequest(true, false).getRemoveRequest();
-    Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.RemoveResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         removeRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Failure);
@@ -88,7 +89,7 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   @Test
   public void processReturnsSuccessWhenKeyIsNotFound() throws Exception {
     RegionAPI.RemoveRequest removeRequest = generateTestRequest(false, true).getRemoveRequest();
-    Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.RemoveResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         removeRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Success);
@@ -108,7 +109,7 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
 
     RegionAPI.RemoveRequest removeRequest =
         ProtobufRequestUtilities.createRemoveRequest(TEST_REGION, encodedKey).getRemoveRequest();;
-    Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
+    Result<RegionAPI.RemoveResponse,MessageExecutionContext> result = operationHandler.process(serializationServiceStub,
         removeRequest, ProtobufTestExecutionContext.getNoAuthExecutionContext(cacheStub));
 
     assertTrue(result instanceof Failure);

-- 
To stop receiving notification emails like this one, please contact
"commits@geode.apache.org" <commits@geode.apache.org>.

Mime
View raw message