geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From u..@apache.org
Subject [geode] 08/08: More changes relating to Authorization
Date Thu, 14 Sep 2017 19:10:28 GMT
This is an automated email from the ASF dual-hosted git repository.

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

commit 4d048a60afd5246b29b63d169f37fbe3eb2368a1
Author: kohlmu-pivotal <ukohlmeyer@pivotal.io>
AuthorDate: Thu Sep 14 11:24:19 2017 -0700

    More changes relating to Authorization
---
 .../sockets/GenericProtocolServerConnection.java   | 27 +++++----
 .../tier/sockets/ServerConnectionFactory.java      | 11 ++--
 .../protocol/ClientProtocolMessageHandler.java     |  2 +
 .../internal/protocol/MessageExecutionContext.java | 28 +++++++---
 .../ProtocolMessageHandlerLookupService.java       | 38 +++++++------
 .../protocol/security/server/Authenticator.java    | 12 +---
 .../server/AuthenticatorLookupService.java         |  2 +-
 ...ervice.java => AuthorizationLookupService.java} | 34 ++++++------
 .../protocol/security/server/Authorizer.java       |  6 +-
 .../security/server/NoOpAuthenticator.java         | 11 +---
 .../protocol/security/server/NoOpAuthorizer.java   |  9 ++-
 ...de.internal.protocol.security.server.Authorizer |  1 +
 .../tier/sockets/ServerConnectionFactoryTest.java  | 36 +++++-------
 .../protocol/operations/OperationHandler.java      |  6 +-
 ...essor.java => ProtobufOperationsProcessor.java} | 32 +++++------
 ...or.java => ProtobufProtocolMessageHandler.java} | 58 ++++++++++++++------
 .../server/ProtobufSimpleAuthenticator.java        | 53 ++++++++----------
 .../security/server/ProtobufSimpleAuthorizer.java  | 16 +++---
 ....internal.protocol.ClientProtocolMessageHandler |  2 +-
 ...de.internal.protocol.security.server.Authorizer |  1 +
 .../GenericProtocolServerConnectionTest.java       | 12 +++-
 ...ava => ProtobufProtocolMessageHandlerTest.java} | 10 ++--
 .../ProtobufSimpleAuthenticatorJUnitTest.java      | 42 ++++++++------
 .../GetAllRequestOperationHandlerJUnitTest.java    | 24 ++++----
 ...egionNamesRequestOperationHandlerJUnitTest.java | 20 ++-----
 .../GetRegionRequestOperationHandlerJUnitTest.java | 48 ++++++----------
 .../GetRequestOperationHandlerJUnitTest.java       | 60 ++++++++++----------
 .../PutAllRequestOperationHandlerJUnitTest.java    | 51 ++++++++---------
 .../PutRequestOperationHandlerJUnitTest.java       | 64 ++++++++++------------
 .../RemoveRequestOperationHandlerJUnitTest.java    | 61 ++++++++++-----------
 .../server/AuthenticationIntegrationTest.java      | 43 ++++++++-------
 .../server/AuthorizationIntegrationTest.java       |  7 ++-
 32 files changed, 416 insertions(+), 411 deletions(-)

diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnection.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnection.java
index 1e69243..6d9d361 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnection.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnection.java
@@ -15,22 +15,22 @@
 
 package org.apache.geode.internal.cache.tier.sockets;
 
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
 import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.cache.tier.Acceptor;
 import org.apache.geode.internal.cache.tier.CachedRegionHelper;
 import org.apache.geode.internal.protocol.ClientProtocolMessageHandler;
 import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.security.server.Authenticator;
-import org.apache.geode.internal.protocol.security.server.AuthenticatorLookupService;
 import org.apache.geode.internal.security.SecurityService;
+import org.apache.geode.security.AuthenticationFailedException;
 import org.apache.geode.security.SecurityManager;
 
-import java.io.EOFException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.Socket;
-
 /**
  * Holds the socket and protocol handler for the new client protocol.
  */
@@ -48,12 +48,12 @@ public class GenericProtocolServerConnection extends ServerConnection {
       CachedRegionHelper cachedRegionHelper, CacheServerStats cacheServerStats, int hsTimeout,
       int socketBufferSize, String communicationModeStr, byte communicationMode, Acceptor acceptor,
       SecurityService securityService, ClientProtocolMessageHandler clientProtocolMessageHandler,
-      AuthenticatorLookupService authenticatorLookupService) {
+      Authenticator authenticator) {
     super(socket, cache, cachedRegionHelper, cacheServerStats, hsTimeout, socketBufferSize,
         communicationModeStr, communicationMode, acceptor, securityService);
     securityManager = securityService.getSecurityManager();
     this.messageHandler = clientProtocolMessageHandler;
-    this.authenticator = authenticatorLookupService.getAuthenticator();
+    this.authenticator = authenticator;
   }
 
   @Override
