enrichment-coordinator-service/src/main/java/org/oransc/enrichment/repository/EiProducers.java

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2019 Nordix Foundation
   6  * %%
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ========================LICENSE_END===================================
  19  */
  20
  21 package org.oransc.enrichment.repository;
  22
  23 import java.lang.invoke.MethodHandles;
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.HashMap;
  27 import java.util.Map;
  28 import java.util.Vector;
  29
  30 import org.immutables.value.Value.Immutable;
  31 import org.oransc.enrichment.controllers.consumer.ConsumerCallbacks;
  32 import org.oransc.enrichment.controllers.producer.ProducerCallbacks;
  33 import org.oransc.enrichment.exceptions.ServiceException;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36 import org.springframework.beans.factory.annotation.Autowired;
  37 import org.springframework.stereotype.Component;
  38
  39 /**
  40  * Dynamic representation of all EiProducers.
  41  */
  42 @SuppressWarnings("squid:S2629") // Invoke method(s) only conditionally
  43 @Component
  44 public class EiProducers {
  45     private final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
  46     private final Map<String, EiProducer> allEiProducers = new HashMap<>();
  47     private final MultiMap<EiProducer> producersByType = new MultiMap<>();
  48
  49     @Autowired
  50     private ProducerCallbacks producerCallbacks;
  51
  52     @Autowired
  53     private ConsumerCallbacks consumerCallbacks;
  54
  55     @Autowired
  56     private EiTypes eiTypes;
  57
  58     @Autowired
  59     private EiJobs eiJobs;
  60
  61     @Immutable
  62     public interface EiTypeRegistrationInfo {
  63         String id();
  64
  65         Object jobDataSchema();
  66     }
  67
  68     @Immutable
  69     public interface EiProducerRegistrationInfo {
  70         String id();
  71
  72         Collection<EiTypeRegistrationInfo> supportedTypes();
  73
  74         String jobCallbackUrl();
  75
  76         String producerSupervisionCallbackUrl();
  77
  78     }
  79
  80     public EiProducer registerProducer(EiProducerRegistrationInfo producerInfo) {
  81         final String producerId = producerInfo.id();
  82         EiProducer previousDefinition = this.get(producerId);
  83         if (previousDefinition != null) {
  84             for (EiType type : previousDefinition.getEiTypes()) {
  85                 producersByType.remove(type.getId(), producerId);
  86             }
  87             allEiProducers.remove(producerId);
  88         }
  89
  90         EiProducer producer = createProducer(producerInfo);
  91         allEiProducers.put(producer.getId(), producer);
  92         for (EiType type : producer.getEiTypes()) {
  93             producersByType.put(type.getId(), producer.getId(), producer);
  94         }
  95
  96         if (previousDefinition != null) {
  97             purgeTypes(previousDefinition.getEiTypes());
  98             this.consumerCallbacks.notifyConsumersProducerDeleted(previousDefinition);
  99         }
 100
 101         producerCallbacks.restartEiJobs(producer, this.eiJobs);
 102         consumerCallbacks.notifyConsumersProducerAdded(producer);
 103         return producer;
 104     }
 105
 106     private void purgeTypes(Collection<EiType> types) {
 107         for (EiType type : types) {
 108             if (getProducersForType(type.getId()).isEmpty()) {
 109                 this.eiTypes.remove(type);
 110             }
 111         }
 112     }
 113
 114     private EiType getType(EiTypeRegistrationInfo typeInfo) {
 115         EiType type = this.eiTypes.get(typeInfo.id());
 116         if (type == null) {
 117             type = new EiType(typeInfo.id(), typeInfo.jobDataSchema());
 118             this.eiTypes.put(type);
 119             this.consumerCallbacks.notifyConsumersTypeAdded(type);
 120         }
 121         return type;
 122     }
 123
 124     private EiProducer createProducer(EiProducerRegistrationInfo producerInfo) {
 125         ArrayList<EiType> types = new ArrayList<>();
 126
 127         EiProducer producer = new EiProducer(producerInfo.id(), types, producerInfo.jobCallbackUrl(),
 128             producerInfo.producerSupervisionCallbackUrl());
 129
 130         for (EiTypeRegistrationInfo typeInfo : producerInfo.supportedTypes()) {
 131             EiType type = getType(typeInfo);
 132             types.add(type);
 133         }
 134         return producer;
 135     }
 136
 137     public synchronized Collection<EiProducer> getAllProducers() {
 138         return new Vector<>(allEiProducers.values());
 139     }
 140
 141     public synchronized EiProducer getProducer(String id) throws ServiceException {
 142         EiProducer p = allEiProducers.get(id);
 143         if (p == null) {
 144             throw new ServiceException("Could not find EI producer: " + id);
 145         }
 146         return p;
 147     }
 148
 149     public synchronized EiProducer get(String id) {
 150         return allEiProducers.get(id);
 151     }
 152
 153     public synchronized int size() {
 154         return allEiProducers.size();
 155     }
 156
 157     public synchronized void clear() {
 158         this.allEiProducers.clear();
 159         this.producersByType.clear();
 160     }
 161
 162     public void deregisterProducer(EiProducer producer, EiTypes eiTypes) {
 163         allEiProducers.remove(producer.getId());
 164         for (EiType type : producer.getEiTypes()) {
 165             if (producersByType.remove(type.getId(), producer.getId()) == null) {
 166                 this.logger.error("Bug, no producer found");
 167             }
 168             if (this.producersByType.get(type.getId()).isEmpty()) {
 169                 eiTypes.remove(type);
 170             }
 171         }
 172         this.consumerCallbacks.notifyConsumersProducerDeleted(producer);
 173     }
 174
 175     public synchronized Collection<EiProducer> getProducersForType(EiType type) {
 176         return this.producersByType.get(type.getId());
 177     }
 178
 179     public synchronized Collection<EiProducer> getProducersForType(String typeId) {
 180         return this.producersByType.get(typeId);
 181     }
 182
 183     public synchronized Collection<String> getProducerIdsForType(String typeId) {
 184         Collection<String> producerIds = new ArrayList<>();
 185         for (EiProducer p : this.getProducersForType(typeId)) {
 186             producerIds.add(p.getId());
 187         }
 188         return producerIds;
 189     }
 190
 191 }