GH-1025: Add Transport Layer abstraction at Client side.

leshan-client-cf/src/main/java/org/eclipse/leshan/client/californium/CaliforniumConnectionController.java

@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2022 Sierra Wireless and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v2.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v20.html
+ * and the Eclipse Distribution License is available at
+ *    http://www.eclipse.org/org/documents/edl-v10.html.
+ *
+ * Contributors:
+ *     Sierra Wireless - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.leshan.client.californium;
+
+import org.eclipse.californium.core.network.Endpoint;
+import org.eclipse.leshan.client.servers.ServerIdentity;
+
+public interface CaliforniumConnectionController {
+    void forceReconnection(Endpoint endpoint, ServerIdentity identity, boolean resume);
+}

leshan-client-cf/src/main/java/org/eclipse/leshan/client/californium/LwM2mClientCoapResource.java

@@ -17,48 +17,35 @@
 
 import org.eclipse.californium.core.CoapResource;
 import org.eclipse.californium.core.coap.CoAP.ResponseCode;
+import org.eclipse.californium.core.coap.Message;
 import org.eclipse.californium.core.network.Exchange;
-import org.eclipse.californium.core.network.Exchange.Origin;
 import org.eclipse.californium.core.server.resources.CoapExchange;
-import org.eclipse.leshan.client.engine.RegistrationEngine;
+import org.eclipse.leshan.client.californium.endpoint.ServerIdentityExtractor;
 import org.eclipse.leshan.client.servers.ServerIdentity;
 import org.eclipse.leshan.core.californium.LwM2mCoapResource;
