package org.opendaylight.yangtools.yang.parser.repo;
import static com.google.common.base.Preconditions.checkArgument;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.base.Verify;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Collection;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
import org.opendaylight.yangtools.yang.model.repo.util.InMemorySchemaSourceCache;
-import org.opendaylight.yangtools.yang.parser.util.ASTSchemaSource;
-import org.opendaylight.yangtools.yang.parser.util.TextToASTTransformer;
+import org.opendaylight.yangtools.yang.parser.rfc7950.repo.ASTSchemaSource;
+import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToASTTransformer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final Collection<SourceIdentifier> requiredSources = new ConcurrentLinkedDeque<>();
private final Multimap<SourceIdentifier, YangTextSchemaSource> texts = ArrayListMultimap.create();
private final AtomicReference<Optional<SchemaContext>> currentSchemaContext =
- new AtomicReference<>(Optional.absent());
+ new AtomicReference<>(Optional.empty());
private final InMemorySchemaSourceCache<ASTSchemaSource> cache;
private final SchemaListenerRegistration transReg;
private final SchemaSourceRegistry registry;
* Register a {@link YangTextSchemaSource}.
*
* @param source YANG text source
+ * @return a YangTextSchemaSourceRegistration
* @throws YangSyntaxErrorException When the YANG file is syntactically invalid
* @throws IOException when the URL is not readable
* @throws SchemaSourceException When parsing encounters general error
- * @return a YangTextSchemaSourceRegistration
*/
public YangTextSchemaSourceRegistration registerSource(@Nonnull final YangTextSchemaSource source)
throws SchemaSourceException, IOException, YangSyntaxErrorException {
LOG.info("Provided module name {} does not match actual text {}, corrected",
providedId.toYangFilename(), parsedId.toYangFilename());
} else {
- final String sourceRev = providedId.getRevision();
- final String astRev = parsedId.getRevision();
- if (sourceRev != null && !SourceIdentifier.NOT_PRESENT_FORMATTED_REVISION.equals(sourceRev)) {
+ final Optional<Revision> sourceRev = providedId.getRevision();
+ final Optional<Revision> astRev = parsedId.getRevision();
+ if (sourceRev.isPresent()) {
if (!sourceRev.equals(astRev)) {
LOG.info("Provided module revision {} does not match actual text {}, corrected",
providedId.toYangFilename(), parsedId.toYangFilename());
* Register a URL containing a YANG text.
*
* @param url YANG text source URL
+ * @return a YangTextSchemaSourceRegistration for this URL
* @throws YangSyntaxErrorException When the YANG file is syntactically invalid
* @throws IOException when the URL is not readable
* @throws SchemaSourceException When parsing encounters general error
- * @return a YangTextSchemaSourceRegistration for this URL
*/
public YangTextSchemaSourceRegistration registerSource(@Nonnull final URL url) throws SchemaSourceException,
IOException, YangSyntaxErrorException {
private static SourceIdentifier guessSourceIdentifier(final String fileName) {
try {
return YangTextSchemaSource.identifierFromFilename(fileName);
- } catch (IllegalArgumentException e) {
+ } catch (final IllegalArgumentException e) {
LOG.warn("Invalid file name format in '{}'", fileName, e);
return RevisionSourceIdentifier.create(fileName);
}
/**
* Try to parse all currently available yang files and build new schema context.
+ *
* @return new schema context iif there is at least 1 yang file registered and
* new schema context was successfully built.
*/
}
/**
- * Try to parse all currently available yang files and build new schema context
- * in dependence on specified parsing mode.
+ * Try to parse all currently available yang files and build new schema context depending on specified parsing mode.
*
* @param statementParserMode mode of statement parser
* @return new schema context iif there is at least 1 yang file registered and
public Optional<SchemaContext> getSchemaContext(final StatementParserMode statementParserMode) {
final SchemaContextFactory factory = repository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
Optional<SchemaContext> sc;
- Object v;
+ Object ver;
do {
// Spin get stable context version
Object cv;
// Version has been updated
Collection<SourceIdentifier> sources;
do {
- v = version;
+ ver = version;
sources = ImmutableSet.copyOf(requiredSources);
- } while (v != version);
+ } while (ver != version);
while (true) {
- final CheckedFuture<SchemaContext, SchemaResolutionException> f = factory.createSchemaContext(sources,
- statementParserMode);
+ final ListenableFuture<SchemaContext> f = factory.createSchemaContext(sources, statementParserMode);
try {
- sc = Optional.of(f.checkedGet());
+ sc = Optional.of(f.get());
break;
- } catch (SchemaResolutionException e) {
+ } catch (final InterruptedException e) {
+ throw new IllegalStateException("Interrupted while assembling schema context", e);
+ } catch (final ExecutionException e) {
LOG.info("Failed to fully assemble schema context for {}", sources, e);
- sources = e.getResolvedSources();
+ final Throwable cause = e.getCause();
+ Verify.verify(cause instanceof SchemaResolutionException);
+ sources = ((SchemaResolutionException) cause).getResolvedSources();
}
}
synchronized (this) {
if (contextVersion == cv) {
currentSchemaContext.set(sc);
- contextVersion = v;
+ contextVersion = ver;
}
}
- } while (version == v);
+ } while (version == ver);
return sc;
}
- @Beta
- public SchemaContext trySchemaContext() throws SchemaResolutionException {
- return trySchemaContext(StatementParserMode.DEFAULT_MODE);
- }
-
- @Beta
- public SchemaContext trySchemaContext(final StatementParserMode statementParserMode)
- throws SchemaResolutionException {
- final SchemaContextFactory factory = repository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
- return factory.createSchemaContext(ImmutableSet.copyOf(requiredSources), statementParserMode).checkedGet();
- }
-
@Override
- public synchronized CheckedFuture<YangTextSchemaSource, SchemaSourceException> getSource(
+ public synchronized FluentFuture<YangTextSchemaSource> getSource(
final SourceIdentifier sourceIdentifier) {
final Collection<YangTextSchemaSource> ret = texts.get(sourceIdentifier);
LOG.debug("Lookup {} result {}", sourceIdentifier, ret);
if (ret.isEmpty()) {
- return Futures.immediateFailedCheckedFuture(new MissingSchemaSourceException(
- "URL for " + sourceIdentifier + " not registered", sourceIdentifier));
+ return immediateFailedFluentFuture(new MissingSchemaSourceException("URL for " + sourceIdentifier
+ + " not registered", sourceIdentifier));
}
- return Futures.immediateCheckedFuture(ret.iterator().next());
+ return immediateFluentFuture(ret.iterator().next());
}
/**
return ImmutableSet.copyOf(texts.keySet());
}
+ @Beta
+ public synchronized Collection<YangTextSchemaSource> getSourceTexts(final SourceIdentifier sourceIdentifier) {
+ return ImmutableSet.copyOf(texts.get(sourceIdentifier));
+ }
+
+ @Beta
+ public SchemaContext trySchemaContext() throws SchemaResolutionException {
+ return trySchemaContext(StatementParserMode.DEFAULT_MODE);
+ }
+
+ @Beta
+ @SuppressWarnings("checkstyle:avoidHidingCauseException")
+ public SchemaContext trySchemaContext(final StatementParserMode statementParserMode)
+ throws SchemaResolutionException {
+ final ListenableFuture<SchemaContext> future = repository
+ .createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT)
+ .createSchemaContext(ImmutableSet.copyOf(requiredSources), statementParserMode);
+
+ try {
+ return future.get();
+ } catch (final InterruptedException e) {
+ throw new IllegalStateException("Interrupted while waiting for SchemaContext assembly", e);
+ } catch (final ExecutionException e) {
+ final Throwable cause = e.getCause();
+ if (cause instanceof SchemaResolutionException) {
+ throw (SchemaResolutionException) cause;
+ }
+
+ throw new SchemaResolutionException("Failed to assemble SchemaContext", e);
+ }
+ }
+
@Override
public void close() {
transReg.close();
Code Review / yangtools.git / blobdiff