diff --git a/server/core/pom.xml b/server/core/pom.xml index c78d349f0d51..b925be0556d0 100644 --- a/server/core/pom.xml +++ b/server/core/pom.xml @@ -41,27 +41,7 @@ - src/main/scala - src/test/scala - - - org.scala-tools - maven-scala-plugin - - - compile - compile - - - test-compile - test-compile - - - process-resources - - - org.apache.felix maven-bundle-plugin @@ -75,4 +55,4 @@ - \ No newline at end of file + diff --git a/server/core/src/main/java/org/infinispan/server/core/AbstractCacheIgnoreAware.java b/server/core/src/main/java/org/infinispan/server/core/AbstractCacheIgnoreAware.java new file mode 100644 index 000000000000..d198101af119 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/AbstractCacheIgnoreAware.java @@ -0,0 +1,35 @@ +package org.infinispan.server.core; + +import org.infinispan.commons.util.concurrent.ConcurrentHashSet; + +import java.util.Set; + +/** + * Abstract class providing stock implementations for {@link CacheIgnoreAware} so all that is required is to extend + * this class. + * @author gustavonalle + * @author wburns + * @since 9.0 + */ +public class AbstractCacheIgnoreAware implements CacheIgnoreAware { + + private Set ignoredCaches = new ConcurrentHashSet<>(); + + public void setIgnoredCaches(Set cacheNames) { + ignoredCaches.clear(); + cacheNames.forEach(ignoredCaches::add); + } + + public void unignore(String cacheName) { + ignoredCaches.remove(cacheName); + } + + public void ignoreCache(String cacheName) { + ignoredCaches.add(cacheName); + } + + public boolean isCacheIgnored(String cacheName) { + return ignoredCaches.contains(cacheName); + } + +} diff --git a/server/core/src/main/java/org/infinispan/server/core/AbstractProtocolServer.java b/server/core/src/main/java/org/infinispan/server/core/AbstractProtocolServer.java new file mode 100644 index 000000000000..216489ddc39d --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/AbstractProtocolServer.java @@ -0,0 +1,150 @@ +package org.infinispan.server.core; + +import java.net.InetSocketAddress; +import javax.management.DynamicMBean; +import javax.management.MBeanServer; +import javax.management.ObjectName; + +import org.infinispan.commons.CacheException; +import org.infinispan.commons.logging.LogFactory; +import org.infinispan.configuration.global.GlobalConfiguration; +import org.infinispan.factories.components.ManageableComponentMetadata; +import org.infinispan.jmx.JmxUtil; +import org.infinispan.jmx.ResourceDMBean; +import org.infinispan.manager.EmbeddedCacheManager; +import org.infinispan.server.core.configuration.ProtocolServerConfiguration; +import org.infinispan.server.core.logging.Log; +import org.infinispan.server.core.transport.NettyTransport; + +/** + * A common protocol server dealing with common property parameter validation and assignment and transport lifecycle. + * + * @author Galder Zamarreño + * @author wburns + * @since 4.1 + */ +public abstract class AbstractProtocolServer extends AbstractCacheIgnoreAware + implements ProtocolServer { + + private final Log log = LogFactory.getLog(getClass(), Log.class); + + private final String protocolName; + + protected NettyTransport transport; + protected EmbeddedCacheManager cacheManager; + protected A configuration; + private ObjectName transportObjName; + private MBeanServer mbeanServer; + + protected AbstractProtocolServer(String protocolName) { + this.protocolName = protocolName; + } + + protected void startInternal(A configuration, EmbeddedCacheManager cacheManager) { + this.configuration = configuration; + this.cacheManager = cacheManager; + + if (log.isDebugEnabled()) { + log.debugf("Starting server with configuration: %s", configuration); + } + + // Start default cache + startDefaultCache(); + + startTransport(); + } + + @Override + public final void start(A configuration, EmbeddedCacheManager cacheManager) { + try { + configuration.ignoredCaches().forEach(this::ignoreCache); + startInternal(configuration, cacheManager); + } catch (RuntimeException t) { + stop(); + throw t; + } + } + + protected void startTransport() { + InetSocketAddress address = new InetSocketAddress(configuration.host(), configuration.port()); + transport = new NettyTransport(address, configuration, getQualifiedName(), cacheManager); + transport.initializeHandler(getInitializer()); + + // Register transport MBean regardless + registerTransportMBean(); + + transport.start(); + } + + protected void registerTransportMBean() { + GlobalConfiguration globalCfg = cacheManager.getCacheManagerConfiguration(); + mbeanServer = JmxUtil.lookupMBeanServer(globalCfg); + String groupName = String.format("type=Server,name=%s", getQualifiedName()); + String jmxDomain = JmxUtil.buildJmxDomain(globalCfg, mbeanServer, groupName); + + // Pick up metadata from the component metadata repository + ManageableComponentMetadata meta = LifecycleCallbacks.componentMetadataRepo + .findComponentMetadata(transport.getClass()).toManageableComponentMetadata(); + try { + // And use this metadata when registering the transport as a dynamic MBean + DynamicMBean dynamicMBean = new ResourceDMBean(transport, meta); + + transportObjName = new ObjectName(String.format("%s:%s,component=%s", jmxDomain, groupName, + meta.getJmxObjectName())); + JmxUtil.registerMBean(dynamicMBean, transportObjName, mbeanServer); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + protected void unregisterTransportMBean() throws Exception { + if (mbeanServer != null && transportObjName != null) { + // Unregister mbean(s) + JmxUtil.unregisterMBean(transportObjName, mbeanServer); + } + } + + protected String getQualifiedName() { + return protocolName + (configuration.name().length() > 0 ? "-" : "") + configuration.name(); + } + + @Override + public void stop() { + boolean isDebug = log.isDebugEnabled(); + if (isDebug && configuration != null) + log.debugf("Stopping server listening in %s:%d", configuration.host(), configuration.port()); + + if (transport != null) + transport.stop(); + + try { + unregisterTransportMBean(); + } catch (Exception e) { + throw new CacheException(e); + } + + if (isDebug) + log.debug("Server stopped"); + } + + public EmbeddedCacheManager getCacheManager() { + return cacheManager; + } + + public String getHost() { + return configuration.host(); + } + + public int getPort() { + return configuration.port(); + } + + @Override + public A getConfiguration() { + return configuration; + } + + protected void startDefaultCache() { + cacheManager.getCache(configuration.defaultCacheName()); + } +} diff --git a/server/core/src/main/java/org/infinispan/server/core/CacheIgnoreAware.java b/server/core/src/main/java/org/infinispan/server/core/CacheIgnoreAware.java new file mode 100644 index 000000000000..97770cb4d794 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/CacheIgnoreAware.java @@ -0,0 +1,38 @@ +package org.infinispan.server.core; + +import java.util.Set; + +/** + * Defines an interface to be used when a cache is to be ignored by a server implementation. Any implementation should + * be thread safe and allow for concurrent methods to be invoked. + * @author gustavonalle + * @author wburns + * @since 9.0 + */ +public interface CacheIgnoreAware { + + /** + * Replaces all ignored caches with the set provided + * @param cacheNames the set of caches to now ignore + */ + void setIgnoredCaches(Set cacheNames); + + /** + * No longer ignore the given cache if it was before + * @param cacheName the cache to now not ignore + */ + void unignore(String cacheName); + + /** + * Ignores a given cache if it wasn't before + * @param cacheName the cache to ignore + */ + void ignoreCache(String cacheName); + + /** + * Queries whether the cache is ignored + * @param cacheName the cache to see if it is ignored + * @return whether or not the cache is ignored + */ + boolean isCacheIgnored(String cacheName); +} diff --git a/server/core/src/main/java/org/infinispan/server/core/ExternalizerIds.java b/server/core/src/main/java/org/infinispan/server/core/ExternalizerIds.java new file mode 100644 index 000000000000..bb8dd2608412 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/ExternalizerIds.java @@ -0,0 +1,29 @@ +package org.infinispan.server.core; + +/** + * Externalizer ids used by Server module {@link org.infinispan.commons.marshall.AdvancedExternalizer} implementations. + * TODO: update URL below + * Information about the valid id range can be found here + * + * @author Galder Zamarreño + * @author wburns + * @since 9.0 + */ +public final class ExternalizerIds { + private ExternalizerIds() { } + + public static final int SERVER_ENTRY_VERSION = 1100; + public static final int MEMCACHED_METADATA = 1101; + public static final int TOPOLOGY_ADDRESS = 1102; + public static final int TOPOLOGY_VIEW = 1103; + public static final int SERVER_ADDRESS = 1104; + public static final int MIME_METADATA = 1105; + public static final int BINARY_FILTER = 1106; + public static final int BINARY_CONVERTER = 1107; + public static final int KEY_VALUE_VERSION_CONVERTER = 1108; + public static final int BINARY_FILTER_CONVERTER = 1109; + public static final int KEY_VALUE_WITH_PREVIOUS_CONVERTER = 1110; + public static final int ITERATION_FILTER = 1111; + public static final int QUERY_ITERATION_FILTER = 1112; + +} \ No newline at end of file diff --git a/server/core/src/main/java/org/infinispan/server/core/LifecycleCallbacks.java b/server/core/src/main/java/org/infinispan/server/core/LifecycleCallbacks.java new file mode 100644 index 000000000000..968bbfbb1e0b --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/LifecycleCallbacks.java @@ -0,0 +1,30 @@ +package org.infinispan.server.core; + +import org.infinispan.configuration.cache.Configuration; +import org.infinispan.configuration.global.GlobalConfiguration; +import org.infinispan.factories.components.ComponentMetadataRepo; +import org.infinispan.factories.ComponentRegistry; +import org.infinispan.factories.GlobalComponentRegistry; +import org.infinispan.lifecycle.AbstractModuleLifecycle; + +/** + * Module lifecycle callbacks implementation that enables module specific + * {@link org.infinispan.commons.marshall.AdvancedExternalizer} implementations to be registered. + * + * @author Galder Zamarreño + * @since 5.0 + */ +public class LifecycleCallbacks extends AbstractModuleLifecycle { + + static ComponentMetadataRepo componentMetadataRepo; + + @Override + public void cacheManagerStarting(GlobalComponentRegistry gcr, GlobalConfiguration globalConfiguration) { + componentMetadataRepo = gcr.getComponentMetadataRepo(); + } + + @Override + public void cacheStarting(ComponentRegistry cr, Configuration configuration, String cacheName) { + configuration.storeAsBinary().enabled(false); + } +} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/ProtocolServer.scala b/server/core/src/main/java/org/infinispan/server/core/ProtocolServer.java similarity index 58% rename from server/core/src/main/scala/org/infinispan/server/core/ProtocolServer.scala rename to server/core/src/main/java/org/infinispan/server/core/ProtocolServer.java index 5f2456c4e275..9fac1bea7c2f 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/ProtocolServer.scala +++ b/server/core/src/main/java/org/infinispan/server/core/ProtocolServer.java @@ -1,48 +1,50 @@ -package org.infinispan.server.core +package org.infinispan.server.core; -import org.infinispan.manager.EmbeddedCacheManager -import org.infinispan.server.core.configuration.ProtocolServerConfiguration -import io.netty.channel.{Channel, ChannelInitializer, ChannelInboundHandler, ChannelOutboundHandler} +import io.netty.channel.Channel; +import io.netty.channel.ChannelInboundHandler; +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelOutboundHandler; +import org.infinispan.manager.EmbeddedCacheManager; +import org.infinispan.server.core.configuration.ProtocolServerConfiguration; /** * Represents a protocol compliant server. * * @author Galder Zamarreño - * @since 4.1 + * @author wburns + * @since 9.0 */ -trait ProtocolServer extends CacheIgnoreAware { - type SuitableConfiguration <: ProtocolServerConfiguration - +public interface ProtocolServer extends CacheIgnoreAware { /** * Starts the server backed by the given cache manager and with the corresponding configuration. */ - def start(configuration: SuitableConfiguration, cacheManager: EmbeddedCacheManager) + void start(C configuration, EmbeddedCacheManager cacheManager); /** * Stops the server */ - def stop + void stop(); /** * Gets the encoder for this protocol server. The encoder is responsible for writing back common header responses * back to client. This method can return null if the server has no encoder. You can find an example of the server * that has no encoder in the Memcached server. */ - def getEncoder: ChannelOutboundHandler + ChannelOutboundHandler getEncoder(); /** * Gets the decoder for this protocol server. The decoder is responsible for reading client requests. * This method cannot return null. */ - def getDecoder: ChannelInboundHandler + ChannelInboundHandler getDecoder(); /** * Returns the configuration used to start this server */ - def getConfiguration: SuitableConfiguration + C getConfiguration(); /** * Returns a pipeline factory */ - def getInitializer: ChannelInitializer[Channel] + ChannelInitializer getInitializer(); } diff --git a/server/core/src/main/java/org/infinispan/server/core/QueryFacade.java b/server/core/src/main/java/org/infinispan/server/core/QueryFacade.java new file mode 100644 index 000000000000..225d2f005007 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/QueryFacade.java @@ -0,0 +1,14 @@ +package org.infinispan.server.core; + +import org.infinispan.AdvancedCache; + +/** + * Query facade + * + * @author Galder Zamarreño + * @author wburns + * @since 9.0 + */ +public interface QueryFacade { + byte[] query(AdvancedCache cache, byte[] query); +} diff --git a/server/core/src/main/java/org/infinispan/server/core/ServerConstants.java b/server/core/src/main/java/org/infinispan/server/core/ServerConstants.java new file mode 100644 index 000000000000..c21bc05cd6e4 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/ServerConstants.java @@ -0,0 +1,14 @@ +package org.infinispan.server.core; + +/** + * Server Constant values + * + * @author Tristan Tarrant + * @author wburns + * @since 9.0 + */ +public final class ServerConstants { + private ServerConstants() { } + public static final int EXPIRATION_NONE = -1; + public static final int EXPIRATION_DEFAULT = -2; +} diff --git a/server/core/src/main/java/org/infinispan/server/core/ServerCoreMetadataFileFinder.java b/server/core/src/main/java/org/infinispan/server/core/ServerCoreMetadataFileFinder.java new file mode 100644 index 000000000000..74ea762cc4cd --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/ServerCoreMetadataFileFinder.java @@ -0,0 +1,9 @@ +package org.infinispan.server.core; + +import org.infinispan.factories.components.ModuleMetadataFileFinder; + +public class ServerCoreMetadataFileFinder implements ModuleMetadataFileFinder { + public String getMetadataFilename() { + return "infinispan-server-core-component-metadata.dat"; + } +} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/ProtocolServerConfiguration.java b/server/core/src/main/java/org/infinispan/server/core/configuration/ProtocolServerConfiguration.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/ProtocolServerConfiguration.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/ProtocolServerConfiguration.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/ProtocolServerConfigurationBuilder.java b/server/core/src/main/java/org/infinispan/server/core/configuration/ProtocolServerConfigurationBuilder.java similarity index 95% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/ProtocolServerConfigurationBuilder.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/ProtocolServerConfigurationBuilder.java index 4d247dd030ed..314beafa94ba 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/configuration/ProtocolServerConfigurationBuilder.java +++ b/server/core/src/main/java/org/infinispan/server/core/configuration/ProtocolServerConfigurationBuilder.java @@ -2,7 +2,7 @@ import org.infinispan.commons.api.BasicCacheContainer; import org.infinispan.commons.configuration.Builder; -import org.infinispan.server.core.logging.JavaLog; +import org.infinispan.server.core.logging.Log; import org.infinispan.util.logging.LogFactory; import java.util.Collections; @@ -10,7 +10,7 @@ public abstract class ProtocolServerConfigurationBuilder> implements ProtocolServerConfigurationChildBuilder, Builder { - private static final JavaLog log = LogFactory.getLog(ProtocolServerConfigurationBuilder.class, JavaLog.class); + private static final Log log = LogFactory.getLog(ProtocolServerConfigurationBuilder.class, Log.class); protected String defaultCacheName = BasicCacheContainer.DEFAULT_CACHE_NAME; protected String name = ""; protected String host = "127.0.0.1"; diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/ProtocolServerConfigurationChildBuilder.java b/server/core/src/main/java/org/infinispan/server/core/configuration/ProtocolServerConfigurationChildBuilder.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/ProtocolServerConfigurationChildBuilder.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/ProtocolServerConfigurationChildBuilder.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/SslConfiguration.java b/server/core/src/main/java/org/infinispan/server/core/configuration/SslConfiguration.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/SslConfiguration.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/SslConfiguration.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/SslConfigurationBuilder.java b/server/core/src/main/java/org/infinispan/server/core/configuration/SslConfigurationBuilder.java similarity index 98% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/SslConfigurationBuilder.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/SslConfigurationBuilder.java index 8eab969f16ac..0090b6494397 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/configuration/SslConfigurationBuilder.java +++ b/server/core/src/main/java/org/infinispan/server/core/configuration/SslConfigurationBuilder.java @@ -1,7 +1,7 @@ package org.infinispan.server.core.configuration; import org.infinispan.commons.configuration.Builder; -import org.infinispan.server.core.logging.JavaLog; +import org.infinispan.server.core.logging.Log; import org.infinispan.util.logging.LogFactory; import javax.net.ssl.KeyManager; @@ -21,7 +21,7 @@ * @since 5.3 */ public class SslConfigurationBuilder> implements Builder, ProtocolServerConfigurationChildBuilder { - private static final JavaLog log = LogFactory.getLog(SslConfigurationBuilder.class, JavaLog.class); + private static final Log log = LogFactory.getLog(SslConfigurationBuilder.class, Log.class); private final ProtocolServerConfigurationChildBuilder parentConfigurationBuilder; private boolean enabled = false; private boolean requireClientAuth = false; diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/SslConfigurationChildBuilder.java b/server/core/src/main/java/org/infinispan/server/core/configuration/SslConfigurationChildBuilder.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/SslConfigurationChildBuilder.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/SslConfigurationChildBuilder.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/SslEngineConfiguration.java b/server/core/src/main/java/org/infinispan/server/core/configuration/SslEngineConfiguration.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/SslEngineConfiguration.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/SslEngineConfiguration.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/SslEngineConfigurationBuilder.java b/server/core/src/main/java/org/infinispan/server/core/configuration/SslEngineConfigurationBuilder.java similarity index 96% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/SslEngineConfigurationBuilder.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/SslEngineConfigurationBuilder.java index 868f155a3c06..39625a551c33 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/configuration/SslEngineConfigurationBuilder.java +++ b/server/core/src/main/java/org/infinispan/server/core/configuration/SslEngineConfigurationBuilder.java @@ -1,6 +1,6 @@ package org.infinispan.server.core.configuration; -import org.infinispan.server.core.logging.JavaLog; +import org.infinispan.server.core.logging.Log; import org.infinispan.util.logging.LogFactory; import javax.net.ssl.KeyManager; @@ -15,7 +15,7 @@ * @since 5.3 */ public class SslEngineConfigurationBuilder implements SslConfigurationChildBuilder { - private static final JavaLog log = LogFactory.getLog(SslEngineConfigurationBuilder.class, JavaLog.class); + private static final Log log = LogFactory.getLog(SslEngineConfigurationBuilder.class, Log.class); private final SslConfigurationBuilder parentSslConfigurationBuilder; private String keyStoreFileName; private char[] keyStorePassword; diff --git a/server/core/src/main/scala/org/infinispan/server/core/configuration/package-info.java b/server/core/src/main/java/org/infinispan/server/core/configuration/package-info.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/configuration/package-info.java rename to server/core/src/main/java/org/infinispan/server/core/configuration/package-info.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/logging/JavaLog.java b/server/core/src/main/java/org/infinispan/server/core/logging/Log.java similarity index 98% rename from server/core/src/main/scala/org/infinispan/server/core/logging/JavaLog.java rename to server/core/src/main/java/org/infinispan/server/core/logging/Log.java index cc335058f20c..135f711b4758 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/logging/JavaLog.java +++ b/server/core/src/main/java/org/infinispan/server/core/logging/Log.java @@ -20,7 +20,7 @@ * @since 5.0 */ @MessageLogger(projectCode = "ISPN") -public interface JavaLog extends org.infinispan.util.logging.Log { +public interface Log extends org.infinispan.util.logging.Log { @LogMessage(level = INFO) @Message(value = "Start main with args: %s", id = 5001) diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/AuthorizingCallbackHandler.java b/server/core/src/main/java/org/infinispan/server/core/security/AuthorizingCallbackHandler.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/AuthorizingCallbackHandler.java rename to server/core/src/main/java/org/infinispan/server/core/security/AuthorizingCallbackHandler.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/InetAddressPrincipal.java b/server/core/src/main/java/org/infinispan/server/core/security/InetAddressPrincipal.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/InetAddressPrincipal.java rename to server/core/src/main/java/org/infinispan/server/core/security/InetAddressPrincipal.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/SaslUtils.java b/server/core/src/main/java/org/infinispan/server/core/security/SaslUtils.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/SaslUtils.java rename to server/core/src/main/java/org/infinispan/server/core/security/SaslUtils.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/ServerAuthenticationProvider.java b/server/core/src/main/java/org/infinispan/server/core/security/ServerAuthenticationProvider.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/ServerAuthenticationProvider.java rename to server/core/src/main/java/org/infinispan/server/core/security/ServerAuthenticationProvider.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/SubjectUserInfo.java b/server/core/src/main/java/org/infinispan/server/core/security/SubjectUserInfo.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/SubjectUserInfo.java rename to server/core/src/main/java/org/infinispan/server/core/security/SubjectUserInfo.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/UserPrincipal.java b/server/core/src/main/java/org/infinispan/server/core/security/UserPrincipal.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/UserPrincipal.java rename to server/core/src/main/java/org/infinispan/server/core/security/UserPrincipal.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/external/ExternalSaslServer.java b/server/core/src/main/java/org/infinispan/server/core/security/external/ExternalSaslServer.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/external/ExternalSaslServer.java rename to server/core/src/main/java/org/infinispan/server/core/security/external/ExternalSaslServer.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/external/ExternalSaslServerFactory.java b/server/core/src/main/java/org/infinispan/server/core/security/external/ExternalSaslServerFactory.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/external/ExternalSaslServerFactory.java rename to server/core/src/main/java/org/infinispan/server/core/security/external/ExternalSaslServerFactory.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleGroupPrincipal.java b/server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleGroupPrincipal.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleGroupPrincipal.java rename to server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleGroupPrincipal.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleServerAuthenticationProvider.java b/server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleServerAuthenticationProvider.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleServerAuthenticationProvider.java rename to server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleServerAuthenticationProvider.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleSubjectUserInfo.java b/server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleSubjectUserInfo.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleSubjectUserInfo.java rename to server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleSubjectUserInfo.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleUserPrincipal.java b/server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleUserPrincipal.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/security/simple/SimpleUserPrincipal.java rename to server/core/src/main/java/org/infinispan/server/core/security/simple/SimpleUserPrincipal.java diff --git a/server/core/src/main/java/org/infinispan/server/core/transport/ExtendedByteBuf.java b/server/core/src/main/java/org/infinispan/server/core/transport/ExtendedByteBuf.java new file mode 100644 index 000000000000..fa2c0e4d66ed --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/transport/ExtendedByteBuf.java @@ -0,0 +1,85 @@ +package org.infinispan.server.core.transport; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import io.netty.util.CharsetUtil; +import org.infinispan.commons.io.SignedNumeric; + +import java.util.Optional; + +/** + * Static helper class that provides methods to be used with a {@link ByteBuf} that are useful for Infinispan. + */ +public class ExtendedByteBuf { + private ExtendedByteBuf() { } + + public static ByteBuf wrappedBuffer(byte[]... arrays) { + return Unpooled.wrappedBuffer(arrays); + } + + public static ByteBuf buffer(int capacity) { + return Unpooled.buffer(capacity); + } + + public static ByteBuf dynamicBuffer() { + return Unpooled.buffer(); + } + + public static int readUnsignedShort(ByteBuf bf) { + return bf.readUnsignedShort(); + } + + public static int readUnsignedInt(ByteBuf bf) { + return VInt.read(bf); + } + + public static long readUnsignedLong(ByteBuf bf) { + return VLong.read(bf); + } + + public static byte[] readRangedBytes(ByteBuf bf) { + int length = readUnsignedInt(bf); + return readRangedBytes(bf, length); + } + + public static byte[] readRangedBytes(ByteBuf bf, int length) { + if (length > 0) { + byte[] array = new byte[length]; + bf.readBytes(array); + return array; + } else { + return new byte[0]; + } + } + + /** + * Reads length of String and then returns an UTF-8 formatted String of such length. + * If the length is 0, an empty String is returned. + */ + public static String readString(ByteBuf bf) { + byte[] bytes = readRangedBytes(bf); + return bytes.length > 0 ? new String(bytes, CharsetUtil.UTF_8) : ""; + } + + public static void writeUnsignedShort(int i, ByteBuf bf) { + bf.writeShort(i); + } + + public static void writeUnsignedInt(int i, ByteBuf bf) { + VInt.write(bf, i); + } + + public static void writeUnsignedLong(long l, ByteBuf bf) { + VLong.write(bf, l); + } + + public static void writeRangedBytes(byte[] src, ByteBuf bf) { + writeUnsignedInt(src.length, bf); + if (src.length > 0) + bf.writeBytes(src); + } + + public static void writeString(String msg, ByteBuf bf) { + writeRangedBytes(msg.getBytes(CharsetUtil.UTF_8), bf); + } +} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/ExtendedByteBufJava.java b/server/core/src/main/java/org/infinispan/server/core/transport/ExtendedByteBufJava.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/transport/ExtendedByteBufJava.java rename to server/core/src/main/java/org/infinispan/server/core/transport/ExtendedByteBufJava.java diff --git a/server/core/src/main/java/org/infinispan/server/core/transport/IdleStateHandlerProvider.java b/server/core/src/main/java/org/infinispan/server/core/transport/IdleStateHandlerProvider.java new file mode 100644 index 000000000000..c344c79a44a2 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/transport/IdleStateHandlerProvider.java @@ -0,0 +1,23 @@ +package org.infinispan.server.core.transport; + +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelInboundHandlerAdapter; +import io.netty.handler.timeout.IdleStateEvent; + +/** + * A Netty channel handler that allows idle channels to be closed. + * + * @author Galder Zamarreño + * @author wburns + * @since 4.1 + */ +public class IdleStateHandlerProvider extends ChannelInboundHandlerAdapter { + + @Override + public void userEventTriggered(ChannelHandlerContext ctx, Object evt) { + if (evt instanceof IdleStateEvent) { + ctx.close(); + } + ctx.fireUserEventTriggered(evt); + } +} \ No newline at end of file diff --git a/server/core/src/main/java/org/infinispan/server/core/transport/NettyChannelInitializer.java b/server/core/src/main/java/org/infinispan/server/core/transport/NettyChannelInitializer.java new file mode 100644 index 000000000000..d47f7e58132f --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/transport/NettyChannelInitializer.java @@ -0,0 +1,90 @@ +package org.infinispan.server.core.transport; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelOutboundHandler; +import io.netty.channel.ChannelPipeline; +import io.netty.handler.logging.LogLevel; +import io.netty.handler.logging.LoggingHandler; +import io.netty.handler.ssl.ClientAuth; +import io.netty.handler.ssl.IdentityCipherSuiteFilter; +import io.netty.handler.ssl.JdkSslContext; +import io.netty.handler.ssl.SniHandler; +import io.netty.util.DomainMappingBuilder; +import org.infinispan.commons.util.SslContextFactory; +import org.infinispan.server.core.ProtocolServer; +import org.infinispan.server.core.configuration.ProtocolServerConfiguration; +import org.infinispan.server.core.configuration.SslConfiguration; +import org.infinispan.server.core.configuration.SslEngineConfiguration; + +import javax.net.ssl.SSLContext; +import java.util.Arrays; + +/** + * Pipeline factory for Netty based channels. For each pipeline created, a new decoder is created which means that + * each incoming connection deals with a unique decoder instance. Since the encoder does not maintain any state, + * a single encoder instance is shared by all incoming connections, if and only if, the protocol mandates an encoder. + * + * @author Galder Zamarreño + * @author Sebastian Łaskawiec + * @since 4.1 + */ +public class NettyChannelInitializer extends ChannelInitializer { + protected final ProtocolServer server; + protected final NettyTransport transport; + protected final ChannelOutboundHandler encoder; + + public NettyChannelInitializer(ProtocolServer server, NettyTransport transport, ChannelOutboundHandler encoder) { + this.server = server; + this.transport = transport; + this.encoder = encoder; + } + + @Override + protected void initChannel(Channel ch) throws Exception { + ChannelPipeline pipeline = ch.pipeline(); + pipeline.addLast("stats", new StatsChannelHandler(transport)); + SslConfiguration ssl = server.getConfiguration().ssl(); + if (ssl.enabled()) { + //add default domain mapping + JdkSslContext defaultNettySslContext = createNettySslContext(ssl, ssl.sniDomainsConfiguration().get("*")); + DomainMappingBuilder domainMappingBuilder = new DomainMappingBuilder<>(defaultNettySslContext); + + //and the rest + ssl.sniDomainsConfiguration().forEach((k, v) -> { + if (!"*".equals(k)) { + domainMappingBuilder.add(k, createNettySslContext(ssl, v)); + } + }); + + pipeline.addLast("sni", new SniHandler(domainMappingBuilder.build())); + } + pipeline.addLast("decoder", server.getDecoder()); + if (encoder != null) + pipeline.addLast("encoder", encoder); + } + + private JdkSslContext createNettySslContext(SslConfiguration sslConfiguration, SslEngineConfiguration sslEngineConfiguration) { + SSLContext sslContext; + if (sslEngineConfiguration.sslContext() != null) { + sslContext = sslEngineConfiguration.sslContext(); + } else { + sslContext = SslContextFactory.getContext(sslEngineConfiguration.keyStoreFileName(), + sslEngineConfiguration.keyStorePassword(), sslEngineConfiguration.keyStoreCertificatePassword(), + sslEngineConfiguration.trustStoreFileName(), sslEngineConfiguration.trustStorePassword()); + } + return createSslContext(sslContext, requireClientAuth(sslConfiguration)); + } + + private JdkSslContext createSslContext(SSLContext sslContext, ClientAuth clientAuth) { + //Unfortunately we need to grap a list of available ciphers from the engine. + //If we won't, JdkSslContext will use common ciphers from DEFAULT and SUPPORTED, which gives us 5 out of ~50 available ciphers + //Of course, we don't need to any specific engine configuration here... just a list of ciphers + String[] ciphers = SslContextFactory.getEngine(sslContext, false, false).getSupportedCipherSuites(); + return new JdkSslContext(sslContext, false, Arrays.asList(ciphers), IdentityCipherSuiteFilter.INSTANCE, null, clientAuth); + } + + private ClientAuth requireClientAuth(SslConfiguration sslConfig) { + return sslConfig.requireClientAuth() ? ClientAuth.REQUIRE : ClientAuth.NONE; + } +} diff --git a/server/core/src/main/java/org/infinispan/server/core/transport/NettyTransport.java b/server/core/src/main/java/org/infinispan/server/core/transport/NettyTransport.java new file mode 100644 index 000000000000..798fb25802fe --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/transport/NettyTransport.java @@ -0,0 +1,324 @@ +package org.infinispan.server.core.transport; + +import io.netty.bootstrap.ServerBootstrap; +import io.netty.buffer.PooledByteBufAllocator; +import io.netty.channel.Channel; +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelOption; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.ServerChannel; +import io.netty.channel.epoll.Epoll; +import io.netty.channel.epoll.EpollEventLoopGroup; +import io.netty.channel.epoll.EpollServerSocketChannel; +import io.netty.channel.group.ChannelGroup; +import io.netty.channel.group.ChannelGroupFuture; +import io.netty.channel.group.DefaultChannelGroup; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioServerSocketChannel; +import io.netty.util.concurrent.DefaultThreadFactory; +import io.netty.util.concurrent.ImmediateEventExecutor; +import io.netty.util.internal.logging.InternalLoggerFactory; +import io.netty.util.internal.logging.Log4JLoggerFactory; +import org.infinispan.Cache; +import org.infinispan.commons.CacheException; +import org.infinispan.commons.logging.LogFactory; +import org.infinispan.commons.util.Util; +import org.infinispan.configuration.global.GlobalConfiguration; +import org.infinispan.distexec.DefaultExecutorService; +import org.infinispan.distexec.DistributedCallable; +import org.infinispan.distexec.DistributedExecutorService; +import org.infinispan.jmx.JmxUtil; +import org.infinispan.manager.EmbeddedCacheManager; +import org.infinispan.server.core.configuration.ProtocolServerConfiguration; +import org.infinispan.server.core.logging.Log; + +import javax.management.AttributeNotFoundException; +import javax.management.InstanceNotFoundException; +import javax.management.MBeanException; +import javax.management.MBeanServer; +import javax.management.MalformedObjectNameException; +import javax.management.ObjectName; +import javax.management.ReflectionException; +import java.io.Serializable; +import java.net.InetSocketAddress; +import java.util.List; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicLong; + +/** + * A Netty based transport. + * + * @author Galder Zamarreño + * @author wburns + * @since 4.1 + */ +public class NettyTransport implements Transport { + + static private final Log log = LogFactory.getLog(NettyTransport.class, Log.class); + + static private final String UseEpollProperty = "infinispan.server.channel.epoll"; + static private final boolean IsLinux = System.getProperty("os.name").toLowerCase().startsWith("linux"); + static private final boolean EpollDisabled = System.getProperty(UseEpollProperty, "true").equalsIgnoreCase("false"); + static private final boolean useEPoll; + + static private final boolean isLog4jAvailable; + + static { + boolean exception; + try { + Util.loadClassStrict("org.apache.log4j.Logger", Thread.currentThread().getContextClassLoader()); + exception = false; + } catch (ClassNotFoundException e) { + exception = true; + } + isLog4jAvailable = !exception; + + if (Epoll.isAvailable()) { + useEPoll = !EpollDisabled && IsLinux; + } else { + log.epollNotAvailable(Epoll.unavailabilityCause().toString()); + useEPoll = false; + } + } + + public NettyTransport(InetSocketAddress address, ProtocolServerConfiguration configuration, String threadNamePrefix, + EmbeddedCacheManager cacheManager) { + this.address = address; + this.configuration = configuration; + this.threadNamePrefix = threadNamePrefix; + this.cacheManager = cacheManager; + + // Need to initialize these in constructor since they require configuration + masterGroup = buildEventLoop(1, new DefaultThreadFactory(threadNamePrefix + "ServerMaster")); + workerGroup = buildEventLoop(0, new DefaultThreadFactory(threadNamePrefix + "ServerWorker")); + + isGlobalStatsEnabled = cacheManager.getCacheManagerConfiguration().globalJmxStatistics().enabled(); + serverChannels = new DefaultChannelGroup(threadNamePrefix + "-Channels", ImmediateEventExecutor.INSTANCE); + acceptedChannels = new DefaultChannelGroup(threadNamePrefix + "-Accepted", ImmediateEventExecutor.INSTANCE); + } + + public void initializeHandler(ChannelInitializer handler) { + this.handler = handler; + } + + private ChannelInitializer handler; + private final InetSocketAddress address; + private final ProtocolServerConfiguration configuration; + private final String threadNamePrefix; + private final EmbeddedCacheManager cacheManager; + + private final ChannelGroup serverChannels; + final ChannelGroup acceptedChannels; + + private final EventLoopGroup masterGroup; + private final EventLoopGroup workerGroup; + + private final AtomicLong totalBytesWritten = new AtomicLong(); + private final AtomicLong totalBytesRead = new AtomicLong(); + private final boolean isGlobalStatsEnabled; + + @Override + public void start() { + // Make netty use log4j, otherwise it goes to JDK logging. + if (isLog4jAvailable) + InternalLoggerFactory.setDefaultFactory(new Log4JLoggerFactory()); + + ServerBootstrap bootstrap = new ServerBootstrap(); + bootstrap.group(masterGroup, workerGroup); + bootstrap.channel(getServerSocketChannel()); + bootstrap.childHandler(handler); + bootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT); + bootstrap.childOption(ChannelOption.TCP_NODELAY, configuration.tcpNoDelay()); // Sets server side tcpNoDelay + if (configuration.sendBufSize() > 0) + bootstrap.childOption(ChannelOption.SO_SNDBUF, configuration.sendBufSize()); // Sets server side send buffer + if (configuration.recvBufSize() > 0) + bootstrap.childOption(ChannelOption.SO_RCVBUF, configuration.recvBufSize()); // Sets server side receive buffer + + Channel ch; + try { + ch = bootstrap.bind(address).sync().channel(); + } catch (InterruptedException e) { + throw new CacheException(e); + } + serverChannels.add(ch); + } + + @Override + public void stop() { + // We *pause* the acceptor so no new connections are made + ChannelGroupFuture future = serverChannels.close().awaitUninterruptibly(); + if (!future.isSuccess()) { + log.serverDidNotUnbind(); + + future.forEach(fut -> { + Channel ch = fut.channel(); + if (ch.isActive()) { + log.channelStillBound(ch, ch.remoteAddress()); + } + }); + } + + future = acceptedChannels.close().awaitUninterruptibly(); + if (!future.isSuccess()) { + log.serverDidNotClose(); + future.forEach(fut -> { + Channel ch = fut.channel(); + if (ch.isActive()) { + log.channelStillConnected(ch, ch.remoteAddress()); + } + }); + } + if (log.isDebugEnabled()) + log.debug("Channel group completely closed, release external resources"); + masterGroup.shutdownGracefully(); + workerGroup.shutdownGracefully(); + } + + @Override + public String getTotalBytesWritten() { + return totalBytesWritten.toString(); + } + + @Override + public String getTotalBytesRead() { + return totalBytesRead.toString(); + } + + @Override + public String getHostName() { + return address.getHostName(); + } + + @Override + public String getPort() { + return Integer.toString(address.getPort()); + } + + @Override + public String getNumberWorkerThreads() { + return Integer.toString(configuration.workerThreads()); + } + + @Override + public String getIdleTimeout() { + return Integer.toString(configuration.idleTimeout()); + } + + @Override + public String getTcpNoDelay() { + return Boolean.toString(configuration.tcpNoDelay()); + } + + @Override + public String getSendBufferSize() { + return Integer.toString(configuration.sendBufSize()); + } + + @Override + public String getReceiveBufferSize() { + return Integer.toString(configuration.recvBufSize()); + } + + @Override + public Integer getNumberOfLocalConnections() { + return Integer.valueOf(acceptedChannels.size()); + } + + @Override + public Integer getNumberOfGlobalConnections() { + if (needDistributedCalculation()) { + return calculateGlobalConnections(); + } else { + return getNumberOfLocalConnections(); + } + } + + public void updateTotalBytesWritten(int bytes) { + if (isGlobalStatsEnabled) + incrementTotalBytes(totalBytesWritten, bytes); + } + + public void updateTotalBytesRead(int bytes) { + if (isGlobalStatsEnabled) + incrementTotalBytes(totalBytesRead, bytes); + } + + private void incrementTotalBytes(AtomicLong base, int bytes) { + if (isGlobalStatsEnabled) + base.addAndGet(bytes); + } + + + private boolean needDistributedCalculation() { + org.infinispan.remoting.transport.Transport transport = cacheManager.getTransport(); + return transport != null && transport.getMembers().size() > 1; + } + + private Class getServerSocketChannel() { + Class channel = useEPoll ? EpollServerSocketChannel.class : NioServerSocketChannel.class; + log.createdSocketChannel(channel.getName(), configuration.toString()); + return channel; + } + + private EventLoopGroup buildEventLoop(int nThreads, DefaultThreadFactory threadFactory) { + EventLoopGroup eventLoop = useEPoll ? new EpollEventLoopGroup(nThreads, threadFactory) : + new NioEventLoopGroup(nThreads, threadFactory); + log.createdNettyEventLoop(eventLoop.getClass().getName(), configuration.toString()); + return eventLoop; + } + + private int calculateGlobalConnections() { + Cache cache = cacheManager.getCache(); + DistributedExecutorService exec = new DefaultExecutorService(cache); + try { + // Submit calculation task + List> results = exec.submitEverywhere( + new ConnectionAdderTask(threadNamePrefix)); + // Take all results and add them up with a bit of functional programming magic :) + return results.stream().mapToInt(f -> { + try { + return f.get(30, TimeUnit.SECONDS); + } catch (InterruptedException | ExecutionException | TimeoutException e) { + throw new CacheException(e); + } + }).sum(); + } finally { + exec.shutdown(); + } + } + + static class ConnectionAdderTask implements Serializable, DistributedCallable { + private final String serverName; + + Cache cache; + + ConnectionAdderTask(String serverName) { + this.serverName = serverName; + } + + @Override + public void setEnvironment(Cache cache, Set inputKeys) { + this.cache = cache; + } + + @Override + public Integer call() throws Exception { + GlobalConfiguration globalCfg = cache.getCacheManager().getCacheManagerConfiguration(); + String jmxDomain = globalCfg.globalJmxStatistics().domain(); + MBeanServer mbeanServer = JmxUtil.lookupMBeanServer(globalCfg); + try { + ObjectName transportMBeanName = new ObjectName( + jmxDomain + ":type=Server,component=Transport,name=" + serverName); + + return (Integer) mbeanServer.getAttribute(transportMBeanName, "NumberOfLocalConnections"); + } catch (MBeanException | AttributeNotFoundException | InstanceNotFoundException | ReflectionException | + MalformedObjectNameException e) { + throw new RuntimeException(e); + } + } + } +} diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/SaslQopHandler.java b/server/core/src/main/java/org/infinispan/server/core/transport/SaslQopHandler.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/transport/SaslQopHandler.java rename to server/core/src/main/java/org/infinispan/server/core/transport/SaslQopHandler.java diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/StatsChannelHandler.java b/server/core/src/main/java/org/infinispan/server/core/transport/StatsChannelHandler.java similarity index 92% rename from server/core/src/main/scala/org/infinispan/server/core/transport/StatsChannelHandler.java rename to server/core/src/main/java/org/infinispan/server/core/transport/StatsChannelHandler.java index 8b1a27621fb0..1f981a883026 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/StatsChannelHandler.java +++ b/server/core/src/main/java/org/infinispan/server/core/transport/StatsChannelHandler.java @@ -5,8 +5,6 @@ import io.netty.channel.ChannelDuplexHandler; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPromise; -import io.netty.util.Attribute; -import io.netty.util.AttributeKey; import java.time.Instant; @@ -32,7 +30,7 @@ public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { - transport.acceptedChannels().add(ctx.channel()); + transport.acceptedChannels.add(ctx.channel()); super.channelActive(ctx); } diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/Transport.java b/server/core/src/main/java/org/infinispan/server/core/transport/Transport.java similarity index 100% rename from server/core/src/main/scala/org/infinispan/server/core/transport/Transport.java rename to server/core/src/main/java/org/infinispan/server/core/transport/Transport.java diff --git a/server/core/src/main/java/org/infinispan/server/core/transport/VInt.java b/server/core/src/main/java/org/infinispan/server/core/transport/VInt.java new file mode 100644 index 000000000000..f693afda8ae1 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/transport/VInt.java @@ -0,0 +1,39 @@ +package org.infinispan.server.core.transport; + +import io.netty.buffer.ByteBuf; + +/** + * Reads and writes unsigned variable length integer values. Even though it's deprecated, do not + * remove from source code for the moment because it's a good scala example and could be used + * as reference. + * + * @author Galder Zamarreño + * @since 4.1 + */ +public class VInt { + + public static void write(ByteBuf out, int i) { + if ((i & ~0x7F) == 0) out.writeByte(i); + else { + out.writeByte(((i & 0x7f) | 0x80)); + write(out, i >>> 7); + } + } + + public static int read(ByteBuf in) { + byte b = in.readByte(); + return read(in, b, 7, b & 0x7F, 1); + } + + private static int read(ByteBuf in, byte b, int shift, int i, int count) { + if ((b & 0x80) == 0) return i; + else { + if (count > 5) + throw new IllegalStateException( + "Stream corrupted. A variable length integer cannot be longer than 5 bytes."); + + byte bb = in.readByte(); + return read(in, bb, shift + 7, i | (int) ((bb & 0x7FL) << shift), count + 1); + } + } +} \ No newline at end of file diff --git a/server/core/src/main/java/org/infinispan/server/core/transport/VLong.java b/server/core/src/main/java/org/infinispan/server/core/transport/VLong.java new file mode 100644 index 000000000000..7434c096f3d2 --- /dev/null +++ b/server/core/src/main/java/org/infinispan/server/core/transport/VLong.java @@ -0,0 +1,39 @@ +package org.infinispan.server.core.transport; + +import io.netty.buffer.ByteBuf; + +/** + * Reads and writes unsigned variable length long values. Even though it's deprecated, do not + * remove from source code for the moment because it's a good scala example and could be used + * as reference. + * + * @author Galder Zamarreño + * @since 4.1 + */ +public class VLong { + + public static void write(ByteBuf out, long i) { + if ((i & ~0x7F) == 0) out.writeByte((byte) i); + else { + out.writeByte((byte) ((i & 0x7f) | 0x80)); + write(out, i >>> 7); + } + } + + public static long read(ByteBuf in) { + byte b = in.readByte(); + return read(in, b, 7, b & 0x7F, 1); + } + + private static long read(ByteBuf in, byte b, int shift, long i, int count) { + if ((b & 0x80) == 0) return i; + else { + if (count > 9) + throw new IllegalStateException( + "Stream corrupted. A variable length long cannot be longer than 9 bytes."); + + byte bb = in.readByte(); + return read(in, bb, shift + 7, i | (bb & 0x7FL) << shift, count + 1); + } + } +} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/AbstractProtocolServer.scala b/server/core/src/main/scala/org/infinispan/server/core/AbstractProtocolServer.scala deleted file mode 100644 index 55f399e6d4d7..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/AbstractProtocolServer.scala +++ /dev/null @@ -1,116 +0,0 @@ -package org.infinispan.server.core - -import java.net.InetSocketAddress -import org.infinispan.manager.EmbeddedCacheManager -import transport.NettyTransport -import logging.Log -import org.infinispan.jmx.{JmxUtil, ResourceDMBean} -import javax.management.{ObjectName, MBeanServer} -import org.infinispan.server.core.transport.TimeoutEnabledChannelInitializer -import org.infinispan.server.core.transport.NettyChannelInitializer -import io.netty.channel.{Channel, ChannelInitializer} -import scala.collection.JavaConversions._ - -/** - * A common protocol server dealing with common property parameter validation and assignment and transport lifecycle. - * - * @author Galder Zamarreño - * @since 4.1 - */ -abstract class AbstractProtocolServer(protocolName: String) extends ProtocolServer with Log { - protected var transport: NettyTransport = _ - protected var cacheManager: EmbeddedCacheManager = _ - protected var configuration: SuitableConfiguration = null.asInstanceOf[SuitableConfiguration] - private var transportObjName: ObjectName = _ - private var mbeanServer: MBeanServer = _ - private var isGlobalStatsEnabled: Boolean = _ - - protected def startInternal(configuration: SuitableConfiguration, cacheManager: EmbeddedCacheManager) { - this.configuration = configuration - this.cacheManager = cacheManager - this.isGlobalStatsEnabled = cacheManager.getCacheManagerConfiguration.globalJmxStatistics().enabled() - - if (isDebugEnabled) { - debugf("Starting server with configuration: %s", configuration) - } - - // Start default cache - startDefaultCache - - startTransport() - } - - final override def start(configuration: SuitableConfiguration, cacheManager: EmbeddedCacheManager) { - try { - configuration.ignoredCaches foreach ignoreCache - startInternal(configuration, cacheManager) - } catch { - case t: Throwable => { - stop - throw t - } - } - } - - def startTransport() { - val address = new InetSocketAddress(configuration.host, configuration.port) - transport = new NettyTransport(this, getInitializer, address, configuration, getQualifiedName, cacheManager) - - // Register transport MBean regardless - registerTransportMBean() - - transport.start() - } - - protected def registerTransportMBean() { - val globalCfg = cacheManager.getCacheManagerConfiguration - mbeanServer = JmxUtil.lookupMBeanServer(globalCfg) - val groupName = "type=Server,name=%s".format(getQualifiedName) - val jmxDomain = JmxUtil.buildJmxDomain(globalCfg, mbeanServer, groupName) - - // Pick up metadata from the component metadata repository - val meta = LifecycleCallbacks.componentMetadataRepo - .findComponentMetadata(transport.getClass).toManageableComponentMetadata - // And use this metadata when registering the transport as a dynamic MBean - val dynamicMBean = new ResourceDMBean(transport, meta) - - transportObjName = new ObjectName( - "%s:%s,component=%s".format(jmxDomain, groupName, meta.getJmxObjectName)) - JmxUtil.registerMBean(dynamicMBean, transportObjName, mbeanServer) - } - - protected def unregisterTransportMBean() { - if (mbeanServer != null && transportObjName != null) { - // Unregister mbean(s) - JmxUtil.unregisterMBean(transportObjName, mbeanServer) - } - } - - protected def getQualifiedName(): String = { - protocolName + (if (configuration.name.length > 0) "-" else "") + configuration.name - } - - override def stop { - val isDebug = isDebugEnabled - if (isDebug && configuration != null) - debug("Stopping server listening in %s:%d", configuration.host, configuration.port) - - if (transport != null) - transport.stop() - - unregisterTransportMBean() - - if (isDebug) - debug("Server stopped") - } - - def getCacheManager = cacheManager - - def getConfiguration = configuration - - def getHost = configuration.host - - def getPort: Int = configuration.port - - def startDefaultCache = cacheManager.getCache[AnyRef, AnyRef](configuration.defaultCacheName) -} diff --git a/server/core/src/main/scala/org/infinispan/server/core/CacheIgnoreAware.scala b/server/core/src/main/scala/org/infinispan/server/core/CacheIgnoreAware.scala deleted file mode 100644 index 6dd6ac0bf762..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/CacheIgnoreAware.scala +++ /dev/null @@ -1,32 +0,0 @@ -package org.infinispan.server.core - -import java.util - -/** - * @author gustavonalle - * @since 8.1 - */ -trait CacheIgnoreAware { - - private val ignoredCaches = new util.HashSet[String]() - - def setIgnoredCaches(cacheNames: java.util.Set[String]) = { - this.synchronized { - ignoredCaches.clear() - ignoredCaches.addAll(cacheNames) - } - } - - def unignore(cacheName: String) = this.synchronized { - ignoredCaches.remove(cacheName) - } - - def ignoreCache(cacheName: String) = this.synchronized { - ignoredCaches.add(cacheName) - } - - def isCacheIgnored(cacheName: String) = this.synchronized { - ignoredCaches.contains(cacheName) - } - -} diff --git a/server/core/src/main/scala/org/infinispan/server/core/ExternalizerIds.scala b/server/core/src/main/scala/org/infinispan/server/core/ExternalizerIds.scala deleted file mode 100644 index 9805e465a0e9..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/ExternalizerIds.scala +++ /dev/null @@ -1,27 +0,0 @@ -package org.infinispan.server.core - -/** - * Externalizer ids used by Server module {@link AdvancedExternalizer} implementations. - * - * Information about the valid id range can be found here - * - * @author Galder Zamarreño - * @since 5.0 - */ -object ExternalizerIds { - - val SERVER_ENTRY_VERSION = 1100 - val MEMCACHED_METADATA = 1101 - val TOPOLOGY_ADDRESS = 1102 - val TOPOLOGY_VIEW = 1103 - val SERVER_ADDRESS = 1104 - val MIME_METADATA = 1105 - val BINARY_FILTER = 1106 - val BINARY_CONVERTER = 1107 - val KEY_VALUE_VERSION_CONVERTER = 1108 - val BINARY_FILTER_CONVERTER = 1109 - val KEY_VALUE_WITH_PREVIOUS_CONVERTER = 1110 - val ITERATION_FILTER = 1111 - val QUERY_ITERATION_FILTER = 1112 - -} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/LifecycleCallbacks.scala b/server/core/src/main/scala/org/infinispan/server/core/LifecycleCallbacks.scala deleted file mode 100644 index f50c6318ed55..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/LifecycleCallbacks.scala +++ /dev/null @@ -1,33 +0,0 @@ -package org.infinispan.server.core - -import org.infinispan.lifecycle.AbstractModuleLifecycle -import org.infinispan.server.core.ExternalizerIds._ -import org.infinispan.factories.{ComponentRegistry, GlobalComponentRegistry} -import org.infinispan.configuration.global.GlobalConfiguration -import org.infinispan.configuration.cache.Configuration -import org.infinispan.factories.components.ComponentMetadataRepo - -/** - * Module lifecycle callbacks implementation that enables module specific - * {@link org.infinispan.marshall.AdvancedExternalizer} implementations to be registered. - * - * @author Galder Zamarreño - * @since 5.0 - */ -class LifecycleCallbacks extends AbstractModuleLifecycle { - - override def cacheManagerStarting(gcr: GlobalComponentRegistry, globalCfg: GlobalConfiguration) { - LifecycleCallbacks.componentMetadataRepo = gcr.getComponentMetadataRepo - } - - override def cacheStarting(cr: ComponentRegistry, cfg: Configuration, cacheName: String) { - cfg.storeAsBinary().enabled(false) - } - -} - -object LifecycleCallbacks { - - var componentMetadataRepo: ComponentMetadataRepo = _ - -} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/Operation.scala b/server/core/src/main/scala/org/infinispan/server/core/Operation.scala deleted file mode 100644 index ae4858529c56..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/Operation.scala +++ /dev/null @@ -1,14 +0,0 @@ -package org.infinispan.server.core - -/** - * Common set of operations for Memcached and Hot Rod protocols. - * - * @author Galder Zamarreño - * @since 4.1 - */ -object Operation extends Enumeration { - type Operation = Value - val PutRequest, PutIfAbsentRequest, ReplaceRequest, ReplaceIfUnmodifiedRequest = Value - val GetRequest, GetWithVersionRequest = Value - val RemoveRequest, StatsRequest = Value -} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/QueryFacade.scala b/server/core/src/main/scala/org/infinispan/server/core/QueryFacade.scala deleted file mode 100644 index bea5eafbfae5..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/QueryFacade.scala +++ /dev/null @@ -1,15 +0,0 @@ -package org.infinispan.server.core - -import org.infinispan.AdvancedCache - -/** - * Query facade - * - * @author Galder Zamarreño - * @since 6.0 - */ -trait QueryFacade { - - def query(cache: AdvancedCache[Array[Byte], Array[Byte]], query: Array[Byte]): Array[Byte] - -} diff --git a/server/core/src/main/scala/org/infinispan/server/core/ServerConstants.scala b/server/core/src/main/scala/org/infinispan/server/core/ServerConstants.scala deleted file mode 100644 index 1bb4d1020422..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/ServerConstants.scala +++ /dev/null @@ -1,14 +0,0 @@ -package org.infinispan.server.core; - -import javax.security.auth.Subject - -/** - * Server Constant values - * - * @author Tristan Tarrant - * @since 5.2 - */ -trait ServerConstants { - val EXPIRATION_NONE = -1 - val EXPIRATION_DEFAULT = -2 -} diff --git a/server/core/src/main/scala/org/infinispan/server/core/ServerCoreMetadataFileFinder.scala b/server/core/src/main/scala/org/infinispan/server/core/ServerCoreMetadataFileFinder.scala deleted file mode 100644 index 484e8ed3d77a..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/ServerCoreMetadataFileFinder.scala +++ /dev/null @@ -1,7 +0,0 @@ -package org.infinispan.server.core - -import org.infinispan.factories.components.ModuleMetadataFileFinder - -class ServerCoreMetadataFileFinder extends ModuleMetadataFileFinder { - def getMetadataFilename = "infinispan-server-core-component-metadata.dat" -} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/logging/Log.scala b/server/core/src/main/scala/org/infinispan/server/core/logging/Log.scala deleted file mode 100644 index 5ebddde77069..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/logging/Log.scala +++ /dev/null @@ -1,100 +0,0 @@ -package org.infinispan.server.core.logging - -import java.net.SocketAddress - -import io.netty.channel.Channel -import org.infinispan.distribution.ch.ConsistentHash -import org.infinispan.util.logging.LogFactory - -/** - * A logging facade for Scala code. - * - * @author Galder Zamarreño - * @since 5.0 - */ -trait Log { - private lazy val log: JavaLog = LogFactory.getLog(getClass, classOf[JavaLog]) - - def info(msg: => String) = log.info(msg) - - def info(msg: => String, param1: Any) = log.infof(msg, param1) - - def error(msg: => String, t: Throwable) = log.errorf(t, msg) - - def warn(msg: => String, t: Throwable) = log.warnf(t, msg) - - def debug(msg: => String) = log.debug(msg) - - def debug(msg: => String, param1: Any) = log.debugf(msg, param1) - - def debug(t: Throwable, msg: => String) = log.debugf(t, msg) - - def debug(t: Throwable, msg: => String, param1: Any) = log.debugf(t, msg, param1) - - def debug(msg: => String, param1: Any, param2: Any) = - log.debugf(msg, param1, param2) - - def debugf(msg: => String, params: Any*) = - log.debugf(msg, params.map(_.asInstanceOf[AnyRef]) : _*) - - def trace(msg: => String) = log.tracef(msg) - - def trace(msg: => String, param1: Any) = log.tracef(msg, param1) - - def trace(msg: => String, param1: Any, param2: Any) = - log.tracef(msg, param1, param2) - - def trace(msg: => String, param1: Any, param2: Any, param3: Any) = - log.tracef(msg, param1, param2, param3) - - def tracef(msg: => String, params: Any*) = - log.tracef(msg, params.map(_.asInstanceOf[AnyRef]) : _*) - - def isDebugEnabled = log.isDebugEnabled - - def isTraceEnabled = log.isTraceEnabled - - // INFO or higher level messages support internationalization - - def logStartWithArgs(args: String) = log.startWithArgs(args) - - def logPostingShutdownRequest = log.postingShutdownRequest - - def logExceptionReported(t: Throwable) = log.exceptionReported(t) - - def logServerDidNotUnbind = log.serverDidNotUnbind - - def logChannelStillBound(ch: Channel, address: SocketAddress) = - log.channelStillBound(ch, address) - - def logServerDidNotClose = log.serverDidNotClose - - def logChannelStillConnected(ch: Channel, address: SocketAddress) = - log.channelStillConnected(ch, address) - - def logSettingMasterThreadsNotSupported = log.settingMasterThreadsNotSupported - - def logErrorBeforeReadingRequest(t: Throwable) = - log.errorBeforeReadingRequest(t) - - def logNoMembersInHashTopology(ch: ConsistentHash, topology: String) = - log.noMembersInHashTopology(ch, topology) - - def logNoMembersInTopology() = log.noMembersInTopology() - - def logServerEndpointTopologyEmpty(clusterMembers: String) = - log.serverEndpointTopologyEmpty(clusterMembers) - - def logErrorWritingResponse(msgId: Long, t: Throwable) = log.errorWritingResponse(msgId, t) - - def logErrorEncodingMessage(msg: Any, t: Throwable) = log.errorEncodingMessage(msg, t) - - def logErrorUnexpectedMessage(msg: Any) = log.errorUnexpectedMessage(msg) - - def logCreatedSocketChannel(channelClassName: String, configuration: String) = log.createdSocketChannel(channelClassName, configuration) - - def logCreatedNettyEventLoop(eventLoopClassName: String, configuration: String) = log.createdNettyEventLoop(eventLoopClassName, configuration) - - def logEpollNotAvailable(t: Throwable) = log.epollNotAvailable(t.getMessage) - -} diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/IdleStateHandlerProvider.scala b/server/core/src/main/scala/org/infinispan/server/core/transport/IdleStateHandlerProvider.scala deleted file mode 100644 index 12f1d0e1063c..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/IdleStateHandlerProvider.scala +++ /dev/null @@ -1,22 +0,0 @@ -package org.infinispan.server.core.transport - -import io.netty.channel.{ChannelHandlerContext, ChannelInboundHandlerAdapter} -import io.netty.handler.timeout.IdleStateEvent - -/** - * A Netty channel handler that allows idle channels to be closed. - * - * @author Galder Zamarreño - * @since 4.1 - */ -class IdleStateHandlerProvider extends ChannelInboundHandlerAdapter { - - - override def userEventTriggered(ctx: ChannelHandlerContext, evt: scala.Any): Unit = { - System.out.println(evt) - if (evt.isInstanceOf[IdleStateEvent]) { - ctx.close - } - ctx.fireUserEventTriggered(evt) - } -} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/NettyChannelInitializer.scala b/server/core/src/main/scala/org/infinispan/server/core/transport/NettyChannelInitializer.scala deleted file mode 100644 index aeb5acc8d4ca..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/NettyChannelInitializer.scala +++ /dev/null @@ -1,72 +0,0 @@ -package org.infinispan.server.core.transport - -import javax.net.ssl.SSLContext - -import io.netty.channel.{Channel, ChannelInitializer, ChannelOutboundHandler} -import io.netty.handler.logging.{LogLevel, LoggingHandler} -import io.netty.handler.ssl._ -import io.netty.util.DomainMappingBuilder -import org.infinispan.commons.util.SslContextFactory -import org.infinispan.server.core.ProtocolServer -import org.infinispan.server.core.configuration.{SslConfiguration, SslEngineConfiguration} - -import scala.collection.JavaConverters._ - -/** - * Pipeline factory for Netty based channels. For each pipeline created, a new decoder is created which means that - * each incoming connection deals with a unique decoder instance. Since the encoder does not maintain any state, - * a single encoder instance is shared by all incoming connections, if and only if, the protocol mandates an encoder. - * - * @author Galder Zamarreño - * @author Sebastian Łaskawiec - * @since 4.1 - */ -class NettyChannelInitializer(server: ProtocolServer, transport: => NettyTransport - , encoder: ChannelOutboundHandler) extends ChannelInitializer[Channel] { - - override def initChannel(ch: Channel): Unit = { - val pipeline = ch.pipeline - pipeline.addLast("stats", new StatsChannelHandler(transport)) - val ssl = server.getConfiguration.ssl - if (ssl.enabled()) { - //add default domain mapping - val defaultNettySslContext = createNettySslContext(ssl, ssl.sniDomainsConfiguration().get("*")) - val domainMappingBuilder = new DomainMappingBuilder(defaultNettySslContext) - - //and the rest - ssl.sniDomainsConfiguration().asScala - .filterKeys(key => !"*".equals(key)) - .foreach(e => domainMappingBuilder.add(e._1, createNettySslContext(ssl, e._2))) - - pipeline.addLast("sni", new SniHandler(domainMappingBuilder.build())) - } - pipeline.addLast("decoder", server.getDecoder) - if (encoder != null) - pipeline.addLast("encoder", encoder) - pipeline.addLast(new LoggingHandler(LogLevel.DEBUG)) - } - - private def createNettySslContext(sslConfiguration: SslConfiguration, sslEngineConfiguration: SslEngineConfiguration): JdkSslContext = { - val sslContext = if (sslEngineConfiguration.sslContext != null) { - sslEngineConfiguration.sslContext - } else { - SslContextFactory.getContext(sslEngineConfiguration.keyStoreFileName, sslEngineConfiguration.keyStorePassword, - sslEngineConfiguration.keyStoreCertificatePassword, sslEngineConfiguration.trustStoreFileName, sslEngineConfiguration.trustStorePassword) - } - return createSslContext(sslContext, requireClientAuth(sslConfiguration)) - } - - private def createSslContext(sslContext: SSLContext, clientAuth: ClientAuth): JdkSslContext = { - //Unfortunately we need to grap a list of available ciphers from the engine. - //If we won't, JdkSslContext will use common ciphers from DEFAULT and SUPPORTED, which gives us 5 out of ~50 available ciphers - //Of course, we don't need to any specific engine configuration here... just a list of ciphers - val ciphers = SslContextFactory.getEngine(sslContext, false, false).getSupportedCipherSuites - val context = new JdkSslContext(sslContext, false, ciphers.toIterable.asJava, IdentityCipherSuiteFilter.INSTANCE, null, clientAuth) - return context - } - - private def requireClientAuth(sslConfig: SslConfiguration): ClientAuth = sslConfig.requireClientAuth() match { - case true => ClientAuth.REQUIRE - case _ => ClientAuth.NONE - } -} diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/NettyTransport.scala b/server/core/src/main/scala/org/infinispan/server/core/transport/NettyTransport.scala deleted file mode 100644 index 6833c9ed6c64..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/NettyTransport.scala +++ /dev/null @@ -1,224 +0,0 @@ -package org.infinispan.server.core.transport - -import java.net.InetSocketAddress -import java.util -import java.util.concurrent.TimeUnit -import java.util.concurrent.atomic.AtomicLong -import javax.management.ObjectName - -import io.netty.bootstrap.ServerBootstrap -import io.netty.buffer.PooledByteBufAllocator -import io.netty.channel.epoll.{Epoll, EpollEventLoopGroup, EpollServerSocketChannel} -import io.netty.channel.group.DefaultChannelGroup -import io.netty.channel.nio.NioEventLoopGroup -import io.netty.channel.socket.nio.NioServerSocketChannel -import io.netty.channel.{Channel, ChannelInitializer, ChannelOption, ServerChannel} -import io.netty.util.concurrent.{DefaultThreadFactory, ImmediateEventExecutor} -import io.netty.util.internal.logging.{InternalLoggerFactory, Log4JLoggerFactory} -import org.infinispan.Cache -import org.infinispan.commons.util.Util -import org.infinispan.distexec.{DefaultExecutorService, DistributedCallable} -import org.infinispan.jmx.JmxUtil -import org.infinispan.manager.EmbeddedCacheManager -import org.infinispan.server.core.ProtocolServer -import org.infinispan.server.core.configuration.ProtocolServerConfiguration -import org.infinispan.server.core.logging.Log - -import scala.collection.JavaConversions._ -import scala.util.Properties - -/** - * A Netty based transport. - * - * @author Galder Zamarreño - * @since 4.1 - */ -class NettyTransport(server: ProtocolServer, handler: ChannelInitializer[Channel], - address: InetSocketAddress, val configuration: ProtocolServerConfiguration, - threadNamePrefix: String, cacheManager: EmbeddedCacheManager) - extends Transport with Log { - - val UseEpollProperty = "infinispan.server.channel.epoll" - val IsLinux = Properties.osName.toLowerCase.startsWith("linux") - val EpollDisabled = Properties.propIsSetTo(UseEpollProperty, "false") - - lazy val isEPollAvailable = if (Epoll.isAvailable) true - else { - logEpollNotAvailable(Epoll.unavailabilityCause()) - false - } - - lazy val useEPoll = !EpollDisabled && IsLinux && isEPollAvailable - - private val serverChannels = new DefaultChannelGroup(threadNamePrefix + "-Channels", ImmediateEventExecutor.INSTANCE) - val acceptedChannels = new DefaultChannelGroup(threadNamePrefix + "-Accepted", ImmediateEventExecutor.INSTANCE) - - private val masterGroup = buildEventLoop(1, new DefaultThreadFactory(threadNamePrefix + "ServerMaster")) - private val workerGroup = buildEventLoop(0, new DefaultThreadFactory(threadNamePrefix + "ServerWorker")) - - private val totalBytesWritten, totalBytesRead = new AtomicLong - private val isGlobalStatsEnabled = - cacheManager.getCacheManagerConfiguration.globalJmxStatistics().enabled() - - override def start() { - // Make netty use log4j, otherwise it goes to JDK logging. - if (isLog4jAvailable) - InternalLoggerFactory.setDefaultFactory(new Log4JLoggerFactory) - - val bootstrap = new ServerBootstrap() - bootstrap.group(masterGroup, workerGroup) - bootstrap.channel(getServerSocketChannel) - bootstrap.childHandler(handler) - bootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) - bootstrap.childOption[java.lang.Boolean](ChannelOption.TCP_NODELAY, configuration.tcpNoDelay) // Sets server side tcpNoDelay - if (configuration.sendBufSize > 0) - bootstrap.childOption[java.lang.Integer](ChannelOption.SO_SNDBUF, configuration.sendBufSize) // Sets server side send buffer - if (configuration.recvBufSize > 0) - bootstrap.childOption[java.lang.Integer](ChannelOption.SO_RCVBUF, configuration.recvBufSize) // Sets server side receive buffer - - val ch = bootstrap.bind(address).sync().channel() - serverChannels.add(ch) - } - - private def isLog4jAvailable: Boolean = { - try { - Util.loadClassStrict("org.apache.log4j.Logger", - Thread.currentThread().getContextClassLoader) - true - } catch { - case cnfe: ClassNotFoundException => false - } - } - - override def stop() { - // We *pause* the acceptor so no new connections are made - var future = serverChannels.close().awaitUninterruptibly() - if (!future.isSuccess) { - logServerDidNotUnbind - for (ch <- asScalaIterator(future.group().iterator)) { - if (ch.isActive) { - logChannelStillBound(ch, ch.remoteAddress()) - } - } - } - - serverChannels.close().awaitUninterruptibly() - future = acceptedChannels.close().awaitUninterruptibly() - if (!future.isSuccess) { - logServerDidNotClose - for (ch <- asScalaIterator(future.group().iterator)) { - if (ch.isActive) { - logChannelStillConnected(ch, ch.remoteAddress) - } - } - } - if (isDebugEnabled) - debug("Channel group completely closed, release external resources") - masterGroup.shutdownGracefully() - workerGroup.shutdownGracefully() - } - - override def getTotalBytesWritten: String = totalBytesWritten.toString - - override def getTotalBytesRead: String = totalBytesRead.toString - - override def getHostName = address.getHostName - - override def getPort = address.getPort.toString - - override def getNumberWorkerThreads = configuration.workerThreads.toString - - override def getIdleTimeout = configuration.idleTimeout.toString - - override def getTcpNoDelay = configuration.tcpNoDelay.toString - - override def getSendBufferSize = configuration.sendBufSize.toString - - override def getReceiveBufferSize = configuration.recvBufSize.toString - - override def getNumberOfLocalConnections: java.lang.Integer = - Integer.valueOf(acceptedChannels.size()) - - override def getNumberOfGlobalConnections: java.lang.Integer = { - if (needDistributedCalculation()) - calculateGlobalConnections - else - getNumberOfLocalConnections - } - - private[server] def updateTotalBytesWritten(bytes: Int) { - if (isGlobalStatsEnabled) - incrementTotalBytesWritten(totalBytesWritten, bytes) - } - - private def incrementTotalBytesWritten(base: AtomicLong, bytes: Int) { - if (isGlobalStatsEnabled) - base.addAndGet(bytes) - } - - private[server] def updateTotalBytesRead(bytes: Int) { - if (isGlobalStatsEnabled) - incrementTotalBytesRead(totalBytesRead, bytes) - } - - private def incrementTotalBytesRead(base: AtomicLong, bytes: Int) { - if (isGlobalStatsEnabled) - base.addAndGet(bytes) - } - - private def needDistributedCalculation(): Boolean = { - val transport = cacheManager.getTransport - transport != null && transport.getMembers.size() > 1 - } - - def getServerSocketChannel: Class[_ <: ServerChannel] = { - val channel = if (useEPoll) classOf[EpollServerSocketChannel] else classOf[NioServerSocketChannel] - logCreatedSocketChannel(channel.getName, configuration.toString) - channel - } - - def buildEventLoop(nThreads: Int, threadFactory: DefaultThreadFactory) = { - val eventLoop = if (useEPoll) new EpollEventLoopGroup(nThreads, threadFactory) - else new NioEventLoopGroup(nThreads, threadFactory) - logCreatedNettyEventLoop(eventLoop.getClass.getName, configuration.toString) - eventLoop - } - - private def calculateGlobalConnections: java.lang.Integer = { - // TODO: Assumes default clustered cache but could be that no caches are clustered - // TODO: A way to make distributed calls with only a cache manager would be ideal - val cache = cacheManager.getCache[AnyRef, AnyRef]() - val exec = new DefaultExecutorService(cache) - try { - // Submit calculation task - val results = exec.submitEverywhere( - new ConnectionAdderTask(threadNamePrefix)).iterator() - // Take all results and add them up with a bit of functional programming magic :) - asScalaIterator(results).map(_.get(30, TimeUnit.SECONDS)).reduceLeft(_ + _) - } finally { - exec.shutdown() - } - } -} -// TODO: Could be generalised to calculate any jmx params cluster wide -class ConnectionAdderTask(serverName: String) - extends DistributedCallable[AnyRef, AnyRef, java.lang.Integer] with Serializable { - - @transient var cache: Cache[AnyRef, AnyRef] = _ - - def call(): java.lang.Integer = { - val globalCfg = cache.getCacheManager.getCacheManagerConfiguration - val jmxDomain = globalCfg.globalJmxStatistics().domain() - val mbeanServer = JmxUtil.lookupMBeanServer(globalCfg) - val transportMBeanName = new ObjectName( - jmxDomain + ":type=Server,component=Transport,name=" + serverName) - - mbeanServer.getAttribute(transportMBeanName, "NumberOfLocalConnections") - .asInstanceOf[java.lang.Integer] - } - - def setEnvironment(cache: Cache[AnyRef, AnyRef], inputKeys: util.Set[AnyRef]) { - this.cache = cache - } - -} diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/VInt.scala b/server/core/src/main/scala/org/infinispan/server/core/transport/VInt.scala deleted file mode 100644 index 01114c2752eb..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/VInt.scala +++ /dev/null @@ -1,40 +0,0 @@ -package org.infinispan.server.core.transport - -import java.lang.IllegalStateException -import io.netty.buffer.ByteBuf - -/** - * Reads and writes unsigned variable length integer values. Even though it's deprecated, do not - * remove from source code for the moment because it's a good scala example and could be used - * as reference. - * - * @author Galder Zamarreño - * @since 4.1 - */ -object VInt { - - def write(out: ByteBuf, i: Int) { - if ((i & ~0x7F) == 0) out.writeByte(i.toByte) - else { - out.writeByte(((i & 0x7f) | 0x80).toByte) - write(out, i >>> 7) - } - } - - def read(in: ByteBuf): Int = { - val b = in.readByte - read(in, b, 7, b & 0x7F, 1) - } - - private def read(in: ByteBuf, b: Byte, shift: Int, i: Int, count: Int): Int = { - if ((b & 0x80) == 0) i - else { - if (count > 5) - throw new IllegalStateException( - "Stream corrupted. A variable length integer cannot be longer than 5 bytes.") - - val bb = in.readByte - read(in, bb, shift + 7, i | ((bb & 0x7FL) << shift).toInt, count + 1) - } - } -} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/VLong.scala b/server/core/src/main/scala/org/infinispan/server/core/transport/VLong.scala deleted file mode 100644 index 4ad41a984f51..000000000000 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/VLong.scala +++ /dev/null @@ -1,39 +0,0 @@ -package org.infinispan.server.core.transport - -import io.netty.buffer.ByteBuf - -/** - * Reads and writes unsigned variable length long values. Even though it's deprecated, do not - * remove from source code for the moment because it's a good scala example and could be used - * as reference. - * - * @author Galder Zamarreño - * @since 4.1 - */ -object VLong { - - def write(out: ByteBuf, i: Long) { - if ((i & ~0x7F) == 0) out.writeByte(i.toByte) - else { - out.writeByte(((i & 0x7f) | 0x80).toByte) - write(out, i >>> 7) - } - } - - def read(in: ByteBuf): Long = { - val b = in.readByte - read(in, b, 7, b & 0x7F, 1) - } - - private def read(in: ByteBuf, b: Byte, shift: Int, i: Long, count: Int): Long = { - if ((b & 0x80) == 0) i - else { - if (count > 9) - throw new IllegalStateException( - "Stream corrupted. A variable length long cannot be longer than 9 bytes.") - - val bb = in.readByte - read(in, bb, shift + 7, i | (bb & 0x7FL) << shift, count + 1) - } - } -} \ No newline at end of file diff --git a/server/core/src/test/java/org/infinispan/server/core/AbstractMarshallingTest.java b/server/core/src/test/java/org/infinispan/server/core/AbstractMarshallingTest.java new file mode 100644 index 000000000000..fcea1a7f7ed4 --- /dev/null +++ b/server/core/src/test/java/org/infinispan/server/core/AbstractMarshallingTest.java @@ -0,0 +1,58 @@ +package org.infinispan.server.core; + +import org.infinispan.commons.CacheException; +import org.infinispan.commons.marshall.AbstractDelegatingMarshaller; +import org.infinispan.manager.EmbeddedCacheManager; +import org.infinispan.test.AbstractInfinispanTest; +import org.infinispan.test.TestingUtil; +import org.infinispan.test.fwk.TestCacheManagerFactory; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectOutputStream; +import java.util.Random; + +/** + * Abstract class to help marshalling tests in different server modules. + * + * @author Galder Zamarreño + * @since 4.1 + */ +public abstract class AbstractMarshallingTest extends AbstractInfinispanTest { + + protected AbstractDelegatingMarshaller marshaller; + protected EmbeddedCacheManager cm; + + @BeforeClass(alwaysRun=true) + public void setUp() { + // Manual addition of externalizers to replication what happens in fully functional tests + cm = TestCacheManagerFactory.createCacheManager(); + marshaller = TestingUtil.extractCacheMarshaller(cm.getCache()); + } + + @AfterClass(alwaysRun=true) + public void tearDown() { + if (cm != null) cm.stop(); + } + + protected byte[] getBigByteArray() { + String value = new String(randomByteArray(1000)); + ByteArrayOutputStream result = new ByteArrayOutputStream(1000); + try { + ObjectOutputStream oos = new ObjectOutputStream(result); + oos.writeObject(value); + return result.toByteArray(); + } catch (IOException e) { + throw new CacheException(e); + } + } + + private byte[] randomByteArray(int i) { + Random r = new Random(); + byte[] result = new byte[i]; + r.nextBytes(result); + return result; + } +} \ No newline at end of file diff --git a/server/core/src/test/java/org/infinispan/server/core/AbstractProtocolServerTest.java b/server/core/src/test/java/org/infinispan/server/core/AbstractProtocolServerTest.java new file mode 100644 index 000000000000..ef3aaa881f69 --- /dev/null +++ b/server/core/src/test/java/org/infinispan/server/core/AbstractProtocolServerTest.java @@ -0,0 +1,86 @@ +package org.infinispan.server.core; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelInboundHandler; +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelOutboundHandler; +import org.infinispan.manager.EmbeddedCacheManager; +import org.infinispan.server.core.configuration.MockServerConfigurationBuilder; +import org.infinispan.server.core.configuration.ProtocolServerConfiguration; +import org.infinispan.server.core.test.Stoppable; +import org.infinispan.test.AbstractInfinispanTest; +import org.infinispan.test.fwk.TestCacheManagerFactory; +import org.testng.annotations.Test; + +/** + * Abstract protocol server test. + * + * @author Galder Zamarreño + * @since 4.1 + */ +@Test(groups = "functional", testName = "server.core.AbstractProtocolServerTest") +public class AbstractProtocolServerTest extends AbstractInfinispanTest { + + public void testValidateNegativeWorkerThreads() { + MockServerConfigurationBuilder b = new MockServerConfigurationBuilder(); + b.workerThreads(-1); + expectIllegalArgument(b, new MockProtocolServer()); + } + + public void testValidateNegativeIdleTimeout() { + MockServerConfigurationBuilder b = new MockServerConfigurationBuilder(); + b.idleTimeout(-2); + expectIllegalArgument(b, new MockProtocolServer()); + } + + public void testValidateNegativeSendBufSize() { + MockServerConfigurationBuilder b = new MockServerConfigurationBuilder(); + b.sendBufSize(-1); + expectIllegalArgument(b, new MockProtocolServer()); + } + + public void testValidateNegativeRecvBufSize() { + MockServerConfigurationBuilder b = new MockServerConfigurationBuilder(); + b.recvBufSize(-1); + expectIllegalArgument(b, new MockProtocolServer()); + } + + private void expectIllegalArgument(MockServerConfigurationBuilder builder, MockProtocolServer server) { + try { +// Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager()) { cm => +// server.start(builder.build(), cm) +// } + } catch (IllegalArgumentException e) { +// case i: IllegalArgumentException => // expected + } finally { + server.stop(); + } + } + + class MockProtocolServer extends AbstractProtocolServer { + protected MockProtocolServer() { + super(null); + } + + @Override + public ChannelOutboundHandler getEncoder() { + return null; + } + + @Override + public ChannelInboundHandler getDecoder() { + return null; + } + + @Override + public ProtocolServerConfiguration getConfiguration() { + return configuration; + } + + @Override + public ChannelInitializer getInitializer() { + return null; + } + } + +} diff --git a/server/core/src/test/java/org/infinispan/server/core/MarshallingTest.java b/server/core/src/test/java/org/infinispan/server/core/MarshallingTest.java new file mode 100644 index 000000000000..9a83198efca6 --- /dev/null +++ b/server/core/src/test/java/org/infinispan/server/core/MarshallingTest.java @@ -0,0 +1,24 @@ +package org.infinispan.server.core; + +import org.testng.AssertJUnit; +import org.testng.annotations.Test; + +import java.io.IOException; +import java.util.Arrays; + + +/** + * Marshalling test for server core classes. + * + * @author Galder Zamarreño + * @since 4.1 + */ +@Test(groups = "functional", testName = "server.core.MarshallingTest") +public class MarshallingTest extends AbstractMarshallingTest { + public void testMarshallingBigByteArrayValue() throws IOException, InterruptedException, ClassNotFoundException { + byte[] cacheValue = getBigByteArray(); + byte[] bytes = marshaller.objectToByteBuffer(cacheValue); + byte[] readValue = (byte[]) marshaller.objectFromByteBuffer(bytes); + AssertJUnit.assertTrue(Arrays.equals(readValue, cacheValue)); + } +} \ No newline at end of file diff --git a/server/core/src/test/java/org/infinispan/server/core/VariableLengthTest.java b/server/core/src/test/java/org/infinispan/server/core/VariableLengthTest.java new file mode 100644 index 000000000000..155091ffd56e --- /dev/null +++ b/server/core/src/test/java/org/infinispan/server/core/VariableLengthTest.java @@ -0,0 +1,132 @@ +package org.infinispan.server.core; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.infinispan.commons.util.Util; +import org.testng.annotations.Test; + +import static org.infinispan.server.core.transport.ExtendedByteBuf.readUnsignedInt; +import static org.infinispan.server.core.transport.ExtendedByteBuf.readUnsignedLong; +import static org.infinispan.server.core.transport.ExtendedByteBuf.writeUnsignedInt; +import static org.infinispan.server.core.transport.ExtendedByteBuf.writeUnsignedLong; +import static org.testng.AssertJUnit.assertEquals; + +/** + * Variable length number test. + * + * @author Galder Zamarreño + * @since 4.1 + */ +@Test(groups = "functional", testName = "server.hotrod.VariableLengthTest") +public class VariableLengthTest { + + public void test2pow7minus1() { + writeReadInt(127, 1); + } + + public void test2pow7() { + writeReadInt(128, 2); + } + + public void test2pow14minus1() { + writeReadInt(16383, 2); + } + + public void test2pow14() { + writeReadInt(16384, 3); + } + + public void test2pow21minus1() { + writeReadInt(2097151, 3); + } + + public void test2pow21() { + writeReadInt(2097152, 4); + } + + public void test2pow28minus1() { + writeReadInt(268435455, 4); + } + + public void test2pow28() { + writeReadInt(268435456, 5); + } + + public void test2pow35minus1() { + writeReadLong(34359738367L, 5); + } + + public void test2pow35() { + writeReadLong(34359738368L, 6); + } + + public void test2pow42minus1() { + writeReadLong(4398046511103L, 6); + } + + public void test2pow42() { + writeReadLong(4398046511104L, 7); + } + + public void test2pow49minus1() { + writeReadLong(562949953421311L, 7); + } + + public void test2pow49() { + writeReadLong(562949953421312L, 8); + } + + public void test2pow56minus1() { + writeReadLong(72057594037927935L, 8); + } + + public void test2pow56() { + writeReadLong(72057594037927936L, 9); + } + + public void test2pow63minus1() { + writeReadLong(9223372036854775807L, 9); + } + + @Test(expectedExceptions = IllegalStateException.class) + public void testTooLongInt() { + ByteBuf buffer = Unpooled.directBuffer(1024); + assert(buffer.writerIndex() == 0); + writeUnsignedLong(9223372036854775807L, buffer); + readUnsignedInt(buffer); + buffer.release(); + } + + @Test(groups = "unstable") + public void testPrintHexadecimalVint() { + ByteBuf buffer = Unpooled.directBuffer(1024); + assert(buffer.writerIndex() == 0); + writeUnsignedLong(512, buffer); + System.out.println(Util.hexDump(buffer.nioBuffer())); + System.out.println(); + buffer.release(); + } + +// public void test2pow63() { +// writeReadLong(9223372036854775808L, 10) +// } + + private void writeReadInt(int num, int expected) { + ByteBuf buffer = Unpooled.directBuffer(1024); + assert(buffer.writerIndex() == 0); + writeUnsignedInt(num, buffer); + assertEquals(buffer.writerIndex(), expected); + assertEquals(readUnsignedInt(buffer), num); + buffer.release(); + } + + private void writeReadLong(long num, int expected) { + ByteBuf buffer = Unpooled.directBuffer(1024); + assert(buffer.writerIndex() == 0); + writeUnsignedLong(num, buffer); + assertEquals(buffer.writerIndex(), expected); + assertEquals(readUnsignedLong(buffer), num); + buffer.release(); + } + +} diff --git a/server/core/src/test/scala/org/infinispan/server/core/configuration/MockServerConfiguration.java b/server/core/src/test/java/org/infinispan/server/core/configuration/MockServerConfiguration.java similarity index 100% rename from server/core/src/test/scala/org/infinispan/server/core/configuration/MockServerConfiguration.java rename to server/core/src/test/java/org/infinispan/server/core/configuration/MockServerConfiguration.java diff --git a/server/core/src/test/scala/org/infinispan/server/core/configuration/MockServerConfigurationBuilder.java b/server/core/src/test/java/org/infinispan/server/core/configuration/MockServerConfigurationBuilder.java similarity index 100% rename from server/core/src/test/scala/org/infinispan/server/core/configuration/MockServerConfigurationBuilder.java rename to server/core/src/test/java/org/infinispan/server/core/configuration/MockServerConfigurationBuilder.java diff --git a/server/core/src/test/java/org/infinispan/server/core/test/ServerTestingUtil.java b/server/core/src/test/java/org/infinispan/server/core/test/ServerTestingUtil.java new file mode 100644 index 000000000000..db8fddf711f2 --- /dev/null +++ b/server/core/src/test/java/org/infinispan/server/core/test/ServerTestingUtil.java @@ -0,0 +1,22 @@ +package org.infinispan.server.core.test; + +import org.infinispan.commons.logging.LogFactory; +import org.infinispan.server.core.AbstractProtocolServer; + +/** + * Infinispan servers testing util + * + * @author Galder Zamarreño + * @author wburns + */ +public class ServerTestingUtil { + + public static void killServer(AbstractProtocolServer server) { + try { + if (server != null) server.stop(); + } catch (Throwable t) { + LogFactory.getLog(ServerTestingUtil.class).error("Error stopping server", t); + } + } + +} diff --git a/server/core/src/test/java/org/infinispan/server/core/test/Stoppable.java b/server/core/src/test/java/org/infinispan/server/core/test/Stoppable.java new file mode 100644 index 000000000000..354ec56916ef --- /dev/null +++ b/server/core/src/test/java/org/infinispan/server/core/test/Stoppable.java @@ -0,0 +1,31 @@ +package org.infinispan.server.core.test; + +import org.infinispan.manager.EmbeddedCacheManager; +import org.infinispan.server.core.AbstractProtocolServer; +import org.infinispan.test.TestingUtil; + +import java.util.function.Consumer; + +/** + * Stoppable implements simple wrappers for objects which need to be stopped in certain way after being used + * @author Galder Zamarreño + * @author wburns + */ +public class Stoppable { + public static void useCacheManager(T stoppable, Consumer consumer) { + try { + consumer.accept(stoppable); + } finally { + TestingUtil.killCacheManagers(stoppable); + } + } + + public static > void useServer(T stoppable, Consumer consumer) { + try { + consumer.accept(stoppable); + } finally { + ServerTestingUtil.killServer(stoppable); + } + } + +} diff --git a/server/core/src/test/scala/org/infinispan/server/core/AbstractMarshallingTest.scala b/server/core/src/test/scala/org/infinispan/server/core/AbstractMarshallingTest.scala deleted file mode 100644 index e912d8f37405..000000000000 --- a/server/core/src/test/scala/org/infinispan/server/core/AbstractMarshallingTest.scala +++ /dev/null @@ -1,50 +0,0 @@ -package org.infinispan.server.core - -import org.testng.annotations.{AfterClass, BeforeClass} -import java.util.Random -import java.io.{ByteArrayOutputStream, ObjectOutputStream} - -import org.infinispan.test.{AbstractInfinispanTest, TestingUtil} -import org.infinispan.commons.marshall.AbstractDelegatingMarshaller -import org.infinispan.manager.EmbeddedCacheManager -import org.infinispan.test.fwk.TestCacheManagerFactory - -/** - * Abstract class to help marshalling tests in different server modules. - * - * @author Galder Zamarreño - * @since 4.1 - */ -abstract class AbstractMarshallingTest extends AbstractInfinispanTest { - - var marshaller : AbstractDelegatingMarshaller = _ - var cm : EmbeddedCacheManager = _ - - @BeforeClass(alwaysRun=true) - def setUp() { - // Manual addition of externalizers to replication what happens in fully functional tests - cm = TestCacheManagerFactory.createCacheManager() - marshaller = TestingUtil.extractCacheMarshaller(cm.getCache()) - } - - @AfterClass(alwaysRun=true) - def tearDown() { - if (cm != null) cm.stop() - } - - protected def getBigByteArray: Array[Byte] = { - val value = new String(randomByteArray(1000)) - val result = new ByteArrayOutputStream(1000) - val oos = new ObjectOutputStream(result) - oos.writeObject(value) - result.toByteArray - } - - private def randomByteArray(i: Int): Array[Byte] = { - val r = new Random - val result = new Array[Byte](i) - r.nextBytes(result) - result - } - -} \ No newline at end of file diff --git a/server/core/src/test/scala/org/infinispan/server/core/AbstractProtocolServerTest.scala b/server/core/src/test/scala/org/infinispan/server/core/AbstractProtocolServerTest.scala deleted file mode 100644 index dbc7d00eb13e..000000000000 --- a/server/core/src/test/scala/org/infinispan/server/core/AbstractProtocolServerTest.scala +++ /dev/null @@ -1,82 +0,0 @@ -package org.infinispan.server.core - -import io.netty.channel.{ChannelInitializer, Channel} -import org.testng.annotations.Test -import org.infinispan.manager.EmbeddedCacheManager -import org.testng.Assert._ -import java.lang.reflect.Method - -import test.Stoppable -import org.infinispan.test.fwk.TestCacheManagerFactory -import org.infinispan.server.core.configuration.MockServerConfigurationBuilder -import org.infinispan.server.core.configuration.MockServerConfiguration -import org.infinispan.test.AbstractInfinispanTest - -/** - * Abstract protocol server test. - * - * @author Galder Zamarreño - * @since 4.1 - */ -@Test(groups = Array("functional"), testName = "server.core.AbstractProtocolServerTest") -class AbstractProtocolServerTest extends AbstractInfinispanTest { - - def testValidateNegativeWorkerThreads() { - val b = new MockServerConfigurationBuilder - b.workerThreads(-1); - expectIllegalArgument(b, createServer) - } - - def testValidateNegativeIdleTimeout() { - val b = new MockServerConfigurationBuilder - b.idleTimeout(-2); - expectIllegalArgument(b, createServer) - } - - def testValidateNegativeSendBufSize() { - val b = new MockServerConfigurationBuilder - b.sendBufSize(-1); - expectIllegalArgument(b, createServer) - } - - def testValidateNegativeRecvBufSize() { - val b = new MockServerConfigurationBuilder - b.recvBufSize(-1); - expectIllegalArgument(b, createServer) - } - - private def expectIllegalArgument(builder: MockServerConfigurationBuilder, server: MockProtocolServer) { - try { - Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager) { cm => - server.start(builder.build(), cm) - } - } catch { - case i: IllegalArgumentException => // expected - } finally { - server.stop - } - } - - private def createServer : MockProtocolServer = new MockProtocolServer - - class MockProtocolServer extends AbstractProtocolServer("Mock") { - type SuitableConfiguration = MockServerConfiguration - - var tcpNoDelay: Boolean = _ - - override def startInternal(configuration: MockServerConfiguration, cacheManager: EmbeddedCacheManager) { - super.startInternal(configuration, cacheManager) - } - - override def getInitializer(): ChannelInitializer[Channel] = null - - override def getEncoder = null - - override def getDecoder = null - - override def startTransport { - this.tcpNoDelay = configuration.tcpNoDelay - } - } - -} diff --git a/server/core/src/test/scala/org/infinispan/server/core/MarshallingTest.scala b/server/core/src/test/scala/org/infinispan/server/core/MarshallingTest.scala deleted file mode 100644 index 5456ae3bd457..000000000000 --- a/server/core/src/test/scala/org/infinispan/server/core/MarshallingTest.scala +++ /dev/null @@ -1,23 +0,0 @@ -package org.infinispan.server.core - -import org.testng.annotations.Test -import org.testng.AssertJUnit._ -import java.util - -/** - * Marshalling test for server core classes. - * - * @author Galder Zamarreño - * @since 4.1 - */ -@Test(groups = Array("functional"), testName = "server.core.MarshallingTest") -class MarshallingTest extends AbstractMarshallingTest { - - def testMarshallingBigByteArrayValue { - val cacheValue = getBigByteArray - val bytes = marshaller.objectToByteBuffer(cacheValue) - val readValue = marshaller.objectFromByteBuffer(bytes).asInstanceOf[Array[Byte]] - assertTrue(util.Arrays.equals(readValue, cacheValue)) - } - -} \ No newline at end of file diff --git a/server/core/src/test/scala/org/infinispan/server/core/VariableLengthTest.scala b/server/core/src/test/scala/org/infinispan/server/core/VariableLengthTest.scala deleted file mode 100644 index 58a0fe563890..000000000000 --- a/server/core/src/test/scala/org/infinispan/server/core/VariableLengthTest.scala +++ /dev/null @@ -1,127 +0,0 @@ -package org.infinispan.server.core - -import org.testng.annotations.Test -import org.testng.Assert._ -import transport.ExtendedByteBuf._ -import org.infinispan.commons.util.Util -import io.netty.buffer.Unpooled - -/** - * Variable length number test. - * - * @author Galder Zamarreño - * @since 4.1 - */ -@Test(groups = Array("functional"), testName = "server.hotrod.VariableLengthTest") -class VariableLengthTest { - - def test2pow7minus1 { - writeReadInt(127, 1) - } - - def test2pow7 { - writeReadInt(128, 2) - } - - def test2pow14minus1 { - writeReadInt(16383, 2) - } - - def test2pow14 { - writeReadInt(16384, 3) - } - - def test2pow21minus1 { - writeReadInt(2097151, 3) - } - - def test2pow21 { - writeReadInt(2097152, 4) - } - - def test2pow28minus1 { - writeReadInt(268435455, 4) - } - - def test2pow28 { - writeReadInt(268435456, 5) - } - - def test2pow35minus1 { - writeReadLong(34359738367L, 5) - } - - def test2pow35 { - writeReadLong(34359738368L, 6) - } - - def test2pow42minus1 { - writeReadLong(4398046511103L, 6) - } - - def test2pow42 { - writeReadLong(4398046511104L, 7) - } - - def test2pow49minus1 { - writeReadLong(562949953421311L, 7) - } - - def test2pow49 { - writeReadLong(562949953421312L, 8) - } - - def test2pow56minus1 { - writeReadLong(72057594037927935L, 8) - } - - def test2pow56 { - writeReadLong(72057594037927936L, 9) - } - - def test2pow63minus1 { - writeReadLong(9223372036854775807L, 9) - } - - @Test(expectedExceptions = Array(classOf[IllegalStateException])) - def testTooLongInt { - val buffer = Unpooled.directBuffer(1024) - assert(buffer.writerIndex == 0) - writeUnsignedLong(9223372036854775807L, buffer) - readUnsignedInt(buffer) - buffer.release() - } - - @Test(groups = Array("unstable")) - def testPrintHexadecimalVint { - val buffer = Unpooled.directBuffer(1024) - assert(buffer.writerIndex == 0) - writeUnsignedLong(512, buffer) - println(Util.hexDump(buffer.nioBuffer())) - println - buffer.release() - } - -// def test2pow63() { -// writeReadLong(9223372036854775808L, 10) -// } - - private def writeReadInt(num: Int, expected: Int) { - val buffer = Unpooled.directBuffer(1024) - assert(buffer.writerIndex == 0) - writeUnsignedInt(num, buffer) - assertEquals(buffer.writerIndex, expected) - assertEquals(readUnsignedInt(buffer), num) - buffer.release() - } - - private def writeReadLong(num: Long, expected: Int) { - val buffer = Unpooled.directBuffer(1024) - assert(buffer.writerIndex == 0) - writeUnsignedLong(num, buffer) - assertEquals(buffer.writerIndex, expected) - assertEquals(readUnsignedLong(buffer), num) - buffer.release() - } - -} diff --git a/server/core/src/test/scala/org/infinispan/server/core/test/ServerTestingUtil.scala b/server/core/src/test/scala/org/infinispan/server/core/test/ServerTestingUtil.scala deleted file mode 100644 index aa272c95d44f..000000000000 --- a/server/core/src/test/scala/org/infinispan/server/core/test/ServerTestingUtil.scala +++ /dev/null @@ -1,22 +0,0 @@ -package org.infinispan.server.core.test - -import org.infinispan.server.core.logging.Log -import org.infinispan.server.core.AbstractProtocolServer - -/** - * Infinispan servers testing util - * - * @author Galder Zamarreño - * @since // TODO - */ -object ServerTestingUtil extends Log { - - def killServer(server: AbstractProtocolServer) { - try { - if (server != null) server.stop - } catch { - case t: Throwable => error("Error stopping server", t) - } - } - -} diff --git a/server/core/src/test/scala/org/infinispan/server/core/test/Stoppable.scala b/server/core/src/test/scala/org/infinispan/server/core/test/Stoppable.scala deleted file mode 100644 index 0bfcd26757d4..000000000000 --- a/server/core/src/test/scala/org/infinispan/server/core/test/Stoppable.scala +++ /dev/null @@ -1,35 +0,0 @@ -package org.infinispan.server.core.test - -import org.infinispan.manager.EmbeddedCacheManager -import org.infinispan.test.TestingUtil -import org.infinispan.server.core.AbstractProtocolServer - -/** - * Stoppable implements simple wrappers for objects which need to be stopped in certain way after being used - * @author Galder Zamarreño - */ -class Stoppable { - // Empty - do not delete! -} - -object Stoppable { - - def useCacheManager[T <: EmbeddedCacheManager](stoppable: T) - (block: T => Unit) { - try { - block(stoppable) - } finally { - TestingUtil.killCacheManagers(stoppable) - } - } - - def useServer[T <: AbstractProtocolServer](stoppable: T) - (block: T => Unit) { - try { - block(stoppable) - } finally { - ServerTestingUtil.killServer(stoppable) - } - } - -} diff --git a/server/hotrod/src/main/java/org/infinispan/server/hotrod/AuthenticationHandler.java b/server/hotrod/src/main/java/org/infinispan/server/hotrod/AuthenticationHandler.java index ff4115c84ba6..539c92da309e 100644 --- a/server/hotrod/src/main/java/org/infinispan/server/hotrod/AuthenticationHandler.java +++ b/server/hotrod/src/main/java/org/infinispan/server/hotrod/AuthenticationHandler.java @@ -54,8 +54,8 @@ public class AuthenticationHandler extends ChannelInboundHandlerAdapter { public AuthenticationHandler(HotRodServer server) { this.server = server; - serverConfig = (HotRodServerConfiguration) server.configuration(); - authenticationConfig = ((HotRodServerConfiguration) server.getConfiguration()).authentication(); + serverConfig = server.getConfiguration(); + authenticationConfig = server.getConfiguration().authentication(); requireAuthentication = authenticationConfig.mechProperties().containsKey(Sasl.POLICY_NOANONYMOUS) && authenticationConfig.mechProperties().get(Sasl.POLICY_NOANONYMOUS).equals("true"); } diff --git a/server/hotrod/src/main/java/org/infinispan/server/hotrod/CacheDecodeContextLog.java b/server/hotrod/src/main/java/org/infinispan/server/hotrod/CacheDecodeContextLog.java index 65546b7c4e60..a3f7d9668041 100644 --- a/server/hotrod/src/main/java/org/infinispan/server/hotrod/CacheDecodeContextLog.java +++ b/server/hotrod/src/main/java/org/infinispan/server/hotrod/CacheDecodeContextLog.java @@ -1,6 +1,6 @@ package org.infinispan.server.hotrod; -import org.infinispan.server.core.logging.JavaLog; +import org.infinispan.server.core.logging.Log; import org.infinispan.util.logging.LogFactory; /** @@ -8,5 +8,5 @@ * @since 9.0 */ public class CacheDecodeContextLog { - static final JavaLog log = LogFactory.getLog(CacheDecodeContext.class, JavaLog.class); + static final Log log = LogFactory.getLog(CacheDecodeContext.class, Log.class); } diff --git a/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodDecoder.java b/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodDecoder.java index 771ed7961813..7826b5f635c8 100644 --- a/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodDecoder.java +++ b/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodDecoder.java @@ -5,7 +5,7 @@ import io.netty.handler.codec.ByteToMessageDecoder; import org.infinispan.commons.logging.LogFactory; import org.infinispan.manager.EmbeddedCacheManager; -import org.infinispan.server.core.logging.JavaLog; +import org.infinispan.server.core.logging.Log; import org.infinispan.server.core.transport.ExtendedByteBufJava; import org.infinispan.server.core.transport.NettyTransport; @@ -20,7 +20,7 @@ * @since 9.0 */ public class HotRodDecoder extends ByteToMessageDecoder { - private final static JavaLog log = LogFactory.getLog(HotRodDecoder.class, JavaLog.class); + private final static Log log = LogFactory.getLog(HotRodDecoder.class, Log.class); private final EmbeddedCacheManager cacheManager; private final NettyTransport transport; diff --git a/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodExceptionHandler.java b/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodExceptionHandler.java index 17fe9e820f95..4923aca70d0f 100644 --- a/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodExceptionHandler.java +++ b/server/hotrod/src/main/java/org/infinispan/server/hotrod/HotRodExceptionHandler.java @@ -5,7 +5,7 @@ import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.handler.codec.DecoderException; import org.infinispan.commons.logging.LogFactory; -import org.infinispan.server.core.logging.JavaLog; +import org.infinispan.server.core.logging.Log; /** * Handler that will transform various exceptions into responses to send back to the client. @@ -14,7 +14,7 @@ * @since 9.0 */ public class HotRodExceptionHandler extends ChannelInboundHandlerAdapter { - private final static JavaLog log = LogFactory.getLog(HotRodExceptionHandler.class, JavaLog.class); + private final static Log log = LogFactory.getLog(HotRodExceptionHandler.class, Log.class); @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable t) throws Exception { diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractEncoder1x.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractEncoder1x.scala index 6d96071d1de0..382b7db9a047 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractEncoder1x.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractEncoder1x.scala @@ -1,6 +1,5 @@ package org.infinispan.server.hotrod -import logging.Log import org.infinispan.distribution.ch.KeyPartitioner import org.infinispan.distribution.ch.impl.HashFunctionPartitioner import org.infinispan.distribution.group.PartitionerConsistentHash @@ -8,13 +7,16 @@ import org.infinispan.distribution.group.impl.GroupingPartitioner import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.remoting.transport.Address import org.infinispan.server.core.transport.ExtendedByteBuf._ + import collection.JavaConversions._ import OperationStatus._ import org.infinispan.configuration.cache.Configuration + import collection.mutable.ArrayBuffer -import org.infinispan.server.hotrod.util.BulkUtil import io.netty.buffer.ByteBuf +import org.infinispan.commons.logging.LogFactory import org.infinispan.server.hotrod.Events.Event +import org.infinispan.server.hotrod.logging.JavaLog /** * Hot Rod encoder for protocol version 1.1 @@ -22,10 +24,12 @@ import org.infinispan.server.hotrod.Events.Event * @author Galder Zamarreño * @since 5.1 */ -abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants with Log { +abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants { import HotRodServer._ + val log = LogFactory.getLog(getClass, classOf[JavaLog]) + override def writeEvent(e: Event, buf: ByteBuf) { // Not implemented in this version of the protocol } @@ -95,7 +99,7 @@ abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants if (g.status == Success) { var iterator = asScalaIterator(g.entries.iterator) if (g.count != 0) { - trace("About to write (max) %d messages to the client", g.count) + log.tracef("About to write (max) %d messages to the client", g.count) iterator = iterator.take(g.count) } for (entry <- iterator) { @@ -202,10 +206,10 @@ abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants val topologyMap = h.serverEndpointsMap if (topologyMap.isEmpty) { - logNoMembersInHashTopology(ch, topologyMap.toString()) + log.noMembersInHashTopology(ch, topologyMap.toString()) buffer.writeByte(0) // Topology not changed } else { - trace("Write hash distribution change response header %s", h) + log.tracef("Write hash distribution change response header %s", h) // This is not quite correct, as the ownership of segments on the 1.0/1.1/1.2 clients is not exactly // the same as on the server. But the difference appears only for (numSegment*numOwners/MAX_INT) // of the keys (at the "segment borders"), so it's still much better than having no hash information. @@ -247,10 +251,10 @@ abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants } def writeLimitedHashTopologyUpdate(t: AbstractTopologyResponse, buffer: ByteBuf) { - trace("Return limited hash distribution aware header because the client %s doesn't ", t) + log.tracef("Return limited hash distribution aware header because the client %s doesn't ", t) val topologyMap = t.serverEndpointsMap if (topologyMap.isEmpty) { - logNoMembersInTopology() + log.noMembersInTopology() buffer.writeByte(0) // Topology not changed } else { writeCommonHashTopologyHeader(buffer, t.topologyId, 0, 0, 0, topologyMap.size) @@ -265,10 +269,10 @@ abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants def writeTopologyUpdate(t: TopologyAwareResponse, buffer: ByteBuf) { val topologyMap = t.serverEndpointsMap if (topologyMap.isEmpty) { - logNoMembersInTopology() + log.noMembersInTopology() buffer.writeByte(0) // Topology not changed } else { - trace("Write topology change response header %s", t) + log.tracef("Write topology change response header %s", t) buffer.writeByte(1) // Topology changed writeUnsignedInt(t.topologyId, buffer) writeUnsignedInt(topologyMap.size, buffer) @@ -281,7 +285,7 @@ abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants def writeNoTopologyUpdate(buffer: ByteBuf) { - trace("Write topology response header with no change") + log.trace("Write topology response header with no change") buffer.writeByte(0) } @@ -293,7 +297,7 @@ abstract class AbstractEncoder1x extends AbstractVersionedEncoder with Constants buffer.writeByte(hashFct) // Hash function writeUnsignedInt(hashSpace, buffer) // Hash space writeUnsignedInt(numServers, buffer) - trace("Topology will contain %d addresses", numServers) + log.tracef("Topology will contain %d addresses", numServers) } } diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractTopologyAwareEncoder1x.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractTopologyAwareEncoder1x.scala index 33bec32d0268..f84c39ba4262 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractTopologyAwareEncoder1x.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/AbstractTopologyAwareEncoder1x.scala @@ -1,6 +1,5 @@ package org.infinispan.server.hotrod -import logging.Log import org.infinispan.commons.hash.Hash import org.infinispan.distribution.ch.impl.HashFunctionPartitioner import org.infinispan.distribution.group.PartitionerConsistentHash @@ -18,7 +17,7 @@ import io.netty.buffer.ByteBuf * @author Galder Zamarreño * @since 5.2 */ -abstract class AbstractTopologyAwareEncoder1x extends AbstractEncoder1x with Constants with Log { +abstract class AbstractTopologyAwareEncoder1x extends AbstractEncoder1x with Constants { override protected def createHashDistAwareResp(lastViewId: Int, serverEndpointsMap: Map[Address, ServerAddress], @@ -41,7 +40,7 @@ abstract class AbstractTopologyAwareEncoder1x extends AbstractEncoder1x with Con def writeHashTopologyUpdate11(h: HashDistAware11Response, server: HotRodServer, r: Response, buf: ByteBuf) { - trace("Write hash distribution change response header %s", h) + log.tracef("Write hash distribution change response header %s", h) if (h.hashFunction == 0) { writeLimitedHashTopologyUpdate(h, buf) return @@ -93,7 +92,7 @@ abstract class AbstractTopologyAwareEncoder1x extends AbstractEncoder1x with Con override def writeLimitedHashTopologyUpdate(t: AbstractTopologyResponse, buf: ByteBuf) { - trace("Return limited hash distribution aware header in spite of having a hash aware client %s", t) + log.tracef("Return limited hash distribution aware header in spite of having a hash aware client %s", t) writeCommonHashTopologyHeader(buf, t.topologyId, 0, 0, 0, t.serverEndpointsMap.size) writeUnsignedInt(1, buf) // Num virtual nodes for (address <- t.serverEndpointsMap.values) { diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CacheDecodeContext.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CacheDecodeContext.scala index 06a53cfc59d4..377d5b626d2a 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CacheDecodeContext.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CacheDecodeContext.scala @@ -19,7 +19,7 @@ import org.infinispan.server.hotrod.OperationStatus._ * Invokes operations against the cache based on the state kept during decoding process * */ -class CacheDecodeContext(server: HotRodServer) extends ServerConstants { +class CacheDecodeContext(server: HotRodServer) { type BytesResponse = Bytes => Response @@ -117,11 +117,11 @@ class CacheDecodeContext(server: HotRodServer) extends ServerConstants { val metadata = new EmbeddedMetadata.Builder metadata.version(generateVersion(server.getCacheRegistry(header.cacheName), cache)) (params.lifespan, params.maxIdle) match { - case (ExpirationParam(EXPIRATION_DEFAULT,_), ExpirationParam(EXPIRATION_DEFAULT,_)) => + case (ExpirationParam(ServerConstants.EXPIRATION_DEFAULT,_), ExpirationParam(ServerConstants.EXPIRATION_DEFAULT,_)) => // Do nothing - default is merged in via embedded - case (_, ExpirationParam(EXPIRATION_DEFAULT,_)) => + case (_, ExpirationParam(ServerConstants.EXPIRATION_DEFAULT,_)) => metadata.lifespan(decoder.toMillis(params.lifespan, header)) - case (ExpirationParam(EXPIRATION_DEFAULT, _), _) => + case (ExpirationParam(ServerConstants.EXPIRATION_DEFAULT, _), _) => metadata.maxIdle(decoder.toMillis(params.maxIdle, header)) case (_, _) => metadata.lifespan(decoder.toMillis(params.lifespan, header)) diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/ClientListenerRegistry.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/ClientListenerRegistry.scala index 2bb1da34d187..c87d4dcef6e3 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/ClientListenerRegistry.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/ClientListenerRegistry.scala @@ -7,6 +7,7 @@ import java.util.concurrent.atomic.AtomicLong import io.netty.channel.Channel import org.infinispan.commons.equivalence.{AnyEquivalence, ByteArrayEquivalence} +import org.infinispan.commons.logging.LogFactory import org.infinispan.commons.marshall.jboss.GenericJBossMarshaller import org.infinispan.commons.marshall.{AbstractExternalizer, Marshaller} import org.infinispan.commons.util.CollectionFactory @@ -15,24 +16,25 @@ import org.infinispan.container.versioning.NumericVersion import org.infinispan.factories.threads.DefaultThreadFactory import org.infinispan.metadata.Metadata import org.infinispan.notifications._ -import org.infinispan.notifications.cachelistener.annotation.{CacheEntryExpired, CacheEntryCreated, CacheEntryModified, CacheEntryRemoved} +import org.infinispan.notifications.cachelistener.annotation.{CacheEntryCreated, CacheEntryExpired, CacheEntryModified, CacheEntryRemoved} import org.infinispan.notifications.cachelistener.event._ import org.infinispan.notifications.cachelistener.filter._ import org.infinispan.notifications.cachelistener.event.Event.Type -import org.infinispan.server.hotrod.Events.{CustomRawEvent, CustomEvent, KeyEvent, KeyWithVersionEvent} +import org.infinispan.server.hotrod.Events.{CustomEvent, CustomRawEvent, KeyEvent, KeyWithVersionEvent} import org.infinispan.server.hotrod.OperationResponse._ import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration -import org.infinispan.server.hotrod.logging.Log +import org.infinispan.server.hotrod.logging.JavaLog import scala.collection.JavaConversions._ /** * @author Galder Zamarreño */ -class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends Log { +class ClientListenerRegistry(configuration: HotRodServerConfiguration) { import ClientListenerRegistry._ - val isTrace = isTraceEnabled + val log = LogFactory.getLog(getClass, classOf[JavaLog]) + val isTrace = log.isTraceEnabled private val messageId = new AtomicLong() private val eventSenders = new EquivalentConcurrentHashMapV8[Bytes, AnyRef]( @@ -54,7 +56,7 @@ class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends L def addCacheEventFilterFactory(name: String, factory: CacheEventFilterFactory): Unit = { factory match { - case x: CacheEventConverterFactory => throw illegalFilterConverterEventFactory(name) + case x: CacheEventConverterFactory => throw log.illegalFilterConverterEventFactory(name) case _ => cacheEventFilterFactories.put(name, factory) } } @@ -65,7 +67,7 @@ class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends L def addCacheEventConverterFactory(name: String, factory: CacheEventConverterFactory): Unit = { factory match { - case x: CacheEventFilterFactory => throw illegalFilterConverterEventFactory(name) + case x: CacheEventFilterFactory => throw log.illegalFilterConverterEventFactory(name) case _ => cacheEventConverterFactories.put(name, factory) } } @@ -155,7 +157,7 @@ class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends L def findFactory[T](name: String, compatEnabled: Boolean, factories: ConcurrentMap[String, T], factoryType: String, useRawData: Boolean): (T, Marshaller) = { val factory = Option(factories.get(name)) - .getOrElse(throw missingCacheEventFactory(factoryType, name)) + .getOrElse(throw log.missingCacheEventFactory(factoryType, name)) val m = marshaller.getOrElse(new GenericJBossMarshaller(factory.getClass.getClassLoader)) if (useRawData || compatEnabled) @@ -222,7 +224,7 @@ class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends L var written = false while(!eventQueue.isEmpty && ch.isWritable) { val event = eventQueue.poll() - if (isTrace) tracef("Write event: %s to channel %s", event, ch) + if (isTrace) log.tracef("Write event: %s to channel %s", Array(event, ch).map(_.asInstanceOf[AnyRef]) : _*) ch.write(event) written = true } @@ -263,7 +265,7 @@ class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends L case Type.CACHE_ENTRY_EXPIRED => true; case _ => - throw unexpectedEvent(event) + throw log.unexpectedEvent(event) } } } @@ -299,7 +301,7 @@ class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends L val (op, isRetried) = getEventResponseType(event) KeyEvent(version, messageId.get(), op, listenerId, isRetried, key) case _ => - throw unexpectedEvent(event) + throw log.unexpectedEvent(event) } case CustomPlain => val (op, isRetried) = getEventResponseType(event) @@ -320,7 +322,7 @@ class ClientListenerRegistry(configuration: HotRodServerConfiguration) extends L (CacheEntryRemovedEventResponse, event.asInstanceOf[CacheEntryRemovedEvent[_, _]].isCommandRetried) case Type.CACHE_ENTRY_EXPIRED => (CacheEntryExpiredEventResponse, false) - case _ => throw unexpectedEvent(event) + case _ => throw log.unexpectedEvent(event) } } diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CrashedMemberDetectorListener.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CrashedMemberDetectorListener.scala index 098fc86b4cf1..fb30c49d92ea 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CrashedMemberDetectorListener.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/CrashedMemberDetectorListener.scala @@ -1,11 +1,13 @@ package org.infinispan.server.hotrod -import logging.Log +import org.infinispan.commons.logging.LogFactory import org.infinispan.notifications.Listener import org.infinispan.notifications.cachemanagerlistener.annotation.ViewChanged import org.infinispan.notifications.cachemanagerlistener.event.ViewChangedEvent + import scala.collection.JavaConversions._ import org.infinispan.context.Flag +import org.infinispan.server.hotrod.logging.JavaLog /** * Listener that detects crashed or stopped members and removes them from @@ -15,11 +17,12 @@ import org.infinispan.context.Flag * @since 5.1 */ @Listener(sync = false) // Use a separate thread to avoid blocking the view handler thread -class CrashedMemberDetectorListener(cache: AddressCache, server: HotRodServer) extends Log { +class CrashedMemberDetectorListener(cache: AddressCache, server: HotRodServer) { // Let all nodes remove the address from their own cache locally. // This will exclude the address from their topology updates. val addressCache = cache.getAdvancedCache.withFlags(Flag.CACHE_MODE_LOCAL) + val log = LogFactory.getLog(getClass, classOf[JavaLog]) @ViewChanged def handleViewChange(e: ViewChangedEvent) { @@ -31,11 +34,11 @@ class CrashedMemberDetectorListener(cache: AddressCache, server: HotRodServer) e val newMembers = collectionAsScalaIterable(e.getNewMembers) val oldMembers = collectionAsScalaIterable(e.getOldMembers) val goneMembers = oldMembers.filterNot(newMembers contains _) - trace("View change received: %s, removing members %s", e, goneMembers) + log.tracef("View change received: %s, removing members %s", Array(e, goneMembers).map(_.asInstanceOf[AnyRef]) : _*) // Consider doing removeAsync and then waiting for all removals... goneMembers.foreach(a => if (addressCache.getStatus.allowInvocations()) addressCache.remove(a)) } catch { - case t: Throwable => logErrorDetectingCrashedMember(t) + case t: Throwable => log.errorDetectingCrashedMember(t) } } diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder10.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder10.scala index ec21704d94ae..8cbbd8468247 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder10.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder10.scala @@ -1,19 +1,22 @@ package org.infinispan.server.hotrod -import logging.Log import org.infinispan.configuration.cache.Configuration import OperationStatus._ import org.infinispan.server.core._ + import collection.mutable import collection.immutable import org.infinispan.util.concurrent.TimeoutException import java.io.IOException + import org.infinispan.context.Flag._ -import org.infinispan.server.core.transport.ExtendedByteBuf._ +import org.infinispan.server.hotrod.transport.ExtendedByteBuf._ import org.infinispan.server.core.transport.NettyTransport import org.infinispan.container.entries.CacheEntry import org.infinispan.container.versioning.NumericVersion import io.netty.buffer.ByteBuf +import org.infinispan.commons.logging.LogFactory +import org.infinispan.server.hotrod.logging.JavaLog import scala.annotation.switch @@ -23,11 +26,12 @@ import scala.annotation.switch * @author Galder Zamarreño * @since 4.1 */ -object Decoder10 extends AbstractVersionedDecoder with ServerConstants with Log { +object Decoder10 extends AbstractVersionedDecoder { import OperationResponse._ import ProtocolFlag._ type SuitableHeader = HotRodHeader - private val isTrace = isTraceEnabled + val log = LogFactory.getLog(getClass, classOf[JavaLog]) + private val isTrace = log.isTraceEnabled override def readHeader(buffer: ByteBuf, version: Byte, messageId: Long, header: HotRodHeader): Boolean = { if (header.op == null) { @@ -55,7 +59,7 @@ object Decoder10 extends AbstractVersionedDecoder with ServerConstants with Log case _ => throw new HotRodUnknownOperationException( "Unknown operation: " + streamOp, version, messageId) } - if (isTrace) trace("Operation code: %d has been matched to %s", streamOp, header.op) + if (isTrace) log.tracef("Operation code: %d has been matched to %s", Array(streamOp, header.op).map(_.asInstanceOf[AnyRef]) : _*) header.cacheName = cacheName // Mark that we read up to here @@ -118,9 +122,9 @@ object Decoder10 extends AbstractVersionedDecoder with ServerConstants with Log readMaybeVInt(buffer).map(stream => { if (stream <= 0) { if (useDefault) - EXPIRATION_DEFAULT + ServerConstants.EXPIRATION_DEFAULT else - EXPIRATION_NONE + ServerConstants.EXPIRATION_NONE } else stream }) } diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder2x.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder2x.scala index c6b45823b9e5..755912401e50 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder2x.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Decoder2x.scala @@ -2,28 +2,26 @@ package org.infinispan.server.hotrod import java.io.IOException import java.security.PrivilegedActionException -import java.util.{BitSet => JavaBitSet, Optional, HashMap, HashSet, Map} import io.netty.buffer.ByteBuf import org.infinispan.IllegalLifecycleStateException import org.infinispan.commons.CacheException -import org.infinispan.commons.util.ByRef +import org.infinispan.commons.logging.LogFactory import org.infinispan.configuration.cache.Configuration import org.infinispan.container.entries.CacheEntry import org.infinispan.container.versioning.NumericVersion import org.infinispan.context.Flag.{IGNORE_RETURN_VALUES, SKIP_CACHE_LOAD, SKIP_INDEXING} import org.infinispan.remoting.transport.jgroups.SuspectException -import org.infinispan.server.core._ -import org.infinispan.server.core.transport.ExtendedByteBuf._ import org.infinispan.server.core.transport.NettyTransport import org.infinispan.server.hotrod.OperationStatus._ -import org.infinispan.server.hotrod.logging.Log +import org.infinispan.server.hotrod.logging.JavaLog +import org.infinispan.server.hotrod.transport.ExtendedByteBuf._ import org.infinispan.stats.ClusterCacheStats import org.infinispan.util.concurrent.TimeoutException -import scala.annotation.{switch, tailrec} -import scala.collection.{immutable, mutable} +import scala.annotation.tailrec import scala.collection.mutable.ListBuffer +import scala.collection.{immutable, mutable} /** * HotRod protocol decoder specific for specification version 2.0. @@ -31,13 +29,15 @@ import scala.collection.mutable.ListBuffer * @author Galder Zamarreño * @since 7.0 */ -object Decoder2x extends AbstractVersionedDecoder with Log with Constants { +object Decoder2x extends AbstractVersionedDecoder with Constants { import OperationResponse._ import ProtocolFlag._ type SuitableHeader = HotRodHeader + val log = LogFactory.getLog(getClass, classOf[JavaLog]) + override def readHeader(buffer: ByteBuf, version: Byte, messageId: Long, header: HotRodHeader): Boolean = Decoder2xJava.readHeader(buffer, version, messageId, header) @@ -441,7 +441,7 @@ object Decoder2x extends AbstractVersionedDecoder with Log with Constants { var optCache = c h.op match { case op if h.op.isConditional && isClustered && !isTransactional => - warnConditionalOperationNonTransactional(h.op.toString) + log.warnConditionalOperationNonTransactional(h.op.toString) case _ => // no-op } @@ -468,7 +468,7 @@ object Decoder2x extends AbstractVersionedDecoder with Log with Constants { } else { h.op match { case op if h.op.canReturnPreviousValue && !isTransactional => - warnForceReturnPreviousNonTransactional(h.op.toString) + log.warnForceReturnPreviousNonTransactional(h.op.toString) case _ => // no-op } } diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoder2x.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoder2x.scala index 702812fc23cd..e5b4bff412d0 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoder2x.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoder2x.scala @@ -1,6 +1,7 @@ package org.infinispan.server.hotrod import io.netty.buffer.ByteBuf +import org.infinispan.commons.logging.LogFactory import org.infinispan.configuration.cache.CacheMode import org.infinispan.container.entries.CacheEntry import org.infinispan.container.versioning.NumericVersion @@ -8,7 +9,7 @@ import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.server.core.transport.ExtendedByteBuf._ import org.infinispan.server.hotrod.Events._ import org.infinispan.server.hotrod.OperationStatus._ -import org.infinispan.server.hotrod.logging.Log +import org.infinispan.server.hotrod.logging.JavaLog import org.infinispan.topology.CacheTopology import scala.collection.JavaConversions._ @@ -16,8 +17,9 @@ import scala.collection.JavaConversions._ /** * @author Galder Zamarreño */ -object Encoder2x extends AbstractVersionedEncoder with Constants with Log { - val isTrace = isTraceEnabled +object Encoder2x extends AbstractVersionedEncoder with Constants { + val log = LogFactory.getLog(getClass, classOf[JavaLog]) + val isTrace = log.isTraceEnabled override def writeEvent(e: Event, buf: ByteBuf) { if (isTrace) @@ -77,7 +79,7 @@ object Encoder2x extends AbstractVersionedEncoder with Constants with Log { writeHashTopologyUpdate(h, cacheTopology, buf) } case None => - if (isTrace) trace("Write topology response header with no change") + if (isTrace) log.trace("Write topology response header with no change") buf.writeByte(0) } } @@ -97,10 +99,10 @@ object Encoder2x extends AbstractVersionedEncoder with Constants with Log { private def writeTopologyUpdate(t: TopologyAwareResponse, buffer: ByteBuf) { val topologyMap = t.serverEndpointsMap if (topologyMap.isEmpty) { - logNoMembersInTopology() + log.noMembersInTopology() buffer.writeByte(0) // Topology not changed } else { - if (isTrace) trace("Write topology change response header %s", t) + if (isTrace) log.tracef("Write topology change response header %s", t) buffer.writeByte(1) // Topology changed writeUnsignedInt(t.topologyId, buffer) writeUnsignedInt(topologyMap.size, buffer) @@ -112,7 +114,7 @@ object Encoder2x extends AbstractVersionedEncoder with Constants with Log { } private def writeEmptyHashInfo(t: AbstractTopologyResponse, buffer: ByteBuf) { - if (isTrace) trace("Return limited hash distribution aware header because the client %s doesn't ", t) + if (isTrace) log.tracef("Return limited hash distribution aware header because the client %s doesn't ", t) buffer.writeByte(0) // Hash Function Version writeUnsignedInt(t.numSegments, buffer) } @@ -125,15 +127,15 @@ object Encoder2x extends AbstractVersionedEncoder with Constants with Log { } if (isTrace) { - trace(s"Topology cache contains: ${h.serverEndpointsMap}") - trace(s"After read consistent hash filter, members are: $members") + log.trace(s"Topology cache contains: ${h.serverEndpointsMap}") + log.trace(s"After read consistent hash filter, members are: $members") } if (members.isEmpty) { - logNoMembersInHashTopology(ch, h.serverEndpointsMap.toString()) + log.noMembersInHashTopology(ch, h.serverEndpointsMap.toString()) buf.writeByte(0) // Topology not changed } else { - if (isTrace) trace("Write hash distribution change response header %s", h) + if (isTrace) log.tracef("Write hash distribution change response header %s", h) buf.writeByte(1) // Topology changed writeUnsignedInt(h.topologyId, buf) // Topology ID @@ -212,23 +214,23 @@ object Encoder2x extends AbstractVersionedEncoder with Constants with Log { val serverEndpoints = addressCache.toMap var topologyId = currentTopologyId - val isTrace = isTraceEnabled + val isTrace = log.isTraceEnabled if (isTrace) { - tracef("Check for partial topologies: members=%s, endpoints=%s, client-topology=%s, server-topology=%s", - cacheMembers, serverEndpoints, r.topologyId, topologyId) + log.tracef("Check for partial topologies: members=%s, endpoints=%s, client-topology=%s, server-topology=%s", + Array(cacheMembers, serverEndpoints, r.topologyId, topologyId).map(_.asInstanceOf[AnyRef]) : _*) } if (!serverEndpoints.keySet.containsAll(cacheMembers)) { // At least one cache member is missing from the topology cache val clientTopologyId = r.topologyId if (currentTopologyId - clientTopologyId < 2) { - if (isTrace) trace("Postpone topology update") + if (isTrace) log.trace("Postpone topology update") return None // Postpone topology update } else { // Send partial topology update topologyId -= 1 - if (isTrace) trace("Send partial topology update with topology id %s", topologyId) + if (isTrace) log.tracef("Send partial topology update with topology id %s", topologyId) } } @@ -282,7 +284,7 @@ object Encoder2x extends AbstractVersionedEncoder with Constants with Log { if (g.status == Success) { var iterator = asScalaIterator(g.entries.iterator) if (g.count != 0) { - if (isTrace) trace("About to write (max) %d messages to the client", g.count) + if (isTrace) log.tracef("About to write (max) %d messages to the client", g.count) iterator = iterator.take(g.count) } for (entry <- iterator) { diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoders.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoders.scala index 162562549865..fab144d0a8d8 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoders.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/Encoders.scala @@ -1,7 +1,5 @@ package org.infinispan.server.hotrod -import logging.Log - /** * Version specific encoders are included here. * @@ -18,15 +16,15 @@ object Encoders { /** * Encoder for version 1.1 of the Hot Rod protocol. */ - object Encoder11 extends AbstractTopologyAwareEncoder1x with Log + object Encoder11 extends AbstractTopologyAwareEncoder1x /** * Encoder for version 1.2 of the Hot Rod protocol. */ - object Encoder12 extends AbstractTopologyAwareEncoder1x with Log + object Encoder12 extends AbstractTopologyAwareEncoder1x /** * Encoder for version 1.3 of the Hot Rod protocol. */ - object Encoder13 extends AbstractTopologyAwareEncoder1x with Log + object Encoder13 extends AbstractTopologyAwareEncoder1x } diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodEncoder.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodEncoder.scala index f53d9be9d15c..73d60ffed424 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodEncoder.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodEncoder.scala @@ -2,14 +2,15 @@ package org.infinispan.server.hotrod import io.netty.buffer.ByteBuf import io.netty.util.internal.PlatformDependent -import logging.Log import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.commons.util.Util import io.netty.handler.codec.MessageToByteEncoder import io.netty.channel.ChannelHandlerContext import io.netty.channel.ChannelHandler.Sharable +import org.infinispan.commons.logging.LogFactory import org.infinispan.server.hotrod.Events.Event import org.infinispan.server.hotrod.OperationStatus._ +import org.infinispan.server.hotrod.logging.JavaLog /** * Hot Rod specific encoder. @@ -19,16 +20,18 @@ import org.infinispan.server.hotrod.OperationStatus._ */ @Sharable class HotRodEncoder(cacheManager: EmbeddedCacheManager, server: HotRodServer) - extends MessageToByteEncoder[Any](PlatformDependent.directBufferPreferred()) with Constants with Log { + extends MessageToByteEncoder[Any](PlatformDependent.directBufferPreferred()) with Constants { private lazy val isClustered: Boolean = cacheManager.getCacheManagerConfiguration.transport.transport != null private lazy val addressCache: AddressCache = if (isClustered) cacheManager.getCache(server.getConfiguration.topologyCacheName) else null - private val isTrace = isTraceEnabled + + val log = LogFactory.getLog(getClass, classOf[JavaLog]) + private val isTrace = log.isTraceEnabled def encode(ctx: ChannelHandlerContext, msg: Any, buf: ByteBuf): Unit = { try { - trace("Encode msg %s", msg) + log.tracef("Encode msg %s", msg) msg match { case r: Response => @@ -46,7 +49,7 @@ class HotRodEncoder(cacheManager: EmbeddedCacheManager, server: HotRodServer) } catch { case t: Throwable => - logErrorWritingResponse(r.messageId, t) + log.errorWritingResponse(r.messageId, t) buf.clear() // reset buffer val error = new ErrorResponse(r.version, r.messageId, r.cacheName, r.clientIntel, ServerError, r.topologyId, t.toString) encoder.writeHeader(error, buf, addressCache, server) @@ -58,16 +61,16 @@ class HotRodEncoder(cacheManager: EmbeddedCacheManager, server: HotRodServer) case None => // Do nothing case _ => - logErrorUnexpectedMessage(msg) + log.errorUnexpectedMessage(msg) } if (isTrace) - trace("Write buffer contents %s to channel %s", - Util.hexDump(buf.nioBuffer), ctx.channel) + log.tracef("Write buffer contents %s to channel %s", + Array(Util.hexDump(buf.nioBuffer), ctx.channel).map(_.asInstanceOf[AnyRef]) : _*) } catch { case t: Throwable => - logErrorEncodingMessage(msg, t) + log.errorEncodingMessage(msg, t) throw t } } diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodServer.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodServer.scala index 7ed39f03bb5d..22a61aad0f07 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodServer.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/HotRodServer.scala @@ -10,6 +10,7 @@ import io.netty.channel.{Channel, ChannelInitializer} import io.netty.util.concurrent.DefaultThreadFactory import org.infinispan import org.infinispan.commons.equivalence.AnyEquivalence +import org.infinispan.commons.logging.LogFactory import org.infinispan.commons.marshall.Marshaller import org.infinispan.commons.util.{CollectionFactory, ServiceFinder} import org.infinispan.configuration.cache.{CacheMode, Configuration, ConfigurationBuilder} @@ -26,13 +27,12 @@ import org.infinispan.notifications.cachelistener.filter.{CacheEventConverterFac import org.infinispan.registry.InternalCacheRegistry import org.infinispan.remoting.transport.Address import org.infinispan.server.core.security.SaslUtils -import org.infinispan.server.core.transport.TimeoutEnabledChannelInitializer import org.infinispan.server.core.{AbstractProtocolServer, QueryFacade} import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration import org.infinispan.server.hotrod.event.KeyValueWithPreviousEventConverterFactory import org.infinispan.server.hotrod.iteration.{DefaultIterationManager, IterationManager} -import org.infinispan.server.hotrod.logging.Log -import org.infinispan.server.hotrod.transport.HotRodChannelInitializer +import org.infinispan.server.hotrod.logging.JavaLog +import org.infinispan.server.hotrod.transport.{HotRodChannelInitializer, TimeoutEnabledChannelInitializer} import org.infinispan.upgrade.RollingUpgradeManager import org.infinispan.util.concurrent.IsolationLevel import org.infinispan.{AdvancedCache, IllegalLifecycleStateException} @@ -49,7 +49,8 @@ import scala.collection.JavaConversions._ * @author Galder Zamarreño * @since 4.1 */ -class HotRodServer extends AbstractProtocolServer("HotRod") with Log { +class HotRodServer extends AbstractProtocolServer[HotRodServerConfiguration]("HotRod") { + private val log = LogFactory.getLog(getClass, classOf[JavaLog]) type SuitableConfiguration = HotRodServerConfiguration @@ -115,8 +116,8 @@ class HotRodServer extends AbstractProtocolServer("HotRod") with Log { isClustered = globalConfig.transport().transport() != null if (isClustered) { defineTopologyCacheConfig(cacheManager) - if (isDebugEnabled) - debug("Externally facing address is %s:%d", configuration.proxyHost, configuration.proxyPort) + if (log.isDebugEnabled) + log.debugf("Externally facing address is %s:%d", configuration.proxyHost, configuration.proxyPort) addSelfToTopologyView(cacheManager) } @@ -152,7 +153,7 @@ class HotRodServer extends AbstractProtocolServer("HotRod") with Log { } if (configuration.idleTimeout > 0) new HotRodChannelInitializer(this, getTransport(), getEncoder, getExecutor(getQualifiedName())) - with TimeoutEnabledChannelInitializer + with TimeoutEnabledChannelInitializer[HotRodServerConfiguration] else // Idle timeout logic is disabled with -1 or 0 values new HotRodChannelInitializer(this, getTransport(), getEncoder, getExecutor(getQualifiedName())) } @@ -209,7 +210,8 @@ class HotRodServer extends AbstractProtocolServer("HotRod") with Log { addressCache.addListener(topologyChangeListener) // Map cluster address to server endpoint address - debug("Map %s cluster address with %s server endpoint in address cache", clusterAddress, address) + log.debugf("Map %s cluster address with %s server endpoint in address cache", + Array(clusterAddress, address).map(_.asInstanceOf[AnyRef]) : _*) // Guaranteed delivery required since if data is lost, there won't be // any further cache calls, so negative acknowledgment can cause issues. addressCache.getAdvancedCache.withFlags(Flag.SKIP_CACHE_LOAD, Flag.GUARANTEED_DELIVERY) @@ -402,7 +404,7 @@ object HotRodServer { } class CheckAddressTask(clusterAddress: Address, serverAddress: ServerAddress) - extends DistributedCallable[Address, ServerAddress, Boolean] with Serializable with Log { + extends DistributedCallable[Address, ServerAddress, Boolean] with Serializable { @transient private var cache: infinispan.Cache[Address, ServerAddress] = null diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/iteration/IterationManager.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/iteration/IterationManager.scala index a649adf3757c..9753b42c9b61 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/iteration/IterationManager.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/iteration/IterationManager.scala @@ -3,6 +3,7 @@ package org.infinispan.server.hotrod.iteration import java.util.stream.{Collectors, Stream} import java.util.{Collections, UUID, BitSet => JavaBitSet, Set => JavaSet} +import org.infinispan.commons.logging.LogFactory import org.infinispan.{BaseCacheStream, CacheStream} import org.infinispan.commons.marshall.Marshaller import org.infinispan.commons.util.CollectionFactory @@ -11,9 +12,10 @@ import org.infinispan.container.entries.CacheEntry import org.infinispan.filter.CacheFilters.filterAndConvert import org.infinispan.filter.{KeyValueFilterConverter, KeyValueFilterConverterFactory, ParamKeyValueFilterConverterFactory} import org.infinispan.manager.EmbeddedCacheManager +import org.infinispan.server.hotrod.Encoder2x._ import org.infinispan.server.hotrod.OperationStatus.OperationStatus import org.infinispan.server.hotrod._ -import org.infinispan.server.hotrod.logging.Log +import org.infinispan.server.hotrod.logging.JavaLog import scala.collection.JavaConversions._ import scala.collection.mutable @@ -84,8 +86,9 @@ object CompatInfo { new CompatInfo(config.enabled(), if (config.enabled()) Some(HotRodTypeConverter(config.marshaller())) else None) } -class DefaultIterationManager(val cacheManager: EmbeddedCacheManager) extends IterationManager with Log { +class DefaultIterationManager(val cacheManager: EmbeddedCacheManager) extends IterationManager { @volatile var marshaller: Option[_ <: Marshaller] = None + val log = LogFactory.getLog(getClass, classOf[JavaLog]) private val iterationStateMap = CollectionFactory.makeConcurrentMap[String, IterationState]() private val filterConverterFactoryMap = CollectionFactory.makeConcurrentMap[String, KeyValueFilterConverterFactory[_, _, _]]() diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/logging/JavaLog.java b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/logging/JavaLog.java index eb6a12c1ab20..240da4662dfa 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/logging/JavaLog.java +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/logging/JavaLog.java @@ -5,6 +5,7 @@ import org.infinispan.commons.CacheConfigurationException; import org.infinispan.commons.marshall.Marshaller; import org.infinispan.notifications.cachelistener.event.Event; +import org.infinispan.server.core.logging.Log; import org.infinispan.server.hotrod.MissingFactoryException; import org.infinispan.util.concurrent.IsolationLevel; import org.jboss.logging.annotations.Cause; @@ -22,7 +23,7 @@ * @since 5.0 */ @MessageLogger(projectCode = "ISPN") -public interface JavaLog extends org.infinispan.util.logging.Log { +public interface JavaLog extends Log { @LogMessage(level = WARN) @Message(value = "While trying to detect a crashed member, current view returned null", id = 6000) diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/logging/Log.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/logging/Log.scala deleted file mode 100644 index 9e35fd3ee303..000000000000 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/logging/Log.scala +++ /dev/null @@ -1,53 +0,0 @@ -package org.infinispan.server.hotrod.logging - -import org.infinispan.commons.marshall.Marshaller -import org.infinispan.util.logging.LogFactory -import org.infinispan.notifications.cachelistener.event.Event - -/** - * A logging facade for Scala code. - * - * @author Galder Zamarreño - * @since 5.0 - */ -trait Log extends org.infinispan.server.core.logging.Log { - - private[hotrod] lazy val log: JavaLog = LogFactory.getLog(getClass, classOf[JavaLog]) - - @volatile private var warnConditionalLogged = false - @volatile private var warnForceReturnPreviousLogged = false - - def logViewNullWhileDetectingCrashedMember = log.viewNullWhileDetectingCrashedMember - - def logUnableToUpdateView = log.unableToUpdateView - - def logErrorDetectingCrashedMember(t: Throwable) = log.errorDetectingCrashedMember(t) - - def unexpectedEvent(e: Event[_, _]) = log.unexpectedEvent(e) - - def warnConditionalOperationNonTransactional(op: String) = { - if (!warnConditionalLogged) { - log.warnConditionalOperationNonTransactional(op) - warnConditionalLogged = true - } - } - - def warnForceReturnPreviousNonTransactional(op: String) = { - if (!warnForceReturnPreviousLogged) { - log.warnForceReturnPreviousNonTransactional(op) - warnForceReturnPreviousLogged = true - } - } - - def warnMarshallerAlreadySet(existingMarshaller: Marshaller, newMarshaller: Marshaller) = - log.warnMarshallerAlreadySet(existingMarshaller, newMarshaller) - - def missingCacheEventFactory(factoryType: String, name: String) = - log.missingCacheEventFactory(factoryType, name) - - def illegalFilterConverterEventFactory(name: String) = - log.illegalFilterConverterEventFactory(name) - - def illegalIterationId(iterationId: String) = log.illegalIterationId(iterationId) - -} \ No newline at end of file diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/ExtendedByteBuf.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/ExtendedByteBuf.scala similarity index 98% rename from server/core/src/main/scala/org/infinispan/server/core/transport/ExtendedByteBuf.scala rename to server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/ExtendedByteBuf.scala index 30407ae3563a..898221f986c6 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/ExtendedByteBuf.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/ExtendedByteBuf.scala @@ -1,8 +1,9 @@ -package org.infinispan.server.core.transport +package org.infinispan.server.hotrod.transport import io.netty.buffer.{ByteBuf, Unpooled} import io.netty.util.CharsetUtil import org.infinispan.commons.io.SignedNumeric +import org.infinispan.server.core.transport.{VInt, VLong} import scala.annotation.tailrec diff --git a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/HotRodChannelInitializer.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/HotRodChannelInitializer.scala index db0c80d4bf77..3f5ae0808048 100644 --- a/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/HotRodChannelInitializer.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/HotRodChannelInitializer.scala @@ -14,19 +14,19 @@ import org.infinispan.server.hotrod.logging.{HotRodAccessLoggingHandler, JavaLog * @author wburns * @since 9.0 */ -class HotRodChannelInitializer(val server: HotRodServer, transport: => NettyTransport, - val encoder: ChannelOutboundHandler, executor: ExecutorService) - extends NettyChannelInitializer(server, transport, encoder) { +class HotRodChannelInitializer(val hotRodServer: HotRodServer, transport: => NettyTransport, + encoder: ChannelOutboundHandler, executor: ExecutorService) + extends NettyChannelInitializer(hotRodServer, transport, encoder) { override def initChannel(ch: Channel): Unit = { super.initChannel(ch) - val authHandler = if (server.getConfiguration.authentication().enabled()) new AuthenticationHandler(server) else null + val authHandler = if (server.getConfiguration.authentication().enabled()) new AuthenticationHandler(hotRodServer) else null if (authHandler != null) { ch.pipeline().addLast("authentication-1", authHandler) } ch.pipeline.addLast("local-handler", new LocalContextHandler(transport)) - ch.pipeline.addLast("handler", new ContextHandler(server, transport, executor)) + ch.pipeline.addLast("handler", new ContextHandler(hotRodServer, transport, executor)) ch.pipeline.addLast("exception", new HotRodExceptionHandler) // Logging handlers diff --git a/server/core/src/main/scala/org/infinispan/server/core/transport/TimeoutEnabledChannelInitializer.scala b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/TimeoutEnabledChannelInitializer.scala similarity index 51% rename from server/core/src/main/scala/org/infinispan/server/core/transport/TimeoutEnabledChannelInitializer.scala rename to server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/TimeoutEnabledChannelInitializer.scala index c87886fe1060..6cf91823f51d 100644 --- a/server/core/src/main/scala/org/infinispan/server/core/transport/TimeoutEnabledChannelInitializer.scala +++ b/server/hotrod/src/main/scala/org/infinispan/server/hotrod/transport/TimeoutEnabledChannelInitializer.scala @@ -1,9 +1,10 @@ -package org.infinispan.server.core.transport +package org.infinispan.server.hotrod.transport -import org.infinispan.server.core.ProtocolServer -import org.infinispan.server.core.configuration.SslConfiguration -import io.netty.channel.{ChannelInitializer, Channel} +import io.netty.channel.{Channel, ChannelInitializer} import io.netty.handler.timeout.IdleStateHandler +import org.infinispan.server.core.ProtocolServer +import org.infinispan.server.core.configuration.ProtocolServerConfiguration +import org.infinispan.server.core.transport.IdleStateHandlerProvider /** * A channel pipeline factory for environments where idle timeout is enabled. This is a trait, useful to extend @@ -13,13 +14,13 @@ import io.netty.handler.timeout.IdleStateHandler * @author William Burns * @since 5.1 */ -trait TimeoutEnabledChannelInitializer extends ChannelInitializer[Channel] { - val server: ProtocolServer +trait TimeoutEnabledChannelInitializer[C <: ProtocolServerConfiguration] extends ChannelInitializer[Channel] { + val hotRodServer: ProtocolServer[C] abstract override def initChannel(ch: Channel): Unit = { super.initChannel(ch) val pipeline = ch.pipeline - pipeline.addLast("idleHandler", new IdleStateHandler(server.getConfiguration.idleTimeout, 0, 0)) + pipeline.addLast("idleHandler", new IdleStateHandler(hotRodServer.getConfiguration.idleTimeout, 0, 0)) pipeline.addLast("idleHandlerProvider", new IdleStateHandlerProvider) } } \ No newline at end of file diff --git a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodAuthenticationTest.scala b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodAuthenticationTest.scala index aad3728cbc8c..7fa676e60a89 100644 --- a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodAuthenticationTest.scala +++ b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodAuthenticationTest.scala @@ -1,16 +1,17 @@ package org.infinispan.server.hotrod -import org.testng.annotations.Test import java.lang.reflect.Method -import test.HotRodTestingUtil._ -import org.testng.Assert._ -import org.infinispan.server.hotrod.test._ -import org.infinispan.manager.EmbeddedCacheManager -import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder -import javax.security.sasl.Sasl import java.util.HashMap +import javax.security.sasl.Sasl + +import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.server.core.security.simple.SimpleServerAuthenticationProvider +import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder +import org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer +import org.infinispan.server.hotrod.test.{TestCallbackHandler, UniquePortThreadLocal} import org.jboss.sasl.JBossSaslProvider +import org.testng.Assert._ +import org.testng.annotations.Test /** * Hot Rod server authentication test. @@ -34,7 +35,7 @@ class HotRodAuthenticationTest extends HotRodSingleNodeTest { val a = client.authMechList assertEquals(a.mechs.size, 1) assertTrue(a.mechs.contains("CRAM-MD5")) - assertEquals(1, server.getDecoder.getTransport.acceptedChannels.size()) + assertEquals(1, server.getDecoder.getTransport.getNumberOfLocalConnections) } def testAuth(m: Method) { @@ -42,9 +43,9 @@ class HotRodAuthenticationTest extends HotRodSingleNodeTest { val sc = Sasl.createSaslClient(Array("CRAM-MD5"), null, "hotrod", "localhost", props, new TestCallbackHandler("user", "realm", "password".toCharArray())) val res = client.auth(sc) assertTrue(res.complete) - assertEquals(1, server.getDecoder.getTransport.acceptedChannels.size()) + assertEquals(1, server.getDecoder.getTransport.getNumberOfLocalConnections) } - + def testUnauthorizedOpCloseConnection(m: Method) { // Ensure the transport is clean server.getDecoder.getTransport.stop() @@ -52,7 +53,7 @@ class HotRodAuthenticationTest extends HotRodSingleNodeTest { try { client.assertPutFail(m) } finally { - assertEquals(0, server.getDecoder.getTransport.acceptedChannels.size()) + assertEquals(0, server.getDecoder.getTransport.getNumberOfLocalConnections) } } diff --git a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodConfigurationTest.scala b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodConfigurationTest.scala index 04bdb853510f..572f6d642c84 100644 --- a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodConfigurationTest.scala +++ b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodConfigurationTest.scala @@ -1,5 +1,7 @@ package org.infinispan.server.hotrod +import java.util.function.Consumer + import test.UniquePortThreadLocal import test.HotRodTestingUtil._ import org.infinispan.test.fwk.TestCacheManagerFactory @@ -13,6 +15,7 @@ import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration import org.infinispan.util.concurrent.IsolationLevel import org.infinispan.commons.CacheConfigurationException import org.infinispan.configuration.cache.VersioningScheme +import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.test.AbstractInfinispanTest /** @@ -63,12 +66,17 @@ class HotRodConfigurationTest extends AbstractInfinispanTest { } private def withClusteredServer(builder: HotRodServerConfigurationBuilder) (assert: (Configuration, Long) => Unit) { - Stoppable.useCacheManager(TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration())) { cm => - Stoppable.useServer(startHotRodServer(cm, UniquePortThreadLocal.get.intValue, builder)) { server => - val cfg = cm.getCache(HotRodServerConfiguration.TOPOLOGY_CACHE_NAME_PREFIX).getCacheConfiguration - assert(cfg, cm.getCacheManagerConfiguration.transport().distributedSyncTimeout()) + + Stoppable.useCacheManager(TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration()), new Consumer[EmbeddedCacheManager] { + override def accept(cm: EmbeddedCacheManager): Unit = { + Stoppable.useServer(startHotRodServer(cm, UniquePortThreadLocal.get.intValue, builder), new Consumer[HotRodServer] { + override def accept(server: HotRodServer): Unit = { + val cfg = cm.getCache(HotRodServerConfiguration.TOPOLOGY_CACHE_NAME_PREFIX).getCacheConfiguration + assert(cfg, cm.getCacheManagerConfiguration.transport().distributedSyncTimeout()) + } + }) } - } + }) } private def validateIsolationLevel(isolationLevel: IsolationLevel, writeSkew: Boolean) { @@ -78,10 +86,15 @@ class HotRodConfigurationTest extends AbstractInfinispanTest { if (writeSkew) { builder.versioning().enable().scheme(VersioningScheme.SIMPLE) } - Stoppable.useCacheManager(TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration(builder))) { - cm => - Stoppable.useServer(startHotRodServer(cm, UniquePortThreadLocal.get.intValue, hotRodBuilder)) { server => {} } - } + + Stoppable.useCacheManager(TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration(builder)), new Consumer[EmbeddedCacheManager] { + override def accept(cm: EmbeddedCacheManager): Unit = { + Stoppable.useServer(startHotRodServer(cm, UniquePortThreadLocal.get.intValue, hotRodBuilder), new Consumer[HotRodServer] { + override def accept(server: HotRodServer): Unit = { + } + }) + } + }) } } \ No newline at end of file diff --git a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodFunctionalTest.scala b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodFunctionalTest.scala index b87f5a86ecb7..59ac155b30b7 100644 --- a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodFunctionalTest.scala +++ b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodFunctionalTest.scala @@ -2,18 +2,23 @@ package org.infinispan.server.hotrod import org.testng.annotations.Test import java.lang.reflect.Method + import test.HotRodTestingUtil._ import org.testng.Assert._ import java.util.Arrays + import org.infinispan.server.hotrod.OperationStatus._ import org.infinispan.server.hotrod.test._ import org.infinispan.test.TestingUtil.generateRandomString import java.util.concurrent.TimeUnit +import java.util.function.Consumer + import org.infinispan.server.core.test.Stoppable import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration import org.infinispan.test.fwk.TestCacheManagerFactory import org.infinispan.server.core.QueryFacade import org.infinispan.AdvancedCache +import org.infinispan.manager.EmbeddedCacheManager /** * Hot Rod server functional test. @@ -460,17 +465,21 @@ class HotRodFunctionalTest extends HotRodSingleNodeTest { } def testStoreAsBinaryOverrideOnNamedCache(m: Method) { - Stoppable.useCacheManager(createTestCacheManager) { cm => - Stoppable.useServer(startHotRodServer(cm, server.getPort + 33)) { server => - val cacheName = "cache-" + m.getName - val namedBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false) - .storeAsBinary.enable - val namedCfg = namedBuilder.build - assertTrue(namedCfg.storeAsBinary().enabled()) - cm.defineConfiguration(cacheName, namedCfg) - assertFalse(cm.getCache(cacheName).getCacheConfiguration.storeAsBinary().enabled()) + Stoppable.useCacheManager(createTestCacheManager, new Consumer[EmbeddedCacheManager] { + override def accept(cm: EmbeddedCacheManager): Unit = { + Stoppable.useServer(startHotRodServer(cm, server.getPort + 33), new Consumer[HotRodServer] { + override def accept(server: HotRodServer): Unit = { + val cacheName = "cache-" + m.getName + val namedBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false) + .storeAsBinary.enable + val namedCfg = namedBuilder.build + assertTrue(namedCfg.storeAsBinary().enabled()) + cm.defineConfiguration(cacheName, namedCfg) + assertFalse(cm.getCache(cacheName).getCacheConfiguration.storeAsBinary().enabled()) + } + }) } - } + }) } def testQuery() { diff --git a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodServerTest.scala b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodServerTest.scala index 28ed9050b12c..cbc5ca03fcd5 100644 --- a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodServerTest.scala +++ b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/HotRodServerTest.scala @@ -1,5 +1,8 @@ package org.infinispan.server.hotrod +import java.util.function.Consumer + +import org.infinispan.manager.EmbeddedCacheManager import org.testng.annotations.Test import org.testng.Assert._ import org.infinispan.server.core.test.Stoppable @@ -18,13 +21,16 @@ import org.infinispan.test.AbstractInfinispanTest class HotRodServerTest extends AbstractInfinispanTest { def testValidateProtocolServerNullProperties() { - Stoppable.useCacheManager(createCacheManager(hotRodCacheConfiguration())) { cm => - Stoppable.useServer(new HotRodServer) { server => - server.start(new HotRodServerConfigurationBuilder().build, cm) - assertEquals(server.getHost, "127.0.0.1") - assertEquals(server.getPort, 11222) + Stoppable.useCacheManager(createCacheManager(hotRodCacheConfiguration()), new Consumer[EmbeddedCacheManager] { + override def accept(cm: EmbeddedCacheManager): Unit = { + Stoppable.useServer(new HotRodServer, new Consumer[HotRodServer] { + override def accept(server: HotRodServer): Unit = { + server.start(new HotRodServerConfigurationBuilder().build, cm) + assertEquals(server.getHost, "127.0.0.1") + assertEquals(server.getPort, 11222) + } + }) } - } + }) } - } diff --git a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodClient.scala b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodClient.scala index 0542b38db3fd..2afa82b36b9d 100644 --- a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodClient.scala +++ b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodClient.scala @@ -1,16 +1,19 @@ package org.infinispan.server.hotrod.test import java.net.InetSocketAddress + import org.testng.Assert._ -import org.infinispan.server.hotrod.logging.Log import org.infinispan.server.hotrod.OperationStatus._ import org.infinispan.server.hotrod.OperationResponse._ + import collection.mutable import collection.immutable import java.lang.reflect.Method + import HotRodTestingUtil._ -import java.util.concurrent.{Future, ConcurrentHashMap} +import java.util.concurrent.{ConcurrentHashMap, Future} import java.util.concurrent.atomic.AtomicLong + import mutable.ListBuffer import org.infinispan.test.TestingUtil import org.infinispan.commons.util.Util @@ -18,16 +21,20 @@ import org.infinispan.server.core.transport.ExtendedByteBuf._ import org.infinispan.server.hotrod._ import java.lang.StringBuilder import javax.net.ssl.SSLEngine + import io.netty.handler.ssl.SslHandler import io.netty.channel._ import io.netty.channel.nio.NioEventLoopGroup import io.netty.bootstrap.Bootstrap -import io.netty.handler.codec.{ReplayingDecoder, MessageToByteEncoder} +import io.netty.handler.codec.{MessageToByteEncoder, ReplayingDecoder} import io.netty.buffer.ByteBuf import io.netty.channel.socket.nio.NioSocketChannel import javax.security.sasl.SaslClient + import org.infinispan.commons.util.concurrent.jdk8backported.EquivalentConcurrentHashMapV8 -import org.infinispan.commons.equivalence.{ByteArrayEquivalence, AnyEquivalence} +import org.infinispan.commons.equivalence.{AnyEquivalence, ByteArrayEquivalence} +import org.infinispan.commons.logging.LogFactory +import org.infinispan.server.hotrod.logging.JavaLog /** * A very simple Hot Rod client for testing purposes. It's a quick and dirty client implementation. @@ -41,9 +48,10 @@ import org.infinispan.commons.equivalence.{ByteArrayEquivalence, AnyEquivalence} * @author Tristan Tarrant * @since 4.1 */ -class HotRodClient(host: String, port: Int, val defaultCacheName: String, rspTimeoutSeconds: Int, val protocolVersion: Byte, sslEngine: SSLEngine = null) extends Log { +class HotRodClient(host: String, port: Int, val defaultCacheName: String, rspTimeoutSeconds: Int, val protocolVersion: Byte, sslEngine: SSLEngine = null) { val idToOp = new ConcurrentHashMap[Long, Op] var saslClient: SaslClient = null + private val log = LogFactory.getLog(getClass, classOf[JavaLog]) private lazy val ch: Channel = { val eventLoopGroup = new NioEventLoopGroup() @@ -313,7 +321,7 @@ private class ClientChannelInitializer(client: HotRodClient, rspTimeoutSeconds: private class Encoder(protocolVersion: Byte) extends MessageToByteEncoder[Object] { override def encode(ctx: ChannelHandlerContext, msg: AnyRef, buffer: ByteBuf): Unit = { - trace("Encode %s so that it's sent to the server", msg) + log.tracef("Encode %s so that it's sent to the server", msg) msg match { case partial: PartialOp => { buffer.writeByte(partial.magic.asInstanceOf[Byte]) // magic @@ -414,10 +422,10 @@ object HotRodClient { val idCounter = new AtomicLong } -private class Decoder(client: HotRodClient) extends ReplayingDecoder[Void] with Log with Constants { +private class Decoder(client: HotRodClient) extends ReplayingDecoder[Void] with Constants { override def decode(ctx: ChannelHandlerContext, buf: ByteBuf, out: java.util.List[AnyRef]): Unit = { - trace("Decode response from server") + log.trace("Decode response from server") buf.readUnsignedByte // magic byte val id = readUnsignedLong(buf) val opCode = OperationResponse.apply(buf.readUnsignedByte) @@ -608,13 +616,13 @@ private class Decoder(client: HotRodClient) extends ReplayingDecoder[Void] with } if (resp != null) { - trace("Got response from server: %s", resp) + log.tracef("Got response from server: %s", resp) out.add(resp) } } override def exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) { - logExceptionReported(cause) + log.exceptionReported(cause) } private def read2xHashDistAwareHeader(buf: ByteBuf, topologyId: Int, op: Op): Option[AbstractTestTopologyAwareResponse] = { @@ -733,7 +741,7 @@ private class ClientHandler(rspTimeoutSeconds: Int) extends ChannelInboundHandle case e: TestCustomEvent => clientListeners.get(e.listenerId).onCustom(e) case resp: TestResponse => - trace("Put %s in responses", resp) + log.tracef("Put %s in responses", resp) responses.put(resp.messageId, resp) } } diff --git a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodSslWithCertPasswdTest.scala b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodSslWithCertPasswdTest.scala index 7f5f3ff80a25..97ae53cb2e42 100644 --- a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodSslWithCertPasswdTest.scala +++ b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodSslWithCertPasswdTest.scala @@ -1,5 +1,8 @@ package org.infinispan.server.hotrod.test +import java.util.function.Consumer + +import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.server.core.test.Stoppable import org.infinispan.server.hotrod.HotRodServer import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder @@ -23,14 +26,18 @@ class HotRodSslWithCertPasswdTest extends AbstractInfinispanTest { def testServerStartWithSslAndCertPasswd() { val builder = new HotRodServerConfigurationBuilder - builder.proxyHost(host).proxyPort(UniquePortThreadLocal.get.intValue).idleTimeout(0) + builder.host(host).port(UniquePortThreadLocal.get.intValue).idleTimeout(0) builder.ssl.enable().keyStoreFileName(keyStoreFileName).keyStorePassword("secret".toCharArray).keyStoreCertificatePassword("secret2".toCharArray).trustStoreFileName(trustStoreFileName).trustStorePassword("secret".toCharArray) - Stoppable.useCacheManager(createCacheManager(hotRodCacheConfiguration())) { cm => - Stoppable.useServer(new HotRodServer) { server => - server.start(builder.build, cm) - assertNotNull(server.getConfiguration.ssl().keyStoreCertificatePassword()) + Stoppable.useCacheManager(createCacheManager(hotRodCacheConfiguration()), new Consumer[EmbeddedCacheManager] { + override def accept(cm: EmbeddedCacheManager): Unit = { + Stoppable.useServer(new HotRodServer, new Consumer[HotRodServer] { + override def accept(server: HotRodServer): Unit = { + server.start(builder.build, cm) + assertNotNull(server.getConfiguration.ssl().keyStoreCertificatePassword()) + } + }) } - } + }) } } diff --git a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodTestingUtil.scala b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodTestingUtil.scala index cee063d30bb8..9144e64444df 100644 --- a/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodTestingUtil.scala +++ b/server/hotrod/src/test/scala/org/infinispan/server/hotrod/test/HotRodTestingUtil.scala @@ -9,6 +9,7 @@ import java.util.concurrent.atomic.AtomicInteger import io.netty.channel.{Channel, ChannelFuture, ChannelInitializer} import org.infinispan.commons.api.BasicCacheContainer import org.infinispan.commons.equivalence.ByteArrayEquivalence +import org.infinispan.commons.logging.LogFactory import org.infinispan.commons.util.Util import org.infinispan.configuration.cache.ConfigurationBuilder import org.infinispan.manager.EmbeddedCacheManager @@ -17,12 +18,11 @@ import org.infinispan.notifications.Listener import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved import org.infinispan.notifications.cachelistener.event.CacheEntryRemovedEvent import org.infinispan.remoting.transport.Address -import org.infinispan.server.core.transport.TimeoutEnabledChannelInitializer import org.infinispan.server.hotrod.OperationStatus._ import org.infinispan.server.hotrod._ -import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder -import org.infinispan.server.hotrod.logging.Log -import org.infinispan.server.hotrod.transport.{HotRodChannelInitializer, SingleByteFrameDecoderChannelInitializer} +import org.infinispan.server.hotrod.configuration.{HotRodServerConfiguration, HotRodServerConfigurationBuilder} +import org.infinispan.server.hotrod.logging.JavaLog +import org.infinispan.server.hotrod.transport.{HotRodChannelInitializer, SingleByteFrameDecoderChannelInitializer, TimeoutEnabledChannelInitializer} import org.infinispan.statetransfer.StateTransferManager import org.infinispan.test.TestingUtil import org.testng.Assert.{assertNull, assertTrue} @@ -37,9 +37,10 @@ import scala.collection.JavaConverters._ * @author Galder Zamarreño * @since 4.1 */ -object HotRodTestingUtil extends Log { +object HotRodTestingUtil { val EXPECTED_HASH_FUNCTION_VERSION: Byte = 2 + val log = LogFactory.getLog(getClass, classOf[JavaLog]) def host = "127.0.0.1" @@ -89,7 +90,7 @@ object HotRodTestingUtil extends Log { startHotRodServer(manager, host, port, delay, false, builder) def startHotRodServer(manager: EmbeddedCacheManager, host: String, port: Int, delay: Long, perf: Boolean, builder: HotRodServerConfigurationBuilder): HotRodServer = { - info("Start server in port %d", port) + log.infof("Start server in port %d", port) val server = new HotRodServer { override protected def createTopologyCacheConfig(distSyncTimeout: Long): ConfigurationBuilder = { if (delay > 0) @@ -108,14 +109,14 @@ object HotRodTestingUtil extends Log { if (perf) { if (configuration.idleTimeout > 0) new HotRodChannelInitializer(this, getTransport(), getEncoder, getExecutor("test")) - with TimeoutEnabledChannelInitializer with SingleByteFrameDecoderChannelInitializer + with TimeoutEnabledChannelInitializer[HotRodServerConfiguration] with SingleByteFrameDecoderChannelInitializer else // Idle timeout logic is disabled with -1 or 0 values new HotRodChannelInitializer(this, getTransport(), getEncoder, getExecutor("test")) with SingleByteFrameDecoderChannelInitializer } else { if (configuration.idleTimeout > 0) new HotRodChannelInitializer(this, getTransport(), getEncoder, getExecutor("test")) - with TimeoutEnabledChannelInitializer + with TimeoutEnabledChannelInitializer[HotRodServerConfiguration] else // Idle timeout logic is disabled with -1 or 0 values new HotRodChannelInitializer(this, getTransport(), getEncoder, getExecutor("test")) } @@ -152,7 +153,7 @@ object HotRodTestingUtil extends Log { def k(m: Method, prefix: String): Array[Byte] = { val bytes: Array[Byte] = (prefix + m.getName).getBytes - trace("String %s is converted to %s bytes", prefix + m.getName, Util.printArray(bytes, true)) + log.tracef("String %s is converted to %s bytes", Array(prefix + m.getName, Util.printArray(bytes, true)).map(_.asInstanceOf[AnyRef]) : _*) bytes } @@ -366,7 +367,7 @@ object HotRodTestingUtil extends Log { } catch { case t: Throwable => { - error("Error stopping client", t) + log.error("Error stopping client", t) null } } @@ -462,9 +463,9 @@ object UniquePortThreadLocal extends ThreadLocal[Int] { private val uniqueAddr = new AtomicInteger(12311) override def initialValue: Int = { - HotRodTestingUtil.debug("Before incrementing, server port is: %d", uniqueAddr.get()) + HotRodTestingUtil.log.debugf("Before incrementing, server port is: %d", uniqueAddr.get()) val port = uniqueAddr.getAndAdd(110) - HotRodTestingUtil.debug("For next thread, server port will be: %d", uniqueAddr.get()) + HotRodTestingUtil.log.debugf("For next thread, server port will be: %d", uniqueAddr.get()) port } diff --git a/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedDecoder.scala b/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedDecoder.scala index 37645f511845..57c8d55548d8 100644 --- a/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedDecoder.scala +++ b/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedDecoder.scala @@ -14,6 +14,7 @@ import io.netty.channel._ import io.netty.util.CharsetUtil import org.infinispan._ import org.infinispan.commons.CacheException +import org.infinispan.commons.logging.LogFactory import org.infinispan.configuration.cache.Configuration import org.infinispan.container.entries.CacheEntry import org.infinispan.container.versioning.{EntryVersion, NumericVersion, NumericVersionGenerator, VersionGenerator} @@ -21,14 +22,12 @@ import org.infinispan.context.Flag import org.infinispan.factories.ComponentRegistry import org.infinispan.metadata.Metadata import org.infinispan.remoting.rpc.RpcManager -import org.infinispan.server.core.Operation._ -import org.infinispan.server.core._ import org.infinispan.server.core.transport.ExtendedByteBuf._ import org.infinispan.server.core.transport.NettyTransport import org.infinispan.server.memcached.MemcachedDecoderState._ import org.infinispan.server.memcached.MemcachedOperation._ import org.infinispan.server.memcached.TextProtocolUtil._ -import org.infinispan.server.memcached.logging.Log +import org.infinispan.server.memcached.logging.JavaLog import scala.collection.mutable.ListBuffer import scala.collection.{immutable, mutable} @@ -41,7 +40,9 @@ import scala.collection.{immutable, mutable} */ class MemcachedDecoder(memcachedCache: AdvancedCache[String, Array[Byte]], scheduler: ScheduledExecutorService, val transport: NettyTransport, val cacheIgnoreAware: String => Boolean = Function.const(false)) -extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConstants { +extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) { + + val log = LogFactory.getLog(getClass, classOf[JavaLog]) val SecondsInAMonth = 60 * 60 * 24 * 30 val DefaultTimeUnit = TimeUnit.MILLISECONDS @@ -68,7 +69,7 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta private final val replaceIfUnmodifiedMisses = new AtomicLong(0) private final val replaceIfUnmodifiedHits = new AtomicLong(0) private final val replaceIfUnmodifiedBadval = new AtomicLong(0) - private val isTrace = isTraceEnabled + private val isTrace = log.isTraceEnabled private val byteBuffer = new ByteArrayOutputStream() protected var header: RequestHeader = _ @@ -117,7 +118,7 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta private def decodeDispatch(ctx: ChannelHandlerContext, in: ByteBuf, out: util.List[AnyRef]): Unit = { try { if (isTrace) // To aid debugging - trace("Decode using instance @%x", System.identityHashCode(this)) + log.tracef("Decode using instance @%x", System.identityHashCode(this)) state match { case DECODE_HEADER => decodeHeader(ctx, in, state, out) case DECODE_KEY => decodeKey(ctx, in, state) @@ -270,7 +271,7 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta override def exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) { val ch = ctx.channel // Log it just in case the channel is closed or similar - debug(cause, "Exception caught") + log.debug("Exception caught", cause) if (!cause.isInstanceOf[IOException]) { val errorResponse = createErrorResponse(cause) if (errorResponse != null) { @@ -315,7 +316,7 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta var endOfOp = false params = if (args.nonEmpty) { - if (isTrace) trace("Operation parameters: %s", args) + if (isTrace) log.tracef("Operation parameters: %s", args) try { header.op match { case PutRequest => readStorageParameters(args, b) @@ -677,10 +678,10 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta case m: MemcachedException => m.getCause match { case u: UnknownOperationException => - logExceptionReported(u) + log.exceptionReported(u) ERROR case c: ClosedChannelException => - logExceptionReported(c) + log.exceptionReported(c) null // no-op, only log case i: IOException => logAndCreateErrorMessage(sb, m) @@ -691,7 +692,7 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta case _ => sb.append(m.getMessage).append(CRLF) } case c: ClosedChannelException => - logExceptionReported(c) + log.exceptionReported(c) null // no-op, only log case _ => sb.append(SERVER_ERROR).append(t.getMessage).append(CRLF) } @@ -708,7 +709,7 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta } private def logAndCreateErrorMessage(sb: StringBuilder, m: MemcachedException): StringBuilder = { - logExceptionReported(m.getCause) + log.exceptionReported(m.getCause) sb.append(m.getMessage).append(CRLF) } @@ -749,7 +750,7 @@ extends ReplayingDecoder[MemcachedDecoderState](DECODE_HEADER) with ServerConsta protected def writeResponse(ch: Channel, response: AnyRef): AnyRef = { try { if (response != null) { - if (isTrace) trace("Write response %s", response) + if (isTrace) log.tracef("Write response %s", response) response match { // We only expect Lists of ChannelBuffer instances, so don't worry about type erasure case l: Array[ByteBuf] => @@ -920,11 +921,12 @@ private class DelayedFlushAll(cache: AdvancedCache[String, Array[Byte]], } } -private object RequestResolver extends Log { - private val isTrace = isTraceEnabled +private object RequestResolver { + private val log = LogFactory.getLog(getClass, classOf[JavaLog]) + private val isTrace = log.isTraceEnabled def toRequest(commandName: String, endOfOp: Boolean, buffer: ByteBuf): Enumeration#Value = { - if (isTrace) trace("Operation: '%s'", commandName) + if (isTrace) log.tracef("Operation: '%s'", commandName) val op = commandName match { case "get" => GetRequest case "set" => PutRequest @@ -945,8 +947,8 @@ private object RequestResolver extends Log { case _ => if (!endOfOp) { val line = readDiscardedLine(buffer) // Read rest of line to clear the operation - debug("Unexpected operation '%s', rest of line contains: %s", - commandName, line) + log.debugf("Unexpected operation '%s', rest of line contains: %s", + Array(commandName, line).map(_.asInstanceOf[AnyRef]) : _*) } throw new UnknownOperationException("Unknown operation: " + commandName) diff --git a/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedOperation.scala b/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedOperation.scala index ee92abc8d086..f9cfc1808885 100644 --- a/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedOperation.scala +++ b/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedOperation.scala @@ -1,13 +1,16 @@ package org.infinispan.server.memcached /** - * Memcached operations. The enumeration stats at a number other than 0 to make sure it does not clash with common operations. + * Memcached operations. * * @author Galder Zamarreño * @since 4.1 */ -object MemcachedOperation extends Enumeration(10) { +object MemcachedOperation extends Enumeration { type MemcachedOperation = Value + val PutRequest, PutIfAbsentRequest, ReplaceRequest, ReplaceIfUnmodifiedRequest = Value + val GetRequest, GetWithVersionRequest = Value + val RemoveRequest, StatsRequest = Value val AppendRequest, PrependRequest = Value val IncrementRequest, DecrementRequest = Value val FlushAllRequest, VersionRequest = Value diff --git a/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedServer.scala b/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedServer.scala index 434f69e5abeb..3e4485a96e42 100644 --- a/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedServer.scala +++ b/server/memcached/src/main/scala/org/infinispan/server/memcached/MemcachedServer.scala @@ -3,12 +3,14 @@ package org.infinispan.server.memcached import io.netty.channel.{Channel, ChannelInitializer} import org.infinispan.server.core.AbstractProtocolServer import java.util.concurrent.Executors + import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.server.core.transport.NettyChannelInitializer import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration import org.infinispan.AdvancedCache +import org.infinispan.commons.logging.LogFactory import org.infinispan.configuration.cache.ConfigurationBuilder -import org.infinispan.server.memcached.logging.Log +import org.infinispan.server.memcached.logging.JavaLog /** * Memcached server defining its decoder/encoder settings. In fact, Memcached does not use an encoder since there's @@ -17,9 +19,10 @@ import org.infinispan.server.memcached.logging.Log * @author Galder Zamarreño * @since 4.1 */ -class MemcachedServer extends AbstractProtocolServer("Memcached") with Log { +class MemcachedServer extends AbstractProtocolServer[MemcachedServerConfiguration]("Memcached") { type SuitableConfiguration = MemcachedServerConfiguration + val log = LogFactory.getLog(getClass, classOf[JavaLog]) protected lazy val scheduler = Executors.newScheduledThreadPool(1) private var memcachedCache: AdvancedCache[String, Array[Byte]] = _ diff --git a/server/memcached/src/main/scala/org/infinispan/server/memcached/logging/JavaLog.java b/server/memcached/src/main/scala/org/infinispan/server/memcached/logging/JavaLog.java index 6b03664d8f74..cc5125a9f510 100644 --- a/server/memcached/src/main/scala/org/infinispan/server/memcached/logging/JavaLog.java +++ b/server/memcached/src/main/scala/org/infinispan/server/memcached/logging/JavaLog.java @@ -1,6 +1,7 @@ package org.infinispan.server.memcached.logging; import org.infinispan.commons.CacheConfigurationException; +import org.infinispan.server.core.logging.Log; import org.jboss.logging.annotations.Message; import org.jboss.logging.annotations.MessageLogger; @@ -12,7 +13,7 @@ * @since 5.0 */ @MessageLogger(projectCode = "ISPN") -public interface JavaLog extends org.infinispan.util.logging.Log { +public interface JavaLog extends Log { @Message(value = "Cache '%s' has expiration enabled which violates the Memcached protocol", id = 11001) CacheConfigurationException invalidExpiration(String cacheName); } diff --git a/server/memcached/src/main/scala/org/infinispan/server/memcached/logging/Log.scala b/server/memcached/src/main/scala/org/infinispan/server/memcached/logging/Log.scala deleted file mode 100644 index a49a0078bed6..000000000000 --- a/server/memcached/src/main/scala/org/infinispan/server/memcached/logging/Log.scala +++ /dev/null @@ -1,15 +0,0 @@ -package org.infinispan.server.memcached.logging - -import org.infinispan.util.logging.LogFactory - -/** - * A logging facade for Scala code. - * - * @author Galder Zamarreño - * @since 5.0 - */ -trait Log extends org.infinispan.server.core.logging.Log { - - private[memcached] lazy val log: JavaLog = LogFactory.getLog(getClass, classOf[JavaLog]) - -} diff --git a/server/core/src/test/scala/org/infinispan/server/core/ConnectionStatsTest.scala b/server/memcached/src/test/scala/org/infinispan/server/memcached/ConnectionStatsTest.scala similarity index 97% rename from server/core/src/test/scala/org/infinispan/server/core/ConnectionStatsTest.scala rename to server/memcached/src/test/scala/org/infinispan/server/memcached/ConnectionStatsTest.scala index 96b36d367e42..ccf36f377c4d 100644 --- a/server/core/src/test/scala/org/infinispan/server/core/ConnectionStatsTest.scala +++ b/server/memcached/src/test/scala/org/infinispan/server/memcached/ConnectionStatsTest.scala @@ -1,7 +1,8 @@ -package org.infinispan.server.core +package org.infinispan.server.memcached -import org.infinispan.jmx.PerThreadMBeanServerLookup import javax.management.{MBeanServer, ObjectName} + +import org.infinispan.jmx.PerThreadMBeanServerLookup import org.testng.Assert._ /** diff --git a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedClusteredStatsTest.scala b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedClusteredStatsTest.scala index 6c08b39fd42d..6645970e5aca 100644 --- a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedClusteredStatsTest.scala +++ b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedClusteredStatsTest.scala @@ -3,7 +3,7 @@ package org.infinispan.server.memcached import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.test.fwk.TestCacheManagerFactory import org.infinispan.configuration.cache.{CacheMode, ConfigurationBuilder} -import org.infinispan.server.core.ConnectionStatsTest._ +import ConnectionStatsTest._ import org.testng.annotations.Test import javax.management.{MBeanServer, MBeanServerFactory} import org.infinispan.jmx.MBeanServerLookup diff --git a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedFunctionalTest.scala b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedFunctionalTest.scala index 198786e3bddb..5e3a7c0c8f20 100644 --- a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedFunctionalTest.scala +++ b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedFunctionalTest.scala @@ -1,7 +1,7 @@ package org.infinispan.server.memcached import java.lang.reflect.Method -import logging.Log + import org.testng.Assert._ import org.testng.annotations.Test import net.spy.memcached.CASResponse @@ -10,10 +10,13 @@ import org.infinispan.notifications.Listener import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved import org.infinispan.notifications.cachelistener.event.CacheEntryRemovedEvent import java.util.concurrent.{CountDownLatch, TimeUnit} + import org.infinispan.test.fwk.TestCacheManagerFactory import org.infinispan.Version +import org.infinispan.commons.logging.LogFactory import test.MemcachedTestingUtil._ import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder +import org.infinispan.server.memcached.logging.JavaLog import scala.util.Try @@ -587,11 +590,13 @@ class MemcachedFunctionalTest extends MemcachedSingleNodeTest { } @Listener -class NoReplyListener(latch: CountDownLatch) extends Log { +class NoReplyListener(latch: CountDownLatch) { + + val log = LogFactory.getLog(getClass, classOf[JavaLog]) @CacheEntryRemoved def removed(event: CacheEntryRemovedEvent[AnyRef, AnyRef]) { - debug("Entry removed, open latch") + log.debug("Entry removed, open latch") latch.countDown } diff --git a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedServerTest.scala b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedServerTest.scala index 4beec6453597..648da868c755 100644 --- a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedServerTest.scala +++ b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedServerTest.scala @@ -1,5 +1,7 @@ package org.infinispan.server.memcached +import java.util.function.Consumer + import org.testng.annotations.Test import org.testng.Assert._ import org.infinispan.server.core.test.Stoppable @@ -7,6 +9,7 @@ import org.infinispan.test.fwk.TestCacheManagerFactory import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder import org.infinispan.configuration.cache.ConfigurationBuilder import org.infinispan.commons.CacheConfigurationException +import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.test.AbstractInfinispanTest /** @@ -19,25 +22,33 @@ import org.infinispan.test.AbstractInfinispanTest class MemcachedServerTest extends AbstractInfinispanTest { def testValidateDefaultConfiguration { - Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager()) { cm => - Stoppable.useServer(new MemcachedServer) { server => - server.start(new MemcachedServerConfigurationBuilder().build(), cm) - assertEquals(server.getHost, "127.0.0.1") - assertEquals(server.getPort, 11211) + Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager(), new Consumer[EmbeddedCacheManager] { + override def accept(cm: EmbeddedCacheManager): Unit = { + Stoppable.useServer(new MemcachedServer(), new Consumer[MemcachedServer] { + override def accept(server: MemcachedServer): Unit = { + server.start(new MemcachedServerConfigurationBuilder().build(), cm) + assertEquals(server.getHost, "127.0.0.1") + assertEquals(server.getPort, 11211) + } + }) } - } + }) } @Test(expectedExceptions = Array(classOf[CacheConfigurationException])) def testValidateInvalidExpiration { val config = new ConfigurationBuilder config.expiration().lifespan(10) - Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager(config)) { cm => - Stoppable.useServer(new MemcachedServer) { server => - server.start(new MemcachedServerConfigurationBuilder().cache("memcachedCache").build(), cm) - fail("Server should not start when expiration is enabled") + Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager(config), new Consumer[EmbeddedCacheManager] { + override def accept(cm: EmbeddedCacheManager): Unit = { + Stoppable.useServer(new MemcachedServer(), new Consumer[MemcachedServer] { + override def accept(server: MemcachedServer): Unit = { + server.start(new MemcachedServerConfigurationBuilder().cache("memcachedCache").build(), cm) + fail("Server should not start when expiration is enabled") + } + }) } - } + }) } } \ No newline at end of file diff --git a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedStatsTest.scala b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedStatsTest.scala index b40201c6191a..e93a437079a7 100644 --- a/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedStatsTest.scala +++ b/server/memcached/src/test/scala/org/infinispan/server/memcached/MemcachedStatsTest.scala @@ -11,7 +11,7 @@ import test.MemcachedTestingUtil._ import org.infinispan.manager.EmbeddedCacheManager import net.spy.memcached.MemcachedClient import annotation.tailrec -import org.infinispan.server.core.ConnectionStatsTest._ +import ConnectionStatsTest._ /** * Tests stats command for Infinispan Memcached server. diff --git a/server/memcached/src/test/scala/org/infinispan/server/memcached/test/MemcachedTestingUtil.scala b/server/memcached/src/test/scala/org/infinispan/server/memcached/test/MemcachedTestingUtil.scala index 891a0195a35e..7299dfc35b13 100644 --- a/server/memcached/src/test/scala/org/infinispan/server/memcached/test/MemcachedTestingUtil.scala +++ b/server/memcached/src/test/scala/org/infinispan/server/memcached/test/MemcachedTestingUtil.scala @@ -3,11 +3,14 @@ package org.infinispan.server.memcached.test import net.spy.memcached.{DefaultConnectionFactory, MemcachedClient} import java.net.InetSocketAddress import java.util.concurrent.atomic.AtomicInteger + import org.infinispan.server.memcached.{MemcachedDecoder, MemcachedServer} import org.infinispan.manager.EmbeddedCacheManager import java.util + +import org.infinispan.commons.logging.LogFactory import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder -import org.infinispan.server.memcached.logging.Log +import org.infinispan.server.memcached.logging.JavaLog /** * Utils for Memcached tests. @@ -15,7 +18,8 @@ import org.infinispan.server.memcached.logging.Log * @author Galder Zamarreño * @since 4.1 */ -object MemcachedTestingUtil extends Log { +object MemcachedTestingUtil { + val log = LogFactory.getLog(getClass, classOf[JavaLog]) def host = "127.0.0.1" @@ -57,7 +61,7 @@ object MemcachedTestingUtil extends Log { } catch { case t: Throwable => { - error("Error stopping client", t) + log.error("Error stopping client", t) } } } diff --git a/server/rest/src/main/scala/org/infinispan/rest/NettyRestServer.scala b/server/rest/src/main/scala/org/infinispan/rest/NettyRestServer.scala index 160a15299773..7b71fa185fe9 100644 --- a/server/rest/src/main/scala/org/infinispan/rest/NettyRestServer.scala +++ b/server/rest/src/main/scala/org/infinispan/rest/NettyRestServer.scala @@ -4,17 +4,21 @@ import java.io.IOException import javax.ws.rs.container.{ContainerRequestFilter, ContainerResponseFilter} import org.infinispan.commons.api.Lifecycle +import org.infinispan.commons.logging.LogFactory import org.infinispan.manager.{DefaultCacheManager, EmbeddedCacheManager} import org.infinispan.rest.configuration.{RestServerConfiguration, RestServerConfigurationBuilder} -import org.infinispan.rest.logging.{RestAccessLoggingHandler, Log} -import org.infinispan.server.core.CacheIgnoreAware +import org.infinispan.rest.logging.{JavaLog, RestAccessLoggingHandler} +import org.infinispan.server.core.{AbstractCacheIgnoreAware, CacheIgnoreAware} import org.jboss.resteasy.plugins.server.netty.NettyJaxrsServer import org.jboss.resteasy.spi.ResteasyDeployment + import scala.collection.JavaConversions._ final class NettyRestServer ( val cacheManager: EmbeddedCacheManager, val configuration: RestServerConfiguration, - netty: NettyJaxrsServer, onStop: EmbeddedCacheManager => Unit) extends Lifecycle with Log with CacheIgnoreAware { + netty: NettyJaxrsServer, onStop: EmbeddedCacheManager => Unit) extends AbstractCacheIgnoreAware with Lifecycle { + + val log = LogFactory.getLog(getClass, classOf[JavaLog]) override def start(): Unit = { netty.start() @@ -25,7 +29,7 @@ final class NettyRestServer ( deployment.getRegistry.addSingletonResource(server) deployment.getProviderFactory.register(new RestAccessLoggingHandler, classOf[ContainerResponseFilter], classOf[ContainerRequestFilter]) - logStartRestServer(configuration.host(), configuration.port()) + log.startRestServer(configuration.host, configuration.port) } override def stop(): Unit = { @@ -35,7 +39,9 @@ final class NettyRestServer ( } -object NettyRestServer extends Log { +object NettyRestServer { + + val log = LogFactory.getLog(getClass, classOf[JavaLog]) def apply(config: RestServerConfiguration): NettyRestServer = { NettyRestServer(config, new DefaultCacheManager(), cm => cm.stop()) @@ -69,7 +75,7 @@ object NettyRestServer extends Log { new DefaultCacheManager(cfgFile) } catch { case e: IOException => - logErrorReadingConfigurationFile(e, cfgFile) + log.errorReadingConfigurationFile(e, cfgFile) new DefaultCacheManager() } } diff --git a/server/rest/src/main/scala/org/infinispan/rest/logging/Log.scala b/server/rest/src/main/scala/org/infinispan/rest/logging/Log.scala deleted file mode 100644 index 724f4c84c8d6..000000000000 --- a/server/rest/src/main/scala/org/infinispan/rest/logging/Log.scala +++ /dev/null @@ -1,23 +0,0 @@ -package org.infinispan.rest.logging - -import org.infinispan.util.logging.LogFactory - -/** - * A logging facade for Scala code. - * - * @author Galder Zamarreño - * @since 5.0 - */ -trait Log extends org.infinispan.server.core.logging.Log { - - private lazy val log: JavaLog = LogFactory.getLog(getClass, classOf[JavaLog]) - - def logErrorReadingConfigurationFile(t: Throwable, path: String): Unit = { - log.errorReadingConfigurationFile(t, path) - } - - def logStartRestServer(host: String, port: Int): Unit = { - log.startRestServer(host, port) - } - -} diff --git a/server/rest/src/test/scala/org/infinispan/rest/IntegrationTest.scala b/server/rest/src/test/scala/org/infinispan/rest/IntegrationTest.scala index 67a475ccda3b..86a65c64b2a6 100644 --- a/server/rest/src/test/scala/org/infinispan/rest/IntegrationTest.scala +++ b/server/rest/src/test/scala/org/infinispan/rest/IntegrationTest.scala @@ -3,31 +3,41 @@ package org.infinispan.rest import org.apache.commons.httpclient.methods._ import javax.servlet.http.HttpServletResponse import javax.servlet.http.HttpServletResponse._ + import org.infinispan.remoting.MIMECacheEntry import java.io._ -import org.testng.annotations.{Test, BeforeClass, AfterClass} + +import org.testng.annotations.{AfterClass, BeforeClass, Test} import java.lang.reflect.Method + import org.infinispan.commons.api.BasicCacheContainer + import scala.concurrent.{Await, Future} import scala.concurrent.duration._ import scala.math._ import org.infinispan.test.TestingUtil import java.text.SimpleDateFormat -import org.apache.commons.httpclient.{HttpMethodBase, Header, HttpClient} + +import org.apache.commons.httpclient.{Header, HttpClient, HttpMethodBase} import org.apache.commons.httpclient.HttpMethod import java.util.{Calendar, Locale} + import org.testng.AssertJUnit._ import org.infinispan.manager.EmbeddedCacheManager import org.infinispan.manager.impl.AbstractDelegatingEmbeddedCacheManager -import org.infinispan.{Cache, AdvancedCache} +import org.infinispan.{AdvancedCache, Cache} import org.infinispan.cache.impl.AbstractDelegatingAdvancedCache -import java.util.concurrent.{TimeUnit, CountDownLatch} -import org.infinispan.server.core.logging.JavaLog +import java.util.concurrent.{CountDownLatch, TimeUnit} + import org.infinispan.util.logging.LogFactory import org.infinispan.test.fwk.TestCacheManagerFactory import java.util + import org.infinispan.metadata.Metadata import javax.ws.rs.core.CacheControl + +import org.infinispan.server.core.logging.Log + import scala.concurrent.ExecutionContext.Implicits.global /** diff --git a/server/websocket/src/main/java/org/infinispan/server/websocket/WebSocketServer.java b/server/websocket/src/main/java/org/infinispan/server/websocket/WebSocketServer.java index 512374a01830..1198abedf33a 100644 --- a/server/websocket/src/main/java/org/infinispan/server/websocket/WebSocketServer.java +++ b/server/websocket/src/main/java/org/infinispan/server/websocket/WebSocketServer.java @@ -11,6 +11,7 @@ import org.infinispan.server.core.AbstractProtocolServer; import org.infinispan.server.core.CacheIgnoreAware; import org.infinispan.server.core.configuration.ProtocolServerConfiguration; +import org.infinispan.server.websocket.configuration.WebSocketServerConfiguration; import org.infinispan.server.websocket.handlers.GetHandler; import org.infinispan.server.websocket.handlers.NotifyHandler; import org.infinispan.server.websocket.handlers.PutHandler; @@ -32,7 +33,7 @@ * Websocket specific code lifted from Netty WebSocket Server example. *

*/ -public class WebSocketServer extends AbstractProtocolServer { +public class WebSocketServer extends AbstractProtocolServer { private static final Log logger = LogFactory.getLog(MethodHandles.lookup().lookupClass(), Log.class); @@ -52,13 +53,13 @@ public ChannelInboundHandler getDecoder() { return null; } - public void startInternal(ProtocolServerConfiguration configuration, EmbeddedCacheManager cacheManager) { + public void startInternal(WebSocketServerConfiguration configuration, EmbeddedCacheManager cacheManager) { super.startInternal(configuration, cacheManager); } @Override public ChannelInitializer getInitializer() { - return new WebSocketServerPipelineFactory(cacheManager(), this); + return new WebSocketServerPipelineFactory(cacheManager, this); } private static class WebSocketServerPipelineFactory extends ChannelInitializer {