ISPN-9459 Remove compat mode from the Memcached server

cli/cli-interpreter/src/main/java/org/infinispan/cli/interpreter/codec/MemcachedCodec.java

@@ -1,6 +1,6 @@
 package org.infinispan.cli.interpreter.codec;
 
-import java.nio.charset.Charset;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 import org.infinispan.cli.interpreter.Interpreter;
 import org.infinispan.cli.interpreter.logging.Log;
@@ -17,7 +17,6 @@
 @MetaInfServices(org.infinispan.cli.interpreter.codec.Codec.class)
 public class MemcachedCodec extends AbstractCodec {
    private static final Log log = LogFactory.getLog(Interpreter.class, Log.class);
-   private Charset UTF8 = Charset.forName("UTF-8");
 
    public MemcachedCodec() {
       try {
@@ -38,14 +37,15 @@ public void setWhiteList(ClassWhiteList whiteList) {
 
    @Override
    public Object encodeKey(Object key) {
-      return key;
+      if (key == null) return null;
+      return key.toString().getBytes(UTF_8);
    }
 
    @Override
    public Object encodeValue(Object value) throws CodecException {
       if (value != null) {
          if (value instanceof String) {
-            return ((String) value).getBytes(UTF8);
+            return ((String) value).getBytes(UTF_8);
          } else if (value instanceof byte[]) {
             return value;
          } else {
@@ -58,13 +58,17 @@ public Object encodeValue(Object value) throws CodecException {
 
    @Override
    public Object decodeKey(Object key) {
-      return key;
+      if (key == null) return null;
+      if (key instanceof byte[]) {
+         return new String((byte[]) key, UTF_8);
+      }
+      return key.toString();
    }
 
    @Override
    public Object decodeValue(Object value) {
       if (value != null) {
-         return new String((byte[]) value, UTF8);
+         return new String((byte[]) value, UTF_8);
       } else {
          return null;
       }

cli/cli-interpreter/src/test/java/org/infinispan/cli/interpreter/MemcachedEncodingTest.java

@@ -57,11 +57,11 @@ public void release() {
    }
 
    public void testMemcachedCodec() throws Exception {
-      Cache<String, byte[]> cache = cacheManager.getCache(MEMCACHED_CACHE);
+      Cache<byte[], byte[]> cache = cacheManager.getCache(MEMCACHED_CACHE);
 
       memcachedClient.set("k1", 3600, "v1").get();
 
-      assertTrue(cache.containsKey("k1"));
+      assertTrue(cache.containsKey("k1".getBytes()));
 
       String sessionId = interpreter.createSessionId(MEMCACHED_CACHE);
       Map<String, String> response = interpreter.execute(sessionId, "get --codec=memcached k1;");
@@ -73,11 +73,11 @@ public void testMemcachedCodec() throws Exception {
    }
 
    public void testMemcachedEncoding() throws Exception {
-      Cache<String, byte[]> cache = cacheManager.getCache(MEMCACHED_CACHE);
+      Cache<byte[], byte[]> cache = cacheManager.getCache(MEMCACHED_CACHE);
 
       memcachedClient.set("k1", 3600, "v1").get();
 
-      assertTrue(cache.containsKey("k1"));
+      assertTrue(cache.containsKey("k1".getBytes()));
 
       String sessionId = interpreter.createSessionId(MEMCACHED_CACHE);
       interpreter.execute(sessionId, "encoding memcached;");

core/src/main/java/org/infinispan/factories/EncoderRegistryFactory.java

@@ -9,9 +9,7 @@
 import org.infinispan.commons.dataconversion.GlobalMarshallerEncoder;
 import org.infinispan.commons.dataconversion.IdentityEncoder;
 import org.infinispan.commons.dataconversion.IdentityWrapper;
-import org.infinispan.commons.dataconversion.JavaCompatEncoder;
 import org.infinispan.commons.dataconversion.JavaSerializationEncoder;
-import org.infinispan.commons.dataconversion.UTF8CompatEncoder;
 import org.infinispan.commons.dataconversion.UTF8Encoder;
 import org.infinispan.commons.marshall.JavaSerializationMarshaller;
 import org.infinispan.commons.marshall.StreamingMarshaller;
@@ -51,8 +49,6 @@ public <T> T construct(Class<T> componentType) {
       encoderRegistry.registerEncoder(new GenericJbossMarshallerEncoder(jBossMarshaller));
       encoderRegistry.registerEncoder(new GlobalMarshallerEncoder(globalMarshaller));
       encoderRegistry.registerEncoder(new CompatModeEncoder(globalMarshaller));
-      encoderRegistry.registerEncoder(new JavaCompatEncoder(classWhiteList));
-      encoderRegistry.registerEncoder(UTF8CompatEncoder.INSTANCE);
       encoderRegistry.registerTranscoder(new DefaultTranscoder(jBossMarshaller, javaSerializationMarshaller));
 
       encoderRegistry.registerWrapper(ByteArrayWrapper.INSTANCE);

documentation/src/main/asciidoc/user_guide/endpoint_interop.adoc

@@ -12,12 +12,15 @@ Depending on the level of interoperability required of a single cache being acce
 
 In general REST clients are better suited to deal with text formats such as JSON, XML or plain text instead of binary, although the REST endpoint does support <<rest.key_content_type, representing binary values in hexadecimal or base64 format>>.
 
+Memcached text clients, due to how the protocol is defined, expect String based keys and byte[] values, and can't negotiate the data types
+with the server, so they have less flexibility when it comes to data formats than the other clients.
+
 Java Hot Rod clients usually deal with objects representing the entities stored in the cache, and through the marshalling operation, will have those entities mapped to/from bytes to be sent across the wire.
 
 Similarly, non-java Hot Rod clients (C++/C#/Javascript) are also better suited to deal with native objects in those languages. The caveat is, if they must interoperate with Java clients, a platform independent format must be chosen.
 
 
-=== Basic Interoperability between REST/Hot Rod using text
+=== Basic Interoperability between REST/Hot Rod/Memcached using text
 
 If querying/indexing is not required, and the cache will store only text, it's enough to configure the cache keys and values MediaType with `text/plain; charset=UTF-8` (or any other charset) or another text based format such as JSON and XML (optionally carrying a custom charset).
 
@@ -29,15 +32,17 @@ and reading:
 
  Accept: text/plain; charset=UTF-8 (or any other charset)
 
+Memcached clients will work without any specific configuration.
+
 In summary:
 
 |===
-|REST clients|Java Hot Rod clients|Query|Non Java Hot Rod clients|Custom objects|Avoid Class deployment
-|[green]*Y*|[green]*Y* |[red]*N*|[red]*N*|[red]*N* |[green]*Y*
+|REST clients|Java Hot Rod clients|Memcached clients|Query|Non Java Hot Rod clients|Custom objects|Avoid Class deployment
+|[green]*Y*|[green]*Y* |[green]*Y*|[red]*N*|[red]*N*|[red]*N* |[green]*Y*
 |===
 
 
-=== Interoperability between REST/Hot Rod using custom Java objects
+=== Interoperability between REST/Hot Rod/Memcached using custom Java objects
 
 If the storage is done using a marshalled, custom java object (this is the default behaviour when using the Java Hot Rod client) and no query is required, it's necessary to configure the cache with the MediaType of the marshalled storage.
 
@@ -55,15 +60,19 @@ By default, the Java Hot Rod client uses JBoss marshalling format to send data t
 
 If the protostream marshaller is used, the media type should be `application/x-protostream`, and for the UTF8Marshaller, `text/plain` should be used.
 
-TIP: When only Hot Rod clients are used to interact with a certain cache, it's not mandatory to configure the MediaType
+TIP: When only Hot Rod clients are used to interact with a certain cache, it's not mandatory to configure the MediaType.
 
 Since REST clients will probably deal with a text friendly format, it's recommended to use as keys `java.lang.String` or any primitive, otherwise they will need to handle byte[] as the key using one of the <<rest.key_content_type,supported binary encoding>> (Base64 or Hex).
 
 The values can be read from REST in XML or JSON format, but the <<entities.deploy,classes must be available in the server>>.
 
+To read and write data from memcached, the keys must be Strings (it will be stored as a marshalled java.lang.String) and the value by default will be returned as it is stored (marshalled objects).
+Some Java Memcached clients allow to plug-in data transformers to marshall and umarshall objects, or alternatively the
+memcached server can be configured to encode the response in a different format, potentially a language neutral format such as JSON, allowing non-java clients to interact even if the cache storage is Java specific. More details in <<memcached.client.encoding, Configuring memcached client encoding>>
+
 |===
-|REST clients|Java Hot Rod clients|Query|Non Java Hot Rod clients|Custom objects|Avoid Class deployment
-|[green]*Y*|[green]*Y*|[red]*N*|[red]*N*|[green]*Y* |[red]*N*
+|REST clients|Java Hot Rod clients|Memcached clients|Query|Non Java Hot Rod clients|Custom objects|Avoid Class deployment
+|[green]*Y*|[green]*Y*|[green]*Y*|[red]*N*|[red]*N*|[green]*Y* |[red]*N*
 |===
 
 
@@ -131,11 +140,14 @@ Hot Rod clients will need to use a marshaller that is supported by {brandname},
 
 REST clients need to use a format that can be converted to/from java objects, currently JSON or XML.
 
+Memcached clients will need to send and receive a serialized version of the stored Pojo, by default it will be a JBoss marshalled payload, but
+by configuring the <<memcached.client.encoding, client-encoding>> in the appropriated memcached connector, it is possible to change the format so that memcached clients can use a platform neutral format such as JSON.
+
 Querying and indexing will work provided that the entities are <<query.library,annotated>>.
 
 |===
-|REST clients|Java Hot Rod clients|Query|Non Java Hot Rod clients|Custom objects|Avoid Class deployment
-|[green]*Y*|[green]*Y*|[green]*Y*|[red]*N*|[green]*Y* |[red]*N*|
+|REST clients|Java Hot Rod clients|Memcached clients|Query|Non Java Hot Rod clients|Custom objects|Avoid Class deployment
+|[green]*Y*|[green]*Y*|[green]*Y*|[green]*Y*|[red]*N*|[green]*Y* |[red]*N*|
 |===
 
 === Deploying entities to the server[[entities.deploy]]

documentation/src/main/asciidoc/user_guide/server_protocols_memcached.adoc

@@ -1,6 +1,16 @@
 ===  Memcached Server
 The {brandname} Server distribution contains a server module that implements the link:http://github.com/memcached/memcached/blob/master/doc/protocol.txt[Memcached text protocol]. This allows Memcached clients to talk to one or several {brandname} backed Memcached servers. These servers could either be working standalone just like Memcached does where each server acts independently and does not communicate with the rest, or they could be clustered where servers replicate or distribute their contents to other {brandname} backed Memcached servers, thus providing clients with failover capabilities.
-Please refer to {brandname} Server's link:../infinispan_server_guide/infinispan_server_guide.html[documentation] for instructions on how to configure and run a Memcached server.
+Please refer to {brandname} Server's link:../server_guide/server_guide.html#memcached[memcached server guide] for instructions on how to configure and run a Memcached server.
+
+==== Client encoding[[memcached.client.encoding]]
+
+The memcached text protocol assumes data values read and written by clients are raw bytes. The support for type negotiation will come
+with link:https://github.com/memcached/memcached/wiki/BinaryProtocolRevamped#data-types[the memcached binary protocol] implementation, as part
+of link:https://issues.jboss.org/browse/ISPN-8726[ISPN-8726].
+
+Although it's not possible for a memcached client to negotiate the data type to obtain data from the server or send data in different formats, the server can optionally be configured to handle values encoded with a certain Media Type. By setting the `client-encoding` attribute in the `memcached-connector` element, the server will return content in this configured format, and clients also send data in this format.
+
+The `client-encoding` is useful when a single cache is accessed from multiple remote endpoints (Rest, HotRod, Memcached) and it allows to tailor the responses/requests to memcached text clients. For more infomarmation on interoperability between endpoints, consult <<endpoint.interop, Endpoint Interop guide>>.
 
 ==== Command Clarifications
 ===== Flush All

integrationtests/compatibility-mode-it/src/test/java/org/infinispan/it/compatibility/CompatibilityCacheFactory.java

@@ -22,6 +22,7 @@
 import org.infinispan.commons.api.BasicCacheContainer;
 import org.infinispan.commons.dataconversion.Encoder;
 import org.infinispan.commons.dataconversion.IdentityEncoder;
+import org.infinispan.commons.dataconversion.MediaType;
 import org.infinispan.commons.marshall.Marshaller;
 import org.infinispan.configuration.cache.CacheMode;
 import org.infinispan.configuration.global.GlobalConfigurationBuilder;
@@ -192,11 +193,12 @@ private void createRestCache() throws Exception {
    }
 
    private void createMemcachedCache() throws IOException {
+      MediaType clientEncoding = marshaller == null ? MediaType.APPLICATION_OCTET_STREAM : marshaller.mediaType();
       memcached = startProtocolServer(findFreePort(), p -> {
          if (memcachedWithDecoder) {
-            return startMemcachedTextServer(cacheManager, p, cacheName);
+            return startMemcachedTextServer(cacheManager, p, cacheName, clientEncoding);
          }
-         return startMemcachedTextServer(cacheManager, p);
+         return startMemcachedTextServer(cacheManager, p, clientEncoding);
       });
       memcachedClient = createMemcachedClient(60000, memcached.getPort());
    }

server/integration/endpoint/src/main/java/org/infinispan/server/endpoint/subsystem/Attribute.java

@@ -41,6 +41,7 @@ public enum Attribute {
     CACHE_CONTAINER(ModelKeys.CACHE_CONTAINER),
     @Deprecated
     CACHE_SUFFIX(ModelKeys.CACHE_SUFFIX),
+   CLIENT_ENCODING(ModelKeys.CLIENT_ENCODING),
     IGNORED_CACHES(ModelKeys.IGNORED_CACHES),
     IO_THREADS(ModelKeys.IO_THREADS),
     EXTENDED_HEADERS(ModelKeys.EXTENDED_HEADERS),

server/integration/endpoint/src/main/java/org/infinispan/server/endpoint/subsystem/EndpointSubsystemReader.java

@@ -151,6 +151,9 @@ private void parseMemcachedConnector(XMLExtendedStreamReader reader, PathAddress
          case CACHE:
             MemcachedConnectorResource.CACHE.parseAndSetParameter(value, connector, reader);
             break;
+            case CLIENT_ENCODING:
+               MemcachedConnectorResource.CLIENT_ENCODING.parseAndSetParameter(value, connector, reader);
+               break;
          default:
             name = parseConnectorAttributes(reader, connector, name, i, value, attribute);
             break;

server/integration/endpoint/src/main/java/org/infinispan/server/endpoint/subsystem/MemcachedConnectorResource.java

@@ -18,6 +18,8 @@
  */
 package org.infinispan.server.endpoint.subsystem;
 
+import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OCTET_STREAM_TYPE;
+
 import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration;
 import org.jboss.as.controller.AttributeDefinition;
 import org.jboss.as.controller.OperationStepHandler;
@@ -48,7 +50,16 @@ public class MemcachedConnectorResource extends ProtocolServerConnectorResource
                  .setDefaultValue(new ModelNode().set(MemcachedServerConfiguration.DEFAULT_MEMCACHED_CACHE))
                  .build();
 
-   static final SimpleAttributeDefinition[] MEMCACHED_CONNECTOR_ATTRIBUTES = { CACHE };
+   static final SimpleAttributeDefinition CLIENT_ENCODING =
+         new SimpleAttributeDefinitionBuilder(ModelKeys.CLIENT_ENCODING, ModelType.STRING, true)
+               .setAllowExpression(true)
+               .setXmlName(ModelKeys.CLIENT_ENCODING)
+               .setRestartAllServices()
+               .setDefaultValue(new ModelNode().set(APPLICATION_OCTET_STREAM_TYPE))
+               .build();
+
+
+   static final SimpleAttributeDefinition[] MEMCACHED_CONNECTOR_ATTRIBUTES = {CACHE, CLIENT_ENCODING};
 
    public MemcachedConnectorResource(boolean isRuntimeRegistration) {
       super(MEMCACHED_CONNECTOR_PATH, EndpointExtension.getResourceDescriptionResolver(ModelKeys.MEMCACHED_CONNECTOR), MemcachedSubsystemAdd.INSTANCE,

server/integration/endpoint/src/main/java/org/infinispan/server/endpoint/subsystem/MemcachedSubsystemAdd.java

@@ -18,6 +18,7 @@
  */
 package org.infinispan.server.endpoint.subsystem;
 
+import org.infinispan.commons.dataconversion.MediaType;
 import org.infinispan.server.memcached.MemcachedServer;
 import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
 import org.jboss.as.controller.AttributeDefinition;
@@ -53,12 +54,13 @@ private static void populate(ModelNode source, ModelNode target) throws Operatio
    protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException {
       // Read the full model
       ModelNode config = Resource.Tools.readModel(context.readResource(PathAddress.EMPTY_ADDRESS));
+      final String cacheName = MemcachedConnectorResource.CACHE.resolveModelAttribute(context, config).asString();
+      final String clientEncoding = MemcachedConnectorResource.CLIENT_ENCODING.resolveModelAttribute(context, config).asString();
       // Create the builder
       MemcachedServerConfigurationBuilder configurationBuilder = new MemcachedServerConfigurationBuilder();
+      configurationBuilder.clientEncoding(MediaType.parse(clientEncoding));
       this.configureProtocolServer(context, configurationBuilder, config);
 
-      final String cacheName = MemcachedConnectorResource.CACHE.resolveModelAttribute(context, config).asString();
-
       // Create the service
       final ProtocolServerService service = new ProtocolServerService(getServiceName(operation), MemcachedServer.class, configurationBuilder, cacheName);
 

server/integration/endpoint/src/main/java/org/infinispan/server/endpoint/subsystem/ModelKeys.java

@@ -40,6 +40,7 @@ public class ModelKeys {
    public static final String KEEP_ALIVE = "keep-alive"; // boolean
    public static final String CACHE = "cache"; // string
    public static final String CACHE_CONTAINER = "cache-container"; // string
+   public static final String CLIENT_ENCODING = "client-encoding"; // string
    public static final String IO_THREADS = "io-threads"; // integer
    public static final String WORKER_THREADS = "worker-threads"; // integer
    public static final String IDLE_TIMEOUT = "idle-timeout"; // integer

server/integration/endpoint/src/main/resources/org/infinispan/server/endpoint/subsystem/LocalDescriptions.properties

@@ -29,6 +29,7 @@ memcached-connector.remove=Removes a Memcached connector
 memcached-connector.name=The name to give to this connector
 memcached-connector.ignored-caches=List of caches ignored for this connector
 memcached-connector.cache=The cache to use
+memcached-connector.client-encoding=The client encoding for the memcached text protocol
 memcached-connector.cache-container=The cache container to use
 memcached-connector.socket-binding=The socket binding to use for this connector
 memcached-connector.io-threads=The number of I/O threads to use for this connector

server/integration/endpoint/src/main/resources/schema/jboss-infinispan-endpoint_9_4.xsd

@@ -162,6 +162,13 @@
                         <xs:documentation>The name of the cache to use for the Memcached connector. Defaults to memcachedCache</xs:documentation>
                     </xs:annotation>
                 </xs:attribute>
+                <xs:attribute name="client-encoding" type="xs:string">
+                    <xs:annotation>
+                        <xs:documentation>The client encoding for the values, only applicable to the memcached text
+                            protocol.
+                        </xs:documentation>
+                    </xs:annotation>
+                </xs:attribute>
             </xs:extension>
         </xs:complexContent>
     </xs:complexType>