import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@SuppressWarnings("IllegalCatch")
private void validateNoLocks() throws ValidationException {
    transactionStatus.checkNotAborted();
    LOG.trace("Validating transaction {}", getTransactionIdentifier());
    // call validate()
    List<ValidationException> collectedExceptions = new ArrayList<>();
    for (Entry<ModuleIdentifier, Module> entry : dependencyResolverManager.getAllModules().entrySet()) {
        ModuleIdentifier name = entry.getKey();
        Module module = entry.getValue();
        try {
            module.validate();
        } catch (final Exception e) {
            LOG.warn("Validation exception in {}", getTransactionName(), e);
            collectedExceptions.add(ValidationException.createForSingleException(name, e));
        }
    }
    if (!collectedExceptions.isEmpty()) {
        throw ValidationException.createFromCollectedValidationExceptions(collectedExceptions);
    }
    LOG.trace("Validated transaction {}", getTransactionIdentifier());
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
/**
 * If this method passes validation, it will grab
 * {@link TransactionStatus#secondPhaseCommitStarted} lock. This lock will
 * prevent calling @{link #validateBeforeCommitAndLockTransaction}, effectively
 * only allowing to call {@link #secondPhaseCommit} after successful return of
 * this method.
 */
@Override
public synchronized CommitInfo validateBeforeCommitAndLockTransaction() throws ValidationException {
    transactionStatus.checkNotAborted();
    transactionStatus.checkNotCommitStarted();
    configBeanModificationDisabled.set(true);
    try {
        validateNoLocks();
    } catch (final ValidationException e) {
        LOG.trace("Commit failed on validation");
        // recoverable error
        configBeanModificationDisabled.set(false);
        throw e;
    }
    // errors in this state are not recoverable. modules are not mutable
    // anymore.
    transactionStatus.setSecondPhaseCommitStarted();
    return dependencyResolverManager.toCommitInfo();
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testInstanceAlreadyExistsException()
        throws ConflictingVersionException, ValidationException,
        InstanceAlreadyExistsException {
    ConfigTransactionJMXClient transaction = configRegistryClient
            .createTransaction();

    createModule(transaction, instanceName);
    transaction.commit();

    transaction = configRegistryClient.createTransaction();
    try {
        createModule(transaction, instanceName);
        fail();
    } catch (InstanceAlreadyExistsException e) {

    }
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException,
        ValidationException {

    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
    createInstance(transaction, instanceName);

    transaction.commit();

    transaction = configRegistryClient.createTransaction();
    assertBeanCount(1, factory.getImplementationName());
    CommitStatus status = transaction.commit();

    assertBeanCount(1, factory.getImplementationName());
    assertStatus(status, 0, 0, 1);
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
private void executeWithMissingModuleFactoryRetries(final ConfigSubsystemFacade facade, final ConfigExecution configExecution)
        throws DocumentedException, ValidationException, ModuleFactoryNotFoundException {
    Stopwatch stopwatch = Stopwatch.createStarted();
    ModuleFactoryNotFoundException lastException = null;
    do {
        try {
            facade.executeConfigExecution(configExecution);
            return;
        } catch (final ModuleFactoryNotFoundException e) {
            LOG.debug("{} - will retry after timeout", e.toString());
            lastException = e;
            sleep();
        }
    } while (stopwatch.elapsed(TimeUnit.MILLISECONDS) < maxWaitForCapabilitiesMillis);

    throw lastException;
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testReconfigure() throws InstanceAlreadyExistsException, ConflictingVersionException,
        ValidationException, InstanceNotFoundException {

    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
    createInstance(transaction, instanceName, null);

    transaction.commit();

    transaction = configRegistryClient.createTransaction();
    assertBeanCount(1, factory.getImplementationName());
    NettyThreadgroupModuleMXBean mxBean = transaction.newMBeanProxy(
            transaction.lookupConfigBean(AbstractNettyThreadgroupModuleFactory.NAME, instanceName),
            NettyThreadgroupModuleMXBean.class);
    mxBean.setThreadCount(1);
    CommitStatus status = transaction.commit();

    assertBeanCount(1, factory.getImplementationName());
    assertStatus(status, 0, 1, 0);
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testDestroyModuleDependency() throws Exception {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
    ObjectName r1 = transaction.createModule(factory.getImplementationName(), "root1");
    ObjectName m1 = transaction.createModule(factory.getImplementationName(), "middle1");

    MultipleDependenciesModuleMXBean r1Proxy = transaction.newMXBeanProxy(r1, MultipleDependenciesModuleMXBean.class);
    r1Proxy.setSingle(m1);
    transaction.commit();

    transaction = configRegistryClient.createTransaction();
    transaction.destroyModule(factory.getImplementationName(), "middle1");
    try {
        transaction.commit();
        fail("Validation exception expected");
    } catch (ValidationException e) {
        assertThat(e.getFailedValidations().keySet(), CoreMatchers.hasItem("multiple-dependencies"));
    }
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
private void test(final ConfigExecution execution, final EditStrategyType editStrategyType)
        throws ValidationException, DocumentedException {
    ObjectName taON = transactionProvider.getTestTransaction();
    try {
        // default strategy = replace wipes config
        if (editStrategyType == EditStrategyType.replace) {
            transactionProvider.wipeTestTransaction(taON);
        }

        ConfigTransactionClient ta = configRegistryClient.getConfigTransactionClient(taON);

        handleMisssingInstancesOnTransaction(ta, execution);
        setServicesOnTransaction(ta, execution);
        setOnTransaction(ta, execution);
        transactionProvider.validateTestTransaction(taON);
    } finally {
        transactionProvider.abortTestTransaction(taON);
    }
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@SuppressWarnings("IllegalCatch")
@Override
public Object invoke(final String actionName, final Object[] params, final String[] signature)
        throws MBeanException, ReflectionException {
    if ("validate".equals(actionName) && (params == null || params.length == 0)
            && (signature == null || signature.length == 0)) {
        try {
            validate();
        } catch (final Exception e) {
            throw new MBeanException(ValidationException.createForSingleException(moduleIdentifier, e));
        }
        return Void.TYPE;
    }
    return super.invoke(actionName, params, signature);
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Override
public CommitStatus commitConfig(final ObjectName transactionControllerON)
        throws ConflictingVersionException, ValidationException {
    final CommitStatus commitStatus = delegate.commitConfig(transactionControllerON);
    notifier.notifyCommit(ObjectNameUtil.getTransactionName(transactionControllerON));
    return commitStatus;
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Override
public synchronized void validateConfig() throws ValidationException {
    if (configBeanModificationDisabled.get()) {
        throw new IllegalStateException("Cannot start validation");
    }
    configBeanModificationDisabled.set(true);
    try {
        validateNoLocks();
    } finally {
        configBeanModificationDisabled.set(false);
    }
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Override
public CommitStatus commitConfig(final ObjectName transactionControllerON)
        throws ValidationException, ConflictingVersionException {
    if (NOOP_TX_NAME.equals(transactionControllerON) || closed.get()) {
        return new CommitStatus(Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
    }

    configTransactionLock.lock();
    try {
        return commitConfigSafe(transactionControllerON);
    } finally {
        configTransactionLock.unlock();
    }
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@GuardedBy("configTransactionLock")
private CommitStatus commitConfigSafe(final ObjectName transactionControllerON)
        throws ConflictingVersionException, ValidationException {
    final String transactionName = ObjectNameUtil.getTransactionName(transactionControllerON);
    LOG.trace("About to commit {}. Current parentVersion: {}, versionCounter {}", transactionName, version,
            versionCounter);

    // find ConfigTransactionController
    Map<String, Entry<ConfigTransactionControllerInternal, ConfigTransactionLookupRegistry>> transactions =
            transactionsHolder.getCurrentTransactions();
    Entry<ConfigTransactionControllerInternal, ConfigTransactionLookupRegistry> configTransactionControllerEntry =
            transactions.get(transactionName);
    if (configTransactionControllerEntry == null) {
        throw new IllegalArgumentException(String.format("Transaction with name '%s' not found", transactionName));
    }
    ConfigTransactionControllerInternal configTransactionController = configTransactionControllerEntry.getKey();
    // check optimistic lock
    if (version != configTransactionController.getParentVersion()) {
        throw new ConflictingVersionException(
                String.format("Optimistic lock failed. Expected parent version %d, was %d", version,
                        configTransactionController.getParentVersion()));
    }
    // optimistic lock ok

    CommitInfo commitInfo = configTransactionController.validateBeforeCommitAndLockTransaction();
    lastListOfFactories = Collections
            .unmodifiableList(configTransactionController.getCurrentlyRegisteredFactories());
    return secondPhaseCommit(configTransactionController, commitInfo, configTransactionControllerEntry.getValue());
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testWithAPSP_useScheduledNames() throws InstanceAlreadyExistsException, ValidationException {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
    ObjectName scheduledName = transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);

    ObjectName apspName = transaction.createModule(TestingParallelAPSPModuleFactory.NAME, "apsp1");
    TestingParallelAPSPConfigMXBean apspProxy = transaction.newMXBeanProxy(apspName,
            TestingParallelAPSPConfigMXBean.class);
    apspProxy.setThreadPool(scheduledName);
    apspProxy.setSomeParam("someParam");
    transaction.validateConfig();

}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
private ObjectName createScheduled()
        throws InstanceAlreadyExistsException, ConflictingVersionException, ValidationException {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();

    // create using TestingThreadPoolIfc:
    ObjectName createdConfigBean = transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME,
            SCHEDULED1);
    // commit
    transaction.commit();
    return createdConfigBean;
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testValidationException() throws Exception {
    IllegalArgumentException argumentException = new IllegalArgumentException();
    ValidationException validationException = ValidationException
            .createForSingleException(new ModuleIdentifier("m", "i"), argumentException);
    doThrow(validationException).when(blankTx).hit();

    tracker.addingService(getMockServiceReference());
    verify(blankTx, times(10)).hit();
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test(expected = ValidationException.class)
public void testValidateBean2() throws Exception {
    MBeanServer mbsLocal = mock(MBeanServer.class);
    MBeanException mBeanException = new MBeanException(new ValidationException(
            Collections.<String, Map<String, ExceptionMessageWithStackTrace>>emptyMap()));
    doThrow(mBeanException).when(mbsLocal).invoke(transactionControllerON, "validate", null, null);

    ConfigTransactionJMXClient jmxTransactionClientFake = new ConfigTransactionJMXClient(null,
            transactionControllerON,
            mbsLocal);
    jmxTransactionClientFake.validateBean(transactionControllerON);
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Override
public CommitStatus commitConfig(final ObjectName transactonControllerON)
        throws ConflictingVersionException, ValidationException {
    if (transactonControllerON == null) {
        Exception e = new RuntimeException("message");
        throw ValidationException.createForSingleException(
                new ModuleIdentifier("moduleName", "instanceName"), e);
    }
    return null;
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testCreateBean() throws InstanceAlreadyExistsException,
        ValidationException, ConflictingVersionException {
    ConfigTransactionJMXClient transaction = configRegistryClient
            .createTransaction();

    createModule(transaction, instanceName);
    transaction.validateConfig();
    CommitStatus status = transaction.commit();

    assertBeanCount(1, factory.getImplementationName());
    assertStatus(status, 1, 0, 0);
}
 

import org.opendaylight.controller.config.api.ValidationException; //导入依赖的package包/类
@Test
public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException,
        ConflictingVersionException {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();

    createInstance(transaction, instanceName);

    transaction.validateConfig();
    CommitStatus status = transaction.commit();

    assertBeanCount(1, factory.getImplementationName());
    assertStatus(status, 1, 0, 0);
}