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.Date;
  21 import java.util.Optional;
  22 import org.opendaylight.yangtools.concepts.SemVer;
  23 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
  24 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
  25 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
  26 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  27 import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
  28 import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
  29 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
  31 import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
  32 import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
  33 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
  34 import org.opendaylight.yangtools.yang.model.util.ModuleIdentifierImpl;
  35 import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
  36 import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
  37 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
  38 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
  39 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
  40 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
  41 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
  42 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
  43 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
  44 import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace;
  45 import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
  46 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  47 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
  48 import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
  49 import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToNamespace;
  50 import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx;
  51 import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToSemVerSourceIdentifier;
  52 import org.opendaylight.yangtools.yang.parser.spi.source.ImportedModuleContext;
  53 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleIdentifier;
  54 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToNamespace;
  55 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  56 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ImportEffectiveStatementImpl;
  57
  58 public class ImportStatementDefinition extends
  59         AbstractStatementSupport<String, ImportStatement, EffectiveStatement<String, ImportStatement>> {
  60     private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
  61             .builder(YangStmtMapping.IMPORT)
  62             .addMandatory(YangStmtMapping.PREFIX)
  63             .addOptional(YangStmtMapping.REVISION_DATE)
  64             .addOptional(SupportedExtensionsMapping.OPENCONFIG_VERSION)
  65             .build();
  66
  67     public ImportStatementDefinition() {
  68         super(YangStmtMapping.IMPORT);
  69     }
  70
  71     @Override
  72     public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
  73         return value;
  74     }
  75
  76     @Override
  77     public ImportStatement createDeclared(final StmtContext<String, ImportStatement, ?> ctx) {
  78         return new ImportStatementImpl(ctx);
  79     }
  80
  81     @Override
  82     public EffectiveStatement<String, ImportStatement> createEffective(
  83             final StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> ctx) {
  84         return new ImportEffectiveStatementImpl(ctx);
  85     }
  86
  87     @Override
  88     public void onPreLinkageDeclared(final Mutable<String, ImportStatement,
  89             EffectiveStatement<String, ImportStatement>> stmt) {
  90         /*
  91          * Add ModuleIdentifier of a module which is required by this module.
  92          * Based on this information, required modules are searched from library
  93          * sources.
  94          */
  95         stmt.addRequiredSource(RevisionImport.getImportedSourceIdentifier(stmt));
  96
  97         final String moduleName = stmt.getStatementArgument();
  98         final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
  99         final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
 100                 PreLinkageModuleNamespace.class, moduleName, SOURCE_PRE_LINKAGE);
 101         final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction
 102                 .mutatesCtx(stmt.getRoot(), SOURCE_PRE_LINKAGE);
 103
 104         importAction.apply(new InferenceAction() {
 105             @Override
 106             public void apply(final InferenceContext ctx) {
 107                 final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx);
 108                 Verify.verify(moduleName.equals(importedModuleContext.getStatementArgument()));
 109                 final URI importedModuleNamespace = importedModuleContext.getFromNamespace(ModuleNameToNamespace.class,
 110                         moduleName);
 111                 Verify.verifyNotNull(importedModuleNamespace);
 112                 final String impPrefix = SourceException.throwIfNull(
 113                     firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class),
 114                     stmt.getStatementSourceReference(), "Missing prefix statement");
 115
 116                 stmt.addToNs(ImpPrefixToNamespace.class, impPrefix, importedModuleNamespace);
 117             }
 118
 119             @Override
 120             public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
 121                 InferenceException.throwIf(failed.contains(imported), stmt.getStatementSourceReference(),
 122                         "Imported module [%s] was not found.", moduleName);
 123             }
 124         });
 125     }
 126
 127     @Override
 128     public void onLinkageDeclared(
 129             final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
 130         if (stmt.isEnabledSemanticVersioning()) {
 131             SemanticVersionImport.onLinkageDeclared(stmt);
 132         } else {
 133             RevisionImport.onLinkageDeclared(stmt);
 134         }
 135     }
 136
 137     @Override
 138     protected SubstatementValidator getSubstatementValidator() {
 139         return SUBSTATEMENT_VALIDATOR;
 140     }
 141
 142     private static class RevisionImport {
 143
 144         private RevisionImport() {
 145             throw new UnsupportedOperationException("Utility class");
 146         }
 147
 148         private static void onLinkageDeclared(
 149                 final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
 150             final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
 151             final Prerequisite<StmtContext<?, ?, ?>> imported;
 152             final String moduleName = stmt.getStatementArgument();
 153             final Date revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
 154             if (revision == null) {
 155                 imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
 156                     NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
 157             } else {
 158                 imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
 159                     ModuleIdentifierImpl.create(moduleName, Optional.of(revision)), SOURCE_LINKAGE);
 160             }
 161
 162             final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
 163                 SOURCE_LINKAGE);
 164
 165             importAction.apply(new InferenceAction() {
 166                 @Override
 167                 public void apply(final InferenceContext ctx) {
 168                     final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
 169
 170                     linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class,
 171                         stmt.getFromNamespace(ModuleCtxToModuleIdentifier.class, importedModule), importedModule);
 172                     final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
 173                     final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
 174                         NamespaceStatement.class);
 175                     stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
 176                     stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
 177                 }
 178
 179                 @Override
 180                 public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
 181                     if (failed.contains(imported)) {
 182                         throw new InferenceException(stmt.getStatementSourceReference(),
 183                                 "Imported module [%s] was not found.", moduleName);
 184                     }
 185                 }
 186             });
 187         }
 188
 189         static SourceIdentifier getImportedSourceIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
 190             final StmtContext<Date, ?, ?> revision = findFirstDeclaredSubstatement(stmt, RevisionDateStatement.class);
 191             return revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
 192                     : RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.rawStatementArgument());
 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             final String formattedRevision = importedModuleIdentifier.getRevision().map(
 331                 date -> SimpleDateFormatUtil.getRevisionFormat().format(date))
 332                     .orElse(null);
 333             return SemVerSourceIdentifier.create(importedModuleIdentifier.getName(), formattedRevision, semVer);
 334         }
 335     }
 336 }