Java tutorial
/* * Copyright (C) 2015 Orange * * This software is distributed under the terms and conditions of the 'GNU GENERAL PUBLIC LICENSE * Version 2' license which can be found in the file 'LICENSE.txt' in this package distribution or * at 'http://www.gnu.org/licenses/gpl-2.0-standalone.html'. */ package com.orange.cepheus.cep; import com.orange.cepheus.cep.model.Attribute; import com.orange.cepheus.cep.model.Configuration; import com.orange.cepheus.cep.model.EventTypeIn; import com.orange.cepheus.cep.model.Provider; import com.orange.ngsi.client.NgsiClient; import com.orange.ngsi.model.EntityId; import com.orange.ngsi.model.SubscribeContext; import com.orange.ngsi.model.SubscribeError; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Scope; import org.springframework.context.annotation.ScopedProxyMode; import org.springframework.http.HttpHeaders; import org.springframework.scheduling.TaskScheduler; import org.springframework.stereotype.Component; import javax.annotation.PreDestroy; import java.io.IOException; import java.net.URI; import java.time.Duration; import java.time.Instant; import java.util.*; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.stream.Collectors; /** * SubscriptionManager manage subscriptions of EventTypeIn to provider * When a configuration is loaded, SubscriptionManager send subscription to every provider * Every five minutes SubscriptionManager verify if subscription is valid */ @Component() public class SubscriptionManager { private static Logger logger = LoggerFactory.getLogger(SubscriptionManager.class); /** * Inner class for concurrent subscriptions tracking using a RW lock. */ private static class Subscriptions { private HashSet<String> subscriptionIds = new HashSet<>(); private ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); public boolean isSubscriptionValid(String subscriptionId) { try { readWriteLock.readLock().lock(); return subscriptionIds.contains(subscriptionId); } finally { readWriteLock.readLock().unlock(); } } private void addSubscription(String subscriptionId) { try { readWriteLock.writeLock().lock(); subscriptionIds.add(subscriptionId); } finally { readWriteLock.writeLock().unlock(); } } private void removeSubscription(String subscriptionId) { try { readWriteLock.writeLock().lock(); subscriptionIds.remove(subscriptionId); } finally { readWriteLock.writeLock().unlock(); } } } /** * Periodicity of the subscription task. Default: every 5 min. * Must be smaller than the subscription duration ! */ @Value("${subscriptionManager.periodicity:300000}") private long subscriptionPeriodicity; /** * Duration of a NGSI subscription as text. */ @Value("${subscriptionManager.duration:PT1H}") private String subscriptionDuration; @Value("${subscriptionManager.validateSubscriptionsId:true}") private boolean validateSubscriptionsId; @Autowired private NgsiClient ngsiClient; @Autowired private TaskScheduler taskScheduler; private List<EventTypeIn> eventTypeIns = Collections.emptyList(); private Subscriptions subscriptions = new Subscriptions(); private ScheduledFuture scheduledFuture; private URI hostURI; /** * Update subscription to new provider of the incoming events defined in the Configuration * * @param configuration the new configuration */ public void setConfiguration(Configuration configuration) { hostURI = configuration.getHost(); // Use a new subscription set on each new configuration // this prevents active subscription tasks to add subscription ids from the previous configuration // this will also copy the subscription information of the previous configuration to this new configuration subscriptions = migrateSubscriptions(configuration); // Keep a reference to configuration for next migration eventTypeIns = configuration.getEventTypeIns(); // TODO : send unsubscribeContext with removedEventTypesIn // force launch of subscription process for new or invalid subscriptions scheduleSubscriptionTask(); } /** * Check that a given subscription is valid * unsubscribe if is invalid * * @param subscriptionId the id of subscription * @return true if subscription is valid */ public boolean validateSubscriptionId(String subscriptionId, String originatorUrl) { if (validateSubscriptionsId) { boolean isValid = subscriptions.isSubscriptionValid(subscriptionId); if (!isValid) { logger.warn("unsubscribeContext request: clean invalid subscription id {} / {}", subscriptionId, originatorUrl); //TODO: add support multi-tenant subscription ngsiClient.unsubscribeContext(originatorUrl, null, subscriptionId).addCallback( unsubscribeContextResponse -> logger.debug("unsubscribeContext completed for {}", originatorUrl), throwable -> logger.warn("unsubscribeContext failed for {}: {}", originatorUrl, throwable.toString())); } return isValid; } return true; } @PreDestroy public void shutdownGracefully() { logger.info("Shutting down SubscriptionManager (cleanup subscriptions)"); // Cancel the scheduled subscription task if (scheduledFuture != null) { scheduledFuture.cancel(true); } // Unsubscribe from all providers eventTypeIns.forEach(eventTypeIn -> eventTypeIn.getProviders().forEach(this::unsubscribeProvider)); // Try to stop gracefully (letting all unsubscribe complete) try { ngsiClient.shutdownGracefully(); } catch (IOException e) { logger.warn("Failed to shutdown gracefully NGSI pending requests", e); } } /** * Cancel any previous schedule, run subscription task immediately and schedule it again. */ private void scheduleSubscriptionTask() { if (scheduledFuture != null) { scheduledFuture.cancel(false); } scheduledFuture = taskScheduler.scheduleWithFixedDelay(this::periodicSubscriptionTask, subscriptionPeriodicity); } private void periodicSubscriptionTask() { Instant now = Instant.now(); Instant nextSubscriptionTaskDate = now.plusMillis(subscriptionPeriodicity); logger.info("Launch of the periodic subscription task at {}", now.toString()); // Futures will use the current subscription list. // So that they will not add old subscriptions to a new configuration. Subscriptions subscriptions = this.subscriptions; for (EventTypeIn eventType : eventTypeIns) { SubscribeContext subscribeContext = null; for (Provider provider : eventType.getProviders()) { boolean deadlineIsPassed = false; Instant subscriptionDate = provider.getSubscriptionDate(); if (subscriptionDate != null) { Instant subscriptionEndDate = subscriptionDate.plus(Duration.parse(subscriptionDuration)); // check if deadline is passed if (nextSubscriptionTaskDate.compareTo(subscriptionEndDate) >= 0) { deadlineIsPassed = true; String subscriptionId = provider.getSubscriptionId(); // if delay is passed then clear the subscription info in provider et suppress subscription if (subscriptionId != null) { subscriptions.removeSubscription(subscriptionId); provider.setSubscriptionId(null); provider.setSubscriptionDate(null); } } } //Send subscription if subscription is a new subscription or we do not receive a response (subscriptionDate is null) //Send subscription if deadline is passed if ((subscriptionDate == null) || deadlineIsPassed) { // lazy build body request only when the first request requires it if (subscribeContext == null) { subscribeContext = buildSubscribeContext(eventType); } subscribeProvider(provider, subscribeContext, subscriptions); } } } } /** * Subscribe to a provider * @param provider * @param subscribeContext * @param subscriptions */ private void subscribeProvider(Provider provider, SubscribeContext subscribeContext, Subscriptions subscriptions) { logger.debug("Subscribe to {} for {}", provider.getUrl(), subscribeContext.toString()); ngsiClient.subscribeContext(provider.getUrl(), null, subscribeContext) .addCallback(subscribeContextResponse -> { SubscribeError error = subscribeContextResponse.getSubscribeError(); if (error == null) { String subscriptionId = subscribeContextResponse.getSubscribeResponse().getSubscriptionId(); provider.setSubscriptionDate(Instant.now()); provider.setSubscriptionId(subscriptionId); subscriptions.addSubscription(subscriptionId); logger.debug("Subscription done for {}", provider.getUrl()); } else { logger.warn("Error during subscription for {}: {}", provider.getUrl(), error.getErrorCode()); } }, throwable -> { logger.warn("Error during subscription for {}:{}", provider.getUrl(), throwable.toString()); }); } /** * Unsubscribe from a provider * @param provider the provider to unusubscribe from */ private void unsubscribeProvider(Provider provider) { final String subscriptionID = provider.getSubscriptionId(); if (subscriptionID != null) { logger.debug("Unsubscribe from {} for {}", provider.getUrl(), provider.getSubscriptionId()); // Don't wait for result, remove immediately from subscriptions list subscriptions.removeSubscription(subscriptionID); ngsiClient.unsubscribeContext(provider.getUrl(), null, provider.getSubscriptionId()).addCallback( response -> logger.debug("Unsubribe response for {}: {}", subscriptionID, response.getStatusCode().getCode()), throwable -> logger.debug("Error during unsubscribe for {}: {}", subscriptionID, throwable.toString())); // Reset provider subscription data provider.setSubscriptionDate(null); provider.setSubscriptionId(null); } } private SubscribeContext buildSubscribeContext(EventTypeIn eventType) { SubscribeContext subscribeContext = new SubscribeContext(); EntityId entityId = new EntityId(eventType.getId(), eventType.getType(), eventType.isPattern()); subscribeContext.setEntityIdList(Collections.singletonList(entityId)); subscribeContext.setAttributeList( eventType.getAttributes().stream().map(Attribute::getName).collect(Collectors.toList())); subscribeContext.setReference(hostURI); subscribeContext.setDuration(subscriptionDuration); return subscribeContext; } /** * Migrate subscriptions from previous configuration to the new configuration * @param configuration the new configuration where the subscriptions must be insterted * @return the list of id of the migrated subscriptions */ private Subscriptions migrateSubscriptions(Configuration configuration) { Subscriptions newSubscriptions = new Subscriptions(); // For every previous eventType, find the corresponding one in new configuration eventTypeIns.forEach(oldEventTypeIn -> { Optional<EventTypeIn> maybeEventTypeIn = configuration.getEventTypeIns().stream() .filter(e -> e.equals(oldEventTypeIn)).findFirst(); if (maybeEventTypeIn.isPresent()) { EventTypeIn newEventTypeIn = maybeEventTypeIn.get(); // For every previous provider, find the corresponding one in new configuration oldEventTypeIn.getProviders().forEach(oldProvider -> { Optional<Provider> optionalProvider = newEventTypeIn.getProviders().stream() .filter(p -> p.getUrl().equals(oldProvider.getUrl())).findFirst(); if (optionalProvider.isPresent()) { Provider provider = optionalProvider.get(); // Migrate the subscription provider.setSubscriptionId(oldProvider.getSubscriptionId()); provider.setSubscriptionDate(oldProvider.getSubscriptionDate()); newSubscriptions.addSubscription(oldProvider.getSubscriptionId()); } else { // Provider not found in new configuration, unsubscribe from it unsubscribeProvider(oldProvider); } }); } else { // EventType not found in new configuration, unsubscribe from all providers oldEventTypeIn.getProviders().forEach(this::unsubscribeProvider); } }); return newSubscriptions; } }