From 063537a3e6fbe60011dccbf7fcb90b0be125fd19 Mon Sep 17 00:00:00 2001 From: Manuel Sangoi Date: Fri, 16 Dec 2016 09:26:03 +0100 Subject: [PATCH] Rename ObservationRegistry to ObservationService --- .../leshan/integration/tests/ObserveTest.java | 16 ++++---- .../tests/QueueModeIntegrationTestHelper.java | 20 +++++----- .../integration/tests/QueueModeTest.java | 10 ++--- .../integration/tests/RegistrationTest.java | 6 +-- .../tests/util/QueueModeLeshanServer.java | 28 +++++++------- .../impl/CaliforniumLwM2mRequestSender.java | 14 +++---- .../server/californium/impl/LeshanServer.java | 38 +++++++++---------- .../impl/LwM2mResponseBuilder.java | 10 ++--- ...yImpl.java => ObservationServiceImpl.java} | 28 +++++++------- .../impl/CaliforniumObservationTest.java | 32 ++++++++-------- .../impl/RegistrationServiceImplTest.java | 18 ++++----- .../server/cluster/LeshanClusterServer.java | 2 +- .../cluster/RedisRequestResponseHandler.java | 12 +++--- .../eclipse/leshan/server/LwM2mServer.java | 6 +-- ...Listener.java => ObservationListener.java} | 3 +- ...nRegistry.java => ObservationService.java} | 9 ++--- .../queue/impl/QueuedRequestSender.java | 26 ++++++------- .../server/demo/servlet/ClientServlet.java | 2 +- .../server/demo/servlet/EventServlet.java | 6 +-- 19 files changed, 143 insertions(+), 143 deletions(-) rename leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/{CaliforniumObservationRegistryImpl.java => ObservationServiceImpl.java} (89%) rename leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/{ObservationRegistryListener.java => ObservationListener.java} (96%) rename leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/{ObservationRegistry.java => ObservationService.java} (90%) diff --git a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/ObserveTest.java b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/ObserveTest.java index 9e5593448d..e14aa284db 100644 --- a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/ObserveTest.java +++ b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/ObserveTest.java @@ -50,7 +50,7 @@ import org.eclipse.leshan.core.response.LwM2mResponse; import org.eclipse.leshan.core.response.ObserveResponse; import org.eclipse.leshan.core.response.ReadResponse; -import org.eclipse.leshan.server.observation.ObservationRegistryListener; +import org.eclipse.leshan.server.observation.ObservationListener; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -79,7 +79,7 @@ public void stop() { @Test public void can_observe_resource() throws InterruptedException { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // observe device timezone ObserveResponse observeResponse = helper.server.send(helper.getCurrentRegistration(), new ObserveRequest(3, 0, 15)); @@ -108,7 +108,7 @@ public void can_observe_resource() throws InterruptedException { @Test public void can_observe_instance() throws InterruptedException { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // observe device timezone ObserveResponse observeResponse = helper.server.send(helper.getCurrentRegistration(), new ObserveRequest(3, 0)); @@ -142,7 +142,7 @@ public void can_observe_instance() throws InterruptedException { @Test public void can_observe_object() throws InterruptedException { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // observe device timezone ObserveResponse observeResponse = helper.server.send(helper.getCurrentRegistration(), new ObserveRequest(3)); @@ -176,7 +176,7 @@ public void can_observe_object() throws InterruptedException { @Test public void can_observe_timestamped_resource() throws InterruptedException { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // observe device timezone ObserveResponse observeResponse = helper.server.send(helper.getCurrentRegistration(), @@ -216,7 +216,7 @@ public void can_observe_timestamped_resource() throws InterruptedException { @Test public void can_observe_timestamped_instance() throws InterruptedException { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // observe device timezone ObserveResponse observeResponse = helper.server.send(helper.getCurrentRegistration(), @@ -256,7 +256,7 @@ public void can_observe_timestamped_instance() throws InterruptedException { @Test public void can_observe_timestamped_object() throws InterruptedException { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // observe device timezone ObserveResponse observeResponse = helper.server.send(helper.getCurrentRegistration(), @@ -322,7 +322,7 @@ private void sendNotification(final byte[] payload, final Response firstCoapResp } } - private final class TestObservationListener implements ObservationRegistryListener { + private final class TestObservationListener implements ObservationListener { private final CountDownLatch latch = new CountDownLatch(1); private final AtomicBoolean receivedNotify = new AtomicBoolean(); diff --git a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeIntegrationTestHelper.java b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeIntegrationTestHelper.java index 8c2d727bb1..bb652db8f9 100644 --- a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeIntegrationTestHelper.java +++ b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeIntegrationTestHelper.java @@ -42,7 +42,7 @@ import org.eclipse.leshan.integration.tests.util.QueueModeLeshanServer; import org.eclipse.leshan.integration.tests.util.QueuedModeLeshanClient; import org.eclipse.leshan.server.californium.impl.CaliforniumLwM2mRequestSender; -import org.eclipse.leshan.server.californium.impl.CaliforniumObservationRegistryImpl; +import org.eclipse.leshan.server.californium.impl.ObservationServiceImpl; import org.eclipse.leshan.server.californium.impl.InMemoryRegistrationStore; import org.eclipse.leshan.server.californium.impl.RegisterResource; import org.eclipse.leshan.server.client.Registration; @@ -115,22 +115,22 @@ protected void saveToFile() { LwM2mModelProvider modelProvider = new StandardModelProvider(); LwM2mNodeEncoder encoder = new DefaultLwM2mNodeEncoder(); LwM2mNodeDecoder decoder = new DefaultLwM2mNodeDecoder(); - CaliforniumObservationRegistryImpl observationRegistry = new CaliforniumObservationRegistryImpl( + ObservationServiceImpl observationService = new ObservationServiceImpl( registrationStore, modelProvider, decoder); - observationRegistry.setSecureEndpoint(secureEndpoint); - secureEndpoint.addNotificationListener(observationRegistry); - observationRegistry.setNonSecureEndpoint(noSecureEndpoint); - noSecureEndpoint.addNotificationListener(observationRegistry); + observationService.setSecureEndpoint(secureEndpoint); + secureEndpoint.addNotificationListener(observationService); + observationService.setNonSecureEndpoint(noSecureEndpoint); + noSecureEndpoint.addNotificationListener(observationService); LwM2mRequestSender delegateSender = new CaliforniumLwM2mRequestSender(new HashSet<>(coapServer.getEndpoints()), - observationRegistry, modelProvider, encoder, decoder); + observationService, modelProvider, encoder, decoder); LwM2mRequestSender secondDelegateSender = new CaliforniumLwM2mRequestSender( - new HashSet<>(coapServer.getEndpoints()), observationRegistry, modelProvider, encoder, decoder); + new HashSet<>(coapServer.getEndpoints()), observationService, modelProvider, encoder, decoder); QueuedRequestSender queueRequestSender = QueuedRequestSender.builder().setMessageStore(inMemoryMessageStore) .setRequestSender(secondDelegateSender).setRegistrationService(registrationService) - .setObservationRegistry(observationRegistry).build(); + .setObservationService(observationService).build(); LwM2mRequestSender lwM2mRequestSender = new LwM2mRequestSenderImpl(delegateSender, queueRequestSender); - server = new QueueModeLeshanServer(coapServer, registrationService, observationRegistry, securityRegistry, + server = new QueueModeLeshanServer(coapServer, registrationService, observationService, securityRegistry, modelProvider, lwM2mRequestSender, inMemoryMessageStore); } diff --git a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeTest.java b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeTest.java index 21f18e3967..1fd4b6185b 100644 --- a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeTest.java +++ b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/QueueModeTest.java @@ -39,7 +39,7 @@ import org.eclipse.leshan.integration.tests.util.QueuedModeLeshanClient; import org.eclipse.leshan.integration.tests.util.QueuedModeLeshanClient.OnGetCallback; import org.eclipse.leshan.server.client.Registration; -import org.eclipse.leshan.server.observation.ObservationRegistryListener; +import org.eclipse.leshan.server.observation.ObservationListener; import org.eclipse.leshan.server.queue.MessageStore; import org.eclipse.leshan.server.queue.impl.InMemoryMessageStore; import org.eclipse.leshan.server.response.ResponseListener; @@ -219,7 +219,7 @@ public boolean handleGet(CoapExchange coapExchange) { @Test public void request_sent_after_client_notify() throws Exception { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // stop default client as we need client with a custom life time. helper.client.stop(false); @@ -282,7 +282,7 @@ public void onError(Registration registration, String requestTicket, Exception e @Test public void all_requests_sent_if_client_reachable() throws Exception { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); QueuedModeLeshanClient client = (QueuedModeLeshanClient) helper.client; responseListener = new ResponseListener() { @@ -350,7 +350,7 @@ public void onError(Registration registration, String requestTicket, Exception e @Test public void no_duplicate_send_on_consecutive_notifies() throws Exception { TestObservationListener listener = new TestObservationListener(); - helper.server.getObservationRegistry().addListener(listener); + helper.server.getObservationService().addListener(listener); // stop default client as we need client with a custom life time. helper.client.stop(false); @@ -665,7 +665,7 @@ public boolean handleGet(CoapExchange coapExchange) { }; } - private final class TestObservationListener implements ObservationRegistryListener { + private final class TestObservationListener implements ObservationListener { private CountDownLatch latch = new CountDownLatch(1); private final AtomicBoolean receivedNotify = new AtomicBoolean(); diff --git a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/RegistrationTest.java b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/RegistrationTest.java index e66dde906f..d9c7f7d58d 100644 --- a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/RegistrationTest.java +++ b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/RegistrationTest.java @@ -213,7 +213,7 @@ public void register_observe_deregister_observe() throws NonUniqueSecurityInfoEx // check observation registry is not null Registration currentRegistration = helper.getCurrentRegistration(); - Set observations = helper.server.getObservationRegistry() + Set observations = helper.server.getObservationService() .getObservations(currentRegistration); assertEquals(1, observations.size()); Observation obs = observations.iterator().next(); @@ -224,7 +224,7 @@ public void register_observe_deregister_observe() throws NonUniqueSecurityInfoEx helper.client.stop(true); helper.waitForDeregistration(1); helper.assertClientNotRegisterered(); - observations = helper.server.getObservationRegistry() + observations = helper.server.getObservationService() .getObservations(currentRegistration); assertTrue(observations.isEmpty()); @@ -233,7 +233,7 @@ public void register_observe_deregister_observe() throws NonUniqueSecurityInfoEx assertNull(observeResponse); // check observationStore is empty - observations = helper.server.getObservationRegistry().getObservations(currentRegistration); + observations = helper.server.getObservationService().getObservations(currentRegistration); assertTrue(observations.isEmpty()); } diff --git a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/util/QueueModeLeshanServer.java b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/util/QueueModeLeshanServer.java index 29dad2fec3..28c66f829e 100644 --- a/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/util/QueueModeLeshanServer.java +++ b/leshan-integration-tests/src/test/java/org/eclipse/leshan/integration/tests/util/QueueModeLeshanServer.java @@ -26,11 +26,11 @@ import org.eclipse.leshan.server.Startable; import org.eclipse.leshan.server.Stoppable; import org.eclipse.leshan.server.client.Registration; -import org.eclipse.leshan.server.client.RegistrationService; import org.eclipse.leshan.server.client.RegistrationListener; +import org.eclipse.leshan.server.client.RegistrationService; import org.eclipse.leshan.server.client.RegistrationUpdate; import org.eclipse.leshan.server.model.LwM2mModelProvider; -import org.eclipse.leshan.server.observation.ObservationRegistry; +import org.eclipse.leshan.server.observation.ObservationService; import org.eclipse.leshan.server.queue.MessageStore; import org.eclipse.leshan.server.request.LwM2mRequestSender; import org.eclipse.leshan.server.response.ResponseListener; @@ -42,20 +42,20 @@ public class QueueModeLeshanServer implements LwM2mServer { private static final Logger LOG = LoggerFactory.getLogger(QueueModeLeshanServer.class); private final CoapServer coapServer; private final RegistrationService registrationService; - private final ObservationRegistry observationRegistry; + private final ObservationService observationService; private final SecurityRegistry securityRegistry; private final LwM2mModelProvider modelProvider; private final LwM2mRequestSender lwM2mRequestSender; private final MessageStore messageStore; public QueueModeLeshanServer(CoapServer coapServer, RegistrationService registrationService, - ObservationRegistry observationRegistry, SecurityRegistry securityRegistry, + ObservationService observationService, SecurityRegistry securityRegistry, LwM2mModelProvider modelProvider, LwM2mRequestSender lwM2mRequestSender, MessageStore inMemoryMessageStore) { this.coapServer = coapServer; this.registrationService = registrationService; - this.observationRegistry = observationRegistry; + this.observationService = observationService; this.securityRegistry = securityRegistry; this.modelProvider = modelProvider; this.lwM2mRequestSender = lwM2mRequestSender; @@ -70,7 +70,7 @@ public void updated(RegistrationUpdate update, Registration updatedRegistration) @Override public void unregistered(Registration registration) { - QueueModeLeshanServer.this.observationRegistry.cancelObservations(registration); + QueueModeLeshanServer.this.observationService.cancelObservations(registration); QueueModeLeshanServer.this.lwM2mRequestSender.cancelPendingRequests(registration); } @@ -90,8 +90,8 @@ public void start() { if (securityRegistry instanceof Startable) { ((Startable) securityRegistry).start(); } - if (observationRegistry instanceof Startable) { - ((Startable) observationRegistry).start(); + if (observationService instanceof Startable) { + ((Startable) observationService).start(); } // Start server @@ -112,8 +112,8 @@ public void stop() { if (securityRegistry instanceof Stoppable) { ((Stoppable) securityRegistry).stop(); } - if (observationRegistry instanceof Stoppable) { - ((Stoppable) observationRegistry).stop(); + if (observationService instanceof Stoppable) { + ((Stoppable) observationService).stop(); } if (lwM2mRequestSender instanceof Stoppable) { ((Stoppable) lwM2mRequestSender).stop(); @@ -134,8 +134,8 @@ public void destroy() { if (securityRegistry instanceof Destroyable) { ((Destroyable) securityRegistry).destroy(); } - if (observationRegistry instanceof Destroyable) { - ((Destroyable) observationRegistry).destroy(); + if (observationService instanceof Destroyable) { + ((Destroyable) observationService).destroy(); } LOG.info("LW-M2M server destroyed"); @@ -180,8 +180,8 @@ public RegistrationService getRegistrationService() { } @Override - public ObservationRegistry getObservationRegistry() { - return observationRegistry; + public ObservationService getObservationService() { + return observationService; } @Override diff --git a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/CaliforniumLwM2mRequestSender.java b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/CaliforniumLwM2mRequestSender.java index f3bee5cffe..e108132d9a 100644 --- a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/CaliforniumLwM2mRequestSender.java +++ b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/CaliforniumLwM2mRequestSender.java @@ -47,7 +47,7 @@ public class CaliforniumLwM2mRequestSender implements LwM2mRequestSender { private final Set endpoints; - private final CaliforniumObservationRegistryImpl observationRegistry; + private final ObservationServiceImpl observationService; private final LwM2mModelProvider modelProvider; private final LwM2mNodeDecoder decoder; private final LwM2mNodeEncoder encoder; @@ -60,16 +60,16 @@ public class CaliforniumLwM2mRequestSender implements LwM2mRequestSender { /** * @param endpoints the CoAP endpoints to use for sending requests - * @param observationRegistry the registry for keeping track of observed resources + * @param observationService the service for keeping track of observed resources * @param modelProvider provides the supported objects definitions */ public CaliforniumLwM2mRequestSender(final Set endpoints, - final CaliforniumObservationRegistryImpl observationRegistry, LwM2mModelProvider modelProvider, + final ObservationServiceImpl observationService, LwM2mModelProvider modelProvider, LwM2mNodeEncoder encoder, LwM2mNodeDecoder decoder) { Validate.notNull(endpoints); - Validate.notNull(observationRegistry); + Validate.notNull(observationService); Validate.notNull(modelProvider); - this.observationRegistry = observationRegistry; + this.observationService = observationService; this.endpoints = endpoints; this.modelProvider = modelProvider; this.encoder = encoder; @@ -96,7 +96,7 @@ public T send(final Registration destination, final Do public T buildResponse(final Response coapResponse) { // Build LwM2m response final LwM2mResponseBuilder lwm2mResponseBuilder = new LwM2mResponseBuilder(coapRequest, - coapResponse, destination, model, observationRegistry, decoder); + coapResponse, destination, model, observationService, decoder); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } @@ -133,7 +133,7 @@ public void send(final Registration destination, final public T buildResponse(final Response coapResponse) { // Build LwM2m response final LwM2mResponseBuilder lwm2mResponseBuilder = new LwM2mResponseBuilder(coapRequest, - coapResponse, destination, model, observationRegistry, decoder); + coapResponse, destination, model, observationService, decoder); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } diff --git a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LeshanServer.java b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LeshanServer.java index 4b0922ca0c..0ea3c883b6 100644 --- a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LeshanServer.java +++ b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LeshanServer.java @@ -53,7 +53,7 @@ import org.eclipse.leshan.server.client.RegistrationUpdate; import org.eclipse.leshan.server.impl.RegistrationServiceImpl; import org.eclipse.leshan.server.model.LwM2mModelProvider; -import org.eclipse.leshan.server.observation.ObservationRegistry; +import org.eclipse.leshan.server.observation.ObservationService; import org.eclipse.leshan.server.registration.RegistrationHandler; import org.eclipse.leshan.server.request.LwM2mRequestSender; import org.eclipse.leshan.server.response.ResponseListener; @@ -86,7 +86,7 @@ public class LeshanServer implements LwM2mServer { private final RegistrationServiceImpl registrationService; - private final CaliforniumObservationRegistryImpl observationRegistry; + private final ObservationServiceImpl observationService; private final SecurityRegistry securityRegistry; @@ -122,7 +122,7 @@ public LeshanServer(InetSocketAddress localAddress, InetSocketAddress localSecur // Init registries this.registrationService = new RegistrationServiceImpl(registrationStore); this.securityRegistry = securityRegistry; - this.observationRegistry = new CaliforniumObservationRegistryImpl(registrationStore, modelProvider, decoder); + this.observationService = new ObservationServiceImpl(registrationStore, modelProvider, decoder); this.modelProvider = modelProvider; // Cancel observations on client unregistering @@ -134,7 +134,7 @@ public void updated(final RegistrationUpdate update, final Registration updatedR @Override public void unregistered(final Registration registration) { - LeshanServer.this.observationRegistry.cancelObservations(registration); + LeshanServer.this.observationService.cancelObservations(registration); requestSender.cancelPendingRequests(registration); } @@ -151,9 +151,9 @@ protected Resource createRoot() { } }; nonSecureEndpoint = new CoapEndpoint(localAddress, NetworkConfig.getStandard(), - this.observationRegistry.getObservationStore()); - nonSecureEndpoint.addNotificationListener(observationRegistry); - observationRegistry.setNonSecureEndpoint(nonSecureEndpoint); + this.observationService.getObservationStore()); + nonSecureEndpoint.addNotificationListener(observationService); + observationService.setNonSecureEndpoint(nonSecureEndpoint); coapServer.addEndpoint(nonSecureEndpoint); // secure endpoint @@ -178,9 +178,9 @@ protected Resource createRoot() { } secureEndpoint = new CoapEndpoint(new DTLSConnector(builder.build()), NetworkConfig.getStandard(), - this.observationRegistry.getObservationStore()); - secureEndpoint.addNotificationListener(observationRegistry); - observationRegistry.setSecureEndpoint(secureEndpoint); + this.observationService.getObservationStore()); + secureEndpoint.addNotificationListener(observationService); + observationService.setSecureEndpoint(secureEndpoint); coapServer.addEndpoint(secureEndpoint); // define /rd resource @@ -192,7 +192,7 @@ protected Resource createRoot() { final Set endpoints = new HashSet<>(); endpoints.add(nonSecureEndpoint); endpoints.add(secureEndpoint); - requestSender = new CaliforniumLwM2mRequestSender(endpoints, this.observationRegistry, modelProvider, encoder, + requestSender = new CaliforniumLwM2mRequestSender(endpoints, this.observationService, modelProvider, encoder, decoder); } @@ -206,8 +206,8 @@ public void start() { if (securityRegistry instanceof Startable) { ((Startable) securityRegistry).start(); } - if (observationRegistry instanceof Startable) { - ((Startable) observationRegistry).start(); + if (observationService instanceof Startable) { + ((Startable) observationService).start(); } // Start server @@ -228,8 +228,8 @@ public void stop() { if (securityRegistry instanceof Stoppable) { ((Stoppable) securityRegistry).stop(); } - if (observationRegistry instanceof Stoppable) { - ((Stoppable) observationRegistry).stop(); + if (observationService instanceof Stoppable) { + ((Stoppable) observationService).stop(); } LOG.info("LWM2M server stopped."); @@ -246,8 +246,8 @@ public void destroy() { if (securityRegistry instanceof Destroyable) { ((Destroyable) securityRegistry).destroy(); } - if (observationRegistry instanceof Destroyable) { - ((Destroyable) observationRegistry).destroy(); + if (observationService instanceof Destroyable) { + ((Destroyable) observationService).destroy(); } LOG.info("LWM2M server destroyed."); @@ -259,8 +259,8 @@ public RegistrationService getRegistrationService() { } @Override - public ObservationRegistry getObservationRegistry() { - return this.observationRegistry; + public ObservationService getObservationService() { + return this.observationService; } @Override diff --git a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LwM2mResponseBuilder.java b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LwM2mResponseBuilder.java index d59541904e..fd6a89bee1 100644 --- a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LwM2mResponseBuilder.java +++ b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/LwM2mResponseBuilder.java @@ -65,7 +65,7 @@ public class LwM2mResponseBuilder implements DownlinkRe private LwM2mResponse lwM2mresponse; private final Request coapRequest; private final Response coapResponse; - private final CaliforniumObservationRegistryImpl observationRegistry; + private final ObservationServiceImpl observationService; private final Registration registration; private final LwM2mModel model; private final LwM2mNodeDecoder decoder; @@ -105,11 +105,11 @@ public static ResponseCode fromCoapCode(final int code) { } public LwM2mResponseBuilder(final Request coapRequest, final Response coapResponse, final Registration registration, - final LwM2mModel model, final CaliforniumObservationRegistryImpl observationRegistry, + final LwM2mModel model, final ObservationServiceImpl observationService, final LwM2mNodeDecoder decoder) { this.coapRequest = coapRequest; this.coapResponse = coapResponse; - this.observationRegistry = observationRegistry; + this.observationService = observationService; this.registration = registration; this.model = model; this.decoder = decoder; @@ -274,10 +274,10 @@ public void visit(final ObserveRequest request) { case CONTENT: LwM2mNode content = decodeCoapResponse(request.getPath(), coapResponse); if (coapResponse.getOptions().hasObserve()) { - // observe request succeed so we can add and observation to registry + // observe request successful Observation observation = new Observation(coapRequest.getToken(), registration.getId(), request.getPath(), request.getContext()); - observationRegistry.addObservation(observation); + observationService.addObservation(observation); // add the observation to an ObserveResponse instance lwM2mresponse = new ObserveResponse(ResponseCode.CONTENT, content, null, observation, null, coapResponse); diff --git a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/CaliforniumObservationRegistryImpl.java b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/ObservationServiceImpl.java similarity index 89% rename from leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/CaliforniumObservationRegistryImpl.java rename to leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/ObservationServiceImpl.java index 01e6d96eda..0742e3445a 100644 --- a/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/CaliforniumObservationRegistryImpl.java +++ b/leshan-server-cf/src/main/java/org/eclipse/leshan/server/californium/impl/ObservationServiceImpl.java @@ -43,20 +43,20 @@ import org.eclipse.leshan.server.californium.CaliforniumRegistrationStore; import org.eclipse.leshan.server.client.Registration; import org.eclipse.leshan.server.model.LwM2mModelProvider; -import org.eclipse.leshan.server.observation.ObservationRegistry; -import org.eclipse.leshan.server.observation.ObservationRegistryListener; +import org.eclipse.leshan.server.observation.ObservationService; +import org.eclipse.leshan.server.observation.ObservationListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * Implementation of the {@link ObservationRegistry} accessing the persisted observation via the provided + * Implementation of the {@link ObservationService} accessing the persisted observation via the provided * {@link LwM2mObservationStore}. * * When a new observation is added or changed or canceled, the registered listeners are notified. */ -public class CaliforniumObservationRegistryImpl implements ObservationRegistry, NotificationListener { +public class ObservationServiceImpl implements ObservationService, NotificationListener { - private final Logger LOG = LoggerFactory.getLogger(CaliforniumObservationRegistryImpl.class); + private final Logger LOG = LoggerFactory.getLogger(ObservationServiceImpl.class); private final CaliforniumRegistrationStore registrationStore; private final LwM2mModelProvider modelProvider; @@ -64,16 +64,16 @@ public class CaliforniumObservationRegistryImpl implements ObservationRegistry, private Endpoint secureEndpoint; private Endpoint nonSecureEndpoint; - private final List listeners = new CopyOnWriteArrayList<>(); + private final List listeners = new CopyOnWriteArrayList<>(); /** - * Creates an instance of {@link CaliforniumObservationRegistryImpl} + * Creates an instance of {@link ObservationServiceImpl} * * @param store instance of californium's {@link ObservationStore} * @param modelProvider instance of {@link LwM2mModelProvider} * @param decoder instance of {@link LwM2mNodeDecoder} */ - public CaliforniumObservationRegistryImpl(CaliforniumRegistrationStore store, LwM2mModelProvider modelProvider, + public ObservationServiceImpl(CaliforniumRegistrationStore store, LwM2mModelProvider modelProvider, LwM2mNodeDecoder decoder) { this.registrationStore = store; this.modelProvider = modelProvider; @@ -91,7 +91,7 @@ public void addObservation(Observation observation) { // the observation is already persisted by the CoAP layer - for (ObservationRegistryListener listener : listeners) { + for (ObservationListener listener : listeners) { listener.newObservation(observation); } } @@ -122,7 +122,7 @@ public int cancelObservations(Registration registration) { if (nonSecureEndpoint != null) nonSecureEndpoint.cancelObservation(observation.getId()); - for (ObservationRegistryListener listener : listeners) { + for (ObservationListener listener : listeners) { listener.cancelled(observation); } } @@ -153,7 +153,7 @@ public void cancelObservation(Observation observation) { nonSecureEndpoint.cancelObservation(observation.getId()); registrationStore.removeObservation(observation.getRegistrationId(), observation.getId()); - for (ObservationRegistryListener listener : listeners) { + for (ObservationListener listener : listeners) { listener.cancelled(observation); } } @@ -192,12 +192,12 @@ public ObservationStore getObservationStore() { } @Override - public void addListener(ObservationRegistryListener listener) { + public void addListener(ObservationListener listener) { listeners.add(listener); } @Override - public void removeListener(ObservationRegistryListener listener) { + public void removeListener(ObservationListener listener) { listeners.remove(listener); } @@ -251,7 +251,7 @@ public void onNotification(Request coapRequest, Response coapResponse) { } // notify all listeners - for (ObservationRegistryListener listener : listeners) { + for (ObservationListener listener : listeners) { listener.newValue(observation, response); } } catch (InvalidValueException e) { diff --git a/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/CaliforniumObservationTest.java b/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/CaliforniumObservationTest.java index cb54465f09..4b60520ec6 100644 --- a/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/CaliforniumObservationTest.java +++ b/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/CaliforniumObservationTest.java @@ -37,7 +37,7 @@ public class CaliforniumObservationTest { Request coapRequest; LwM2mPath target; - CaliforniumObservationRegistryImpl registry; + ObservationServiceImpl observationService; CaliforniumRegistrationStore store; private CaliforniumTestSupport support = new CaliforniumTestSupport(); @@ -46,7 +46,7 @@ public class CaliforniumObservationTest { public void setUp() throws Exception { support.givenASimpleClient(); store = new InMemoryRegistrationStore(); - registry = new CaliforniumObservationRegistryImpl(store, + observationService = new ObservationServiceImpl(store, new StandardModelProvider(), new DefaultLwM2mNodeDecoder()); } @@ -57,34 +57,34 @@ public void observe_twice_cancels_first() { givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 12)); // check the presence of only one observation. - Set observations = registry.getObservations(support.registration); + Set observations = observationService.getObservations(support.registration); Assert.assertEquals(1, observations.size()); } @Test public void cancel_by_client() { - // create some observations and add it to registry + // create some observations givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 13)); givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 12)); givenAnObservation("anotherClient", new LwM2mPath(3, 0, 12)); // check its presence - Set observations = registry.getObservations(support.registration); + Set observations = observationService.getObservations(support.registration); Assert.assertEquals(2, observations.size()); // cancel it - int nbCancelled = registry.cancelObservations(support.registration); + int nbCancelled = observationService.cancelObservations(support.registration); Assert.assertEquals(2, nbCancelled); // check its absence - observations = registry.getObservations(support.registration); + observations = observationService.getObservations(support.registration); Assert.assertTrue(observations.isEmpty()); } @Test public void cancel_by_path() { - // create some observations and add it to registry + // create some observations givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 13)); givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 12)); givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 12)); @@ -92,21 +92,21 @@ public void cancel_by_path() { givenAnObservation("anotherClient", new LwM2mPath(3, 0, 12)); // check its presence - Set observations = registry.getObservations(support.registration); + Set observations = observationService.getObservations(support.registration); Assert.assertEquals(2, observations.size()); // cancel it - int nbCancelled = registry.cancelObservations(support.registration, "/3/0/12"); + int nbCancelled = observationService.cancelObservations(support.registration, "/3/0/12"); Assert.assertEquals(1, nbCancelled); // check its absence - observations = registry.getObservations(support.registration); + observations = observationService.getObservations(support.registration); Assert.assertEquals(1, observations.size()); } @Test public void cancel_by_observation() throws UnknownHostException { - // create some observations and add it to registry + // create some observations givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 13)); givenAnObservation(support.registration.getId(), new LwM2mPath(3, 0, 12)); givenAnObservation("anotherClient", new LwM2mPath(3, 0, 12)); @@ -115,14 +115,14 @@ public void cancel_by_observation() throws UnknownHostException { new LwM2mPath(3, 0, 12)); // check its presence - Set observations = registry.getObservations(support.registration); + Set observations = observationService.getObservations(support.registration); Assert.assertEquals(2, observations.size()); // cancel it - registry.cancelObservation(observationToCancel); + observationService.cancelObservation(observationToCancel); // check its absence - observations = registry.getObservations(support.registration); + observations = observationService.getObservations(support.registration); Assert.assertEquals(1, observations.size()); } @@ -145,7 +145,7 @@ private Observation givenAnObservation(String registrationId, LwM2mPath target) store.add(new org.eclipse.californium.core.observe.Observation(coapRequest, null)); Observation observation = new Observation(coapRequest.getToken(), registrationId, target, null); - registry.addObservation(observation); + observationService.addObservation(observation); return observation; } diff --git a/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/RegistrationServiceImplTest.java b/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/RegistrationServiceImplTest.java index 1dfcee1b81..640f9808e8 100644 --- a/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/RegistrationServiceImplTest.java +++ b/leshan-server-cf/src/test/java/org/eclipse/leshan/server/californium/impl/RegistrationServiceImplTest.java @@ -29,7 +29,7 @@ public class RegistrationServiceImplTest { - RegistrationServiceImpl registry; + RegistrationServiceImpl registrationService; String ep = "urn:endpoint"; InetAddress address; int port = 23452; @@ -43,21 +43,21 @@ public class RegistrationServiceImplTest { @Before public void setUp() throws Exception { address = InetAddress.getLocalHost(); - registry = new RegistrationServiceImpl(new InMemoryRegistrationStore()); + registrationService = new RegistrationServiceImpl(new InMemoryRegistrationStore()); } @Test public void update_registration_keeps_properties_unchanged() { givenASimpleRegistration(lifetime); - registry.registerClient(registration); + registrationService.registerClient(registration); RegistrationUpdate update = new RegistrationUpdate(registrationId, address, port, null, null, null, null); - Registration updatedRegistration = registry.updateRegistration(update); + Registration updatedRegistration = registrationService.updateRegistration(update); Assert.assertEquals(lifetime, updatedRegistration.getLifeTimeInSec()); Assert.assertSame(binding, updatedRegistration.getBindingMode()); Assert.assertEquals(sms, updatedRegistration.getSmsNumber()); - Registration reg = registry.getByEndpoint(ep); + Registration reg = registrationService.getByEndpoint(ep); Assert.assertEquals(lifetime, reg.getLifeTimeInSec()); Assert.assertSame(binding, reg.getBindingMode()); Assert.assertEquals(sms, reg.getSmsNumber()); @@ -66,21 +66,21 @@ public void update_registration_keeps_properties_unchanged() { @Test public void client_registration_sets_time_to_live() { givenASimpleRegistration(lifetime); - registry.registerClient(registration); + registrationService.registerClient(registration); Assert.assertTrue(registration.isAlive()); } @Test public void update_registration_to_extend_time_to_live() { givenASimpleRegistration(0L); - registry.registerClient(registration); + registrationService.registerClient(registration); Assert.assertFalse(registration.isAlive()); RegistrationUpdate update = new RegistrationUpdate(registrationId, address, port, lifetime, null, null, null); - Registration updatedRegistration = registry.updateRegistration(update); + Registration updatedRegistration = registrationService.updateRegistration(update); Assert.assertTrue(updatedRegistration.isAlive()); - Registration reg = registry.getByEndpoint(ep); + Registration reg = registrationService.getByEndpoint(ep); Assert.assertTrue(reg.isAlive()); } diff --git a/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/LeshanClusterServer.java b/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/LeshanClusterServer.java index 8f28342a75..22a147cf77 100644 --- a/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/LeshanClusterServer.java +++ b/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/LeshanClusterServer.java @@ -165,7 +165,7 @@ public static void createAndStartServer(String clusterInstanceId, String localAd // Create Clustering support RedisTokenHandler tokenHandler = new RedisTokenHandler(jedis, clusterInstanceId); new RedisRequestResponseHandler(jedis, lwServer, lwServer.getRegistrationService(), tokenHandler, - lwServer.getObservationRegistry()); + lwServer.getObservationService()); lwServer.getRegistrationService().addListener(tokenHandler); lwServer.getRegistrationService().addListener(new RedisRegistrationEventPublisher(jedis)); diff --git a/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/RedisRequestResponseHandler.java b/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/RedisRequestResponseHandler.java index 37ee889ad6..88238e11bd 100644 --- a/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/RedisRequestResponseHandler.java +++ b/leshan-server-cluster/src/main/java/org/eclipse/leshan/server/cluster/RedisRequestResponseHandler.java @@ -32,8 +32,8 @@ import org.eclipse.leshan.server.client.RegistrationService; import org.eclipse.leshan.server.cluster.serialization.DownlinkRequestSerDes; import org.eclipse.leshan.server.cluster.serialization.ResponseSerDes; -import org.eclipse.leshan.server.observation.ObservationRegistry; -import org.eclipse.leshan.server.observation.ObservationRegistryListener; +import org.eclipse.leshan.server.observation.ObservationService; +import org.eclipse.leshan.server.observation.ObservationListener; import org.eclipse.leshan.server.response.ResponseListener; import org.eclipse.leshan.util.NamedThreadFactory; import org.slf4j.Logger; @@ -63,21 +63,21 @@ public class RedisRequestResponseHandler { private final RegistrationService registrationService; private final ExecutorService executorService; private final RedisTokenHandler tokenHandler; - private final ObservationRegistry observationRegistry; + private final ObservationService observationService; private final Map observatioIdToTicket = new ConcurrentHashMap<>(); public RedisRequestResponseHandler(Pool p, LwM2mServer server, RegistrationService registrationService, - RedisTokenHandler tokenHandler, ObservationRegistry observationRegistry) { + RedisTokenHandler tokenHandler, ObservationService observationService) { // Listen LWM2M response this.server = server; this.registrationService = registrationService; - this.observationRegistry = observationRegistry; + this.observationService = observationService; this.tokenHandler = tokenHandler; this.executorService = Executors.newCachedThreadPool( new NamedThreadFactory(String.format("Redis %s channel writer", RESPONSE_CHANNEL))); // Listen LWM2M notification from client - this.observationRegistry.addListener(new ObservationRegistryListener() { + this.observationService.addListener(new ObservationListener() { @Override public void newValue(Observation observation, ObserveResponse response) { diff --git a/leshan-server-core/src/main/java/org/eclipse/leshan/server/LwM2mServer.java b/leshan-server-core/src/main/java/org/eclipse/leshan/server/LwM2mServer.java index f712b53298..740bd19076 100644 --- a/leshan-server-core/src/main/java/org/eclipse/leshan/server/LwM2mServer.java +++ b/leshan-server-core/src/main/java/org/eclipse/leshan/server/LwM2mServer.java @@ -22,7 +22,7 @@ import org.eclipse.leshan.server.client.Registration; import org.eclipse.leshan.server.client.RegistrationService; import org.eclipse.leshan.server.model.LwM2mModelProvider; -import org.eclipse.leshan.server.observation.ObservationRegistry; +import org.eclipse.leshan.server.observation.ObservationService; import org.eclipse.leshan.server.response.ResponseListener; import org.eclipse.leshan.server.security.SecurityRegistry; @@ -112,10 +112,10 @@ void send(Registration destination, DownlinkRequest RegistrationService getRegistrationService(); /** - * Get the Observation registry containing of current observation. You can use this object for listening resource + * Get the Observation service to access current observations. You can use this object for listening resource * observation or cancel it. */ - ObservationRegistry getObservationRegistry(); + ObservationService getObservationService(); /** * Get the SecurityRegistry containing of security information. diff --git a/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationRegistryListener.java b/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationListener.java similarity index 96% rename from leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationRegistryListener.java rename to leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationListener.java index 7a4a869fa4..9dc88d5054 100644 --- a/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationRegistryListener.java +++ b/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationListener.java @@ -18,7 +18,8 @@ import org.eclipse.leshan.core.observation.Observation; import org.eclipse.leshan.core.response.ObserveResponse; -public interface ObservationRegistryListener { +public interface ObservationListener { + void newObservation(Observation observation); void cancelled(Observation observation); diff --git a/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationRegistry.java b/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationService.java similarity index 90% rename from leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationRegistry.java rename to leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationService.java index 7ffed0ce3f..d7848b7e21 100644 --- a/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationRegistry.java +++ b/leshan-server-core/src/main/java/org/eclipse/leshan/server/observation/ObservationService.java @@ -21,10 +21,9 @@ import org.eclipse.leshan.server.client.Registration; /** - * A registry for keeping track of observed resources implemented by LWM2M Clients. - * + * A service keeping track observation. Can be used for finding observations and cancel them. */ -public interface ObservationRegistry { +public interface ObservationService { /** * Cancels all active observations of resource(s) implemented by a particular LWM2M registration. @@ -66,7 +65,7 @@ public interface ObservationRegistry { */ Set getObservations(Registration registration); - void addListener(ObservationRegistryListener listener); + void addListener(ObservationListener listener); - void removeListener(ObservationRegistryListener listener); + void removeListener(ObservationListener listener); } diff --git a/leshan-server-core/src/main/java/org/eclipse/leshan/server/queue/impl/QueuedRequestSender.java b/leshan-server-core/src/main/java/org/eclipse/leshan/server/queue/impl/QueuedRequestSender.java index f263319f1a..6587c5833a 100644 --- a/leshan-server-core/src/main/java/org/eclipse/leshan/server/queue/impl/QueuedRequestSender.java +++ b/leshan-server-core/src/main/java/org/eclipse/leshan/server/queue/impl/QueuedRequestSender.java @@ -38,8 +38,8 @@ import org.eclipse.leshan.server.client.RegistrationListener; import org.eclipse.leshan.server.client.RegistrationService; import org.eclipse.leshan.server.client.RegistrationUpdate; -import org.eclipse.leshan.server.observation.ObservationRegistry; -import org.eclipse.leshan.server.observation.ObservationRegistryListener; +import org.eclipse.leshan.server.observation.ObservationListener; +import org.eclipse.leshan.server.observation.ObservationService; import org.eclipse.leshan.server.queue.MessageStore; import org.eclipse.leshan.server.queue.QueuedRequest; import org.eclipse.leshan.server.request.LwM2mRequestSender; @@ -62,9 +62,9 @@ public class QueuedRequestSender implements LwM2mRequestSender, Stoppable { .newCachedThreadPool(new NamedThreadFactory("leshan-qmode-processingExecutor-%d")); private final MessageStore messageStore; private final QueueModeRegistrationListener queueModeRegistrationListener; - private final QueueModeObservationRegistryListener queueModeObservationRegistryListener; + private final QueueModeObservationListener queueModeObservationListener; private final RegistrationService registrationService; - private final ObservationRegistry observationRegistry; + private final ObservationService observationService; private final ClientStatusTracker clientStatusTracker; private final Collection responseListeners = new ConcurrentLinkedQueue<>(); @@ -78,15 +78,15 @@ public class QueuedRequestSender implements LwM2mRequestSender, Stoppable { private QueuedRequestSender(Builder builder) { this.messageStore = builder.messageStore; this.registrationService = builder.registrationService; - this.observationRegistry = builder.observationRegistry; + this.observationService = builder.observationService; this.delegateSender = builder.delegateSender; this.clientStatusTracker = new ClientStatusTracker(); this.queueModeRegistrationListener = new QueueModeRegistrationListener(); registrationService.addListener(queueModeRegistrationListener); - this.queueModeObservationRegistryListener = new QueueModeObservationRegistryListener(); - observationRegistry.addListener(queueModeObservationRegistryListener); + this.queueModeObservationListener = new QueueModeObservationListener(); + observationService.addListener(queueModeObservationListener); delegateSender.addResponseListener(createResponseListener()); } @@ -158,7 +158,7 @@ public void removeResponseListener(ResponseListener listener) { @Override public void stop() { registrationService.removeListener(queueModeRegistrationListener); - observationRegistry.removeListener(queueModeObservationRegistryListener); + observationService.removeListener(queueModeObservationListener); processingExecutor.shutdown(); try { boolean queueProcessingExecutorTerminated = processingExecutor.awaitTermination(5, TimeUnit.SECONDS); @@ -258,7 +258,7 @@ private RequestSendingTask newRequestSendingTask(String clientEndpoint) { clientEndpoint); } - private final class QueueModeObservationRegistryListener implements ObservationRegistryListener { + private final class QueueModeObservationListener implements ObservationListener { @Override public void newValue(Observation observation, ObserveResponse response) { Registration registration = registrationService.getById(observation.getRegistrationId()); @@ -332,7 +332,7 @@ public static class Builder { private MessageStore messageStore; private LwM2mRequestSender delegateSender; private RegistrationService registrationService; - private ObservationRegistry observationRegistry; + private ObservationService observationService; public Builder setMessageStore(MessageStore messageStore) { this.messageStore = messageStore; @@ -349,8 +349,8 @@ public Builder setRegistrationService(RegistrationService registrationService) { return this; } - public Builder setObservationRegistry(ObservationRegistry observationRegistry) { - this.observationRegistry = observationRegistry; + public Builder setObservationService(ObservationService observationService) { + this.observationService = observationService; return this; } @@ -358,7 +358,7 @@ public QueuedRequestSender build() { Validate.notNull(messageStore, "messageStore cannot be null"); Validate.notNull(delegateSender, "delegateSender cannot be null"); Validate.notNull(registrationService, "registrationService cannot be null"); - Validate.notNull(observationRegistry, "observationRegistry cannot be null"); + Validate.notNull(observationService, "observationService cannot be null"); return new QueuedRequestSender(this); } diff --git a/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/ClientServlet.java b/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/ClientServlet.java index 901f80d2a5..1add9f046b 100644 --- a/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/ClientServlet.java +++ b/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/ClientServlet.java @@ -329,7 +329,7 @@ protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws String target = StringUtils.substringsBetween(req.getPathInfo(), clientEndpoint, "/observe")[0]; Registration registration = server.getRegistrationService().getByEndpoint(clientEndpoint); if (registration != null) { - server.getObservationRegistry().cancelObservations(registration, target); + server.getObservationService().cancelObservations(registration, target); resp.setStatus(HttpServletResponse.SC_OK); } else { resp.setStatus(HttpServletResponse.SC_BAD_REQUEST); diff --git a/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/EventServlet.java b/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/EventServlet.java index 06c8ec2399..70fd3860ce 100644 --- a/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/EventServlet.java +++ b/leshan-server-demo/src/main/java/org/eclipse/leshan/server/demo/servlet/EventServlet.java @@ -37,7 +37,7 @@ import org.eclipse.leshan.server.demo.servlet.log.CoapMessageTracer; import org.eclipse.leshan.server.demo.utils.EventSource; import org.eclipse.leshan.server.demo.utils.EventSourceServlet; -import org.eclipse.leshan.server.observation.ObservationRegistryListener; +import org.eclipse.leshan.server.observation.ObservationListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -92,7 +92,7 @@ public void unregistered(Registration registration) { } }; - private final ObservationRegistryListener observationRegistryListener = new ObservationRegistryListener() { + private final ObservationListener observationListener = new ObservationListener() { @Override public void cancelled(Observation observation) { @@ -124,7 +124,7 @@ public void newObservation(Observation observation) { public EventServlet(LeshanServer server, int securePort) { this.server = server; server.getRegistrationService().addListener(this.registrationListener); - server.getObservationRegistry().addListener(this.observationRegistryListener); + server.getObservationService().addListener(this.observationListener); // add an interceptor to each endpoint to trace all CoAP messages coapMessageTracer = new CoapMessageTracer(server.getRegistrationService());