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.manager.impl.CommitInfo;
  15 import org.opendaylight.controller.config.manager.impl.ModuleInternalTransactionalInfo;
  16 import org.opendaylight.controller.config.manager.impl.TransactionStatus;
  17 import org.opendaylight.controller.config.spi.Module;
  18 import org.opendaylight.controller.config.spi.ModuleFactory;
  19
  20 import javax.annotation.concurrent.GuardedBy;
  21 import javax.management.InstanceAlreadyExistsException;
  22 import java.util.ArrayList;
  23 import java.util.Collections;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27
  28 /**
  29  * Holds information about modules being created and destroyed within this
  30  * transaction. Observes usage of DependencyResolver within modules to figure
  31  * out dependency tree.
  32  */
  33 public class DependencyResolverManager implements TransactionHolder, DependencyResolverFactory {
  34     @GuardedBy("this")
  35     private final Map<ModuleIdentifier, DependencyResolverImpl> moduleIdentifiersToDependencyResolverMap = new HashMap<>();
  36     private final ModulesHolder modulesHolder;
  37     private final TransactionStatus transactionStatus;
  38
  39     public DependencyResolverManager(String transactionName,
  40             TransactionStatus transactionStatus) {
  41         this.modulesHolder = new ModulesHolder(transactionName);
  42         this.transactionStatus = transactionStatus;
  43     }
  44
  45     @Override
  46     public DependencyResolver createDependencyResolver(ModuleIdentifier moduleIdentifier) {
  47         return getOrCreate(moduleIdentifier);
  48     }
  49
  50     public synchronized DependencyResolverImpl getOrCreate(ModuleIdentifier name) {
  51         DependencyResolverImpl dependencyResolver = moduleIdentifiersToDependencyResolverMap
  52                 .get(name);
  53         if (dependencyResolver == null) {
  54             transactionStatus.checkNotCommitted();
  55             dependencyResolver = new DependencyResolverImpl(name,
  56                     transactionStatus, modulesHolder);
  57             moduleIdentifiersToDependencyResolverMap.put(name,
  58                     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 }