+import org.eclipse.leshan.core.californium.identity.IdentityHandlerProvider;
+import org.eclipse.leshan.core.request.Identity;
 
 /**
  * A Common {@link CoapResource} used to handle LWM2M request with some specific method for LWM2M client.
  */
 public class LwM2mClientCoapResource extends LwM2mCoapResource {
 
-    protected final CaliforniumEndpointsManager endpointsManager;
-    protected final RegistrationEngine registrationEngine;
+    protected final ServerIdentityExtractor serverIdentityExtractor;
 
-    public LwM2mClientCoapResource(String name, RegistrationEngine registrationEngine,
-            CaliforniumEndpointsManager endpointsManager) {
-        super(name, null);
-        this.registrationEngine = registrationEngine;
-        this.endpointsManager = endpointsManager;
-    }
-
-    /**
-     * @return the server identity of a registered or bootstrap server, return null if this identity does match to any
-     *         server for which we are in communication.
-     */
-    protected ServerIdentity getServer(CoapExchange exchange) {
-        ServerIdentity serverIdentity = extractIdentity(exchange);
-        if (registrationEngine.isAllowedToCommunicate(serverIdentity)) {
-            return serverIdentity;
-        } else {
-            return null;
-        }
+    public LwM2mClientCoapResource(String name, IdentityHandlerProvider identityHandlerProvider,
+            ServerIdentityExtractor identityExtractor) {
+        super(name, identityHandlerProvider);
+        this.serverIdentityExtractor = identityExtractor;
     }
 
     /**
      * Extract the {@link ServerIdentity} for this exchange. If there is no corresponding server currently in
      * communication with this client. Answer with an {@link ResponseCode#INTERNAL_SERVER_ERROR}.
      */
-    protected ServerIdentity getServerOrRejectRequest(CoapExchange exchange) {
+    protected ServerIdentity getServerOrRejectRequest(CoapExchange exchange, Message receivedMessage) {
         // search if we are in communication with this server.
-        ServerIdentity server = getServer(exchange);
+        ServerIdentity server = extractIdentity(exchange.advanced(), receivedMessage);
         if (server != null)
             return server;
 
@@ -73,9 +60,10 @@ protected ServerIdentity getServerOrRejectRequest(CoapExchange exchange) {
      * @return The corresponding Leshan {@link ServerIdentity}.
      * @throws IllegalStateException if we are not able to extract {@link ServerIdentity}.
      */
-    protected ServerIdentity extractIdentity(CoapExchange exchange) {
-        return endpointsManager.getServerIdentity(exchange.advanced().getEndpoint(), exchange.getSourceSocketAddress(),
-                exchange.advanced().getOrigin() == Origin.REMOTE ? exchange.advanced().getRequest().getSourceContext()
-                        : exchange.advanced().getRequest().getDestinationContext());
+    protected ServerIdentity extractIdentity(Exchange exchange, Message receivedMessage) {
+        Identity foreignPeerIdentity = getForeignPeerIdentity(exchange, receivedMessage);
+        if (foreignPeerIdentity == null)
+            return null;
+        return serverIdentityExtractor.extractIdentity(exchange, foreignPeerIdentity);
     }
 }

leshan-client-cf/src/main/java/org/eclipse/leshan/client/californium/ObserveCompositeRelationFilter.java

@@ -28,7 +28,7 @@
 /**
  * An {@link ObserveRelationFilter} which select {@link ObserveRelation} based on one of resource URIs.
  */
-class ObserveCompositeRelationFilter implements ObserveRelationFilter {
+public class ObserveCompositeRelationFilter implements ObserveRelationFilter {
 
     private final List<LwM2mPath> paths;
 

leshan-client-cf/src/main/java/org/eclipse/leshan/client/californium/RootResource.java

@@ -30,17 +30,14 @@
 import org.eclipse.californium.core.coap.MediaTypeRegistry;
 import org.eclipse.californium.core.coap.Request;
 import org.eclipse.californium.core.server.resources.CoapExchange;
-import org.eclipse.leshan.client.bootstrap.BootstrapHandler;
-import org.eclipse.leshan.client.engine.RegistrationEngine;
-import org.eclipse.leshan.client.resource.LwM2mRootEnabler;
-import org.eclipse.leshan.client.resource.listener.ObjectsListenerAdapter;
+import org.eclipse.leshan.client.californium.endpoint.ServerIdentityExtractor;
+import org.eclipse.leshan.client.endpoint.ClientEndpointToolbox;
+import org.eclipse.leshan.client.request.DownlinkRequestReceiver;
 import org.eclipse.leshan.client.servers.ServerIdentity;
 import org.eclipse.leshan.core.californium.ObserveUtil;
-import org.eclipse.leshan.core.link.LinkSerializer;
+import org.eclipse.leshan.core.californium.identity.IdentityHandlerProvider;
 import org.eclipse.leshan.core.node.LwM2mNode;
 import org.eclipse.leshan.core.node.LwM2mPath;
-import org.eclipse.leshan.core.node.codec.LwM2mDecoder;
-import org.eclipse.leshan.core.node.codec.LwM2mEncoder;
 import org.eclipse.leshan.core.request.BootstrapDeleteRequest;
 import org.eclipse.leshan.core.request.BootstrapDiscoverRequest;
 import org.eclipse.leshan.core.request.ContentFormat;
@@ -59,65 +56,54 @@
  */
 public class RootResource extends LwM2mClientCoapResource {
 
-    protected CoapServer coapServer;
-    protected BootstrapHandler bootstrapHandler;
-    protected LwM2mRootEnabler rootEnabler;
-    protected LwM2mEncoder encoder;
-    protected LwM2mDecoder decoder;
-    protected LinkSerializer linkSerializer;
-
-    public RootResource(RegistrationEngine registrationEngine, CaliforniumEndpointsManager endpointsManager,
-            BootstrapHandler bootstrapHandler, CoapServer coapServer, LwM2mRootEnabler rootEnabler,
-            LwM2mEncoder encoder, LwM2mDecoder decoder, LinkSerializer linkSerializer) {
-        super("", registrationEngine, endpointsManager);
-        this.bootstrapHandler = bootstrapHandler;
+    protected DownlinkRequestReceiver requestReceiver;
+    protected ClientEndpointToolbox toolbox;
+
+    public RootResource(IdentityHandlerProvider identityHandlerProvider,
+            ServerIdentityExtractor serverIdentityExtractor, CoapServer coapServer,
+            DownlinkRequestReceiver requestReceiver, ClientEndpointToolbox toolbox) {
+        super("", identityHandlerProvider, serverIdentityExtractor);
         setVisible(false);
         setObservable(true);
-        this.coapServer = coapServer;
-        this.rootEnabler = rootEnabler;
-        this.encoder = encoder;
-        this.decoder = decoder;
-        this.linkSerializer = linkSerializer;
-
-        addListeners();
+        this.requestReceiver = requestReceiver;
+        this.toolbox = toolbox;
     }
 
     @Override
     public void handleGET(CoapExchange exchange) {
-        ServerIdentity identity = getServerOrRejectRequest(exchange);
+        // Manage Bootstrap Discover Request
+        Request coapRequest = exchange.advanced().getRequest();
+        ServerIdentity identity = getServerOrRejectRequest(exchange, coapRequest);
         if (identity == null)
             return;
 
         String URI = exchange.getRequestOptions().getUriPathString();
 
-        // Manage Bootstrap Discover Request
-        Request coapRequest = exchange.advanced().getRequest();
-        BootstrapDiscoverResponse response = bootstrapHandler.discover(identity,
-                new BootstrapDiscoverRequest(URI, coapRequest));
+        BootstrapDiscoverResponse response = requestReceiver
+                .requestReceived(identity, new BootstrapDiscoverRequest(URI, coapRequest)).getResponse();
         if (response.getCode().isError()) {
             exchange.respond(toCoapResponseCode(response.getCode()), response.getErrorMessage());
         } else {
             exchange.respond(toCoapResponseCode(response.getCode()),
-                    linkSerializer.serializeCoreLinkFormat(response.getObjectLinks()),
+                    toolbox.getLinkSerializer().serializeCoreLinkFormat(response.getObjectLinks()),
                     MediaTypeRegistry.APPLICATION_LINK_FORMAT);
         }
         return;
     }
 
     @Override
     public void handleFETCH(CoapExchange exchange) {
-        ServerIdentity identity = getServerOrRejectRequest(exchange);
+        Request coapRequest = exchange.advanced().getRequest();
+        ServerIdentity identity = getServerOrRejectRequest(exchange, coapRequest);
         if (identity == null)
             return;
 
-        Request coapRequest = exchange.advanced().getRequest();
-
         // Handle content format for the response
         ContentFormat responseContentFormat = ContentFormat.SENML_CBOR; // use CBOR as default
         if (exchange.getRequestOptions().hasAccept()) {
             // If an request ask for a specific content format, use it (if we support it)
             responseContentFormat = ContentFormat.fromCode(exchange.getRequestOptions().getAccept());
-            if (!encoder.isSupported(responseContentFormat)) {
+            if (!toolbox.getEncoder().isSupported(responseContentFormat)) {
                 exchange.respond(ResponseCode.NOT_ACCEPTABLE);
                 return;
             }
@@ -129,36 +115,38 @@ public void handleFETCH(CoapExchange exchange) {
             return;
         }
         ContentFormat requestContentFormat = ContentFormat.fromCode(exchange.getRequestOptions().getContentFormat());
-        List<LwM2mPath> paths = decoder.decodePaths(coapRequest.getPayload(), requestContentFormat);
+        List<LwM2mPath> paths = toolbox.getDecoder().decodePaths(coapRequest.getPayload(), requestContentFormat);
 
         if (exchange.getRequestOptions().hasObserve()) {
             // Manage Observe Composite request
             ObserveCompositeRequest observeRequest = new ObserveCompositeRequest(requestContentFormat,
                     responseContentFormat, paths, coapRequest);
-            ObserveCompositeResponse response = rootEnabler.observe(identity, observeRequest);
+            ObserveCompositeResponse response = requestReceiver.requestReceived(identity, observeRequest).getResponse();
 
             updateUserContextWithPaths(coapRequest, paths);
 
             if (response.getCode().isError()) {
                 exchange.respond(toCoapResponseCode(response.getCode()), response.getErrorMessage());
                 return;
             } else {
-                exchange.respond(toCoapResponseCode(response.getCode()),
-                        encoder.encodeNodes(response.getContent(), responseContentFormat, rootEnabler.getModel()),
+                exchange.respond(toCoapResponseCode(response.getCode()), toolbox.getEncoder()
+                        .encodeNodes(response.getContent(), responseContentFormat, toolbox.getModel()),
                         responseContentFormat.getCode());
                 return;
             }
         } else {
             // Manage Read Composite request
-            ReadCompositeResponse response = rootEnabler.read(identity,
-                    new ReadCompositeRequest(paths, requestContentFormat, responseContentFormat, coapRequest));
+            ReadCompositeResponse response = requestReceiver
+                    .requestReceived(identity,
+                            new ReadCompositeRequest(paths, requestContentFormat, responseContentFormat, coapRequest))
+                    .getResponse();
             if (response.getCode().isError()) {
                 exchange.respond(toCoapResponseCode(response.getCode()), response.getErrorMessage());
             } else {
                 // TODO we could maybe face some race condition if an objectEnabler is removed from LwM2mObjectTree
                 // between rootEnabler.read() and rootEnabler.getModel()
-                exchange.respond(toCoapResponseCode(response.getCode()),
-                        encoder.encodeNodes(response.getContent(), responseContentFormat, rootEnabler.getModel()),
+                exchange.respond(toCoapResponseCode(response.getCode()), toolbox.getEncoder()
+                        .encodeNodes(response.getContent(), responseContentFormat, toolbox.getModel()),
                         responseContentFormat.getCode());
             }
             return;
@@ -176,25 +164,24 @@ private void updateUserContextWithPaths(Request coapRequest, List<LwM2mPath> pat
 
     @Override
     public void handleIPATCH(CoapExchange exchange) {
-        ServerIdentity identity = getServerOrRejectRequest(exchange);
-        if (identity == null)
-            return;
-
         // Manage Read Composite request
         Request coapRequest = exchange.advanced().getRequest();
+        ServerIdentity identity = getServerOrRejectRequest(exchange, coapRequest);
+        if (identity == null)
+            return;
 
         // Handle content format
         ContentFormat contentFormat = ContentFormat.fromCode(exchange.getRequestOptions().getContentFormat());
-        if (!decoder.isSupported(contentFormat)) {
+        if (!toolbox.getDecoder().isSupported(contentFormat)) {
             exchange.respond(ResponseCode.UNSUPPORTED_CONTENT_FORMAT);
             return;
         }
 
-        Map<LwM2mPath, LwM2mNode> nodes = decoder.decodeNodes(coapRequest.getPayload(), contentFormat, null,
-                rootEnabler.getModel());
+        Map<LwM2mPath, LwM2mNode> nodes = toolbox.getDecoder().decodeNodes(coapRequest.getPayload(), contentFormat,
+                null, toolbox.getModel());
 
-        WriteCompositeResponse response = rootEnabler.write(identity,
-                new WriteCompositeRequest(contentFormat, nodes, coapRequest));
+        WriteCompositeResponse response = requestReceiver
+                .requestReceived(identity, new WriteCompositeRequest(contentFormat, nodes, coapRequest)).getResponse();
         if (response.getCode().isError()) {
             exchange.respond(toCoapResponseCode(response.getCode()), response.getErrorMessage());
         } else {
@@ -211,23 +198,13 @@ public void handleDELETE(CoapExchange exchange) {
             return;
         }
 
-        ServerIdentity identity = getServerOrRejectRequest(exchange);
+        Request coapRequest = exchange.advanced().getRequest();
+        ServerIdentity identity = getServerOrRejectRequest(exchange, coapRequest);
         if (identity == null)
             return;
 
-        Request coapRequest = exchange.advanced().getRequest();
-        BootstrapDeleteResponse response = bootstrapHandler.delete(identity,
-                new BootstrapDeleteRequest(URI, coapRequest));
+        BootstrapDeleteResponse response = requestReceiver
+                .requestReceived(identity, new BootstrapDeleteRequest(URI, coapRequest)).getResponse();
         exchange.respond(toCoapResponseCode(response.getCode()), response.getErrorMessage());
     }
-
-    private void addListeners() {
-        rootEnabler.addListener(new ObjectsListenerAdapter() {
-
-            @Override
-            public void resourceChanged(LwM2mPath... paths) {
-                changed(new ObserveCompositeRelationFilter(paths));
-            }
-        });
-    }
 }

leshan-client-cf/src/main/java/org/eclipse/leshan/client/californium/bootstrap/BootstrapResource.java

@@ -24,11 +24,11 @@
 import org.eclipse.californium.core.coap.Response;
 import org.eclipse.californium.core.server.resources.CoapExchange;
 import org.eclipse.californium.core.server.resources.Resource;
-import org.eclipse.leshan.client.bootstrap.BootstrapHandler;
-import org.eclipse.leshan.client.californium.CaliforniumEndpointsManager;
 import org.eclipse.leshan.client.californium.LwM2mClientCoapResource;
-import org.eclipse.leshan.client.engine.RegistrationEngine;
+import org.eclipse.leshan.client.californium.endpoint.ServerIdentityExtractor;
+import org.eclipse.leshan.client.request.DownlinkRequestReceiver;
 import org.eclipse.leshan.client.servers.ServerIdentity;
+import org.eclipse.leshan.core.californium.identity.IdentityHandlerProvider;
 import org.eclipse.leshan.core.request.BootstrapFinishRequest;
 import org.eclipse.leshan.core.response.BootstrapFinishResponse;
 import org.eclipse.leshan.core.response.SendableResponse;
@@ -38,26 +38,26 @@
  */
 public class BootstrapResource extends LwM2mClientCoapResource {
 
-    protected BootstrapHandler bootstrapHandler;
+    protected DownlinkRequestReceiver requestReceiver;
 
-    public BootstrapResource(RegistrationEngine registrationEngine, CaliforniumEndpointsManager endpointsManager,
-            BootstrapHandler bootstrapHandler) {
-        super("bs", registrationEngine, endpointsManager);
-        this.bootstrapHandler = bootstrapHandler;
+    public BootstrapResource(IdentityHandlerProvider identityHandlerProvider,
+            ServerIdentityExtractor serverIdentityExtractor, DownlinkRequestReceiver requestReceiver) {
+        super("bs", identityHandlerProvider, serverIdentityExtractor);
+        this.requestReceiver = requestReceiver;
         this.setVisible(false);
     }
 
     @Override
     public void handlePOST(CoapExchange exchange) {
         // Handle bootstrap request
-        ServerIdentity identity = getServerOrRejectRequest(exchange);
+        Request coapRequest = exchange.advanced().getRequest();
+        ServerIdentity identity = getServerOrRejectRequest(exchange, coapRequest);
         if (identity == null)
             return;
 
         // Acknowledge bootstrap finished request
         exchange.accept();
-        Request coapRequest = exchange.advanced().getRequest();
-        final SendableResponse<BootstrapFinishResponse> sendableResponse = bootstrapHandler.finished(identity,
+        final SendableResponse<BootstrapFinishResponse> sendableResponse = requestReceiver.requestReceived(identity,
                 new BootstrapFinishRequest(coapRequest));
 
         // Create CoAP response