nbinotifications/src/main/java/org/opendaylight/transportpce/nbinotifications/impl/NbiNotificationsImpl.java

   1 /*
   2  * Copyright © 2020 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.nbinotifications.impl;
   9
  10 import com.google.common.util.concurrent.ListenableFuture;
  11 import java.nio.charset.StandardCharsets;
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.NoSuchElementException;
  18 import java.util.Optional;
  19 import java.util.Set;
  20 import java.util.UUID;
  21 import java.util.concurrent.ExecutionException;
  22 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  23 import org.opendaylight.transportpce.common.converter.JsonStringConverter;
  24 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  25 import org.opendaylight.transportpce.nbinotifications.consumer.Subscriber;
  26 import org.opendaylight.transportpce.nbinotifications.serialization.NotificationAlarmServiceDeserializer;
  27 import org.opendaylight.transportpce.nbinotifications.serialization.NotificationServiceDeserializer;
  28 import org.opendaylight.transportpce.nbinotifications.serialization.TapiNotificationDeserializer;
  29 import org.opendaylight.transportpce.nbinotifications.utils.TopicManager;
  30 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.GetNotificationsAlarmServiceInput;
  31 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.GetNotificationsAlarmServiceOutput;
  32 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.GetNotificationsAlarmServiceOutputBuilder;
  33 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.GetNotificationsProcessServiceInput;
  34 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.GetNotificationsProcessServiceOutput;
  35 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.GetNotificationsProcessServiceOutputBuilder;
  36 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.NbiNotificationsService;
  37 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.NotificationAlarmService;
  38 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.NotificationProcessService;
  39 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.NotificationTapiService;
  40 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.get.notifications.alarm.service.output.NotificationsAlarmService;
  41 import org.opendaylight.yang.gen.v1.nbi.notifications.rev211013.get.notifications.process.service.output.NotificationsProcessService;
  42 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Context;
  43 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid;
  44 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.Context1;
  45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.CreateNotificationSubscriptionServiceInput;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.CreateNotificationSubscriptionServiceOutput;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.CreateNotificationSubscriptionServiceOutputBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.DeleteNotificationSubscriptionServiceInput;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.DeleteNotificationSubscriptionServiceOutput;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.DeleteNotificationSubscriptionServiceOutputBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationListInput;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationListOutput;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationListOutputBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationSubscriptionServiceDetailsInput;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationSubscriptionServiceDetailsOutput;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationSubscriptionServiceDetailsOutputBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationSubscriptionServiceListInput;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationSubscriptionServiceListOutput;
  59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetNotificationSubscriptionServiceListOutputBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetSupportedNotificationTypesInput;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetSupportedNotificationTypesOutput;
  62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.GetSupportedNotificationTypesOutputBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.NotificationType;
  64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.ObjectType;
  65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.TapiNotificationService;
  66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.UpdateNotificationSubscriptionServiceInput;
  67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.UpdateNotificationSubscriptionServiceOutput;
  68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.context.NotificationContext;
  69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.context.NotificationContextBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.create.notification.subscription.service.output.SubscriptionService;
  71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.create.notification.subscription.service.output.SubscriptionServiceBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.get.notification.list.output.Notification;
  73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.get.notification.list.output.NotificationKey;
  74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.get.notification.subscription.service.list.output.SubscriptionServiceKey;
  75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.notification.context.NotifSubscription;
  76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.notification.context.NotifSubscriptionBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.notification.context.NotifSubscriptionKey;
  78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.notification.subscription.service.SubscriptionFilter;
  79 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev181210.notification.subscription.service.SubscriptionFilterBuilder;
  80 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  81 import org.opendaylight.yangtools.yang.common.ErrorType;
  82 import org.opendaylight.yangtools.yang.common.RpcResult;
  83 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  84 import org.slf4j.Logger;
  85 import org.slf4j.LoggerFactory;
  86
  87 public class NbiNotificationsImpl implements NbiNotificationsService, TapiNotificationService {
  88     private static final Logger LOG = LoggerFactory.getLogger(NbiNotificationsImpl.class);
  89     private final JsonStringConverter<NotificationProcessService> converterService;
  90     private final JsonStringConverter<NotificationAlarmService> converterAlarmService;
  91     private final JsonStringConverter<NotificationTapiService> converterTapiService;
  92     private final String server;
  93     private final NetworkTransactionService networkTransactionService;
  94     private final TopicManager topicManager;
  95
  96     public NbiNotificationsImpl(JsonStringConverter<NotificationProcessService> converterService,
  97                                 JsonStringConverter<NotificationAlarmService> converterAlarmService,
  98                                 JsonStringConverter<NotificationTapiService> converterTapiService, String server,
  99                                 NetworkTransactionService networkTransactionService, TopicManager topicManager) {
 100         this.converterService = converterService;
 101         this.converterAlarmService = converterAlarmService;
 102         this.converterTapiService = converterTapiService;
 103         this.server = server;
 104         this.networkTransactionService = networkTransactionService;
 105         this.topicManager = topicManager;
 106     }
 107
 108     @Override
 109     public ListenableFuture<RpcResult<GetNotificationsProcessServiceOutput>> getNotificationsProcessService(
 110             GetNotificationsProcessServiceInput input) {
 111         LOG.info("RPC getNotificationsService received");
 112         if (input == null || input.getIdConsumer() == null || input.getGroupId() == null) {
 113             LOG.warn("Missing mandatory params for input {}", input);
 114             return RpcResultBuilder.success(new GetNotificationsProcessServiceOutputBuilder().build()).buildFuture();
 115         }
 116         Subscriber<NotificationProcessService, NotificationsProcessService> subscriber = new Subscriber<>(
 117                 input.getIdConsumer(), input.getGroupId(), server, converterService,
 118                 NotificationServiceDeserializer.class);
 119         List<NotificationsProcessService> notificationServiceList = subscriber
 120                 .subscribe(input.getConnectionType().getName(), NotificationsProcessService.QNAME);
 121         return RpcResultBuilder.success(new GetNotificationsProcessServiceOutputBuilder()
 122                 .setNotificationsProcessService(notificationServiceList).build()).buildFuture();
 123     }
 124
 125     @Override
 126     public ListenableFuture<RpcResult<GetNotificationsAlarmServiceOutput>> getNotificationsAlarmService(
 127             GetNotificationsAlarmServiceInput input) {
 128         LOG.info("RPC getNotificationsAlarmService received");
 129         if (input == null || input.getIdConsumer() == null || input.getGroupId() == null) {
 130             LOG.warn("Missing mandatory params for input {}", input);
 131             return RpcResultBuilder.success(new GetNotificationsAlarmServiceOutputBuilder().build()).buildFuture();
 132         }
 133         Subscriber<NotificationAlarmService, NotificationsAlarmService> subscriber = new Subscriber<>(
 134                 input.getIdConsumer(), input.getGroupId(), server, converterAlarmService,
 135                 NotificationAlarmServiceDeserializer.class);
 136         List<NotificationsAlarmService> notificationAlarmServiceList = subscriber
 137                 .subscribe("alarm" + input.getConnectionType().getName(), NotificationsAlarmService.QNAME);
 138         return RpcResultBuilder.success(new GetNotificationsAlarmServiceOutputBuilder()
 139                 .setNotificationsAlarmService(notificationAlarmServiceList).build()).buildFuture();
 140     }
 141
 142     @Override
 143     public ListenableFuture<RpcResult<GetSupportedNotificationTypesOutput>>
 144             getSupportedNotificationTypes(GetSupportedNotificationTypesInput input) {
 145         NotificationContext notificationContext = getNotificationContext();
 146         if (notificationContext == null) {
 147             return RpcResultBuilder.<GetSupportedNotificationTypesOutput>failed()
 148                 .withError(ErrorType.APPLICATION, "Couldnt get Notification Context from Datastore")
 149                 .buildFuture();
 150         }
 151         if (notificationContext.getNotifSubscription() == null) {
 152             return RpcResultBuilder.success(new GetSupportedNotificationTypesOutputBuilder()
 153                 .setSupportedNotificationTypes(new HashSet<>())
 154                 .setSupportedObjectTypes(new HashSet<>()).build()).buildFuture();
 155         }
 156         Set<NotificationType> notificationTypeList = new HashSet<>();
 157         Set<ObjectType> objectTypeList = new HashSet<>();
 158         for (NotifSubscription notifSubscription:notificationContext.getNotifSubscription().values()) {
 159             if (notifSubscription.getSupportedNotificationTypes() != null) {
 160                 notificationTypeList.addAll(notifSubscription.getSupportedNotificationTypes());
 161             }
 162             if (notifSubscription.getSupportedObjectTypes() != null) {
 163                 objectTypeList.addAll(notifSubscription.getSupportedObjectTypes());
 164             }
 165         }
 166         return RpcResultBuilder.success(new GetSupportedNotificationTypesOutputBuilder()
 167             .setSupportedNotificationTypes(notificationTypeList)
 168             .setSupportedObjectTypes(objectTypeList).build()).buildFuture();
 169     }
 170
 171     @Override
 172     public ListenableFuture<RpcResult<CreateNotificationSubscriptionServiceOutput>>
 173             createNotificationSubscriptionService(CreateNotificationSubscriptionServiceInput input) {
 174         for (Uuid uuid:input.getSubscriptionFilter().getRequestedObjectIdentifier()) {
 175             LOG.info("Adding T-API topic: {} to Kafka server", uuid.getValue());
 176             this.topicManager.addTapiTopic(uuid.getValue());
 177         }
 178         SubscriptionFilter subscriptionFilter = new SubscriptionFilterBuilder()
 179             .setName(input.getSubscriptionFilter().getName())
 180             .setLocalId(input.getSubscriptionFilter().getLocalId())
 181             .setIncludeContent(input.getSubscriptionFilter().getIncludeContent())
 182             .setRequestedNotificationTypes(input.getSubscriptionFilter().getRequestedNotificationTypes())
 183             .setRequestedLayerProtocols(input.getSubscriptionFilter().getRequestedLayerProtocols())
 184             .setRequestedObjectIdentifier(input.getSubscriptionFilter().getRequestedObjectIdentifier())
 185             .setRequestedObjectTypes(input.getSubscriptionFilter().getRequestedObjectTypes())
 186             .build();
 187         Uuid notifSubscriptionUuid = new Uuid(UUID.randomUUID().toString());
 188         SubscriptionService subscriptionService = new SubscriptionServiceBuilder()
 189             .setSubscriptionFilter(subscriptionFilter)
 190             .setSubscriptionState(input.getSubscriptionState())
 191             .setUuid(notifSubscriptionUuid)
 192             .build();
 193
 194         NotifSubscriptionKey notifSubscriptionKey = new NotifSubscriptionKey(notifSubscriptionUuid);
 195         Set<NotificationType> notificationTypes = (subscriptionFilter.getRequestedNotificationTypes() != null)
 196             ? subscriptionFilter.getRequestedNotificationTypes()
 197             : new HashSet<>(List.of(NotificationType.ALARMEVENT));
 198         Set<ObjectType> objectTypes = (subscriptionFilter.getRequestedObjectTypes() != null)
 199             ? subscriptionFilter.getRequestedObjectTypes()
 200             : new HashSet<>(List.of(ObjectType.CONNECTIVITYSERVICE));
 201         NotifSubscription notifSubscription = new NotifSubscriptionBuilder()
 202             .setSubscriptionState(subscriptionService.getSubscriptionState())
 203             .setSubscriptionFilter(subscriptionService.getSubscriptionFilter())
 204             .setUuid(notifSubscriptionUuid)
 205             .setSupportedNotificationTypes(notificationTypes)
 206             .setSupportedObjectTypes(objectTypes)
 207             .setName(subscriptionService.getName())
 208             .build();
 209         NotificationContext notificationContext = getNotificationContext();
 210         Map<NotifSubscriptionKey, NotifSubscription> notifSubscriptions = new HashMap<>();
 211         if (notificationContext != null && notificationContext.getNotifSubscription() != null) {
 212             notifSubscriptions.putAll(notificationContext.getNotifSubscription());
 213         }
 214         notifSubscriptions.put(notifSubscriptionKey, notifSubscription);
 215         NotificationContext notificationContext1 = new NotificationContextBuilder()
 216             .setNotification(notificationContext == null ? new HashMap<>() : notificationContext.getNotification())
 217             .setNotifSubscription(notifSubscriptions)
 218             .build();
 219         if (!updateNotificationContext(notificationContext1)) {
 220             LOG.error("Failed to update Notification context");
 221             return RpcResultBuilder.<CreateNotificationSubscriptionServiceOutput>failed()
 222                 .withError(ErrorType.RPC, "Failed to update notification context").buildFuture();
 223         }
 224         CreateNotificationSubscriptionServiceOutput serviceOutput =
 225             new CreateNotificationSubscriptionServiceOutputBuilder()
 226                 .setSubscriptionService(subscriptionService)
 227                 .build();
 228         return RpcResultBuilder.success(serviceOutput).buildFuture();
 229     }
 230
 231     @Override
 232     public ListenableFuture<RpcResult<UpdateNotificationSubscriptionServiceOutput>>
 233             updateNotificationSubscriptionService(UpdateNotificationSubscriptionServiceInput input) {
 234         // TODO --> Not yet implemented
 235         return null;
 236     }
 237
 238     @Override
 239     public ListenableFuture<RpcResult<DeleteNotificationSubscriptionServiceOutput>>
 240             deleteNotificationSubscriptionService(DeleteNotificationSubscriptionServiceInput input) {
 241         try {
 242             if (input == null || input.getSubscriptionIdOrName() == null) {
 243                 LOG.warn("Missing mandatory params for input {}", input);
 244                 return RpcResultBuilder.<DeleteNotificationSubscriptionServiceOutput>failed()
 245                     .withError(ErrorType.RPC, "Missing input parameters").buildFuture();
 246             }
 247             Uuid notifSubsUuid = getUuidFromIput(input.getSubscriptionIdOrName());
 248             InstanceIdentifier<NotifSubscription> notifSubscriptionIID = InstanceIdentifier.builder(Context.class)
 249                 .augmentation(Context1.class).child(NotificationContext.class).child(NotifSubscription.class,
 250                     new NotifSubscriptionKey(notifSubsUuid)).build();
 251             Optional<NotifSubscription> optionalNotifSub = this.networkTransactionService.read(
 252                 LogicalDatastoreType.OPERATIONAL, notifSubscriptionIID).get();
 253
 254             if (!optionalNotifSub.isPresent()) {
 255                 return RpcResultBuilder.<DeleteNotificationSubscriptionServiceOutput>failed()
 256                     .withError(ErrorType.APPLICATION,
 257                         "Notification subscription doesnt exist").buildFuture();
 258             }
 259             NotifSubscription notifSubscription = optionalNotifSub.orElseThrow();
 260             this.networkTransactionService.delete(LogicalDatastoreType.OPERATIONAL, notifSubscriptionIID);
 261             this.networkTransactionService.commit().get();
 262             for (Uuid objectUuid:notifSubscription.getSubscriptionFilter().getRequestedObjectIdentifier()) {
 263                 this.topicManager.deleteTapiTopic(objectUuid.getValue());
 264             }
 265             return RpcResultBuilder.success(new DeleteNotificationSubscriptionServiceOutputBuilder().build())
 266                 .buildFuture();
 267         } catch (InterruptedException | ExecutionException | NoSuchElementException e) {
 268             LOG.error("Failed to delete Notification subscription service", e);
 269         }
 270         return RpcResultBuilder.<DeleteNotificationSubscriptionServiceOutput>failed()
 271             .withError(ErrorType.APPLICATION,
 272                 "Failed to delete notification subscription service").buildFuture();
 273     }
 274
 275     @Override
 276     public ListenableFuture<RpcResult<GetNotificationSubscriptionServiceDetailsOutput>>
 277             getNotificationSubscriptionServiceDetails(GetNotificationSubscriptionServiceDetailsInput input) {
 278         if (input == null || input.getSubscriptionIdOrName() == null) {
 279             LOG.warn("Missing mandatory params for input {}", input);
 280             return RpcResultBuilder.<GetNotificationSubscriptionServiceDetailsOutput>failed()
 281                 .withError(ErrorType.RPC, "Missing input parameters").buildFuture();
 282         }
 283         Uuid notifSubsUuid = getUuidFromIput(input.getSubscriptionIdOrName());
 284         NotificationContext notificationContext = getNotificationContext();
 285         if (notificationContext == null) {
 286             return RpcResultBuilder.<GetNotificationSubscriptionServiceDetailsOutput>failed()
 287                 .withError(ErrorType.APPLICATION, "Notification context is empty")
 288                 .buildFuture();
 289         }
 290         if (notificationContext.getNotifSubscription() == null) {
 291             return RpcResultBuilder.success(new GetNotificationSubscriptionServiceDetailsOutputBuilder()
 292                 .setSubscriptionService(new org.opendaylight.yang.gen.v1
 293                     .urn.onf.otcc.yang.tapi.notification.rev181210.get.notification.subscription.service
 294                         .details.output.SubscriptionServiceBuilder().build()).build()).buildFuture();
 295         }
 296         if (!notificationContext.getNotifSubscription().containsKey(new NotifSubscriptionKey(notifSubsUuid))) {
 297             return RpcResultBuilder.<GetNotificationSubscriptionServiceDetailsOutput>failed()
 298                 .withError(ErrorType.APPLICATION,
 299                     "Notification subscription service doesnt exist").buildFuture();
 300         }
 301         return RpcResultBuilder.success(new GetNotificationSubscriptionServiceDetailsOutputBuilder()
 302             .setSubscriptionService(new org.opendaylight.yang.gen.v1.urn
 303                 .onf.otcc.yang.tapi.notification.rev181210.get.notification.subscription.service.details.output
 304                 .SubscriptionServiceBuilder(notificationContext.getNotifSubscription().get(
 305                     new NotifSubscriptionKey(notifSubsUuid))).build()).build()).buildFuture();
 306     }
 307
 308     @Override
 309     public ListenableFuture<RpcResult<GetNotificationSubscriptionServiceListOutput>>
 310             getNotificationSubscriptionServiceList(GetNotificationSubscriptionServiceListInput input) {
 311         NotificationContext notificationContext = getNotificationContext();
 312         if (notificationContext == null) {
 313             return RpcResultBuilder.<GetNotificationSubscriptionServiceListOutput>failed()
 314                 .withError(ErrorType.APPLICATION, "Notification context is empty")
 315                 .buildFuture();
 316         }
 317         if (notificationContext.getNotifSubscription() == null) {
 318             return RpcResultBuilder.success(new GetNotificationSubscriptionServiceListOutputBuilder()
 319                 .setSubscriptionService(new HashMap<>()).build()).buildFuture();
 320         }
 321         Map<SubscriptionServiceKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang
 322             .tapi.notification.rev181210.get.notification.subscription.service.list.output.SubscriptionService>
 323                 notifSubsMap = new HashMap<>();
 324         for (NotifSubscription notifSubscription:notificationContext.getNotifSubscription().values()) {
 325             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang
 326                 .tapi.notification.rev181210.get.notification.subscription.service.list.output.SubscriptionService
 327                     subscriptionService = new org.opendaylight.yang.gen.v1
 328                         .urn.onf.otcc.yang.tapi.notification.rev181210.get.notification.subscription.service
 329                             .list.output.SubscriptionServiceBuilder(notifSubscription).build();
 330             notifSubsMap.put(subscriptionService.key(), subscriptionService);
 331         }
 332         return RpcResultBuilder.success(new GetNotificationSubscriptionServiceListOutputBuilder()
 333             .setSubscriptionService(notifSubsMap).build()).buildFuture();
 334     }
 335
 336     @Override
 337     public ListenableFuture<RpcResult<GetNotificationListOutput>> getNotificationList(GetNotificationListInput input) {
 338         try {
 339             LOG.info("RPC getNotificationList received");
 340             if (input == null || input.getSubscriptionIdOrName() == null) {
 341                 LOG.warn("Missing mandatory params for input {}", input);
 342                 return RpcResultBuilder.<GetNotificationListOutput>failed().withError(ErrorType.RPC,
 343                     "Missing input parameters").buildFuture();
 344             }
 345             Uuid notifSubsUuid = getUuidFromIput(input.getSubscriptionIdOrName());
 346             InstanceIdentifier<NotifSubscription> notifSubscriptionIID = InstanceIdentifier.builder(Context.class)
 347                 .augmentation(Context1.class).child(NotificationContext.class).child(NotifSubscription.class,
 348                     new NotifSubscriptionKey(notifSubsUuid)).build();
 349             Optional<NotifSubscription> optionalNotifSub = this.networkTransactionService.read(
 350                 LogicalDatastoreType.OPERATIONAL, notifSubscriptionIID).get();
 351
 352             if (!optionalNotifSub.isPresent()) {
 353                 return RpcResultBuilder.<GetNotificationListOutput>failed()
 354                     .withError(ErrorType.APPLICATION,
 355                         "Notification subscription doesnt exist").buildFuture();
 356             }
 357             NotifSubscription notifSubscription = optionalNotifSub.orElseThrow();
 358             List<Notification> notificationTapiList = new ArrayList<>();
 359             for (Uuid objectUuid:notifSubscription.getSubscriptionFilter().getRequestedObjectIdentifier()) {
 360                 if (!this.topicManager.getTapiTopicMap().containsKey(objectUuid.getValue())) {
 361                     LOG.warn("Topic doesnt exist for {}", objectUuid.getValue());
 362                     continue;
 363                 }
 364                 LOG.info("Going to get notifications for topic {}", objectUuid.getValue());
 365                 Subscriber<NotificationTapiService, Notification> subscriber = new Subscriber<>(
 366                     objectUuid.getValue(), objectUuid.getValue(), server, converterTapiService,
 367                     TapiNotificationDeserializer.class);
 368                 notificationTapiList.addAll(subscriber.subscribe(objectUuid.getValue(), Notification.QNAME));
 369             }
 370             LOG.info("TAPI notifications = {}", notificationTapiList);
 371             Map<NotificationKey, Notification> notificationMap = new HashMap<>();
 372             for (Notification notif:notificationTapiList) {
 373                 notificationMap.put(notif.key(), notif);
 374             }
 375             return RpcResultBuilder.success(new GetNotificationListOutputBuilder()
 376                 .setNotification(notificationMap).build()).buildFuture();
 377         } catch (InterruptedException | ExecutionException | NoSuchElementException e) {
 378             LOG.error("Failed to get Notifications from Kafka", e);
 379         }
 380         return RpcResultBuilder.<GetNotificationListOutput>failed()
 381             .withError(ErrorType.APPLICATION,
 382                 "Notifications couldnt be retrieved from Kafka server").buildFuture();
 383     }
 384
 385     private NotificationContext getNotificationContext() {
 386         LOG.info("Getting tapi notification context");
 387         try {
 388             InstanceIdentifier<NotificationContext> notificationcontextIID =
 389                 InstanceIdentifier.builder(Context.class).augmentation(Context1.class)
 390                     .child(NotificationContext.class).build();
 391             Optional<NotificationContext> notificationContextOptional
 392                 = this.networkTransactionService.read(LogicalDatastoreType.OPERATIONAL, notificationcontextIID).get();
 393             if (!notificationContextOptional.isPresent()) {
 394                 LOG.error("Could not get TAPI notification context");
 395                 return null;
 396             }
 397             return notificationContextOptional.orElseThrow();
 398         } catch (InterruptedException | ExecutionException e) {
 399             LOG.error("Could not get TAPI notification context");
 400         }
 401         return null;
 402     }
 403
 404     private boolean updateNotificationContext(NotificationContext notificationContext1) {
 405         try {
 406             InstanceIdentifier<NotificationContext> notificationcontextIID =
 407                 InstanceIdentifier.builder(Context.class).augmentation(Context1.class)
 408                     .child(NotificationContext.class).build();
 409             this.networkTransactionService.merge(LogicalDatastoreType.OPERATIONAL, notificationcontextIID,
 410                 notificationContext1);
 411             this.networkTransactionService.commit().get();
 412             return true;
 413         } catch (InterruptedException | ExecutionException e) {
 414             LOG.error("Could not update TAPI notification context");
 415         }
 416         return false;
 417     }
 418
 419     private Uuid getUuidFromIput(String serviceIdOrName) {
 420         try {
 421             UUID.fromString(serviceIdOrName);
 422             LOG.info("Given attribute {} is a UUID", serviceIdOrName);
 423             return new Uuid(serviceIdOrName);
 424         } catch (IllegalArgumentException e) {
 425             LOG.info("Given attribute {} is not a UUID", serviceIdOrName);
 426             return new Uuid(UUID.nameUUIDFromBytes(serviceIdOrName.getBytes(StandardCharsets.UTF_8)).toString());
 427         }
 428     }
 429 }