opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManager.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, 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.controller.config.manager.impl.dependencyresolver;
   9
  10 import org.opendaylight.controller.config.api.DependencyResolver;
  11 import org.opendaylight.controller.config.api.DependencyResolverFactory;
  12 import org.opendaylight.controller.config.api.JmxAttribute;
  13 import org.opendaylight.controller.config.api.ModuleIdentifier;
  14 import org.opendaylight.controller.config.api.ServiceReferenceReadableRegistry;
  15 import org.opendaylight.controller.config.manager.impl.CommitInfo;
  16 import org.opendaylight.controller.config.manager.impl.ModuleInternalTransactionalInfo;
  17 import org.opendaylight.controller.config.manager.impl.TransactionStatus;
  18 import org.opendaylight.controller.config.spi.Module;
  19 import org.opendaylight.controller.config.spi.ModuleFactory;
  20
  21 import javax.annotation.concurrent.GuardedBy;
  22 import javax.management.InstanceAlreadyExistsException;
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 /**
  30  * Holds information about modules being created and destroyed within this
  31  * transaction. Observes usage of DependencyResolver within modules to figure
  32  * out dependency tree.
  33  */
  34 public class DependencyResolverManager implements TransactionHolder, DependencyResolverFactory {
  35     @GuardedBy("this")
  36     private final Map<ModuleIdentifier, DependencyResolverImpl> moduleIdentifiersToDependencyResolverMap = new HashMap<>();
  37     private final ModulesHolder modulesHolder;
  38     private final TransactionStatus transactionStatus;
  39     private final ServiceReferenceReadableRegistry readableRegistry;
  40
  41     public DependencyResolverManager(String transactionName,
  42             TransactionStatus transactionStatus, ServiceReferenceReadableRegistry readableRegistry) {
  43         this.modulesHolder = new ModulesHolder(transactionName);
  44         this.transactionStatus = transactionStatus;
  45         this.readableRegistry = readableRegistry;
  46     }
  47
  48     @Override
  49     public DependencyResolver createDependencyResolver(ModuleIdentifier moduleIdentifier) {
  50         return getOrCreate(moduleIdentifier);
  51     }
  52
  53     public synchronized DependencyResolverImpl getOrCreate(ModuleIdentifier name) {
  54         DependencyResolverImpl dependencyResolver = moduleIdentifiersToDependencyResolverMap.get(name);
  55         if (dependencyResolver == null) {
  56             transactionStatus.checkNotCommitted();
  57             dependencyResolver = new DependencyResolverImpl(name, transactionStatus, modulesHolder, readableRegistry);
  58             moduleIdentifiersToDependencyResolverMap.put(name, dependencyResolver);
  59         }
  60         return dependencyResolver;
  61     }
  62
  63     /**
  64      * Get all dependency resolvers, including those that belong to destroyed
  65      * things?
  66      */
  67     private List<DependencyResolverImpl> getAllSorted() {
  68         transactionStatus.checkCommitted();
  69         List<DependencyResolverImpl> sorted = new ArrayList<>(
  70                 moduleIdentifiersToDependencyResolverMap.values());
  71         for (DependencyResolverImpl dri : sorted) {
  72             dri.countMaxDependencyDepth(this);
  73         }
  74         Collections.sort(sorted);
  75         return sorted;
  76     }
  77
  78     public List<ModuleIdentifier> getSortedModuleIdentifiers() {
  79         List<ModuleIdentifier> result = new ArrayList<>(
  80                 moduleIdentifiersToDependencyResolverMap.size());
  81         for (DependencyResolverImpl dri : getAllSorted()) {
  82             ModuleIdentifier driName = dri.getIdentifier();
  83             result.add(driName);
  84         }
  85         return result;
  86     }
  87
  88     @Override
  89     public ModuleInternalTransactionalInfo destroyModule(
  90             ModuleIdentifier moduleIdentifier) {
  91         transactionStatus.checkNotCommitted();
  92         ModuleInternalTransactionalInfo found = modulesHolder
  93                 .destroyModule(moduleIdentifier);
  94         moduleIdentifiersToDependencyResolverMap.remove(moduleIdentifier);
  95         return found;
  96     }
  97
  98     // protect write access
  99     @Override
 100     public void put(
 101             ModuleInternalTransactionalInfo moduleInternalTransactionalInfo) {
 102         transactionStatus.checkNotCommitted();
 103         modulesHolder.put(moduleInternalTransactionalInfo);
 104     }
 105
 106     // wrapped methods:
 107
 108     @Override
 109     public CommitInfo toCommitInfo() {
 110         return modulesHolder.toCommitInfo();
 111     }
 112
 113     @Override
 114     public Module findModule(ModuleIdentifier moduleIdentifier,
 115             JmxAttribute jmxAttributeForReporting) {
 116         return modulesHolder.findModule(moduleIdentifier,
 117                 jmxAttributeForReporting);
 118     }
 119
 120     @Override
 121     public ModuleInternalTransactionalInfo findModuleInternalTransactionalInfo(ModuleIdentifier moduleIdentifier) {
 122         return modulesHolder.findModuleInternalTransactionalInfo(moduleIdentifier);
 123     }
 124
 125     @Override
 126     public ModuleFactory findModuleFactory(ModuleIdentifier moduleIdentifier,
 127             JmxAttribute jmxAttributeForReporting) {
 128         return modulesHolder.findModuleFactory(moduleIdentifier,
 129                 jmxAttributeForReporting);
 130     }
 131
 132     @Override
 133     public Map<ModuleIdentifier, Module> getAllModules() {
 134         return modulesHolder.getAllModules();
 135     }
 136
 137     @Override
 138     public void assertNotExists(ModuleIdentifier moduleIdentifier)
 139             throws InstanceAlreadyExistsException {
 140         modulesHolder.assertNotExists(moduleIdentifier);
 141     }
 142
 143     public List<ModuleIdentifier> findAllByFactory(ModuleFactory factory) {
 144         List<ModuleIdentifier> result = new ArrayList<>();
 145         for( ModuleInternalTransactionalInfo  info : modulesHolder.getAllInfos()) {
 146             if (factory.equals(info.getModuleFactory())) {
 147                 result.add(info.getIdentifier());
 148             }
 149         }
 150         return result;
 151     }
 152 }