openecomp-be/tools/migration/1702_to_1707_zusammen/src/main/java/org/openecomp/core/migration/MigrationMain.java

   1 package org.openecomp.core.migration;
   2
   3 import com.amdocs.zusammen.datatypes.SessionContext;
   4 import com.amdocs.zusammen.datatypes.UserInfo;
   5 import com.amdocs.zusammen.plugin.statestore.cassandra.dao.impl.ItemCassandraDao;
   6 import com.amdocs.zusammen.plugin.statestore.cassandra.dao.impl.VersionCassandraDao;
   7 import org.openecomp.core.migration.convertors.ComponentConvertor;
   8 import org.openecomp.core.migration.convertors.EntitlementPoolConvertor;
   9 import org.openecomp.core.migration.convertors.FeatureGroupConvertor;
  10 import org.openecomp.core.migration.convertors.LKGConvertor;
  11 import org.openecomp.core.migration.convertors.LicenseAgreementConvertor;
  12 import org.openecomp.core.migration.convertors.MibConvertor;
  13 import org.openecomp.core.migration.convertors.NetworkConvertor;
  14 import org.openecomp.core.migration.convertors.NicConvertor;
  15 import org.openecomp.core.migration.convertors.OrchestrationTemplateCandidateConvertor;
  16 import org.openecomp.core.migration.convertors.ProcessConvertor;
  17 import org.openecomp.core.migration.convertors.VlmConvertor;
  18 import org.openecomp.core.migration.convertors.VspInformationConvertor;
  19 import org.openecomp.core.migration.convertors.VspServiceArtifactConvertor;
  20 import org.openecomp.core.migration.convertors.VspServiceTemplateConvertor;
  21 import org.openecomp.core.migration.loaders.ComponentCassandraLoader;
  22 import org.openecomp.core.migration.loaders.EntitlementPoolCassandraLoader;
  23 import org.openecomp.core.migration.loaders.FeatureGroupCassandraLoader;
  24 import org.openecomp.core.migration.loaders.LKGCassandraLoader;
  25 import org.openecomp.core.migration.loaders.LicenseAgreementCassandraLoader;
  26 import org.openecomp.core.migration.loaders.MibCassandraLoader;
  27 import org.openecomp.core.migration.loaders.NetworkCassandraLoader;
  28 import org.openecomp.core.migration.loaders.NicCassandraLoader;
  29 import org.openecomp.core.migration.loaders.OrchestrationTemplateCandidateCassandraLoader;
  30 import org.openecomp.core.migration.loaders.ProcessCassandraLoader;
  31 import org.openecomp.core.migration.loaders.ServiceArtifactCassandraLoader;
  32 import org.openecomp.core.migration.loaders.ServiceTemplateCassandraLoader;
  33 import org.openecomp.core.migration.loaders.VendorLicenseModelCassandraLoader;
  34 import org.openecomp.core.migration.loaders.VendorSoftwareProductInfoLoader;
  35 import org.openecomp.core.migration.loaders.VersionInfoCassandraLoader;
  36 import org.openecomp.core.migration.loaders.VspInformation;
  37 import org.openecomp.core.migration.store.ElementHandler;
  38 import org.openecomp.core.migration.store.ItemHandler;
  39 import org.openecomp.core.migration.util.marker.MigrationMarker;
  40 import org.openecomp.core.model.types.ServiceArtifact;
  41 import org.openecomp.core.model.types.ServiceTemplate;
  42 import org.openecomp.core.zusammen.impl.CassandraConnectionInitializer;
  43 import org.openecomp.core.zusammen.plugin.dao.impl.CassandraElementRepository;
  44 import org.openecomp.sdc.logging.api.Logger;
  45 import org.openecomp.sdc.logging.api.LoggerFactory;
  46 import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
  47 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
  48 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
  49 import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
  50 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
  51 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  52 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentMonitoringUploadEntity;
  53 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  54 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  55 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
  56 import org.openecomp.sdc.versioning.dao.types.Version;
  57 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
  58
  59 import java.time.Duration;
  60 import java.time.Instant;
  61 import java.util.Collection;
  62 import java.util.Date;
  63 import java.util.HashMap;
  64 import java.util.Map;
  65
  66 import static org.openecomp.core.migration.util.Utils.printMessage;
  67
  68 public class MigrationMain {
  69   private static final String GLOBAL_USER = "GLOBAL_USER";
  70   private static Logger logger = LoggerFactory.getLogger(MigrationMain.class);
  71   private static int status = 0;
  72
  73   private static Map<String, VersionInfoEntity> versionInfoMap = new HashMap<>();
  74
  75   public static void main(String[] args) {
  76     CassandraElementRepository cassandraElementRepository = new CassandraElementRepository();
  77     CassandraConnectionInitializer.setCassandraConnectionPropertiesToSystem();
  78     printMessage(logger, "Checking whether a migration has already been run.");
  79     if (MigrationMarker.isMigrated()) {
  80       printMessage(logger, "The DB has already been migrated, this script will now exit.");
  81       System.exit(status);
  82     }
  83     ItemCassandraDao itemCassandraDao = new ItemCassandraDao();
  84     VersionCassandraDao versionCassandraDao = new VersionCassandraDao();
  85     SessionContext context = new SessionContext();
  86     context.setUser(new UserInfo(GLOBAL_USER));
  87     context.setTenant("dox");
  88     printMessage(logger, "Starting migration.\n");
  89     Instant startTime = Instant.now();
  90
  91     migrateToZusammen(cassandraElementRepository, itemCassandraDao, versionCassandraDao, context);
  92
  93     Instant stopTime = Instant.now();
  94     Duration duration = Duration.between(startTime, stopTime);
  95     long minutesPart = duration.toMinutes();
  96     long secondsPart = duration.minusMinutes(minutesPart).getSeconds();
  97
  98     if (status == 0) {
  99       MigrationMarker.markMigrated();
 100     }
 101     printMessage(logger,
 102         "Migration finished . Total run time was : " + minutesPart + ":" + secondsPart
 103             + " minutes");
 104     System.exit(status);
 105   }
 106
 107
 108   private static void migrateToZusammen(CassandraElementRepository cassandraElementRepository,
 109                                         ItemCassandraDao itemCassandraDao,
 110                                         VersionCassandraDao versionCassandraDao,
 111                                         SessionContext context) {
 112     loadVersionInfo();
 113
 114
 115     try {
 116       convertVsp(context, itemCassandraDao, versionCassandraDao, cassandraElementRepository);
 117       printMessage(logger, "Converted VSPs\n");
 118     } catch (Exception e) {
 119       logger.debug(e.getMessage(), e);
 120       status = -1;
 121     }
 122
 123     try {
 124       convertOrchestrationTemplateCandidate(context, cassandraElementRepository);
 125       printMessage(logger, "Converted OrchestrationTemplateCandidates\n");
 126     } catch (Exception e) {
 127       logger.debug(e.getMessage(), e);
 128       status = -1;
 129     }
 130
 131
 132     try {
 133       convertComponent(context, cassandraElementRepository);
 134       printMessage(logger, "Converted Components\n");
 135     } catch (Exception e) {
 136       logger.debug(e.getMessage(), e);
 137       status = -1;
 138     }
 139     try {
 140       convertNic(context, cassandraElementRepository);
 141       printMessage(logger, "Converted Nics\n");
 142     } catch (Exception e) {
 143       logger.debug(e.getMessage(), e);
 144       status = -1;
 145     }
 146     try {
 147       convertNetwork(context, cassandraElementRepository);
 148       printMessage(logger, "Converted Networks\n");
 149     } catch (Exception e) {
 150       logger.debug(e.getMessage(), e);
 151       status = -1;
 152     }
 153     try {
 154       convertMibs(context, cassandraElementRepository);
 155       printMessage(logger, "Converted MIBs\n");
 156     } catch (Exception e) {
 157       logger.debug(e.getMessage(), e);
 158       status = -1;
 159     }
 160     try {
 161       convertServiceArtifact(context, cassandraElementRepository);
 162       printMessage(logger, "Converted Service Artifacts\n");
 163     } catch (Exception e) {
 164       logger.debug(e.getMessage(), e);
 165       status = -1;
 166     }
 167     try {
 168       convertServiceTemplate(context, cassandraElementRepository);
 169       printMessage(logger, "Converted Service Templates\n");
 170     } catch (Exception e) {
 171       logger.debug(e.getMessage(), e);
 172       status = -1;
 173     }
 174     try {
 175       convertProcesses(context, cassandraElementRepository);
 176       printMessage(logger, "Converted Processes\n");
 177     } catch (Exception e) {
 178       logger.debug(e.getMessage(), e);
 179       status = -1;
 180     }
 181
 182
 183     try {
 184       convertVlm(context, itemCassandraDao, versionCassandraDao, cassandraElementRepository);
 185       printMessage(logger, "Converted VLMs\n");
 186     } catch (Exception e) {
 187       logger.debug(e.getMessage(), e);
 188       status = -1;
 189     }
 190     try {
 191       convertLKG(context, cassandraElementRepository);
 192       printMessage(logger, "Converted LKGs\n");
 193     } catch (Exception e) {
 194       logger.debug(e.getMessage(), e);
 195       status = -1;
 196     }
 197     try {
 198       convertFeatureGroup(context, cassandraElementRepository);
 199       printMessage(logger, "Converted Feature Groups\n");
 200     } catch (Exception e) {
 201       logger.debug(e.getMessage(), e);
 202       status = -1;
 203     }
 204     try {
 205       convertEP(context, cassandraElementRepository);
 206       printMessage(logger, "Converted EPs\n");
 207     } catch (Exception e) {
 208       logger.debug(e.getMessage(), e);
 209       status = -1;
 210     }
 211     try {
 212       convertLicenseAgreement(context, cassandraElementRepository);
 213       printMessage(logger, "Converted License Agreements\n");
 214     } catch (Exception e) {
 215       logger.debug(e.getMessage(), e);
 216       status = -1;
 217     }
 218   }
 219
 220   private static void convertOrchestrationTemplateCandidate(SessionContext context,
 221                                                             CassandraElementRepository cassandraElementRepository) {
 222     OrchestrationTemplateCandidateCassandraLoader orchestrationTemplateCandidateCassandraLoader =
 223         new OrchestrationTemplateCandidateCassandraLoader();
 224
 225     orchestrationTemplateCandidateCassandraLoader.list().stream()
 226         .filter(entity -> needMigration(entity.getId(), entity.getVersion()) &&
 227             entity.getContentData()!=null && entity.getFilesDataStructure()!=null)
 228         .forEach(entity -> ElementHandler
 229             .save(context, cassandraElementRepository, entity.getId(), entity.getVersion(),
 230                 OrchestrationTemplateCandidateConvertor
 231                     .convertOrchestrationTemplateCandidateToElement(entity)));
 232   }
 233
 234   private static void loadVersionInfo() {
 235
 236     VersionInfoCassandraLoader versionInfoCassandraLoader = new VersionInfoCassandraLoader();
 237     Collection<VersionInfoEntity> versions =
 238         versionInfoCassandraLoader.list();
 239
 240     versions.forEach(versionInfoEntity -> versionInfoMap.put(versionInfoEntity.getEntityId
 241         (), versionInfoEntity));
 242
 243
 244   }
 245
 246   private static void convertMibs(SessionContext context,
 247                                   CassandraElementRepository cassandraElementRepository) {
 248     MibCassandraLoader cassandraLoader = new MibCassandraLoader();
 249     Collection<ComponentMonitoringUploadEntity> mibs = cassandraLoader.list();
 250     mibs.stream().filter(mibEntity -> needMigration(mibEntity.getVspId(), mibEntity.getVersion()))
 251         .forEach
 252             (mibEntity -> {
 253               ElementHandler.save(context, cassandraElementRepository,
 254                   mibEntity
 255                       .getVspId(), mibEntity.getVersion(),
 256                   MibConvertor.convertMibToElement
 257                       (mibEntity));
 258             });
 259   }
 260
 261   private static void convertProcesses(SessionContext context,
 262                                        CassandraElementRepository cassandraElementRepository) {
 263     ProcessCassandraLoader cassandraLoader = new ProcessCassandraLoader();
 264     Collection<ProcessEntity> processes = cassandraLoader.list();
 265     processes.stream()
 266         .filter(processEntity -> needMigration(processEntity.getVspId(), processEntity.getVersion
 267             ())).forEach(processEntity -> {
 268       ElementHandler.save(
 269           context,
 270           cassandraElementRepository,
 271           processEntity
 272               .getId(), processEntity.getVersion(),
 273           ProcessConvertor.convertProcessToElement(processEntity));
 274     });
 275   }
 276
 277   private static void convertVsp(SessionContext context, ItemCassandraDao itemCassandraDao,
 278                                  VersionCassandraDao versionCassandraDao,
 279                                  CassandraElementRepository cassandraElementRepository) {
 280     VendorSoftwareProductInfoLoader vendorSoftwareProductInfoLoader = new
 281         VendorSoftwareProductInfoLoader();
 282     Collection<VspInformation> vsps =
 283         vendorSoftwareProductInfoLoader.list();
 284     vsps.stream().filter(vspInformation -> needMigration(vspInformation.getId(),
 285         vspInformation.getVersion())).forEach
 286         (vspInformation
 287             ->
 288             ItemHandler.save(context,
 289                 itemCassandraDao,
 290                 versionCassandraDao,
 291                 vspInformation.getId(), vspInformation
 292                     .getVersion(),
 293                 VspInformationConvertor
 294                     .getVspInfo
 295                         (vspInformation),
 296                 VspInformationConvertor.getItemVersionData(vspInformation),
 297                 vspInformation.getWritetimeMicroSeconds()));
 298
 299     vsps.stream().filter(vspInformation -> needMigration(vspInformation.getId(),
 300         vspInformation.getVersion()))
 301         .forEach(vspInformation -> ElementHandler.save(context, cassandraElementRepository,
 302             vspInformation.getId(), vspInformation.getVersion(),
 303             VspInformationConvertor.convertVspToElement
 304                 (vspInformation)));
 305   }
 306
 307   private static void convertVlm(SessionContext context, ItemCassandraDao itemCassandraDao,
 308                                  VersionCassandraDao versionCassandraDao,
 309                                  CassandraElementRepository cassandraElementRepository) {
 310     VendorLicenseModelCassandraLoader
 311         vendorLicenseModelCassandraDao = new VendorLicenseModelCassandraLoader();
 312     Collection<VendorLicenseModelEntity> vlms =
 313         vendorLicenseModelCassandraDao.list();
 314     vlms.stream().filter(vlm -> needMigration(vlm.getId(), vlm.getVersion())).forEach(vlmEntity ->
 315         ItemHandler.save
 316             (context, itemCassandraDao,
 317                 versionCassandraDao,
 318                 vlmEntity.getId(), vlmEntity.getVersion(),
 319                 VlmConvertor.getVlmInfo
 320                     (vlmEntity),
 321                 VlmConvertor.getItemVersionData(vlmEntity), new Date().getTime()));
 322     vlms.stream().filter(vlm -> needMigration(vlm.getId(), vlm.getVersion()))
 323         .forEach(vlmEntity -> ElementHandler.save(context, cassandraElementRepository,
 324             vlmEntity.getId(), vlmEntity.getVersion(),
 325             VlmConvertor.convertVlmToElement
 326                 (vlmEntity)));
 327
 328   }
 329
 330   private static void convertNic(SessionContext context,
 331                                  CassandraElementRepository cassandraElementRepository) {
 332     NicCassandraLoader nicCassandraLoader = new NicCassandraLoader();
 333     Collection<NicEntity> nics = nicCassandraLoader.list();
 334     nics.stream().filter(entity -> needMigration(entity.getVspId(), entity.getVersion
 335         ())).forEach(nicEntity -> ElementHandler.save(context, cassandraElementRepository,
 336         nicEntity.getVspId(), nicEntity.getVersion(), NicConvertor.convertNicToElement
 337             (nicEntity)));
 338
 339   }
 340
 341   private static void convertNetwork(SessionContext context,
 342                                      CassandraElementRepository cassandraElementRepository) {
 343     NetworkCassandraLoader networkCassandraLoader = new NetworkCassandraLoader();
 344     Collection<NetworkEntity> networks = networkCassandraLoader.list();
 345     networks.stream().filter(entity -> needMigration(entity.getVspId(), entity.getVersion
 346         ())).forEach(networkEntity -> ElementHandler.save(context, cassandraElementRepository,
 347         networkEntity.getVspId(), networkEntity.getVersion(), NetworkConvertor
 348             .convertNetworkToElement(networkEntity)));
 349
 350   }
 351
 352   private static void convertComponent(SessionContext context,
 353                                        CassandraElementRepository cassandraElementRepository) {
 354     ComponentCassandraLoader componentCassandraLoader = new ComponentCassandraLoader();
 355     Collection<ComponentEntity> components = componentCassandraLoader.list();
 356     components.stream().filter(entity -> needMigration(entity.getVspId(), entity.getVersion
 357         ())).forEach(componentEntity -> ElementHandler.save(context, cassandraElementRepository,
 358         componentEntity
 359             .getVspId(), componentEntity.getVersion(), ComponentConvertor
 360             .convertComponentToElement(componentEntity)));
 361
 362   }
 363
 364   private static void convertServiceArtifact(SessionContext context,
 365                                              CassandraElementRepository cassandraElementRepository) {
 366     ServiceArtifactCassandraLoader serviceArtifactCassandraLoader =
 367         new ServiceArtifactCassandraLoader();
 368     Collection<ServiceArtifact> serviceArtifacts = serviceArtifactCassandraLoader.list();
 369     serviceArtifacts.stream().filter(entity -> needMigration(entity.getVspId(), entity.getVersion
 370         ())).forEach(serviceArtifact -> ElementHandler.save(context,
 371         cassandraElementRepository,
 372         serviceArtifact
 373             .getVspId(), serviceArtifact.getVersion(),
 374         VspServiceArtifactConvertor
 375             .convertServiceArtifactToElement(serviceArtifact)));
 376
 377   }
 378
 379   private static void convertServiceTemplate(SessionContext context,
 380                                              CassandraElementRepository cassandraElementRepository) {
 381     ServiceTemplateCassandraLoader serviceTemplateCassandraLoader =
 382         new ServiceTemplateCassandraLoader();
 383     Collection<ServiceTemplate> serviceTemplates = serviceTemplateCassandraLoader.list();
 384     serviceTemplates.stream().filter(entity -> needMigration(entity.getVspId(), entity.getVersion
 385         ())).forEach(serviceTemplate -> ElementHandler.save(context,
 386         cassandraElementRepository,
 387         serviceTemplate
 388             .getVspId(), serviceTemplate.getVersion(),
 389         VspServiceTemplateConvertor
 390             .convertServiceTemplateToElement(serviceTemplate)));
 391
 392   }
 393
 394   private static void convertLKG(SessionContext context,
 395                                  CassandraElementRepository cassandraElementRepository) {
 396     LKGCassandraLoader LKGCassandraLoader = new LKGCassandraLoader();
 397     Collection<LicenseKeyGroupEntity> lkgs = LKGCassandraLoader.list();
 398     lkgs.stream().filter(entity -> needMigration(entity.getVendorLicenseModelId(), entity.getVersion
 399         ()))
 400         .forEach(licenseKeyGroupEntity -> ElementHandler.save(context, cassandraElementRepository,
 401             licenseKeyGroupEntity
 402                 .getVendorLicenseModelId(), licenseKeyGroupEntity.getVersion(),
 403             LKGConvertor.convertLKGToElement
 404                 (licenseKeyGroupEntity)));
 405   }
 406
 407   private static void convertEP(SessionContext context,
 408                                 CassandraElementRepository cassandraElementRepository) {
 409     EntitlementPoolCassandraLoader entitlementPoolCassandraLoader =
 410         new EntitlementPoolCassandraLoader();
 411     Collection<EntitlementPoolEntity> entitlementPools = entitlementPoolCassandraLoader.list();
 412     entitlementPools.stream()
 413         .filter(entity -> needMigration(entity.getVendorLicenseModelId(), entity.getVersion
 414             ()))
 415         .forEach(entitlementPoolEntity -> ElementHandler.save(context, cassandraElementRepository,
 416             entitlementPoolEntity
 417                 .getVendorLicenseModelId(), entitlementPoolEntity.getVersion(),
 418             EntitlementPoolConvertor.convertEntitlementPoolToElement(entitlementPoolEntity)));
 419   }
 420
 421   private static void convertFeatureGroup(SessionContext context,
 422                                           CassandraElementRepository cassandraElementRepository) {
 423     FeatureGroupCassandraLoader featureGroupCassandraLoader = new FeatureGroupCassandraLoader();
 424     Collection<FeatureGroupEntity> featureGroupEntities = featureGroupCassandraLoader.list();
 425     featureGroupEntities.stream()
 426         .filter(entity -> needMigration(entity.getVendorLicenseModelId(), entity.getVersion
 427             ()))
 428         .forEach(featureGroupEntity -> ElementHandler.save(context, cassandraElementRepository,
 429             featureGroupEntity
 430                 .getVendorLicenseModelId(), featureGroupEntity.getVersion(),
 431             FeatureGroupConvertor.convertFeatureGroupToElement(featureGroupEntity)));
 432   }
 433
 434   private static void convertLicenseAgreement(SessionContext context,
 435                                               CassandraElementRepository cassandraElementRepository) {
 436     LicenseAgreementCassandraLoader licenseAgreementCassandraLoader =
 437         new LicenseAgreementCassandraLoader();
 438     Collection<LicenseAgreementEntity> licenseAgreementEntities =
 439         licenseAgreementCassandraLoader.list();
 440     licenseAgreementEntities.stream()
 441         .filter(entity -> needMigration(entity.getVendorLicenseModelId(), entity.getVersion
 442             ()))
 443         .forEach(licenseAgreementEntity -> ElementHandler.save(context, cassandraElementRepository,
 444             licenseAgreementEntity
 445                 .getVendorLicenseModelId(), licenseAgreementEntity.getVersion(),
 446             LicenseAgreementConvertor.convertLicenseAgreementToElement(licenseAgreementEntity)));
 447   }
 448
 449
 450   private static boolean needMigration(String itemId, Version versionId) {
 451
 452     VersionInfoEntity versionInfo =
 453         MigrationMain.versionInfoMap.get(itemId);
 454     if (versionInfo == null) {
 455       printMessage(logger, "ItemId: " + itemId + " is not in version_info table.");
 456       return false;
 457     }
 458     return (versionInfo.getCandidate() != null && versionId.equals(versionInfo.getCandidate()
 459         .getVersion()))
 460         || (versionInfo
 461         .getViewableVersions() != null && versionInfo
 462         .getViewableVersions().contains(versionId));
 463   }
 464
 465   public static Map<String, VersionInfoEntity> getVersionInfoMap()
 466   {
 467     return versionInfoMap;
 468   }
 469 }