gerrit.o-ran-sc Code Review - smo/teiv.git/blob

   1 /*
   2  *  ============LICENSE_START=======================================================
   3  *  Copyright (C) 2024 Ericsson
   4  *  Modifications Copyright (C) 2024 OpenInfra Foundation Europe
   5  *  ================================================================================
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *
  18  *  SPDX-License-Identifier: Apache-2.0
  19  *  ============LICENSE_END=========================================================
  20  */
  21 package org.oran.smo.teiv.pgsqlgenerator.schema;
  22
  23 import org.oran.smo.teiv.pgsqlgenerator.Column;
  24 import org.oran.smo.teiv.pgsqlgenerator.ForeignKeyConstraint;
  25 import org.oran.smo.teiv.pgsqlgenerator.PgSchemaGeneratorException;
  26 import org.oran.smo.teiv.pgsqlgenerator.PostgresConstraint;
  27 import org.oran.smo.teiv.pgsqlgenerator.PostgresIndex;
  28 import org.oran.smo.teiv.pgsqlgenerator.Table;
  29 import org.oran.smo.teiv.pgsqlgenerator.Relationship;
  30
  31 import lombok.extern.slf4j.Slf4j;
  32 import org.springframework.beans.factory.annotation.Value;
  33 import org.springframework.stereotype.Component;
  34
  35 import java.util.List;
  36 import java.util.Optional;
  37
  38 @Slf4j
  39 @Component
  40 public class BackwardCompatibilityChecker {
  41
  42     @Value("${green-field-installation}")
  43     private boolean isGreenFieldInstallation;
  44
  45     public void checkForNBCChangesInModel(List<Relationship> relationshipsInBaselineSql,
  46             List<Relationship> relationshipsFromModelSvc) {
  47         if (!isGreenFieldInstallation) {
  48             relationshipsInBaselineSql.forEach(baselineRel -> {
  49                 Optional<Relationship> matchingRelationship = relationshipsFromModelSvc.stream().filter(rel -> rel.getName()
  50                         .equals(baselineRel.getName())).findFirst();
  51                 matchingRelationship.ifPresentOrElse(modelSvcRel -> {
  52                     if (!(baselineRel.getBSideMinCardinality() == modelSvcRel.getBSideMinCardinality() && baselineRel
  53                             .getBSideMaxCardinality() == modelSvcRel.getBSideMaxCardinality() && baselineRel
  54                                     .getASideMinCardinality() == modelSvcRel.getASideMinCardinality() && baselineRel
  55                                             .getASideMaxCardinality() == modelSvcRel.getASideMaxCardinality())) {
  56                         throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
  57                                 "modified cardinalities for relationship(%s)", baselineRel.getName()),
  58                                 new UnsupportedOperationException());
  59                     }
  60                 }, () -> {
  61                     throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
  62                             "modified/removed relationship(%s) present in baseline", baselineRel.getName()),
  63                             new UnsupportedOperationException());
  64                 });
  65             });
  66         } else {
  67             log.info("No NBC checks done as green field installation is enabled");
  68         }
  69     }
  70
  71     public void checkForNBCChangesInData(List<Table> tablesInBaselineSql, List<Table> tablesFromModelSvc) {
  72         if (!isGreenFieldInstallation) {
  73             tablesInBaselineSql.forEach(baselineTable -> {
  74                 Optional<Table> matchingTable = tablesFromModelSvc.stream().filter(modelTable -> modelTable.getName()
  75                         .equals(baselineTable.getName())).findFirst();
  76                 matchingTable.ifPresentOrElse(table -> {
  77                     verifyTableColumns(baselineTable.getColumns(), table.getColumns(), table.getName());
  78                 }, () -> {
  79                     throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
  80                             "modified/removed table(%s) present in baseline", baselineTable.getName()),
  81                             new UnsupportedOperationException());
  82                 });
  83             });
  84         } else {
  85             log.info("No NBC checks done as green field installation is enabled");
  86         }
  87     }
  88
  89     public void checkForNBCChangesInConsumerDataSchema(String baselineConsumerDataSchema,
  90             String skeletonConsumerDataSchema) {
  91         if (!isGreenFieldInstallation) {
  92             final List<Table> baselineTables = SchemaParser.extractDataFromBaseline(baselineConsumerDataSchema);
  93             final List<Table> skeletonTables = SchemaParser.extractDataFromBaseline(skeletonConsumerDataSchema);
  94             checkForNBCChangesInData(baselineTables, skeletonTables);
  95         } else {
  96             log.info("No NBC checks done as green field installation is enabled");
  97         }
  98     }
  99
 100     private void verifyTableColumns(List<Column> columnsInBaseline, List<Column> columnsInModelSvc, String tableName) {
 101         columnsInBaseline.forEach(baselineColumn -> {
 102             Optional<Column> matchingColumn = columnsInModelSvc.stream().filter(modelColumn -> modelColumn.getName().equals(
 103                     baselineColumn.getName())).findFirst();
 104             matchingColumn.ifPresentOrElse(modelColumn -> {
 105                 validateColumnConstraints(baselineColumn, modelColumn, tableName);
 106                 validateColumnIndexes(baselineColumn, modelColumn, tableName);
 107                 validateColumnDataType(baselineColumn, modelColumn, tableName);
 108             }, () -> {
 109                 throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
 110                         "modified/removed column(%s.%s) present in baseline", tableName, baselineColumn.getName()),
 111                         new UnsupportedOperationException());
 112             });
 113         });
 114     }
 115
 116     private void validateColumnConstraints(Column baselineColumn, Column modelColumn, String tableName) {
 117         for (PostgresConstraint constraint : baselineColumn.getPostgresConstraints()) {
 118             Optional<PostgresConstraint> matchingConstraint = modelColumn.getPostgresConstraints().stream().filter(
 119                     constraint1 -> constraint1.getConstraintName().equals(constraint.getConstraintName())).findFirst();
 120
 121             matchingConstraint.ifPresentOrElse(constraint1 -> {
 122                 if (!constraint.getTableToAddConstraintTo().equals(constraint1.getTableToAddConstraintTo()) && !constraint
 123                         .getColumnToAddConstraintTo().equals(constraint1.getColumnToAddConstraintTo()) && !constraint
 124                                 .getConstraintName().equals(constraint1.getConstraintName())) {
 125                     throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
 126                             "modified/removed constraint for column(%s.%s) present in baseline", tableName, baselineColumn
 127                                     .getName()), new UnsupportedOperationException());
 128                 }
 129                 if (constraint instanceof ForeignKeyConstraint && !constraint.getTableToAddConstraintTo().equals(constraint1
 130                         .getTableToAddConstraintTo())) {
 131                     throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
 132                             "modified/removed constraint for column(%s.%s) present in baseline", tableName, baselineColumn
 133                                     .getName()), new UnsupportedOperationException());
 134                 }
 135             }, () -> {
 136                 throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
 137                         "modified/removed constraint for column(%s.%s) present in baseline", tableName, baselineColumn
 138                                 .getName()), new UnsupportedOperationException());
 139             });
 140         }
 141     }
 142
 143     private void validateColumnIndexes(Column baselineColumn, Column modelColumn, String tableName) {
 144         for (PostgresIndex indexInBaseline : baselineColumn.getPostgresIndexList()) {
 145             Optional<PostgresIndex> matchingIndex = modelColumn.getPostgresIndexList().stream().filter(
 146                     indexInGenerated -> indexInGenerated.getIndexName().equals(indexInBaseline.getIndexName())).findFirst();
 147
 148             matchingIndex.ifPresentOrElse(indexInGenerated -> {
 149                 String indexStatementInBaseline = String.format(indexInBaseline.getIndexType().getCreateIndexStmt(),
 150                         indexInBaseline.getIndexName(), indexInBaseline.getTableNameToAddIndexTo(), indexInBaseline
 151                                 .getColumnNameToAddIndexTo());
 152                 String indexStatementInGenerated = String.format(indexInGenerated.getIndexType().getCreateIndexStmt(),
 153                         indexInGenerated.getIndexName(), indexInGenerated.getTableNameToAddIndexTo(), indexInGenerated
 154                                 .getColumnNameToAddIndexTo());
 155                 if (!indexStatementInGenerated.equals(indexStatementInBaseline)) {
 156                     throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
 157                             "modified/removed index %s for column(%s.%s) present in baseline", indexInBaseline
 158                                     .getIndexName(), tableName, baselineColumn.getName()),
 159                             new UnsupportedOperationException());
 160                 }
 161             }, () -> {
 162                 throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
 163                         "modified/removed index %s for column(%s.%s) present in baseline", indexInBaseline.getIndexName(),
 164                         tableName, baselineColumn.getName()), new UnsupportedOperationException());
 165             });
 166         }
 167     }
 168
 169     private void validateColumnDataType(Column baselineColumn, Column modelColumn, String tableName) {
 170         if (!baselineColumn.getDataType().equals(modelColumn.getDataType())) {
 171             throw PgSchemaGeneratorException.nbcChangeIdentifiedException(String.format(
 172                     "modified/removed datatype for column(%s.%s) present in baseline", tableName, baselineColumn.getName()),
 173                     new UnsupportedOperationException());
 174         }
 175     }
 176
 177 }