You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ud...@apache.org on 2017/09/14 19:10:28 UTC
[geode] 08/08: More changes relating to Authorization
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 <uk...@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" <co...@geode.apache.org>.