opendaylight/netconf/config-netconf-connector/src/main/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/editconfig/EditConfig.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
   9 package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
  10
  11 import com.google.common.annotations.VisibleForTesting;
  12 import com.google.common.collect.Maps;
  13 import com.google.common.collect.Multimap;
  14 import org.opendaylight.controller.config.api.JmxAttributeValidationException;
  15 import org.opendaylight.controller.config.api.ValidationException;
  16 import org.opendaylight.controller.config.util.ConfigRegistryClient;
  17 import org.opendaylight.controller.config.util.ConfigTransactionClient;
  18 import org.opendaylight.controller.config.yang.store.api.YangStoreSnapshot;
  19 import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
  20 import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
  21 import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorSeverity;
  22 import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorTag;
  23 import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorType;
  24 import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Config;
  25 import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.InstanceConfig;
  26 import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.InstanceConfigElementResolved;
  27 import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ModuleConfig;
  28 import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ModuleElementDefinition;
  29 import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ModuleElementResolved;
  30 import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Services;
  31 import org.opendaylight.controller.netconf.confignetconfconnector.operations.AbstractConfigNetconfOperation;
  32 import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfigXmlParser.EditConfigExecution;
  33 import org.opendaylight.controller.netconf.confignetconfconnector.transactions.TransactionProvider;
  34 import org.opendaylight.controller.netconf.util.xml.XmlElement;
  35 import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38 import org.w3c.dom.Document;
  39 import org.w3c.dom.Element;
  40
  41 import javax.management.InstanceNotFoundException;
  42 import javax.management.ObjectName;
  43 import java.util.HashMap;
  44 import java.util.Map;
  45 import java.util.Map.Entry;
  46
  47 public class EditConfig extends AbstractConfigNetconfOperation {
  48
  49     private static final Logger logger = LoggerFactory.getLogger(EditConfig.class);
  50
  51     private final YangStoreSnapshot yangStoreSnapshot;
  52
  53     private final TransactionProvider transactionProvider;
  54     private EditConfigXmlParser editConfigXmlParser;
  55
  56     public EditConfig(YangStoreSnapshot yangStoreSnapshot, TransactionProvider transactionProvider,
  57             ConfigRegistryClient configRegistryClient, String netconfSessionIdForReporting) {
  58         super(configRegistryClient, netconfSessionIdForReporting);
  59         this.yangStoreSnapshot = yangStoreSnapshot;
  60         this.transactionProvider = transactionProvider;
  61         this.editConfigXmlParser = new EditConfigXmlParser();
  62     }
  63
  64     @VisibleForTesting
  65     Element getResponseInternal(final Document document,
  66             final EditConfigXmlParser.EditConfigExecution editConfigExecution) throws NetconfDocumentedException {
  67
  68         if (editConfigExecution.shouldTest()) {
  69             executeTests(configRegistryClient, editConfigExecution);
  70         }
  71
  72         if (editConfigExecution.shouldSet()) {
  73             executeSet(configRegistryClient, editConfigExecution);
  74         }
  75
  76         logger.trace("Operation {} successful", EditConfigXmlParser.EDIT_CONFIG);
  77
  78         return document.createElement(XmlNetconfConstants.OK);
  79     }
  80
  81     private void executeSet(ConfigRegistryClient configRegistryClient,
  82             EditConfigXmlParser.EditConfigExecution editConfigExecution) throws NetconfDocumentedException {
  83         try {
  84             set(configRegistryClient, editConfigExecution);
  85         } catch (IllegalStateException | JmxAttributeValidationException | ValidationException e) {
  86             logger.warn("Set phase for {} failed", EditConfigXmlParser.EDIT_CONFIG, e);
  87             final Map<String, String> errorInfo = new HashMap<>();
  88             errorInfo.put(ErrorTag.operation_failed.name(), e.getMessage());
  89             throw new NetconfDocumentedException("Test phase: " + e.getMessage(), e, ErrorType.application,
  90                     ErrorTag.operation_failed, ErrorSeverity.error, errorInfo);
  91         }
  92         logger.debug("Set phase for {} operation successful", EditConfigXmlParser.EDIT_CONFIG);
  93     }
  94
  95     private void executeTests(ConfigRegistryClient configRegistryClient,
  96             EditConfigExecution editConfigExecution) throws NetconfDocumentedException {
  97         try {
  98             test(configRegistryClient, editConfigExecution, editConfigExecution.getDefaultStrategy());
  99         } catch (IllegalStateException | JmxAttributeValidationException | ValidationException e) {
 100             logger.warn("Test phase for {} failed", EditConfigXmlParser.EDIT_CONFIG, e);
 101             final Map<String, String> errorInfo = new HashMap<>();
 102             errorInfo.put(ErrorTag.operation_failed.name(), e.getMessage());
 103             throw new NetconfDocumentedException("Test phase: " + e.getMessage(), e, ErrorType.application,
 104                     ErrorTag.operation_failed, ErrorSeverity.error, errorInfo);
 105         }
 106         logger.debug("Test phase for {} operation successful", EditConfigXmlParser.EDIT_CONFIG);
 107     }
 108
 109     private void test(ConfigRegistryClient configRegistryClient, EditConfigExecution execution,
 110             EditStrategyType editStrategyType) {
 111         ObjectName taON = transactionProvider.getTestTransaction();
 112         try {
 113
 114             // default strategy = replace wipes config
 115             if (editStrategyType == EditStrategyType.replace) {
 116                 transactionProvider.wipeTestTransaction(taON);
 117             }
 118
 119             ConfigTransactionClient ta = configRegistryClient.getConfigTransactionClient(taON);
 120
 121             handleMisssingInstancesOnTransaction(ta, execution);
 122             setServicesOnTransaction(ta, execution);
 123             setOnTransaction(ta, execution);
 124             transactionProvider.validateTestTransaction(taON);
 125         } finally {
 126             transactionProvider.abortTestTransaction(taON);
 127         }
 128     }
 129
 130     private void set(ConfigRegistryClient configRegistryClient,
 131             EditConfigXmlParser.EditConfigExecution editConfigExecution) {
 132         ObjectName taON = transactionProvider.getOrCreateTransaction();
 133
 134         // default strategy = replace wipes config
 135         if (editConfigExecution.getDefaultStrategy() == EditStrategyType.replace) {
 136             transactionProvider.wipeTransaction();
 137         }
 138
 139         ConfigTransactionClient ta = configRegistryClient.getConfigTransactionClient(taON);
 140
 141         handleMisssingInstancesOnTransaction(ta, editConfigExecution);
 142         setServicesOnTransaction(ta, editConfigExecution);
 143         setOnTransaction(ta, editConfigExecution);
 144     }
 145
 146     private void setServicesOnTransaction(ConfigTransactionClient ta, EditConfigExecution execution) {
 147
 148         Services services = execution.getServices();
 149
 150         Map<String, Map<String, Map<String, Services.ServiceInstance>>> namespaceToServiceNameToRefNameToInstance = services
 151                 .getNamespaceToServiceNameToRefNameToInstance();
 152
 153         for (String serviceNamespace : namespaceToServiceNameToRefNameToInstance.keySet()) {
 154             for (String serviceName : namespaceToServiceNameToRefNameToInstance.get(serviceNamespace).keySet()) {
 155
 156                 String qnameOfService = getQname(ta, serviceNamespace, serviceName);
 157                 Map<String, Services.ServiceInstance> refNameToInstance = namespaceToServiceNameToRefNameToInstance
 158                         .get(serviceNamespace).get(serviceName);
 159
 160                 for (String refName : refNameToInstance.keySet()) {
 161                     ObjectName on = refNameToInstance.get(refName).getObjectName(ta.getTransactionName());
 162                     try {
 163                         ObjectName saved = ta.saveServiceReference(qnameOfService, refName, on);
 164                         logger.debug("Saving service {} with on {} under name {} with service on {}", qnameOfService,
 165                                 on, refName, saved);
 166                     } catch (InstanceNotFoundException e) {
 167                         throw new IllegalStateException("Unable to save ref name " + refName + " for instance " + on, e);
 168                     }
 169                 }
 170             }
 171         }
 172     }
 173
 174     private String getQname(ConfigTransactionClient ta, String namespace, String serviceName) {
 175         return ta.getServiceInterfaceName(namespace, serviceName);
 176     }
 177
 178     private void setOnTransaction(ConfigTransactionClient ta, EditConfigExecution execution) {
 179
 180         for (Multimap<String, ModuleElementResolved> modulesToResolved : execution.getResolvedXmlElements(ta).values()) {
 181
 182             for (Entry<String, ModuleElementResolved> moduleToResolved : modulesToResolved.entries()) {
 183                 String moduleName = moduleToResolved.getKey();
 184
 185                 ModuleElementResolved moduleElementResolved = moduleToResolved.getValue();
 186                 String instanceName = moduleElementResolved.getInstanceName();
 187
 188                 InstanceConfigElementResolved ice = moduleElementResolved.getInstanceConfigElementResolved();
 189                 EditConfigStrategy strategy = ice.getEditStrategy();
 190                 strategy.executeConfiguration(moduleName, instanceName, ice.getConfiguration(), ta, execution.getServiceRegistryWrapper(ta));
 191             }
 192         }
 193     }
 194
 195     private void handleMisssingInstancesOnTransaction(ConfigTransactionClient ta,
 196             EditConfigExecution execution) {
 197
 198         for (Multimap<String,ModuleElementDefinition> modulesToResolved : execution.getModulesDefinition(ta).values()) {
 199             for (Entry<String, ModuleElementDefinition> moduleToResolved : modulesToResolved.entries()) {
 200                 String moduleName = moduleToResolved.getKey();
 201
 202                 ModuleElementDefinition moduleElementDefinition = moduleToResolved.getValue();
 203
 204                 EditConfigStrategy strategy = moduleElementDefinition.getEditStrategy();
 205                 strategy.executeConfiguration(moduleName, moduleElementDefinition.getInstanceName(), null, ta, execution.getServiceRegistryWrapper(ta));
 206             }
 207         }
 208     }
 209
 210     public static Config getConfigMapping(ConfigRegistryClient configRegistryClient,
 211             Map<String/* Namespace from yang file */,
 212                     Map<String /* Name of module entry from yang file */, ModuleMXBeanEntry>> mBeanEntries) {
 213         Map<String, Map<String, ModuleConfig>> factories = transformMbeToModuleConfigs(configRegistryClient, mBeanEntries);
 214
 215         return new Config(factories);
 216     }
 217
 218     public static Map<String/* Namespace from yang file */,
 219             Map<String /* Name of module entry from yang file */, ModuleConfig>> transformMbeToModuleConfigs
 220             (final ConfigRegistryClient configRegistryClient, Map<String/* Namespace from yang file */,
 221                     Map<String /* Name of module entry from yang file */, ModuleMXBeanEntry>> mBeanEntries) {
 222
 223         Map<String, Map<String, ModuleConfig>> namespaceToModuleNameToModuleConfig = Maps.newHashMap();
 224
 225         for (String namespace : mBeanEntries.keySet()) {
 226             for (Entry<String, ModuleMXBeanEntry> moduleNameToMbe : mBeanEntries.get(namespace).entrySet()) {
 227                 String moduleName = moduleNameToMbe.getKey();
 228                 ModuleMXBeanEntry moduleMXBeanEntry = moduleNameToMbe.getValue();
 229
 230                 ModuleConfig moduleConfig = new ModuleConfig(moduleName, new InstanceConfig(configRegistryClient,
 231                         moduleMXBeanEntry.getAttributes()), moduleMXBeanEntry
 232                         .getProvidedServices().values());
 233
 234                 Map<String, ModuleConfig> moduleNameToModuleConfig = namespaceToModuleNameToModuleConfig.get(namespace);
 235                 if(moduleNameToModuleConfig == null) {
 236                     moduleNameToModuleConfig = Maps.newHashMap();
 237                     namespaceToModuleNameToModuleConfig.put(namespace, moduleNameToModuleConfig);
 238                 }
 239
 240                 moduleNameToModuleConfig.put(moduleName, moduleConfig);
 241             }
 242         }
 243
 244         return namespaceToModuleNameToModuleConfig;
 245     }
 246
 247     @Override
 248     protected String getOperationName() {
 249         return EditConfigXmlParser.EDIT_CONFIG;
 250     }
 251
 252     @Override
 253     protected Element handle(Document document, XmlElement xml) throws NetconfDocumentedException {
 254
 255         EditConfigXmlParser.EditConfigExecution editConfigExecution;
 256         Config cfg = getConfigMapping(configRegistryClient, yangStoreSnapshot.getModuleMXBeanEntryMap());
 257         try {
 258             editConfigExecution = editConfigXmlParser.fromXml(xml, cfg, transactionProvider, configRegistryClient);
 259         } catch (IllegalStateException e) {
 260             logger.warn("Error parsing xml", e);
 261             final Map<String, String> errorInfo = new HashMap<>();
 262             errorInfo.put(ErrorTag.missing_attribute.name(), "Error parsing xml: " + e.getMessage());
 263             throw new NetconfDocumentedException(e.getMessage(), ErrorType.rpc, ErrorTag.missing_attribute,
 264                     ErrorSeverity.error, errorInfo);
 265         } catch (final IllegalArgumentException e) {
 266             logger.warn("Error parsing xml", e);
 267             final Map<String, String> errorInfo = new HashMap<>();
 268             errorInfo.put(ErrorTag.bad_attribute.name(), e.getMessage());
 269             throw new NetconfDocumentedException(e.getMessage(), ErrorType.rpc, ErrorTag.bad_attribute,
 270                     ErrorSeverity.error, errorInfo);
 271         } catch (final UnsupportedOperationException e) {
 272             logger.warn("Unsupported", e);
 273             final Map<String, String> errorInfo = new HashMap<>();
 274             errorInfo.put(ErrorTag.operation_not_supported.name(), "Unsupported option for 'edit-config'");
 275             throw new NetconfDocumentedException(e.getMessage(), ErrorType.application,
 276                     ErrorTag.operation_not_supported, ErrorSeverity.error, errorInfo);
 277         }
 278
 279         return getResponseInternal(document, editConfigExecution);
 280     }
 281 }