yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java

   1 /*
   2  * Copyright (c) 2015 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 package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
   9
  10 import static java.util.Objects.requireNonNull;
  11 import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
  12 import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_PRE_LINKAGE;
  13 import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
  14 import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
  15
  16 import com.google.common.base.MoreObjects.ToStringHelper;
  17 import com.google.common.base.Verify;
  18 import java.net.URI;
  19 import java.util.Collection;
  20 import java.util.Optional;
  21 import org.opendaylight.yangtools.concepts.SemVer;
  22 import org.opendaylight.yangtools.yang.common.Revision;
  23 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
  24 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
  25 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  26 import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
  27 import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
  28 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
  29 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
  30 import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
  31 import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
  32 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
  33 import org.opendaylight.yangtools.yang.model.util.ModuleIdentifierImpl;
  34 import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
  35 import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
  36 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
  37 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
  38 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
  39 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
  40 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
  41 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
  42 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
  43 import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace;
  44 import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
  45 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  46 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
  47 import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
  48 import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToNamespace;
  49 import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx;
  50 import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToSemVerSourceIdentifier;
  51 import org.opendaylight.yangtools.yang.parser.spi.source.ImportedModuleContext;
  52 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleIdentifier;
  53 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToNamespace;
  54 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  55 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ImportEffectiveStatementImpl;
  56
  57 public class ImportStatementDefinition extends
  58         AbstractStatementSupport<String, ImportStatement, EffectiveStatement<String, ImportStatement>> {
  59     private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
  60             .builder(YangStmtMapping.IMPORT)
  61             .addMandatory(YangStmtMapping.PREFIX)
  62             .addOptional(YangStmtMapping.REVISION_DATE)
  63             .addOptional(SupportedExtensionsMapping.OPENCONFIG_VERSION)
  64             .build();
  65
  66     public ImportStatementDefinition() {
  67         super(YangStmtMapping.IMPORT);
  68     }
  69
  70     @Override
  71     public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
  72         return value;
  73     }
  74
  75     @Override
  76     public ImportStatement createDeclared(final StmtContext<String, ImportStatement, ?> ctx) {
  77         return new ImportStatementImpl(ctx);
  78     }
  79
  80     @Override
  81     public EffectiveStatement<String, ImportStatement> createEffective(
  82             final StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> ctx) {
  83         return new ImportEffectiveStatementImpl(ctx);
  84     }
  85
  86     @Override
  87     public void onPreLinkageDeclared(final Mutable<String, ImportStatement,
  88             EffectiveStatement<String, ImportStatement>> stmt) {
  89         /*
  90          * Add ModuleIdentifier of a module which is required by this module.
  91          * Based on this information, required modules are searched from library
  92          * sources.
  93          */
  94         stmt.addRequiredSource(RevisionImport.getImportedSourceIdentifier(stmt));
  95
  96         final String moduleName = stmt.getStatementArgument();
  97         final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
  98         final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
  99                 PreLinkageModuleNamespace.class, moduleName, SOURCE_PRE_LINKAGE);
 100         final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction
 101                 .mutatesCtx(stmt.getRoot(), SOURCE_PRE_LINKAGE);
 102
 103         importAction.apply(new InferenceAction() {
 104             @Override
 105             public void apply(final InferenceContext ctx) {
 106                 final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx);
 107                 Verify.verify(moduleName.equals(importedModuleContext.getStatementArgument()));
 108                 final URI importedModuleNamespace = importedModuleContext.getFromNamespace(ModuleNameToNamespace.class,
 109                         moduleName);
 110                 Verify.verifyNotNull(importedModuleNamespace);
 111                 final String impPrefix = SourceException.throwIfNull(
 112                     firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class),
 113                     stmt.getStatementSourceReference(), "Missing prefix statement");
 114
 115                 stmt.addToNs(ImpPrefixToNamespace.class, impPrefix, importedModuleNamespace);
 116             }
 117
 118             @Override
 119             public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
 120                 InferenceException.throwIf(failed.contains(imported), stmt.getStatementSourceReference(),
 121                         "Imported module [%s] was not found.", moduleName);
 122             }
 123         });
 124     }
 125
 126     @Override
 127     public void onLinkageDeclared(
 128             final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
 129         if (stmt.isEnabledSemanticVersioning()) {
 130             SemanticVersionImport.onLinkageDeclared(stmt);
 131         } else {
 132             RevisionImport.onLinkageDeclared(stmt);
 133         }
 134     }
 135
 136     @Override
 137     protected SubstatementValidator getSubstatementValidator() {
 138         return SUBSTATEMENT_VALIDATOR;
 139     }
 140
 141     private static class RevisionImport {
 142
 143         private RevisionImport() {
 144             throw new UnsupportedOperationException("Utility class");
 145         }
 146
 147         private static void onLinkageDeclared(
 148                 final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
 149             final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
 150             final Prerequisite<StmtContext<?, ?, ?>> imported;
 151             final String moduleName = stmt.getStatementArgument();
 152             final Revision revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
 153             if (revision == null) {
 154                 imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
 155                     NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
 156             } else {
 157                 imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
 158                     ModuleIdentifierImpl.create(moduleName, Optional.of(revision)), SOURCE_LINKAGE);
 159             }
 160
 161             final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
 162                 SOURCE_LINKAGE);
 163
 164             importAction.apply(new InferenceAction() {
 165                 @Override
 166                 public void apply(final InferenceContext ctx) {
 167                     final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
 168
 169                     linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class,
 170                         stmt.getFromNamespace(ModuleCtxToModuleIdentifier.class, importedModule), importedModule);
 171                     final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
 172                     final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
 173                         NamespaceStatement.class);
 174                     stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
 175                     stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
 176                 }
 177
 178                 @Override
 179                 public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
 180                     if (failed.contains(imported)) {
 181                         throw new InferenceException(stmt.getStatementSourceReference(),
 182                                 "Imported module [%s] was not found.", moduleName);
 183                     }
 184                 }
 185             });
 186         }
 187
 188         static SourceIdentifier getImportedSourceIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
 189             final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
 190                 RevisionDateStatement.class);
 191             return revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
 192                     : RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.getStatementArgument());
 193         }
 194     }
 195
 196     private static class SemanticVersionImport {
 197
 198         private abstract static class CompatibleCriterion extends NamespaceKeyCriterion<SemVerSourceIdentifier> {
 199             private final String moduleName;
 200
 201             CompatibleCriterion(final String moduleName) {
 202                 this.moduleName = requireNonNull(moduleName);
 203             }
 204
 205             @Override
 206             public boolean match(final SemVerSourceIdentifier key) {
 207                 return moduleName.equals(key.getName());
 208             }
 209
 210             @Override
 211             protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 212                 return toStringHelper.add("moduleName", moduleName);
 213             }
 214         }
 215
 216         private static final class NoVerCompatibleCriterion extends CompatibleCriterion {
 217             NoVerCompatibleCriterion(final String moduleName) {
 218                 super(moduleName);
 219             }
 220
 221             @Override
 222             public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
 223                     final SemVerSourceIdentifier second) {
 224                 // TODO Auto-generated method stub
 225                 return null;
 226             }
 227         }
 228
 229         private static final class SemVerCompatibleCriterion extends CompatibleCriterion {
 230             private final SemVer semVer;
 231
 232             SemVerCompatibleCriterion(final String moduleName, final SemVer semVer) {
 233                 super(moduleName);
 234                 this.semVer = requireNonNull(semVer);
 235             }
 236
 237             @Override
 238             public boolean match(final SemVerSourceIdentifier key) {
 239                 if (!super.match(key)) {
 240                     return false;
 241                 }
 242                 final Optional<SemVer> optKeyVer = key.getSemanticVersion();
 243                 if (!optKeyVer.isPresent()) {
 244                     return false;
 245                 }
 246
 247                 final SemVer keyVer = optKeyVer.get();
 248                 if (semVer.getMajor() != keyVer.getMajor()) {
 249                     return false;
 250                 }
 251                 if (semVer.getMinor() > keyVer.getMinor()) {
 252                     return false;
 253                 }
 254                 return semVer.getMinor() < keyVer.getMinor() || semVer.getPatch() <= keyVer.getPatch();
 255             }
 256
 257             @Override
 258             public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
 259                     final SemVerSourceIdentifier second) {
 260                 return first.getSemanticVersion().get().compareTo(second.getSemanticVersion().get()) >= 0 ? first
 261                         : second;
 262             }
 263
 264             @Override
 265             protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 266                 return super.addToStringAttributes(toStringHelper).add("version", semVer);
 267             }
 268         }
 269
 270
 271         private SemanticVersionImport() {
 272             throw new UnsupportedOperationException("Utility class");
 273         }
 274
 275         private static void onLinkageDeclared(
 276                 final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
 277             final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
 278             final String moduleName = stmt.getStatementArgument();
 279             final SemVer semanticVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
 280             final CompatibleCriterion criterion = semanticVersion == null ? new NoVerCompatibleCriterion(moduleName)
 281                     : new SemVerCompatibleCriterion(moduleName, semanticVersion);
 282
 283             final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
 284                 SemanticVersionModuleNamespace.class, criterion, SOURCE_LINKAGE);
 285             final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
 286                 SOURCE_LINKAGE);
 287
 288             importAction.apply(new InferenceAction() {
 289                 @Override
 290                 public void apply(final InferenceContext ctx) {
 291                     final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
 292                     final SemVer importedVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
 293                     final ModuleIdentifier importedModuleIdentifier = importedModule.getFromNamespace(
 294                         ModuleCtxToModuleIdentifier.class, importedModule);
 295                     final SemVerSourceIdentifier semVerModuleIdentifier = createSemVerModuleIdentifier(
 296                         importedModuleIdentifier, importedVersion);
 297
 298                     linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier,
 299                         importedModule);
 300                     final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
 301                     stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
 302                     stmt.addToNs(ImportPrefixToSemVerSourceIdentifier.class, impPrefix, semVerModuleIdentifier);
 303
 304                     final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
 305                         NamespaceStatement.class);
 306                     stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
 307                 }
 308
 309                 @Override
 310                 public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
 311                     if (failed.contains(imported)) {
 312                         throw new InferenceException(stmt.getStatementSourceReference(),
 313                                 "Unable to find module compatible with requested import [%s(%s)].", moduleName,
 314                                 getRequestedImportVersionString(stmt));
 315                     }
 316                 }
 317             });
 318         }
 319
 320         private static Optional<SemVer> getRequestedImportVersion(final StmtContext<?, ?, ?> stmt) {
 321             return Optional.ofNullable(stmt.getFromNamespace(SemanticVersionNamespace.class, stmt));
 322         }
 323
 324         private static String getRequestedImportVersionString(final StmtContext<?, ?, ?> stmt) {
 325             return getRequestedImportVersion(stmt).map(SemVer::toString).orElse("<any>");
 326         }
 327
 328         private static SemVerSourceIdentifier createSemVerModuleIdentifier(
 329                 final ModuleIdentifier importedModuleIdentifier, final SemVer semVer) {
 330             return SemVerSourceIdentifier.create(importedModuleIdentifier.getName(),
 331                 importedModuleIdentifier.getRevision(), semVer);
 332         }
 333     }
 334 }