import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
-import org.opendaylight.yangtools.yang.parser.util.ASTSchemaSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final FutureCallback<DeviceSources> resolvedSourceCallback = new FutureCallback<DeviceSources>() {
@Override
- public void onSuccess(final DeviceSources result) {
+ public void onSuccess(@Nonnull final DeviceSources result) {
addProvidedSourcesToSchemaRegistry(result);
setUpSchema(result);
}
updateTransformer(null);
}
- private void updateTransformer(final MessageTransformer<NetconfMessage> transformer) {
+ private synchronized void updateTransformer(final MessageTransformer<NetconfMessage> transformer) {
messageTransformer = transformer;
}
}
private static SourceIdentifier toSourceId(final QName input) {
- return RevisionSourceIdentifier.create(input.getLocalName(),
- Optional.fromNullable(input.getFormattedRevision()));
+ return RevisionSourceIdentifier.create(input.getLocalName(), input.getRevision());
}
}
}
private Collection<SourceIdentifier> filterMissingSources(final Collection<SourceIdentifier> requiredSources) {
-
return requiredSources.parallelStream().filter(sourceIdentifier -> {
- boolean remove = false;
try {
- schemaRepository.getSchemaSource(sourceIdentifier, ASTSchemaSource.class).checkedGet();
- } catch (SchemaSourceException e) {
- remove = true;
+ schemaRepository.getSchemaSource(sourceIdentifier, YangTextSchemaSource.class).get();
+ return false;
+ } catch (InterruptedException | ExecutionException e) {
+ return true;
}
- return remove;
}).collect(Collectors.toList());
}
while (!requiredSources.isEmpty()) {
LOG.trace("{}: Trying to build schema context from {}", id, requiredSources);
try {
- final CheckedFuture<SchemaContext, SchemaResolutionException> schemaBuilderFuture =
- schemaContextFactory.createSchemaContext(requiredSources);
- final SchemaContext result = schemaBuilderFuture.checkedGet();
+ final ListenableFuture<SchemaContext> schemaBuilderFuture = schemaContextFactory
+ .createSchemaContext(requiredSources);
+ final SchemaContext result = schemaBuilderFuture.get();
LOG.debug("{}: Schema context built successfully from {}", id, requiredSources);
final Collection<QName> filteredQNames = Sets.difference(deviceSources.getRequiredSourcesQName(),
capabilities.getUnresolvedCapabilites().keySet());
handleSalInitializationSuccess(result, remoteSessionCapabilities, getDeviceSpecificRpc(result));
return;
- } catch (final SchemaResolutionException e) {
+ } catch (final ExecutionException e) {
// schemaBuilderFuture.checkedGet() throws only SchemaResolutionException
// that might be wrapping a MissingSchemaSourceException so we need to look
// at the cause of the exception to make sure we don't misinterpret it.
- if (e.getCause() instanceof MissingSchemaSourceException) {
+ final Throwable cause = e.getCause();
+
+ if (cause instanceof MissingSchemaSourceException) {
requiredSources = handleMissingSchemaSourceException(
- requiredSources, (MissingSchemaSourceException) e.getCause());
+ requiredSources, (MissingSchemaSourceException) cause);
continue;
}
- requiredSources = handleSchemaResolutionException(requiredSources, e);
+ if (cause instanceof SchemaResolutionException) {
+ requiredSources = handleSchemaResolutionException(requiredSources,
+ (SchemaResolutionException) cause);
+ } else {
+ handleSalInitializationFailure(e, listener);
+ return;
+ }
} catch (final Exception e) {
// unknown error, fail
handleSalInitializationFailure(e, listener);
final Collection<SourceIdentifier> requiredSources, final MissingSchemaSourceException exception) {
// In case source missing, try without it
final SourceIdentifier missingSource = exception.getSourceId();
- LOG.warn("{}: Unable to build schema context, missing source {}, will reattempt without it", id,
- missingSource);
+ LOG.warn("{}: Unable to build schema context, missing source {}, will reattempt without it",
+ id, missingSource);
LOG.debug("{}: Unable to build schema context, missing source {}, will reattempt without it",
- exception);
+ id, missingSource, exception);
final Collection<QName> qNameOfMissingSource =
- getQNameFromSourceIdentifiers(Sets.newHashSet(missingSource));
+ getQNameFromSourceIdentifiers(Sets.newHashSet(missingSource));
if (!qNameOfMissingSource.isEmpty()) {
capabilities.addUnresolvedCapabilities(
qNameOfMissingSource, UnavailableCapability.FailureReason.MissingSource);
// flawed model - exclude it
final SourceIdentifier failedSourceId = resolutionException.getFailedSource();
LOG.warn("{}: Unable to build schema context, failed to resolve source {}, will reattempt without it",
- id, failedSourceId);
+ id, failedSourceId);
LOG.warn("{}: Unable to build schema context, failed to resolve source {}, will reattempt without it",
- id, resolutionException);
- capabilities.addUnresolvedCapabilities(getQNameFromSourceIdentifiers(
- Collections.singleton(failedSourceId)), UnavailableCapability.FailureReason.UnableToResolve);
+ id, failedSourceId, resolutionException);
+ capabilities.addUnresolvedCapabilities(
+ getQNameFromSourceIdentifiers(Collections.singleton(failedSourceId)),
+ UnavailableCapability.FailureReason.UnableToResolve);
return stripUnavailableSource(requiredSources, resolutionException.getFailedSource());
}
// unsatisfied imports
final Set<SourceIdentifier> unresolvedSources = resolutionException.getUnsatisfiedImports().keySet();
- capabilities.addUnresolvedCapabilities(
- getQNameFromSourceIdentifiers(unresolvedSources), UnavailableCapability.FailureReason.UnableToResolve);
+ capabilities.addUnresolvedCapabilities(getQNameFromSourceIdentifiers(unresolvedSources),
+ UnavailableCapability.FailureReason.UnableToResolve);
LOG.warn("{}: Unable to build schema context, unsatisfied imports {}, will reattempt with resolved only",
- id, resolutionException.getUnsatisfiedImports());
+ id, resolutionException.getUnsatisfiedImports());
LOG.debug("{}: Unable to build schema context, unsatisfied imports {}, will reattempt with resolved only",
- resolutionException);
+ id, resolutionException.getUnsatisfiedImports(), resolutionException);
return resolutionException.getResolvedSources();
}
continue;
}
- final String rev = getNullableRev(identifier);
- if (rev == null) {
- if (qname.getRevision() == null) {
- return qname;
- }
- } else if (qname.getFormattedRevision().equals(rev)) {
+ if (identifier.getRevision().equals(qname.getRevision())) {
return qname;
}
}
// this capability will be removed from required sources and not reported as unresolved-capability
return null;
}
-
- private String getNullableRev(final SourceIdentifier identifier) {
- final String rev = identifier.getRevision();
- return rev == null || SourceIdentifier.NOT_PRESENT_FORMATTED_REVISION.equals(rev) ? null : rev;
- }
}
}
Code Review / netconf.git / blobdiff