@@ -63,9 +63,14 @@ public class GenericProtocolServerConnection extends ServerConnection {
       InputStream inputStream = socket.getInputStream();
       OutputStream outputStream = socket.getOutputStream();
 
-      authenticator.authenticate(inputStream, outputStream, securityManager);
+      Object authenticationToken =
+          authenticator.authenticate(inputStream, outputStream, securityManager);
       messageHandler.receiveMessage(inputStream, outputStream,
-          new MessageExecutionContext(this.getCache(), authenticator.getAuthorizer()));
+          new MessageExecutionContext(this.getCache(), authenticationToken, securityManager));
+    } catch (AuthenticationFailedException e) {
+      logger.warn(e);
+      this.setFlagProcessMessagesAsFalse();
+      setClientDisconnectedException(e);
     } catch (EOFException e) {
       this.setFlagProcessMessagesAsFalse();
       setClientDisconnectedException(e);
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactory.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactory.java
index c86ab83..3058c81 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactory.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactory.java
@@ -23,9 +23,10 @@ import java.net.Socket;
 import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.cache.tier.Acceptor;
 import org.apache.geode.internal.cache.tier.CachedRegionHelper;
+import org.apache.geode.internal.protocol.ClientProtocolMessageHandler;
 import org.apache.geode.internal.protocol.ProtocolMessageHandlerLookupService;
-import org.apache.geode.internal.security.SecurityService;
 import org.apache.geode.internal.protocol.security.server.AuthenticatorLookupService;
+import org.apache.geode.internal.security.SecurityService;
 
 /**
  * Creates instances of ServerConnection based on the connection mode provided.
@@ -37,6 +38,7 @@ public class ServerConnectionFactory {
   public ServerConnectionFactory() {
     protocolMessageHandlerLookupService = new ProtocolMessageHandlerLookupService();
     authenticatorLookupService = new AuthenticatorLookupService();
+
   }
 
   public ServerConnection makeServerConnection(Socket socket, InternalCache cache,
@@ -47,11 +49,12 @@ public class ServerConnectionFactory {
       if (!Boolean.getBoolean("geode.feature-protobuf-protocol")) {
         throw new IOException("Server received unknown communication mode: " + communicationMode);
       } else {
+        ClientProtocolMessageHandler clientProtocolMessageHandler =
+            protocolMessageHandlerLookupService.lookupProtocolHandler("PROTOBUF");
         return new GenericProtocolServerConnection(socket, cache, cachedRegionHelper,
             cacheServerStats, hsTimeout, socketBufferSize, communicationModeStr, communicationMode,
-            acceptor, securityService,
-            protocolMessageHandlerLookupService.lookupProtocolHandler("protobuf"),
-            authenticatorLookupService);
+            acceptor, securityService, clientProtocolMessageHandler,
+            authenticatorLookupService.getAuthenticator());
       }
     } else {
       return new LegacyServerConnection(socket, cache, cachedRegionHelper, cacheServerStats,
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/ClientProtocolMessageHandler.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/ClientProtocolMessageHandler.java
index 3c9be1c..86bd563 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/ClientProtocolMessageHandler.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/ClientProtocolMessageHandler.java
@@ -34,4 +34,6 @@ import org.apache.geode.internal.cache.tier.sockets.ServerConnectionFactory;
 public interface ClientProtocolMessageHandler {
   void receiveMessage(InputStream inputStream, OutputStream outputStream,
       MessageExecutionContext executionContext) throws IOException;
+
+  String getMessageHandlerProtocolName();
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/MessageExecutionContext.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/MessageExecutionContext.java
index f895688..c52419b 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/MessageExecutionContext.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/MessageExecutionContext.java
@@ -19,22 +19,27 @@ import org.apache.geode.annotations.Experimental;
 import org.apache.geode.cache.Cache;
 import org.apache.geode.distributed.Locator;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
-import org.apache.geode.internal.protocol.security.server.Authorizer;
+import org.apache.geode.security.SecurityManager;
 
 @Experimental
 public class MessageExecutionContext {
   private Cache cache;
   private Locator locator;
-  private Authorizer authorizer;
+  private final Object authenticationToken;
+  private final SecurityManager securityManager;
 
-  public MessageExecutionContext(Cache cache, Authorizer streamAuthorizer) {
+  public MessageExecutionContext(Cache cache, Object authenticationToken,
+      SecurityManager securityManager) {
     this.cache = cache;
-    this.authorizer = streamAuthorizer;
+    this.authenticationToken = authenticationToken;
+    this.securityManager = securityManager;
   }
 
 
   public MessageExecutionContext(Locator locator) {
     this.locator = locator;
+    this.authenticationToken = null;
+    this.securityManager = null;
   }
 
   /**
@@ -67,10 +72,19 @@ public class MessageExecutionContext {
   }
 
   /**
-   * Returns the Authorizer associated with this execution. This can be used to perform
+   * Returns the AuthenticatedTokenassociated with this execution. This can be used to perform
    * authorization checks for the user associated with this thread.
    */
-  public Authorizer getAuthorizer() {
-    return authorizer;
+  public Object getAuthenticationToken() {
+    return authenticationToken;
+  }
+
+  /**
+   * Returns the security manager.
+   * 
+   * @return
+   */
+  public SecurityManager getSecurityManager() {
+    return securityManager;
   }
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/ProtocolMessageHandlerLookupService.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/ProtocolMessageHandlerLookupService.java
index 418eecc..4196fd6 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/ProtocolMessageHandlerLookupService.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/ProtocolMessageHandlerLookupService.java
@@ -1,32 +1,38 @@
+/*
+ * 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;
 
-import java.util.Iterator;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.ServiceLoader;
 
-import org.apache.geode.internal.cache.tier.sockets.ServiceLoadingFailureException;
-
 public class ProtocolMessageHandlerLookupService {
-  private ClientProtocolMessageHandler protocolHandler;
+  private Map<String, ClientProtocolMessageHandler> protocolMessageHandlers = new HashMap<>();
 
   public ProtocolMessageHandlerLookupService() {
-    protocolHandler = findFirstProtocolMessageHandler();
-  }
-
-  private ClientProtocolMessageHandler findFirstProtocolMessageHandler() {
     ServiceLoader<ClientProtocolMessageHandler> loader =
         ServiceLoader.load(ClientProtocolMessageHandler.class);
-    Iterator<ClientProtocolMessageHandler> iterator = loader.iterator();
-
-    if (!iterator.hasNext()) {
-      throw new ServiceLoadingFailureException(
-          "There is no ClientProtocolMessageHandler implementation found in JVM");
+    for (ClientProtocolMessageHandler clientProtocolMessageHandler : loader) {
+      protocolMessageHandlers.put(clientProtocolMessageHandler.getMessageHandlerProtocolName(),
+          clientProtocolMessageHandler);
     }
 
-    return iterator.next();
   }
 
   public ClientProtocolMessageHandler lookupProtocolHandler(String protocolType) {
-    // TODO Do we need to make provision for different protocols here right now?
-    return protocolHandler;
+    return protocolMessageHandlers.get(protocolType);
   }
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authenticator.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authenticator.java
index f4d2b14..7d68aa0 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authenticator.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authenticator.java
@@ -19,7 +19,6 @@ import java.io.InputStream;
 import java.io.OutputStream;
 
 import org.apache.geode.annotations.Experimental;
-import org.apache.geode.security.AuthenticationRequiredException;
 import org.apache.geode.security.SecurityManager;
 
 /**
@@ -36,9 +35,10 @@ public interface Authenticator {
    * @param inputStream to read auth messages from.
    * @param outputStream to send messages to.
    * @param securityManager can be used for validating credentials against.
+   * @return a authentication token that proves that the remote entity was authenticated
    * @throws IOException if EOF or if invalid input is received.
    */
-  void authenticate(InputStream inputStream, OutputStream outputStream,
+  Object authenticate(InputStream inputStream, OutputStream outputStream,
       SecurityManager securityManager) throws IOException;
 
   /**
@@ -49,13 +49,7 @@ public interface Authenticator {
   boolean isAuthenticated();
 
   /**
-   * Return an authorization object which can be used to determine which permissions this stream has
-   * according to the provided securityManager.
-   */
-  Authorizer getAuthorizer() throws AuthenticationRequiredException;
-
-  /**
    * @return a unique identifier for this particular implementation (NOOP, PASSTHROUGH, etc.)
    */
-  String implementationID();
+  String getImplementationID();
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthenticatorLookupService.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthenticatorLookupService.java
index 06c92e3..ccea628 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthenticatorLookupService.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthenticatorLookupService.java
@@ -37,7 +37,7 @@ public class AuthenticatorLookupService {
     authenticators = new HashMap<>();
     ServiceLoader<Authenticator> loader = ServiceLoader.load(Authenticator.class);
     for (Authenticator streamAuthenticator : loader) {
-      authenticators.put(streamAuthenticator.implementationID(), streamAuthenticator.getClass());
+      authenticators.put(streamAuthenticator.getImplementationID(), streamAuthenticator.getClass());
     }
   }
 
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthenticatorLookupService.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthorizationLookupService.java
similarity index 59%
copy from geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthenticatorLookupService.java
copy to geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthorizationLookupService.java
index 06c92e3..2002dc3 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthenticatorLookupService.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/AuthorizationLookupService.java
@@ -21,41 +21,39 @@ import java.util.ServiceLoader;
 import org.apache.geode.GemFireConfigException;
 import org.apache.geode.internal.cache.tier.sockets.ServiceLoadingFailureException;
 
-public class AuthenticatorLookupService {
-  private Map<String, Class<? extends Authenticator>> authenticators = null;
+public class AuthorizationLookupService {
+  private Map<String, Class<? extends Authorizer>> authorizers = null;
 
-  public AuthenticatorLookupService() {
-    if (authenticators == null) {
+  public AuthorizationLookupService() {
+    if (authorizers == null) {
       initializeAuthenticatorsMap();
     }
   }
 
   private synchronized void initializeAuthenticatorsMap() {
-    if (authenticators != null) {
+    if (authorizers != null) {
       return;
     }
-    authenticators = new HashMap<>();
-    ServiceLoader<Authenticator> loader = ServiceLoader.load(Authenticator.class);
-    for (Authenticator streamAuthenticator : loader) {
-      authenticators.put(streamAuthenticator.implementationID(), streamAuthenticator.getClass());
+    authorizers = new HashMap<>();
+    ServiceLoader<Authorizer> loader = ServiceLoader.load(Authorizer.class);
+    for (Authorizer authorizer : loader) {
+      authorizers.put(authorizer.getImplementationID(), authorizer.getClass());
     }
   }
 
-  public Authenticator getAuthenticator() {
-    String authenticationMode = System.getProperty("geode.protocol-authentication-mode", "NOOP");
+  public Authorizer getAuthorizer() {
+    String authorizationMode = System.getProperty("geode.protocol-authentication-mode", "NOOP");
 
-    Class<? extends Authenticator> streamAuthenticatorClass =
-        authenticators.get(authenticationMode);
-    if (streamAuthenticatorClass == null) {
+    Class<? extends Authorizer> authorizationClass = authorizers.get(authorizationMode);
+    if (authorizationClass == null) {
       throw new GemFireConfigException(
-          "Could not find implementation for Authenticator with implementation ID "
-              + authenticationMode);
+          "Could not find implementation for Authorizer with ID " + authorizationMode);
     } else {
       try {
-        return streamAuthenticatorClass.newInstance();
+        return authorizationClass.newInstance();
       } catch (InstantiationException | IllegalAccessException e) {
         throw new ServiceLoadingFailureException(
-            "Unable to instantiate authenticator for ID " + authenticationMode, e);
+            "Unable to instantiate authenticator for ID " + authorizationMode, e);
       }
     }
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authorizer.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authorizer.java
index b9c69fe..5d92208 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authorizer.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/Authorizer.java
@@ -16,8 +16,12 @@ package org.apache.geode.internal.protocol.security.server;
 
 import org.apache.geode.annotations.Experimental;
 import org.apache.geode.security.ResourcePermission;
+import org.apache.geode.security.SecurityManager;
 
 @Experimental
 public interface Authorizer {
-  boolean authorize(ResourcePermission permissionRequested);
+  boolean authorize(Object authenticatedToken, ResourcePermission permissionRequested,
+      SecurityManager securityManager);
+
+  String getImplementationID();
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthenticator.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthenticator.java
index 4b41c9f..d68415f 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthenticator.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthenticator.java
@@ -26,9 +26,9 @@ import org.apache.geode.security.SecurityManager;
  */
 public class NoOpAuthenticator implements Authenticator {
   @Override
-  public void authenticate(InputStream inputStream, OutputStream outputStream,
+  public Object authenticate(InputStream inputStream, OutputStream outputStream,
       SecurityManager securityManager) throws IOException {
-    // this method needs to do nothing as it is a pass-through implementation
+    return null;
   }
 
   @Override
@@ -37,12 +37,7 @@ public class NoOpAuthenticator implements Authenticator {
   }
 
   @Override
-  public Authorizer getAuthorizer() {
-    return new NoOpAuthorizer();
-  }
-
-  @Override
-  public String implementationID() {
+  public String getImplementationID() {
     return "NOOP";
   }
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthorizer.java b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthorizer.java
index 3f0e01a..d3cdab4 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthorizer.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/protocol/security/server/NoOpAuthorizer.java
@@ -15,13 +15,20 @@
 package org.apache.geode.internal.protocol.security.server;
 
 import org.apache.geode.security.ResourcePermission;
+import org.apache.geode.security.SecurityManager;
 
 /**
  * An implementation of {@link Authorizer} that doesn't use its parameters and always returns true.
  */
 public class NoOpAuthorizer implements Authorizer {
   @Override
-  public boolean authorize(ResourcePermission permissionRequested) {
+  public boolean authorize(Object authenticatedToken, ResourcePermission permissionRequested,
+      SecurityManager securityManager) {
     return true;
   }
+
+  @Override
+  public String getImplementationID() {
+    return "NOOP";
+  }
 }
diff --git a/geode-core/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.security.server.Authorizer b/geode-core/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.security.server.Authorizer
new file mode 100644
index 0000000..85fcb4a
--- /dev/null
+++ b/geode-core/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.security.server.Authorizer
@@ -0,0 +1 @@
+org.apache.geode.internal.protocol.security.server.NoOpAuthorizer
\ No newline at end of file
diff --git a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactoryTest.java b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactoryTest.java
index 09c5949..568571d 100644
--- a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactoryTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionFactoryTest.java
@@ -15,23 +15,24 @@
 
 package org.apache.geode.internal.cache.tier.sockets;
 
-import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.tier.CommunicationMode;
-import org.apache.geode.internal.cache.tier.CachedRegionHelper;
-import org.apache.geode.internal.security.SecurityService;
-import org.apache.geode.test.junit.categories.UnitTest;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.contrib.java.lang.system.RestoreSystemProperties;
-import org.junit.experimental.categories.Category;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.Socket;
 
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.contrib.java.lang.system.RestoreSystemProperties;
+import org.junit.experimental.categories.Category;
+
+import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.cache.tier.CachedRegionHelper;
+import org.apache.geode.internal.cache.tier.CommunicationMode;
+import org.apache.geode.internal.security.SecurityService;
+import org.apache.geode.test.junit.categories.UnitTest;
 
 /**
  * We don't test the path where the service providing protobufProtocolHandler is actually present,
@@ -58,17 +59,6 @@ public class ServerConnectionFactoryTest {
 
   }
 
-  /**
-   * @throws ServiceLoadingFailureException because the service is implemented in a different
-   *         module, and when this unit test is run, that module won't be present.
-   */
-  @Test(expected = ServiceLoadingFailureException.class)
-  public void newClientProtocolFailsWithSystemPropertySet() throws IOException {
-    System.setProperty("geode.feature-protobuf-protocol", "true");
-    ServerConnection serverConnection = serverConnectionMockedExceptForCommunicationMode(
-        CommunicationMode.ProtobufClientServerProtocol.getModeNumber());
-  }
-
   @Test
   public void makeServerConnection() throws Exception {
     CommunicationMode[] communicationModes = new CommunicationMode[] {
diff --git a/geode-protobuf/src/main/java/org/apache/geode/protocol/operations/OperationHandler.java b/geode-protobuf/src/main/java/org/apache/geode/protocol/operations/OperationHandler.java
index 8e9e4c0..b954039 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/protocol/operations/OperationHandler.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/protocol/operations/OperationHandler.java
@@ -15,9 +15,9 @@
 package org.apache.geode.protocol.operations;
 
 import org.apache.geode.annotations.Experimental;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
-import org.apache.geode.protocol.protobuf.ProtobufOpsProcessor;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
+import org.apache.geode.protocol.protobuf.ProtobufOperationsProcessor;
 import org.apache.geode.protocol.responses.Result;
 import org.apache.geode.serialization.SerializationService;
 
@@ -25,7 +25,7 @@ import org.apache.geode.serialization.SerializationService;
  * This interface is implemented by a object capable of handling request types 'Req' and returning
  * an a response of type 'Resp'
  *
- * See {@link ProtobufOpsProcessor}
+ * See {@link ProtobufOperationsProcessor}
  */
 @Experimental
 public interface OperationHandler<Req, Resp> {
diff --git a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufOpsProcessor.java b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufOperationsProcessor.java
similarity index 78%
rename from geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufOpsProcessor.java
rename to geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufOperationsProcessor.java
index 555c189..9cc072e 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufOpsProcessor.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufOperationsProcessor.java
@@ -15,13 +15,12 @@
 package org.apache.geode.protocol.protobuf;
 
 import org.apache.geode.annotations.Experimental;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
+import org.apache.geode.internal.protocol.security.server.Authorizer;
 import org.apache.geode.protocol.protobuf.registry.OperationContextRegistry;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufResponseUtilities;
-import org.apache.geode.internal.protocol.security.server.Authorizer;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
 import org.apache.geode.protocol.responses.Failure;
 import org.apache.geode.protocol.responses.Result;
 import org.apache.geode.serialization.SerializationService;
@@ -31,26 +30,30 @@ import org.apache.geode.serialization.SerializationService;
  * it to the appropriate handler.
  */
 @Experimental
-public class ProtobufOpsProcessor {
+public class ProtobufOperationsProcessor {
 
   private final OperationContextRegistry operationContextRegistry;
   private final SerializationService serializationService;
+  private final Authorizer authorizer;
 
-  public ProtobufOpsProcessor(SerializationService serializationService,
-      OperationContextRegistry operationContextRegistry) {
+  ProtobufOperationsProcessor(SerializationService serializationService,
+      OperationContextRegistry operationContextRegistry, Authorizer autherizer) {
     this.serializationService = serializationService;
     this.operationContextRegistry = operationContextRegistry;
+    this.authorizer = autherizer;
   }
 
-  public ClientProtocol.Response process(ClientProtocol.Request request,
-      MessageExecutionContext context) {
+  public ClientProtocol.Response process(final ClientProtocol.Request request,
+      final MessageExecutionContext context) {
     ClientProtocol.Request.RequestAPICase requestType = request.getRequestAPICase();
     OperationContext operationContext = operationContextRegistry.getOperationContext(requestType);
     ClientProtocol.Response.Builder builder;
     Result result;
-    Authorizer authorizer = findAuthorizer(context);
+
     try {
-      if (authorizer.authorize(operationContext.getAccessPermissionRequired())) {
+      boolean authorized = authorizer.authorize(context.getAuthenticationToken(),
+          operationContext.getAccessPermissionRequired(), context.getSecurityManager());
+      if (authorized) {
         result = operationContext.getOperationHandler().process(serializationService,
             operationContext.getFromRequest().apply(request), context);
       } else {
@@ -69,13 +72,4 @@ public class ProtobufOpsProcessor {
     return builder.build();
   }
 
-  private Authorizer findAuthorizer(MessageExecutionContext context) {
-    Authorizer authorizer = context.getAuthorizer();
-    if (authorizer != null) {
-      return authorizer;
-    } else {
-      // TODO Horrible HACK because we need to look this up correctly.
-      return new NoOpAuthorizer();
-    }
-  }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufStreamProcessor.java b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufProtocolMessageHandler.java
similarity index 58%
rename from geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufStreamProcessor.java
rename to geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufProtocolMessageHandler.java
index 22534ab..8607392 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufStreamProcessor.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/ProtobufProtocolMessageHandler.java
@@ -22,8 +22,10 @@ import java.io.OutputStream;
 import org.apache.geode.annotations.Experimental;
 import org.apache.geode.internal.protocol.ClientProtocolMessageHandler;
 import org.apache.geode.internal.protocol.MessageExecutionContext;
-import org.apache.geode.protocol.exception.InvalidProtocolMessageException;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
+import org.apache.geode.internal.protocol.security.server.AuthorizationLookupService;
+import org.apache.geode.internal.protocol.security.server.Authorizer;
+import org.apache.geode.protocol.exception.InvalidProtocolMessageException;
 import org.apache.geode.protocol.protobuf.registry.OperationContextRegistry;
 import org.apache.geode.protocol.protobuf.serializer.ProtobufProtocolSerializer;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufUtilities;
@@ -35,40 +37,60 @@ import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredF
  * and then pushes it to the output stream.
  */
 @Experimental
-public class ProtobufStreamProcessor implements ClientProtocolMessageHandler {
+public class ProtobufProtocolMessageHandler implements ClientProtocolMessageHandler {
   private final ProtobufProtocolSerializer protobufProtocolSerializer;
-  private final ProtobufOpsProcessor protobufOpsProcessor;
+  private final ProtobufOperationsProcessor protobufOperationProcessor;
+  private final OperationContextRegistry operationContextRegistry;
+  private final ProtobufSerializationService protobufSerializationService;
+  private final Authorizer authorizer;
 
-  public ProtobufStreamProcessor() throws CodecAlreadyRegisteredForTypeException {
+  public ProtobufProtocolMessageHandler() throws CodecAlreadyRegisteredForTypeException {
     protobufProtocolSerializer = new ProtobufProtocolSerializer();
-    protobufOpsProcessor = new ProtobufOpsProcessor(new ProtobufSerializationService(),
-        new OperationContextRegistry());
+    operationContextRegistry = new OperationContextRegistry();
+    protobufSerializationService = new ProtobufSerializationService();
+    authorizer = new AuthorizationLookupService().getAuthorizer();
+    protobufOperationProcessor = new ProtobufOperationsProcessor(protobufSerializationService,
+        operationContextRegistry, authorizer);
+
   }
 
   @Override
   public void receiveMessage(InputStream inputStream, OutputStream outputStream,
       MessageExecutionContext executionContext) throws IOException {
     try {
-      processOneMessage(inputStream, outputStream, executionContext);
+      ClientProtocol.Message incomingMessage = deserializeMessageFromInputStream(inputStream);
+      ClientProtocol.Message outgoingMessage = processMessage(incomingMessage, executionContext);
+      serializeMessageToOutputStream(outgoingMessage, outputStream);
     } catch (InvalidProtocolMessageException e) {
       throw new IOException(e);
     }
   }
 
-  private void processOneMessage(InputStream inputStream, OutputStream outputStream,
-      MessageExecutionContext executionContext)
-      throws InvalidProtocolMessageException, IOException {
-    ClientProtocol.Message message = protobufProtocolSerializer.deserialize(inputStream);
-    if (message == null) {
-      throw new EOFException("Tried to deserialize protobuf message at EOF");
-    }
+  @Override
+  public String getMessageHandlerProtocolName() {
+    return "PROTOBUF";
+  }
 
-    ClientProtocol.Request request = message.getRequest();
-    ClientProtocol.Response response = protobufOpsProcessor.process(request, executionContext);
+  private ClientProtocol.Message processMessage(ClientProtocol.Message message,
+      MessageExecutionContext executionContext) {
+    ClientProtocol.Response response =
+        protobufOperationProcessor.process(message.getRequest(), executionContext);
     ClientProtocol.MessageHeader responseHeader =
         ProtobufUtilities.createMessageHeaderForRequest(message);
-    ClientProtocol.Message responseMessage =
-        ProtobufUtilities.createProtobufResponse(responseHeader, response);
+    return ProtobufUtilities.createProtobufResponse(responseHeader, response);
+  }
+
+  private void serializeMessageToOutputStream(ClientProtocol.Message responseMessage,
+      OutputStream outputStream) throws IOException {
     protobufProtocolSerializer.serialize(responseMessage, outputStream);
   }
+
+  private ClientProtocol.Message deserializeMessageFromInputStream(InputStream inputStream)
+      throws InvalidProtocolMessageException, EOFException {
+    ClientProtocol.Message message = protobufProtocolSerializer.deserialize(inputStream);
+    if (message == null) {
+      throw new EOFException("Tried to deserialize protobuf message at EOF");
+    }
+    return message;
+  }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthenticator.java b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthenticator.java
index ed2b9ec..2cdbeae 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthenticator.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthenticator.java
@@ -14,31 +14,32 @@
  */
 package org.apache.geode.protocol.protobuf.security.server;
 
-import org.apache.geode.management.internal.security.ResourceConstants;
-import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
-import org.apache.geode.security.AuthenticationRequiredException;
-import org.apache.geode.internal.protocol.security.server.Authenticator;
-import org.apache.geode.security.AuthenticationFailedException;
-import org.apache.geode.security.SecurityManager;
-import org.apache.geode.internal.protocol.security.server.Authorizer;
-
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Properties;
 
+import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
+import org.apache.geode.internal.protocol.security.server.Authenticator;
+import org.apache.geode.management.internal.security.ResourceConstants;
+import org.apache.geode.security.AuthenticationFailedException;
+import org.apache.geode.security.SecurityManager;
+
 public class ProtobufSimpleAuthenticator implements Authenticator {
-  private ProtobufSimpleAuthorizer authorizer = null;
   private boolean authenticationSuccessfull = false;
+  private Object principal;
 
   @Override
-  public void authenticate(InputStream inputStream, OutputStream outputStream,
+  public Object authenticate(InputStream inputStream, OutputStream outputStream,
       SecurityManager securityManager) throws IOException {
-    if (!authenticationSuccessfull) {
+    if (authenticationSuccessfull) {
+      return principal;
+    } else {
       AuthenticationAPI.SimpleAuthenticationRequest authenticationRequest =
           AuthenticationAPI.SimpleAuthenticationRequest.parseDelimitedFrom(inputStream);
       if (authenticationRequest == null) {
+        // TODO Why are we returning and EOF here?
         throw new EOFException();
       }
 
@@ -47,19 +48,19 @@ public class ProtobufSimpleAuthenticator implements Authenticator {
       properties.setProperty(ResourceConstants.PASSWORD, authenticationRequest.getPassword());
 
       try {
-        Object principal = securityManager.authenticate(properties);
-        if (principal != null) {
-          authenticationSuccessfull = true;
-          authorizer = new ProtobufSimpleAuthorizer(principal, securityManager);
-        }
+        principal = securityManager.authenticate(properties);
+        authenticationSuccessfull = true;
+        AuthenticationAPI.SimpleAuthenticationResponse.newBuilder()
+            .setAuthenticated(isAuthenticated()).build().writeDelimitedTo(outputStream);
+        return principal;
       } catch (AuthenticationFailedException e) {
-        authorizer = null;
+        // We need to add some logging here;
+        // logger.error(e);
+        AuthenticationAPI.SimpleAuthenticationResponse.newBuilder().setAuthenticated(false).build()
+            .writeDelimitedTo(outputStream);
+        throw e;
       }
-
-      AuthenticationAPI.SimpleAuthenticationResponse.newBuilder()
-          .setAuthenticated(isAuthenticated()).build().writeDelimitedTo(outputStream);
     }
-
   }
 
   @Override
@@ -68,15 +69,7 @@ public class ProtobufSimpleAuthenticator implements Authenticator {
   }
 
   @Override
-  public Authorizer getAuthorizer() throws AuthenticationRequiredException {
-    if (authorizer == null) {
-      throw new AuthenticationRequiredException("Not yet authenticated");
-    }
-    return authorizer;
-  }
-
-  @Override
-  public String implementationID() {
+  public String getImplementationID() {
     return "SIMPLE";
   }
 }
diff --git a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthorizer.java b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthorizer.java
index a67f9c4..067bb6a 100644
--- a/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthorizer.java
+++ b/geode-protobuf/src/main/java/org/apache/geode/protocol/protobuf/security/server/ProtobufSimpleAuthorizer.java
@@ -14,21 +14,19 @@
  */
 package org.apache.geode.protocol.protobuf.security.server;
 
+import org.apache.geode.internal.protocol.security.server.Authorizer;
 import org.apache.geode.security.ResourcePermission;
 import org.apache.geode.security.SecurityManager;
-import org.apache.geode.internal.protocol.security.server.Authorizer;
 
 public class ProtobufSimpleAuthorizer implements Authorizer {
-  private final Object authenticatedPrincipal;
-  private final SecurityManager securityManager;
-
-  public ProtobufSimpleAuthorizer(Object authenticatedPrincipal, SecurityManager securityManager) {
-    this.authenticatedPrincipal = authenticatedPrincipal;
-    this.securityManager = securityManager;
+  @Override
+  public boolean authorize(Object authenticatedPrincipal, ResourcePermission permissionRequested,
+      SecurityManager securityManager) {
+    return securityManager.authorize(authenticatedPrincipal, permissionRequested);
   }
 
   @Override
-  public boolean authorize(ResourcePermission permissionRequested) {
-    return securityManager.authorize(authenticatedPrincipal, permissionRequested);
+  public String getImplementationID() {
+    return "SIMPLE";
   }
 }
diff --git a/geode-protobuf/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.ClientProtocolMessageHandler b/geode-protobuf/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.ClientProtocolMessageHandler
index 5a17eda..33fe588 100644
--- a/geode-protobuf/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.ClientProtocolMessageHandler
+++ b/geode-protobuf/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.ClientProtocolMessageHandler
@@ -1 +1 @@
-org.apache.geode.protocol.protobuf.ProtobufStreamProcessor
\ No newline at end of file
+org.apache.geode.protocol.protobuf.ProtobufProtocolMessageHandler
\ No newline at end of file
diff --git a/geode-protobuf/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.security.server.Authorizer b/geode-protobuf/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.security.server.Authorizer
new file mode 100644
index 0000000..a2bf30d
--- /dev/null
+++ b/geode-protobuf/src/main/resources/META-INF/services/org.apache.geode.internal.protocol.security.server.Authorizer
@@ -0,0 +1 @@
+org.apache.geode.protocol.protobuf.security.server.ProtobufSimpleAuthorizer
\ No newline at end of file
diff --git a/geode-protobuf/src/test/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnectionTest.java b/geode-protobuf/src/test/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnectionTest.java
index 6020b58..a6a0907 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnectionTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/internal/cache/tier/sockets/GenericProtocolServerConnectionTest.java
@@ -19,13 +19,20 @@ import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
 import org.apache.geode.internal.Assert;
 import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.cache.tier.CachedRegionHelper;
 import org.apache.geode.internal.cache.tier.CommunicationMode;
 import org.apache.geode.internal.protocol.ClientProtocolMessageHandler;
-import org.apache.geode.internal.security.SecurityService;
 import org.apache.geode.internal.protocol.security.server.AuthenticatorLookupService;
+import org.apache.geode.internal.security.SecurityService;
 import org.apache.geode.test.junit.categories.UnitTest;
 
 import org.junit.Test;
@@ -80,6 +87,7 @@ public class GenericProtocolServerConnectionTest {
     return new GenericProtocolServerConnection(socketMock, mock(InternalCache.class),
         mock(CachedRegionHelper.class), mock(CacheServerStats.class), 0, 0, "",
         CommunicationMode.ProtobufClientServerProtocol.getModeNumber(), mock(AcceptorImpl.class),
-        mock(SecurityService.class), clientProtocolMock, new AuthenticatorLookupService());
+        mock(SecurityService.class), clientProtocolMock,
+        new AuthenticatorLookupService().getAuthenticator());
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufStreamProcessorTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufProtocolMessageHandlerTest.java
similarity index 82%
rename from geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufStreamProcessorTest.java
rename to geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufProtocolMessageHandlerTest.java
index 44f5158..6cd56af 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufStreamProcessorTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufProtocolMessageHandlerTest.java
@@ -27,19 +27,19 @@ import org.junit.experimental.categories.Category;
 
 import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.protocol.MessageExecutionContext;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
 import org.apache.geode.test.junit.categories.UnitTest;
 
 @Category(UnitTest.class)
-public class ProtobufStreamProcessorTest {
+public class ProtobufProtocolMessageHandlerTest {
   @Test(expected = EOFException.class)
   public void receiveMessage() throws Exception {
     InputStream inputStream = new ByteArrayInputStream(new byte[0]);
     OutputStream outputStream = new ByteArrayOutputStream(2);
 
-    ProtobufStreamProcessor protobufStreamProcessor = new ProtobufStreamProcessor();
+    ProtobufProtocolMessageHandler protobufProtocolMessageHandler =
+        new ProtobufProtocolMessageHandler();
     InternalCache mockInternalCache = mock(InternalCache.class);
-    protobufStreamProcessor.receiveMessage(inputStream, outputStream,
-        new MessageExecutionContext(mockInternalCache, new NoOpAuthorizer()));
+    protobufProtocolMessageHandler.receiveMessage(inputStream, outputStream,
+        new MessageExecutionContext(mockInternalCache, null, null));
   }
 }
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufSimpleAuthenticatorJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufSimpleAuthenticatorJUnitTest.java
index 2f09f8c..118ea03 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufSimpleAuthenticatorJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/ProtobufSimpleAuthenticatorJUnitTest.java
@@ -15,22 +15,7 @@
 
 package org.apache.geode.protocol.protobuf;
 
-import org.apache.geode.examples.security.ExampleSecurityManager;
-import org.apache.geode.management.internal.security.ResourceConstants;
-import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
-import org.apache.geode.protocol.protobuf.security.server.ProtobufSimpleAuthenticator;
-import org.apache.geode.security.AuthenticationFailedException;
-import org.apache.geode.security.SecurityManager;
-import org.apache.geode.test.junit.categories.UnitTest;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.Properties;
-
+import static org.apache.geode.internal.Assert.fail;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
@@ -38,6 +23,23 @@ import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Properties;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import org.apache.geode.examples.security.ExampleSecurityManager;
+import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
+import org.apache.geode.management.internal.security.ResourceConstants;
+import org.apache.geode.protocol.protobuf.security.server.ProtobufSimpleAuthenticator;
+import org.apache.geode.security.AuthenticationFailedException;
+import org.apache.geode.security.SecurityManager;
+import org.apache.geode.test.junit.categories.UnitTest;
+
 @Category(UnitTest.class)
 public class ProtobufSimpleAuthenticatorJUnitTest {
   private static final String TEST_USERNAME = "user1";
@@ -97,8 +99,12 @@ public class ProtobufSimpleAuthenticatorJUnitTest {
     when(mockSecurityManager.authenticate(expectedAuthProperties))
         .thenThrow(new AuthenticationFailedException("BOOM!"));
 
-    protobufSimpleAuthenticator.authenticate(byteArrayInputStream, byteArrayOutputStream,
-        mockSecurityManager);
+    try {
+      protobufSimpleAuthenticator.authenticate(byteArrayInputStream, byteArrayOutputStream,
+          mockSecurityManager);
+      fail("This should throw an AuthenticationFailedException.");
+    } catch (AuthenticationFailedException e) {
+    }
 
     AuthenticationAPI.SimpleAuthenticationResponse simpleAuthenticationResponse =
         getSimpleAuthenticationResponse(byteArrayOutputStream);
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java
index 9b75a7c..09f9177 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetAllRequestOperationHandlerJUnitTest.java
@@ -33,15 +33,14 @@ import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.CacheLoaderException;
 import org.apache.geode.cache.Region;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.protocol.responses.Result;
-import org.apache.geode.protocol.responses.Success;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufUtilities;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
+import org.apache.geode.protocol.responses.Result;
+import org.apache.geode.protocol.responses.Success;
 import org.apache.geode.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
 import org.apache.geode.serialization.registry.exception.CodecNotRegisteredForTypeException;
@@ -80,9 +79,8 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   public void processReturnsExpectedValuesForValidKeys()
       throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
-    Result<RegionAPI.GetAllResponse> result =
-        operationHandler.process(serializationServiceStub, generateTestRequest(true, false),
-            new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+    Result<RegionAPI.GetAllResponse> result = operationHandler.process(serializationServiceStub,
+        generateTestRequest(true, false), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
 
@@ -101,9 +99,8 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   @Test
   public void processReturnsNoEntriesForNoKeysRequested() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
-    Result<RegionAPI.GetAllResponse> result =
-        operationHandler.process(serializationServiceStub, generateTestRequest(false, false),
-            new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+    Result<RegionAPI.GetAllResponse> result = operationHandler.process(serializationServiceStub,
+        generateTestRequest(false, false), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
 
@@ -120,7 +117,7 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
     RegionAPI.GetAllRequest getAllRequest =
         ProtobufRequestUtilities.createGetAllRequest(TEST_REGION, testKeys);
     Result<RegionAPI.GetAllResponse> result = operationHandler.process(serializationServiceStub,
-        getAllRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        getAllRequest, new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
     RegionAPI.GetAllResponse message = result.getMessage();
@@ -134,9 +131,8 @@ public class GetAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   @Test
   public void multipleKeysWhereOneThrows() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
-    Result<RegionAPI.GetAllResponse> result =
-        operationHandler.process(serializationServiceStub, generateTestRequest(true, true),
-            new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+    Result<RegionAPI.GetAllResponse> result = operationHandler.process(serializationServiceStub,
+        generateTestRequest(true, true), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
 
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java
index dfb5798..97c7bf0 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionNamesRequestOperationHandlerJUnitTest.java
@@ -27,16 +27,12 @@ import org.junit.experimental.categories.Category;
 
 import org.apache.geode.cache.Cache;
 import org.apache.geode.cache.Region;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
+import org.apache.geode.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.protocol.responses.Result;
 import org.apache.geode.protocol.responses.Success;
-import org.apache.geode.protocol.protobuf.utilities.ProtobufRequestUtilities;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
-import org.apache.geode.serialization.exception.UnsupportedEncodingTypeException;
-import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
-import org.apache.geode.serialization.registry.exception.CodecNotRegisteredForTypeException;
 import org.apache.geode.test.dunit.Assert;
 import org.apache.geode.test.junit.categories.UnitTest;
 
@@ -63,12 +59,10 @@ public class GetRegionNamesRequestOperationHandlerJUnitTest extends OperationHan
   }
 
   @Test
-  public void processReturnsCacheRegions()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+  public void processReturnsCacheRegions() throws InvalidExecutionContextException {
     Result<RegionAPI.GetRegionNamesResponse> result = operationHandler.process(
         serializationServiceStub, ProtobufRequestUtilities.createGetRegionNamesRequest(),
-        new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        new MessageExecutionContext(cacheStub, null, null));
     Assert.assertTrue(result instanceof Success);
 
     RegionAPI.GetRegionNamesResponse getRegionsResponse = result.getMessage();
@@ -86,15 +80,13 @@ public class GetRegionNamesRequestOperationHandlerJUnitTest extends OperationHan
   }
 
   @Test
-  public void processReturnsNoCacheRegions()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+  public void processReturnsNoCacheRegions() throws InvalidExecutionContextException {
     Cache emptyCache = mock(Cache.class);;
     when(emptyCache.rootRegions())
         .thenReturn(Collections.unmodifiableSet(new HashSet<Region<String, String>>()));
     Result<RegionAPI.GetRegionNamesResponse> result = operationHandler.process(
         serializationServiceStub, ProtobufRequestUtilities.createGetRegionNamesRequest(),
-        new MessageExecutionContext(emptyCache, new NoOpAuthorizer()));
+        new MessageExecutionContext(emptyCache, null, null));
     Assert.assertTrue(result instanceof Success);
 
     RegionAPI.GetRegionNamesResponse getRegionsResponse = result.getMessage();
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java
index ae6fdec..67aa1b5 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRegionRequestOperationHandlerJUnitTest.java
@@ -14,35 +14,31 @@
  */
 package org.apache.geode.protocol.protobuf.operations;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.Collections;
+import java.util.HashSet;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
 import org.apache.geode.cache.Cache;
 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.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
-import org.apache.geode.protocol.MessageUtil;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.protocol.responses.Failure;
-import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
+import org.apache.geode.protocol.MessageUtil;
+import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
+import org.apache.geode.protocol.responses.Failure;
 import org.apache.geode.protocol.responses.Result;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
-import org.apache.geode.serialization.exception.UnsupportedEncodingTypeException;
-import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
-import org.apache.geode.serialization.registry.exception.CodecNotRegisteredForTypeException;
 import org.apache.geode.test.dunit.Assert;
 import org.apache.geode.test.junit.categories.UnitTest;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.util.Collections;
-import java.util.HashSet;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 @Category(UnitTest.class)
 public class GetRegionRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTest {
@@ -60,9 +56,7 @@ public class GetRegionRequestOperationHandlerJUnitTest extends OperationHandlerJ
   }
 
   @Test
-  public void processReturnsCacheRegions()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+  public void processReturnsCacheRegions() throws InvalidExecutionContextException {
 
     RegionAttributes regionAttributesStub = mock(RegionAttributes.class);
     when(cacheStub.getRegion(TEST_REGION1)).thenReturn(region1Stub);
@@ -77,7 +71,7 @@ public class GetRegionRequestOperationHandlerJUnitTest extends OperationHandlerJ
 
     Result<RegionAPI.GetRegionResponse> result = operationHandler.process(serializationServiceStub,
         MessageUtil.makeGetRegionRequest(TEST_REGION1),
-        new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        new MessageExecutionContext(cacheStub, null, null));
     RegionAPI.GetRegionResponse response = result.getMessage();
     BasicTypes.Region region = response.getRegion();
     Assert.assertEquals(TEST_REGION1, region.getName());
@@ -89,21 +83,15 @@ public class GetRegionRequestOperationHandlerJUnitTest extends OperationHandlerJ
     Assert.assertEquals(10, region.getSize());
   }
 
-  private ClientProtocol.Request createRequestMessage(RegionAPI.GetRegionRequest getRegionRequest) {
-    return ClientProtocol.Request.newBuilder().setGetRegionRequest(getRegionRequest).build();
-  }
-
   @Test
-  public void processReturnsNoCacheRegions()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+  public void processReturnsNoCacheRegions() throws InvalidExecutionContextException {
     Cache emptyCache = mock(Cache.class);
     when(emptyCache.rootRegions())
         .thenReturn(Collections.unmodifiableSet(new HashSet<Region<String, String>>()));
     String unknownRegionName = "UNKNOWN_REGION";
     Result<RegionAPI.GetRegionResponse> result = operationHandler.process(serializationServiceStub,
         MessageUtil.makeGetRegionRequest(unknownRegionName),
-        new MessageExecutionContext(emptyCache, new NoOpAuthorizer()));
+        new MessageExecutionContext(emptyCache, null, null));
     Assert.assertTrue(result instanceof Failure);
     Assert.assertEquals(ProtocolErrorCode.REGION_NOT_FOUND.codeValue,
         result.getErrorMessage().getError().getErrorCode());
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java
index e45c9b7..1769a14 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/GetRequestOperationHandlerJUnitTest.java
@@ -14,33 +14,32 @@
  */
 package org.apache.geode.protocol.protobuf.operations;
 
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.UnsupportedEncodingException;
+
 import com.google.protobuf.ByteString;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
 import org.apache.geode.cache.Region;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.protocol.responses.Failure;
-import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.protocol.responses.Result;
-import org.apache.geode.protocol.responses.Success;
+import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufUtilities;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
+import org.apache.geode.protocol.responses.Failure;
+import org.apache.geode.protocol.responses.Result;
+import org.apache.geode.protocol.responses.Success;
 import org.apache.geode.serialization.exception.UnsupportedEncodingTypeException;
-import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
 import org.apache.geode.serialization.registry.exception.CodecNotRegisteredForTypeException;
 import org.apache.geode.test.dunit.Assert;
 import org.apache.geode.test.junit.categories.UnitTest;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.io.UnsupportedEncodingException;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 @Category(UnitTest.class)
 public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTest {
@@ -68,12 +67,11 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   }
 
   @Test
-  public void processReturnsTheEncodedValueFromTheRegion()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
+  public void processReturnsTheEncodedValueFromTheRegion() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
     RegionAPI.GetRequest getRequest = generateTestRequest(false, false, false);
     Result<RegionAPI.GetResponse> result = operationHandler.process(serializationServiceStub,
-        getRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        getRequest, new MessageExecutionContext(cacheStub, null, null));
 
     Assert.assertTrue(result instanceof Success);
     Assert.assertEquals(BasicTypes.EncodedValue.ValueCase.STRINGRESULT,
@@ -84,11 +82,11 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
 
   @Test
   public void processReturnsUnsucessfulResponseForInvalidRegion()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
+      InvalidExecutionContextException {
     RegionAPI.GetRequest getRequest = generateTestRequest(true, false, false);
     Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
-        getRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        getRequest, new MessageExecutionContext(cacheStub, null, null));
 
     Assert.assertTrue(response instanceof Failure);
     Assert.assertEquals(ProtocolErrorCode.REGION_NOT_FOUND.codeValue,
@@ -96,32 +94,30 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   }
 
   @Test
-  public void processReturnsKeyNotFoundWhenKeyIsNotFound()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
+  public void processReturnsKeyNotFoundWhenKeyIsNotFound() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
     RegionAPI.GetRequest getRequest = generateTestRequest(false, true, false);
     Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
-        getRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        getRequest, new MessageExecutionContext(cacheStub, null, null));
 
     Assert.assertTrue(response instanceof Success);
   }
 
   @Test
   public void processReturnsLookupFailureWhenKeyFoundWithNoValue()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
+      InvalidExecutionContextException {
     RegionAPI.GetRequest getRequest = generateTestRequest(false, false, true);
     Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
-        getRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        getRequest, new MessageExecutionContext(cacheStub, null, null));
 
     Assert.assertTrue(response instanceof Success);
   }
 
   @Test
   public void processReturnsErrorWhenUnableToDecodeRequest()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, UnsupportedEncodingException,
-      InvalidExecutionContextException {
+      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
+      UnsupportedEncodingException, InvalidExecutionContextException {
     CodecNotRegisteredForTypeException exception =
         new CodecNotRegisteredForTypeException("error finding codec for type");
     when(serializationServiceStub.decode(any(), any())).thenThrow(exception);
@@ -134,7 +130,7 @@ public class GetRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
     RegionAPI.GetRequest getRequest =
         ProtobufRequestUtilities.createGetRequest(TEST_REGION, encodedKey).getGetRequest();
     Result<RegionAPI.GetResponse> response = operationHandler.process(serializationServiceStub,
-        getRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        getRequest, new MessageExecutionContext(cacheStub, null, null));
 
     Assert.assertTrue(response instanceof Failure);
     Assert.assertEquals(ProtocolErrorCode.VALUE_ENCODING_ERROR.codeValue,
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java
index b0acb22..18c2ec4 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutAllRequestOperationHandlerJUnitTest.java
@@ -14,35 +14,35 @@
  */
 package org.apache.geode.protocol.protobuf.operations;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
 import org.apache.geode.cache.Region;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.protocol.responses.Result;
-import org.apache.geode.protocol.responses.Success;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufUtilities;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
+import org.apache.geode.protocol.responses.Result;
+import org.apache.geode.protocol.responses.Success;
 import org.apache.geode.serialization.exception.UnsupportedEncodingTypeException;
 import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
 import org.apache.geode.serialization.registry.exception.CodecNotRegisteredForTypeException;
 import org.apache.geode.test.dunit.Assert;
 import org.apache.geode.test.junit.categories.UnitTest;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
 @Category(UnitTest.class)
 public class PutAllRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTest {
@@ -74,9 +74,8 @@ public class PutAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
       CodecAlreadyRegisteredForTypeException, InvalidExecutionContextException {
     PutAllRequestOperationHandler operationHandler = new PutAllRequestOperationHandler();
 
-    Result<RegionAPI.PutAllResponse> result =
-        operationHandler.process(serializationServiceStub, generateTestRequest(false, true),
-            new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+    Result<RegionAPI.PutAllResponse> result = operationHandler.process(serializationServiceStub,
+        generateTestRequest(false, true), new MessageExecutionContext(cacheStub, null, null));
 
     Assert.assertTrue(result instanceof Success);
 
@@ -89,9 +88,8 @@ public class PutAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   public void processWithInvalidEntrySucceedsAndReturnsFailedKey() throws Exception {
     PutAllRequestOperationHandler operationHandler = new PutAllRequestOperationHandler();
 
-    Result<RegionAPI.PutAllResponse> result =
-        operationHandler.process(serializationServiceStub, generateTestRequest(true, true),
-            new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+    Result<RegionAPI.PutAllResponse> result = operationHandler.process(serializationServiceStub,
+        generateTestRequest(true, true), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
     verify(regionMock).put(TEST_KEY1, TEST_VALUE1);
@@ -109,9 +107,8 @@ public class PutAllRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   public void processWithNoEntriesPasses() throws Exception {
     PutAllRequestOperationHandler operationHandler = new PutAllRequestOperationHandler();
 
-    Result<RegionAPI.PutAllResponse> result =
-        operationHandler.process(serializationServiceStub, generateTestRequest(false, false),
-            new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+    Result<RegionAPI.PutAllResponse> result = operationHandler.process(serializationServiceStub,
+        generateTestRequest(false, false), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
 
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java
index d4d988c..70b34c3 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/PutRequestOperationHandlerJUnitTest.java
@@ -14,37 +14,36 @@
  */
 package org.apache.geode.protocol.protobuf.operations;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.UnsupportedEncodingException;
+
 import com.google.protobuf.ByteString;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
 import org.apache.geode.cache.Region;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
-import org.apache.geode.protocol.responses.Failure;
-import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.protocol.responses.Result;
-import org.apache.geode.protocol.responses.Success;
+import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufUtilities;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
+import org.apache.geode.protocol.responses.Failure;
+import org.apache.geode.protocol.responses.Result;
+import org.apache.geode.protocol.responses.Success;
 import org.apache.geode.serialization.exception.UnsupportedEncodingTypeException;
-import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
 import org.apache.geode.serialization.registry.exception.CodecNotRegisteredForTypeException;
 import org.apache.geode.test.junit.categories.UnitTest;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.io.UnsupportedEncodingException;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.anyString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
 @Category(UnitTest.class)
 public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTest {
@@ -64,12 +63,11 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   }
 
   @Test
-  public void test_puttingTheEncodedEntryIntoRegion()
-      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
-      CodecAlreadyRegisteredForTypeException, InvalidExecutionContextException {
+  public void test_puttingTheEncodedEntryIntoRegion() throws UnsupportedEncodingTypeException,
+      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
     PutRequestOperationHandler operationHandler = new PutRequestOperationHandler();
     Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
-        generateTestRequest(), new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        generateTestRequest(), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
 
@@ -78,8 +76,8 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   }
 
   @Test
-  public void test_invalidEncodingType() throws CodecAlreadyRegisteredForTypeException,
-      UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
+  public void test_invalidEncodingType()
+      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
       UnsupportedEncodingException, InvalidExecutionContextException {
     String exceptionText = "unsupported type!";
     UnsupportedEncodingTypeException exception =
@@ -100,7 +98,7 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
     RegionAPI.PutRequest putRequest =
         ProtobufRequestUtilities.createPutRequest(TEST_REGION, testEntry).getPutRequest();
     Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
-        putRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        putRequest, new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Failure);
     assertEquals(ProtocolErrorCode.VALUE_ENCODING_ERROR.codeValue,
@@ -108,13 +106,12 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   }
 
   @Test
-  public void test_RegionNotFound()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
+  public void test_RegionNotFound() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
     when(cacheStub.getRegion(TEST_REGION)).thenReturn(null);
     PutRequestOperationHandler operationHandler = new PutRequestOperationHandler();
     Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
-        generateTestRequest(), new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        generateTestRequest(), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Failure);
     assertEquals(ProtocolErrorCode.REGION_NOT_FOUND.codeValue,
@@ -122,14 +119,13 @@ public class PutRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTe
   }
 
   @Test
-  public void test_RegionThrowsClasscastException()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
+  public void test_RegionThrowsClasscastException() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
     when(regionMock.put(any(), any())).thenThrow(ClassCastException.class);
 
     PutRequestOperationHandler operationHandler = new PutRequestOperationHandler();
     Result<RegionAPI.PutResponse> result = operationHandler.process(serializationServiceStub,
-        generateTestRequest(), new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        generateTestRequest(), new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Failure);
     assertEquals(ProtocolErrorCode.CONSTRAINT_VIOLATION.codeValue,
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java
index 9c89e74..db77184 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/protobuf/operations/RemoveRequestOperationHandlerJUnitTest.java
@@ -14,36 +14,35 @@
  */
 package org.apache.geode.protocol.protobuf.operations;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.UnsupportedEncodingException;
+
 import com.google.protobuf.ByteString;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
 import org.apache.geode.cache.Region;
-import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.exception.InvalidExecutionContextException;
+import org.apache.geode.internal.protocol.MessageExecutionContext;
 import org.apache.geode.internal.protocol.protobuf.BasicTypes;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
-import org.apache.geode.protocol.responses.Failure;
-import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
-import org.apache.geode.protocol.responses.Result;
-import org.apache.geode.protocol.responses.Success;
+import org.apache.geode.protocol.protobuf.ProtocolErrorCode;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufRequestUtilities;
 import org.apache.geode.protocol.protobuf.utilities.ProtobufUtilities;
-import org.apache.geode.internal.protocol.security.server.NoOpAuthorizer;
+import org.apache.geode.protocol.responses.Failure;
+import org.apache.geode.protocol.responses.Result;
+import org.apache.geode.protocol.responses.Success;
 import org.apache.geode.serialization.exception.UnsupportedEncodingTypeException;
-import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
 import org.apache.geode.serialization.registry.exception.CodecNotRegisteredForTypeException;
 import org.apache.geode.test.junit.categories.UnitTest;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.io.UnsupportedEncodingException;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
 @Category(UnitTest.class)
 public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUnitTest {
@@ -70,11 +69,11 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
 
   @Test
   public void processValidKeyRemovesTheEntryAndReturnSuccess()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
+      InvalidExecutionContextException {
     RegionAPI.RemoveRequest removeRequest = generateTestRequest(false, false).getRemoveRequest();
     Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
-        removeRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        removeRequest, new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
     verify(regionStub).remove(TEST_KEY);
@@ -82,11 +81,11 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
 
   @Test
   public void processReturnsUnsucessfulResponseForInvalidRegion()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, InvalidExecutionContextException {
+      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
+      InvalidExecutionContextException {
     RegionAPI.RemoveRequest removeRequest = generateTestRequest(true, false).getRemoveRequest();
     Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
-        removeRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        removeRequest, new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Failure);
     assertEquals(ProtocolErrorCode.REGION_NOT_FOUND.codeValue,
@@ -94,21 +93,19 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
   }
 
   @Test
-  public void processReturnsSuccessWhenKeyIsNotFound()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
+  public void processReturnsSuccessWhenKeyIsNotFound() throws UnsupportedEncodingTypeException,
       CodecNotRegisteredForTypeException, InvalidExecutionContextException {
     RegionAPI.RemoveRequest removeRequest = generateTestRequest(false, true).getRemoveRequest();
     Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
-        removeRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        removeRequest, new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Success);
   }
 
   @Test
   public void processReturnsErrorWhenUnableToDecodeRequest()
-      throws CodecAlreadyRegisteredForTypeException, UnsupportedEncodingTypeException,
-      CodecNotRegisteredForTypeException, UnsupportedEncodingException,
-      InvalidExecutionContextException {
+      throws UnsupportedEncodingTypeException, CodecNotRegisteredForTypeException,
+      UnsupportedEncodingException, InvalidExecutionContextException {
     CodecNotRegisteredForTypeException exception =
         new CodecNotRegisteredForTypeException("error finding codec for type");
     when(serializationServiceStub.decode(any(), any())).thenThrow(exception);
@@ -122,7 +119,7 @@ public class RemoveRequestOperationHandlerJUnitTest extends OperationHandlerJUni
     RegionAPI.RemoveRequest removeRequest =
         ProtobufRequestUtilities.createRemoveRequest(TEST_REGION, encodedKey).getRemoveRequest();;
     Result<RegionAPI.RemoveResponse> result = operationHandler.process(serializationServiceStub,
-        removeRequest, new MessageExecutionContext(cacheStub, new NoOpAuthorizer()));
+        removeRequest, new MessageExecutionContext(cacheStub, null, null));
 
     assertTrue(result instanceof Failure);
     assertEquals(ProtocolErrorCode.VALUE_ENCODING_ERROR.codeValue,
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthenticationIntegrationTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthenticationIntegrationTest.java
index 9db8342..6406431 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthenticationIntegrationTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthenticationIntegrationTest.java
@@ -14,39 +14,40 @@
  */
 package org.apache.geode.protocol.security.server;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.util.Properties;
+import java.util.concurrent.TimeUnit;
+
+import org.awaitility.Awaitility;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.contrib.java.lang.system.RestoreSystemProperties;
+import org.junit.experimental.categories.Category;
+
 import org.apache.geode.cache.Cache;
 import org.apache.geode.cache.CacheFactory;
 import org.apache.geode.cache.server.CacheServer;
 import org.apache.geode.distributed.ConfigurationProperties;
 import org.apache.geode.internal.AvailablePortHelper;
-import org.apache.geode.management.internal.security.ResourceConstants;
 import org.apache.geode.internal.protocol.protobuf.AuthenticationAPI;
 import org.apache.geode.internal.protocol.protobuf.ClientProtocol;
 import org.apache.geode.internal.protocol.protobuf.RegionAPI;
+import org.apache.geode.management.internal.security.ResourceConstants;
 import org.apache.geode.protocol.protobuf.serializer.ProtobufProtocolSerializer;
 import org.apache.geode.security.SecurityManager;
 import org.apache.geode.serialization.registry.exception.CodecAlreadyRegisteredForTypeException;
 import org.apache.geode.test.junit.categories.IntegrationTest;
-import org.awaitility.Awaitility;
-import org.junit.After;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.contrib.java.lang.system.RestoreSystemProperties;
-import org.junit.experimental.categories.Category;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.Socket;
-import java.util.Properties;
-import java.util.concurrent.TimeUnit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 @Category(IntegrationTest.class)
 public class AuthenticationIntegrationTest {
diff --git a/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthorizationIntegrationTest.java b/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthorizationIntegrationTest.java
index c518ca8..af93924 100644
--- a/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthorizationIntegrationTest.java
+++ b/geode-protobuf/src/test/java/org/apache/geode/protocol/security/server/AuthorizationIntegrationTest.java
@@ -73,7 +73,6 @@ public class AuthorizationIntegrationTest {
   private ProtobufProtocolSerializer protobufProtocolSerializer;
   private Object securityPrincipal;
   private SecurityManager mockSecurityManager;
-  private String testRegion;
   public static final ResourcePermission READ_PERMISSION =
       new ResourcePermission(ResourcePermission.Resource.DATA, ResourcePermission.Operation.READ);
   public static final ResourcePermission WRITE_PERMISSION =
@@ -81,6 +80,10 @@ public class AuthorizationIntegrationTest {
 
   @Before
   public void setUp() throws IOException, CodecAlreadyRegisteredForTypeException {
+
+    System.setProperty("geode.feature-protobuf-protocol", "true");
+    System.setProperty("geode.protocol-authentication-mode", "SIMPLE");
+
     Properties expectedAuthProperties = new Properties();
     expectedAuthProperties.setProperty(ResourceConstants.USER_NAME, TEST_USERNAME);
     expectedAuthProperties.setProperty(ResourceConstants.PASSWORD, TEST_PASSWORD);
@@ -103,8 +106,6 @@ public class AuthorizationIntegrationTest {
 
     cache.createRegionFactory().create(TEST_REGION);
 
-    System.setProperty("geode.feature-protobuf-protocol", "true");
-    System.setProperty("geode.protocol-authentication-mode", "SIMPLE");
     socket = new Socket("localhost", cacheServerPort);
 
     Awaitility.await().atMost(5, TimeUnit.SECONDS).until(socket::isConnected);

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

Mime
View raw message