*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
-
-import java.util.Map.Entry;
-import java.util.Collection;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import com.google.common.base.Preconditions;
-import com.google.common.base.Throwables;
+import com.google.common.base.Verify;
+import com.google.common.collect.HashBasedTable;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
+import com.google.common.collect.Table;
+import com.google.common.collect.TreeBasedTable;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
+import java.util.SortedMap;
import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.util.RecursiveObjectLeaker;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
+import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedNamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
+import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceNotAvailableException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupportBundle;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModulesDeviatedByModules;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModulesDeviatedByModules.SupportedModules;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
+import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace.SupportedFeatures;
+import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.SourceSpecificContext.PhaseCompletionProgress;
-
-class BuildGlobalContext extends NamespaceStorageSupport implements NamespaceBehaviour.Registry {
-
- private static final List<ModelProcessingPhase> PHASE_EXECUTION_ORDER = ImmutableList.<ModelProcessingPhase>builder()
- .add(ModelProcessingPhase.SOURCE_LINKAGE)
- .add(ModelProcessingPhase.STATEMENT_DEFINITION)
- .add(ModelProcessingPhase.FULL_DECLARATION)
- .add(ModelProcessingPhase.EFFECTIVE_MODEL)
- .build();
-
- private final Map<QName,StatementDefinitionContext<?,?,?>> definitions = new HashMap<>();
- private final Map<Class<?>,NamespaceBehaviourWithListeners<?, ?, ?>> supportedNamespaces = new HashMap<>();
-
-
- private final Map<ModelProcessingPhase,StatementSupportBundle> supports;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class BuildGlobalContext extends NamespaceStorageSupport implements Registry {
+ private static final Logger LOG = LoggerFactory.getLogger(BuildGlobalContext.class);
+
+ private static final List<ModelProcessingPhase> PHASE_EXECUTION_ORDER =
+ ImmutableList.<ModelProcessingPhase>builder().add(ModelProcessingPhase.SOURCE_PRE_LINKAGE)
+ .add(ModelProcessingPhase.SOURCE_LINKAGE).add(ModelProcessingPhase.STATEMENT_DEFINITION)
+ .add(ModelProcessingPhase.FULL_DECLARATION).add(ModelProcessingPhase.EFFECTIVE_MODEL).build();
+
+ private final Table<YangVersion, QName, StatementDefinitionContext<?, ?, ?>> definitions = HashBasedTable.create();
+ private final Map<QName, StatementDefinitionContext<?, ?, ?>> modelDefinedStmtDefs = new HashMap<>();
+ private final Map<Class<?>, NamespaceBehaviourWithListeners<?, ?, ?>> supportedNamespaces = new HashMap<>();
+ private final List<MutableStatement> mutableStatementsToSeal = new ArrayList<>();
+ private final Map<ModelProcessingPhase, StatementSupportBundle> supports;
private final Set<SourceSpecificContext> sources = new HashSet<>();
+ private final Set<YangVersion> supportedVersions;
+ private final boolean enabledSemanticVersions;
+ private Set<SourceSpecificContext> libSources = new HashSet<>();
private ModelProcessingPhase currentPhase = ModelProcessingPhase.INIT;
private ModelProcessingPhase finishedPhase = ModelProcessingPhase.INIT;
- public BuildGlobalContext(Map<ModelProcessingPhase, StatementSupportBundle> supports) {
- super();
+ BuildGlobalContext(final Map<ModelProcessingPhase, StatementSupportBundle> supports,
+ final Map<ValidationBundleType, Collection<?>> supportedValidation,
+ final StatementParserMode statementParserMode) {
this.supports = Preconditions.checkNotNull(supports, "BuildGlobalContext#supports cannot be null");
- }
- public BuildGlobalContext(Map<ModelProcessingPhase, StatementSupportBundle> supports, Map<ValidationBundleType,Collection<?>> supportedValidation) {
- super();
- this.supports = Preconditions.checkNotNull(supports, "BuildGlobalContext#supports cannot be null");
+ switch (statementParserMode) {
+ case DEFAULT_MODE:
+ enabledSemanticVersions = false;
+ break;
+ case SEMVER_MODE:
+ enabledSemanticVersions = true;
+ break;
+ default:
+ throw new IllegalArgumentException("Unhandled parser mode " + statementParserMode);
+ }
- Set<Entry<ValidationBundleType, Collection<?>>> validationBundles = supportedValidation.entrySet();
- for (Entry<ValidationBundleType, Collection<?>> validationBundle : validationBundles) {
+ for (final Entry<ValidationBundleType, Collection<?>> validationBundle : supportedValidation.entrySet()) {
addToNs(ValidationBundlesNamespace.class, validationBundle.getKey(), validationBundle.getValue());
}
+
+ this.supportedVersions = ImmutableSet.copyOf(supports.get(ModelProcessingPhase.INIT).getSupportedVersions());
}
- public StatementSupportBundle getSupportsForPhase(ModelProcessingPhase currentPhase) {
+ boolean isEnabledSemanticVersioning() {
+ return enabledSemanticVersions;
+ }
+
+ StatementSupportBundle getSupportsForPhase(final ModelProcessingPhase currentPhase) {
return supports.get(currentPhase);
}
- public void addSource(@Nonnull StatementStreamSource source) {
- sources.add(new SourceSpecificContext(this,source));
+ void addSource(@Nonnull final StatementStreamSource source) {
+ sources.add(new SourceSpecificContext(this, source));
+ }
+
+ void addLibSource(@Nonnull final StatementStreamSource libSource) {
+ Preconditions.checkState(!isEnabledSemanticVersioning(),
+ "Library sources are not supported in semantic version mode currently.");
+ Preconditions.checkState(currentPhase == ModelProcessingPhase.INIT,
+ "Add library source is allowed in ModelProcessingPhase.INIT only");
+ libSources.add(new SourceSpecificContext(this, libSource));
+ }
+
+ void setSupportedFeatures(final Set<QName> supportedFeatures) {
+ addToNs(SupportedFeaturesNamespace.class, SupportedFeatures.SUPPORTED_FEATURES,
+ ImmutableSet.copyOf(supportedFeatures));
+ }
+
+ void setModulesDeviatedByModules(final Map<QNameModule, Set<QNameModule>> modulesDeviatedByModules) {
+ addToNs(ModulesDeviatedByModules.class, SupportedModules.SUPPORTED_MODULES,
+ ImmutableMap.copyOf(modulesDeviatedByModules));
}
@Override
}
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> getNamespaceBehaviour(Class<N> type) {
+ public <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> getNamespaceBehaviour(
+ final Class<N> type) {
NamespaceBehaviourWithListeners<?, ?, ?> potential = supportedNamespaces.get(type);
if (potential == null) {
- NamespaceBehaviour<K, V, N> potentialRaw = supports.get(currentPhase).getNamespaceBehaviour(type);
- if(potentialRaw != null) {
- potential = new NamespaceBehaviourWithListeners<>(potentialRaw);
+ final NamespaceBehaviour<K, V, N> potentialRaw = supports.get(currentPhase).getNamespaceBehaviour(type);
+ if (potentialRaw != null) {
+ potential = createNamespaceContext(potentialRaw);
supportedNamespaces.put(type, potential);
+ } else {
+ throw new NamespaceNotAvailableException("Namespace " + type + " is not available in phase "
+ + currentPhase);
}
}
- if (potential != null) {
- Preconditions.checkState(type.equals(potential.getIdentifier()));
- /*
- * Safe cast, previous checkState checks equivalence of key from
- * which type argument are derived
- */
- return (NamespaceBehaviourWithListeners<K, V, N>) potential;
+ Verify.verify(type.equals(potential.getIdentifier()));
+ /*
+ * Safe cast, previous checkState checks equivalence of key from which
+ * type argument are derived
+ */
+ return (NamespaceBehaviourWithListeners<K, V, N>) potential;
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ private <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> createNamespaceContext(
+ final NamespaceBehaviour<K, V, N> potentialRaw) {
+ if (potentialRaw instanceof DerivedNamespaceBehaviour) {
+ final VirtualNamespaceContext derivedContext = new VirtualNamespaceContext(
+ (DerivedNamespaceBehaviour) potentialRaw);
+ getNamespaceBehaviour(((DerivedNamespaceBehaviour) potentialRaw).getDerivedFrom()).addDerivedNamespace(
+ derivedContext);
+ return derivedContext;
}
- throw new NamespaceNotAvailableException("Namespace " + type + " is not available in phase " + currentPhase);
+ return new SimpleNamespaceContext<>(potentialRaw);
}
- public StatementDefinitionContext<?, ?, ?> getStatementDefinition(QName name) {
- StatementDefinitionContext<?, ?, ?> potential = definitions.get(name);
- if(potential == null) {
- StatementSupport<?, ?, ?> potentialRaw = supports.get(currentPhase).getStatementDefinition(name);
- if(potentialRaw != null) {
+ StatementDefinitionContext<?, ?, ?> getStatementDefinition(final YangVersion version, final QName name) {
+ StatementDefinitionContext<?, ?, ?> potential = definitions.get(version, name);
+ if (potential == null) {
+ final StatementSupport<?, ?, ?> potentialRaw = supports.get(currentPhase).getStatementDefinition(version,
+ name);
+ if (potentialRaw != null) {
potential = new StatementDefinitionContext<>(potentialRaw);
- definitions.put(name, potential);
+ definitions.put(version, name, potential);
}
}
return potential;
}
- public EffectiveModelContext build() throws SourceException, ReactorException {
- for(ModelProcessingPhase phase : PHASE_EXECUTION_ORDER) {
+ StatementDefinitionContext<?, ?, ?> getModelDefinedStatementDefinition(final QName name) {
+ return modelDefinedStmtDefs.get(name);
+ }
+
+ void putModelDefinedStatementDefinition(final QName name, final StatementDefinitionContext<?, ?, ?> def) {
+ modelDefinedStmtDefs.put(name, def);
+ }
+
+ private void executePhases() throws ReactorException {
+ for (final ModelProcessingPhase phase : PHASE_EXECUTION_ORDER) {
startPhase(phase);
loadPhaseStatements();
completePhaseActions();
endPhase(phase);
}
+ }
+
+ EffectiveModelContext build() throws ReactorException {
+ executePhases();
return transform();
}
+ EffectiveSchemaContext buildEffective() throws ReactorException {
+ executePhases();
+ return transformEffective();
+ }
+
private EffectiveModelContext transform() {
Preconditions.checkState(finishedPhase == ModelProcessingPhase.EFFECTIVE_MODEL);
- List<DeclaredStatement<?>> rootStatements = new ArrayList<>();
- for(SourceSpecificContext source : sources) {
- DeclaredStatement<?> root = source.getRoot().buildDeclared();
- rootStatements.add(root);
+ final List<DeclaredStatement<?>> rootStatements = new ArrayList<>(sources.size());
+ for (final SourceSpecificContext source : sources) {
+ rootStatements.add(source.getRoot().buildDeclared());
}
return new EffectiveModelContext(rootStatements);
}
- public EffectiveSchemaContext buildEffective() throws SourceException, ReactorException {
- for(ModelProcessingPhase phase : PHASE_EXECUTION_ORDER) {
- startPhase(phase);
- loadPhaseStatements();
- completePhaseActions();
- endPhase(phase);
+ private SomeModifiersUnresolvedException propagateException(final SourceSpecificContext source,
+ final RuntimeException cause) throws SomeModifiersUnresolvedException {
+ final SourceIdentifier sourceId = StmtContextUtils.createSourceIdentifier(source.getRoot());
+ if (!(cause instanceof SourceException)) {
+ /*
+ * This should not be happening as all our processing should provide SourceExceptions.
+ * We will wrap the exception to provide enough information to identify the problematic model,
+ * but also emit a warning so the offending codepath will get fixed.
+ */
+ LOG.warn("Unexpected error processing source {}. Please file an issue with this model attached.",
+ sourceId, cause);
}
- return transformEffective();
+
+ throw new SomeModifiersUnresolvedException(currentPhase, sourceId, cause);
}
- private EffectiveSchemaContext transformEffective() {
+ @SuppressWarnings("checkstyle:illegalCatch")
+ private EffectiveSchemaContext transformEffective() throws ReactorException {
Preconditions.checkState(finishedPhase == ModelProcessingPhase.EFFECTIVE_MODEL);
- List<DeclaredStatement<?>> rootStatements = new ArrayList<>();
- List<EffectiveStatement<?,?>> rootEffectiveStatements = new ArrayList<>();
+ final List<DeclaredStatement<?>> rootStatements = new ArrayList<>(sources.size());
+ final List<EffectiveStatement<?, ?>> rootEffectiveStatements = new ArrayList<>(sources.size());
- for(SourceSpecificContext source : sources) {
- DeclaredStatement<?> root = source.getRoot().buildDeclared();
- rootStatements.add(root);
-
- EffectiveStatement<?,?> rootEffective = source.getRoot().buildEffective();
- rootEffectiveStatements.add(rootEffective);
+ try {
+ for (final SourceSpecificContext source : sources) {
+ final RootStatementContext<?, ?, ?> root = source.getRoot();
+ try {
+ rootStatements.add(root.buildDeclared());
+ rootEffectiveStatements.add(root.buildEffective());
+ } catch (final RuntimeException ex) {
+ throw propagateException(source, ex);
+ }
+ }
+ } finally {
+ RecursiveObjectLeaker.cleanup();
}
- return new EffectiveSchemaContext(rootStatements,rootEffectiveStatements);
+ sealMutableStatements();
+ return EffectiveSchemaContext.create(rootStatements, rootEffectiveStatements);
}
- private void startPhase(ModelProcessingPhase phase) {
+ private void startPhase(final ModelProcessingPhase phase) {
Preconditions.checkState(Objects.equals(finishedPhase, phase.getPreviousPhase()));
- for(SourceSpecificContext source : sources) {
+ startPhaseFor(phase, sources);
+ startPhaseFor(phase, libSources);
+
+ currentPhase = phase;
+ LOG.debug("Global phase {} started", phase);
+ }
+
+ private static void startPhaseFor(final ModelProcessingPhase phase, final Set<SourceSpecificContext> sources) {
+ for (final SourceSpecificContext source : sources) {
source.startPhase(phase);
}
- currentPhase = phase;
}
- private void loadPhaseStatements() throws SourceException {
+ private void loadPhaseStatements() throws ReactorException {
Preconditions.checkState(currentPhase != null);
- for(SourceSpecificContext source : sources) {
- source.loadStatements();
+ loadPhaseStatementsFor(sources);
+ loadPhaseStatementsFor(libSources);
+ }
+
+ @SuppressWarnings("checkstyle:illegalCatch")
+ private void loadPhaseStatementsFor(final Set<SourceSpecificContext> sources) throws ReactorException {
+ for (final SourceSpecificContext source : sources) {
+ try {
+ source.loadStatements();
+ } catch (final RuntimeException ex) {
+ throw propagateException(source, ex);
+ }
}
}
- private SomeModifiersUnresolvedException addSourceExceptions(SomeModifiersUnresolvedException buildFailure,
- List<SourceSpecificContext> sourcesToProgress) {
- for(SourceSpecificContext failedSource : sourcesToProgress) {
- SourceException sourceEx = failedSource.failModifiers(currentPhase);
- buildFailure.addSuppressed(sourceEx);
+ private SomeModifiersUnresolvedException addSourceExceptions(final List<SourceSpecificContext> sourcesToProgress) {
+ boolean addedCause = false;
+ SomeModifiersUnresolvedException buildFailure = null;
+ for (final SourceSpecificContext failedSource : sourcesToProgress) {
+ final Optional<SourceException> optSourceEx = failedSource.failModifiers(currentPhase);
+ if (!optSourceEx.isPresent()) {
+ continue;
+ }
+
+ final SourceException sourceEx = optSourceEx.get();
+ // Workaround for broken logging implementations which ignore
+ // suppressed exceptions
+ final Throwable cause = sourceEx.getCause() != null ? sourceEx.getCause() : sourceEx;
+ if (LOG.isDebugEnabled()) {
+ LOG.error("Failed to parse YANG from source {}", failedSource, sourceEx);
+ } else {
+ LOG.error("Failed to parse YANG from source {}: {}", failedSource, cause.getMessage());
+ }
+
+ final Throwable[] suppressed = sourceEx.getSuppressed();
+ if (suppressed.length > 0) {
+ LOG.error("{} additional errors reported:", suppressed.length);
+
+ int count = 1;
+ for (final Throwable t : suppressed) {
+ // FIXME: this should be configured in the appender, really
+ if (LOG.isDebugEnabled()) {
+ LOG.error("Error {}: {}", count, t.getMessage(), t);
+ } else {
+ LOG.error("Error {}: {}", count, t.getMessage());
+ }
+
+ count++;
+ }
+ }
+
+ if (!addedCause) {
+ addedCause = true;
+ final SourceIdentifier sourceId = StmtContextUtils.createSourceIdentifier(failedSource.getRoot());
+ buildFailure = new SomeModifiersUnresolvedException(currentPhase, sourceId, sourceEx);
+ } else {
+ buildFailure.addSuppressed(sourceEx);
+ }
}
return buildFailure;
}
- private void completePhaseActions() throws ReactorException {
+ @SuppressWarnings("checkstyle:illegalCatch")
+ private void completePhaseActions() throws ReactorException {
Preconditions.checkState(currentPhase != null);
- List<SourceSpecificContext> sourcesToProgress = Lists.newArrayList(sources);
- try {
- boolean progressing = true;
- while(progressing) {
- // We reset progressing to false.
- progressing = false;
- Iterator<SourceSpecificContext> currentSource = sourcesToProgress.iterator();
- while(currentSource.hasNext()) {
- SourceSpecificContext nextSourceCtx = currentSource.next();
- PhaseCompletionProgress sourceProgress = nextSourceCtx.tryToCompletePhase(currentPhase);
+ final List<SourceSpecificContext> sourcesToProgress = Lists.newArrayList(sources);
+ if (!libSources.isEmpty()) {
+ Preconditions.checkState(currentPhase == ModelProcessingPhase.SOURCE_PRE_LINKAGE,
+ "Yang library sources should be empty after ModelProcessingPhase.SOURCE_PRE_LINKAGE, "
+ + "but current phase was %s", currentPhase);
+ sourcesToProgress.addAll(libSources);
+ }
+
+ boolean progressing = true;
+ while (progressing) {
+ // We reset progressing to false.
+ progressing = false;
+ final Iterator<SourceSpecificContext> currentSource = sourcesToProgress.iterator();
+ while (currentSource.hasNext()) {
+ final SourceSpecificContext nextSourceCtx = currentSource.next();
+ try {
+ final PhaseCompletionProgress sourceProgress = nextSourceCtx.tryToCompletePhase(currentPhase);
switch (sourceProgress) {
case FINISHED:
currentSource.remove();
- // Fallback to progress, since we were able to make progress in computation
+ // we were able to make progress in computation
+ progressing = true;
+ break;
case PROGRESS:
progressing = true;
break;
// Noop
break;
default:
- throw new IllegalStateException("Unsupported phase progress " + sourceProgress);
+ throw new IllegalStateException("Unsupported phase progress " + sourceProgress);
}
+ } catch (final RuntimeException ex) {
+ throw propagateException(nextSourceCtx, ex);
}
}
- } catch (SourceException e) {
- throw Throwables.propagate(e);
}
- if(!sourcesToProgress.isEmpty()) {
- SomeModifiersUnresolvedException buildFailure = new SomeModifiersUnresolvedException(currentPhase);
- buildFailure = addSourceExceptions(buildFailure, sourcesToProgress);
- throw buildFailure;
+
+ if (!libSources.isEmpty()) {
+ final Set<SourceSpecificContext> requiredLibs = getRequiredSourcesFromLib();
+ sources.addAll(requiredLibs);
+ libSources = ImmutableSet.of();
+ /*
+ * We want to report errors of relevant sources only, so any others can
+ * be removed.
+ */
+ sourcesToProgress.retainAll(sources);
+ }
+
+ if (!sourcesToProgress.isEmpty()) {
+ final SomeModifiersUnresolvedException buildFailure = addSourceExceptions(sourcesToProgress);
+ if (buildFailure != null) {
+ throw buildFailure;
+ }
+ }
+ }
+
+ private Set<SourceSpecificContext> getRequiredSourcesFromLib() {
+ Preconditions.checkState(currentPhase == ModelProcessingPhase.SOURCE_PRE_LINKAGE,
+ "Required library sources can be collected only in ModelProcessingPhase.SOURCE_PRE_LINKAGE phase,"
+ + " but current phase was %s", currentPhase);
+ final TreeBasedTable<String, Date, SourceSpecificContext> libSourcesTable = TreeBasedTable.create();
+ for (final SourceSpecificContext libSource : libSources) {
+ final ModuleIdentifier libSourceIdentifier = Preconditions.checkNotNull(libSource.getRootIdentifier());
+ libSourcesTable.put(libSourceIdentifier.getName(), libSourceIdentifier.getRevision(), libSource);
+ }
+
+ final Set<SourceSpecificContext> requiredLibs = new HashSet<>();
+ for (final SourceSpecificContext source : sources) {
+ collectRequiredSourcesFromLib(libSourcesTable, requiredLibs, source);
+ removeConflictingLibSources(source, requiredLibs);
+ }
+ return requiredLibs;
+ }
+
+ private void collectRequiredSourcesFromLib(
+ final TreeBasedTable<String, Date, SourceSpecificContext> libSourcesTable,
+ final Set<SourceSpecificContext> requiredLibs, final SourceSpecificContext source) {
+ final Collection<ModuleIdentifier> requiredModules = source.getRequiredModules();
+ for (final ModuleIdentifier requiredModule : requiredModules) {
+ final SourceSpecificContext libSource = getRequiredLibSource(requiredModule, libSourcesTable);
+ if (libSource != null && requiredLibs.add(libSource)) {
+ collectRequiredSourcesFromLib(libSourcesTable, requiredLibs, libSource);
+ }
+ }
+ }
+
+ private static SourceSpecificContext getRequiredLibSource(final ModuleIdentifier requiredModule,
+ final TreeBasedTable<String, Date, SourceSpecificContext> libSourcesTable) {
+ return requiredModule.getRevision() == SimpleDateFormatUtil.DEFAULT_DATE_IMP
+ || requiredModule.getRevision() == SimpleDateFormatUtil.DEFAULT_BELONGS_TO_DATE ? getLatestRevision(
+ libSourcesTable.row(requiredModule.getName())) : libSourcesTable.get(requiredModule.getName(),
+ requiredModule.getRevision());
+ }
+
+ private static SourceSpecificContext getLatestRevision(final SortedMap<Date, SourceSpecificContext> sourceMap) {
+ return sourceMap != null && !sourceMap.isEmpty() ? sourceMap.get(sourceMap.lastKey()) : null;
+ }
+
+ // removes required library sources which would cause namespace/name conflict with one of the main sources
+ // later in the parsing process. this can happen if we add a parent module or a submodule as a main source
+ // and the same parent module or submodule is added as one of the library sources.
+ // such situation may occur when using the yang-system-test artifact - if a parent module/submodule is specified
+ // as its argument and the same dir is specified as one of the library dirs through -p option).
+ private static void removeConflictingLibSources(final SourceSpecificContext source,
+ final Set<SourceSpecificContext> requiredLibs) {
+ final Iterator<SourceSpecificContext> requiredLibsIter = requiredLibs.iterator();
+ while (requiredLibsIter.hasNext()) {
+ final SourceSpecificContext currentReqSource = requiredLibsIter.next();
+ if (source.getRootIdentifier().equals(currentReqSource.getRootIdentifier())) {
+ requiredLibsIter.remove();
+ }
}
}
- private void endPhase(ModelProcessingPhase phase) {
+ private void endPhase(final ModelProcessingPhase phase) {
Preconditions.checkState(currentPhase == phase);
finishedPhase = currentPhase;
+ LOG.debug("Global phase {} finished", phase);
}
- public Set<SourceSpecificContext> getSources() {
+ Set<SourceSpecificContext> getSources() {
return sources;
}
+ public Set<YangVersion> getSupportedVersions() {
+ return supportedVersions;
+ }
+
+ void addMutableStmtToSeal(final MutableStatement mutableStatement) {
+ mutableStatementsToSeal.add(mutableStatement);
+ }
+
+ void sealMutableStatements() {
+ for (final MutableStatement mutableStatement : mutableStatementsToSeal) {
+ mutableStatement.seal();
+ }
+ mutableStatementsToSeal.clear();
+ }
}
Code Review / yangtools.git / blobdiff