openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorsoftwareproduct.impl;
  22
  23 import org.openecomp.core.util.UniqueValueUtil;
  24 import org.openecomp.core.utilities.file.FileUtils;
  25 import org.openecomp.sdc.common.errors.CoreException;
  26 import org.openecomp.sdc.common.errors.ErrorCategory;
  27 import org.openecomp.sdc.common.errors.ErrorCode;
  28 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  29 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  30 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  31 import org.openecomp.sdc.logging.types.LoggerConstants;
  32 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  33 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  34 import org.openecomp.sdc.vendorsoftwareproduct.ProcessManager;
  35 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  36 import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDao;
  37 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
  38 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  39 import org.openecomp.sdc.vendorsoftwareproduct.errors.UploadInvalidErrorBuilder;
  40 import org.openecomp.sdc.versioning.VersioningUtil;
  41 import org.openecomp.sdc.versioning.dao.types.Version;
  42 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  43
  44 import java.io.File;
  45 import java.io.FileOutputStream;
  46 import java.io.IOException;
  47 import java.io.InputStream;
  48 import java.nio.ByteBuffer;
  49 import java.util.Collection;
  50
  51 public class ProcessManagerImpl implements ProcessManager {
  52   private static final String PROCESS_ARTIFACT_NOT_EXIST_MSG =
  53       "Process artifact for process with Id %s does not exist for %s with Id %s and version %s";
  54
  55   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  56
  57   private ProcessDao processDao;
  58
  59   public ProcessManagerImpl(ProcessDao processDao) {
  60     this.processDao = processDao;
  61   }
  62
  63   @Override
  64   public Collection<ProcessEntity> listProcesses(String vspId, Version version,
  65                                                  String componentId) {
  66     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
  67     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
  68
  69     return processDao.list(new ProcessEntity(vspId, version, componentId, null));
  70   }
  71
  72   @Override
  73   public void deleteProcesses(String vspId, Version version, String componentId) {
  74     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
  75
  76     ProcessEntity allProcesses = new ProcessEntity(vspId, version, componentId, null);
  77     Collection<ProcessEntity> processes = processDao.list(allProcesses);
  78
  79     if (!processes.isEmpty()) {
  80       for (ProcessEntity process : processes) {
  81         deleteUniqueValue(process.getVspId(), process.getVersion(), process.getComponentId(),
  82             process.getName());
  83       }
  84     }
  85
  86     if (componentId == null) {
  87       processDao.deleteVspAll(vspId,version);
  88     } else {
  89       processDao.deleteAll(allProcesses);
  90     }
  91
  92     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
  93   }
  94
  95   @Override
  96   public ProcessEntity createProcess(ProcessEntity process) {
  97     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", process.getId(),
  98         process.getComponentId());
  99     validateUniqueName(process.getVspId(), process.getVersion(), process.getComponentId(),
 100         process.getName());
 101
 102     processDao.create(process);
 103     createUniqueName(process.getVspId(), process.getVersion(), process.getComponentId(),
 104         process.getName());
 105
 106     mdcDataDebugMessage.debugExitMessage("VSP id, component id", process.getId(),
 107         process.getComponentId());
 108
 109     return process;
 110   }
 111
 112   @Override
 113   public ProcessEntity getProcess(String vspId, Version version, String componentId,
 114                                   String processId) {
 115     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 116
 117     ProcessEntity retrieved =
 118         processDao.get(new ProcessEntity(vspId, version, componentId, processId));
 119     validateProcessExistence(vspId, version, componentId, processId, retrieved);
 120
 121     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 122
 123     return retrieved;
 124   }
 125
 126   @Override
 127   public void updateProcess(ProcessEntity process) {
 128     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", process.getId(),
 129         process.getComponentId());
 130
 131     ProcessEntity retrieved = processDao.get(process);
 132     validateProcessExistence(process.getVspId(), process.getVersion(), process.getComponentId(),
 133         process.getId(), retrieved);
 134
 135     updateUniqueName(process.getVspId(), process.getVersion(), process.getComponentId(),
 136         retrieved.getName(), process.getName());
 137     processDao.update(process);
 138
 139     mdcDataDebugMessage.debugExitMessage("VSP id, component id", process.getId(),
 140         process.getComponentId());
 141   }
 142
 143   @Override
 144   public void deleteProcess(String vspId, Version version, String componentId, String processId) {
 145     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 146
 147     ProcessEntity retrieved = getProcess(vspId, version, componentId, processId);
 148
 149     processDao.delete(retrieved);
 150     deleteUniqueValue(retrieved.getVspId(), retrieved.getVersion(), retrieved.getComponentId(),
 151         retrieved.getName());
 152
 153     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 154   }
 155
 156
 157   @Override
 158   public File getProcessArtifact(String vspId, Version version, String componentId,
 159                                  String processId) {
 160     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 161
 162     ProcessEntity retrieved = getValidatedProcessArtifact(vspId, version, componentId, processId);
 163
 164     File file = new File(String.format("%s_%s_%s", vspId, componentId, processId));
 165     try (FileOutputStream fos = new FileOutputStream(file)) {
 166       fos.write(retrieved.getArtifact().array());
 167     } catch (IOException exception) {
 168       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 169           LoggerTragetServiceName.GET_PROCESS_ARTIFACT, ErrorLevel.ERROR.name(),
 170           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't get process artifact");
 171       throw new CoreException(new UploadInvalidErrorBuilder().build());
 172     }
 173
 174     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 175
 176     return file;
 177   }
 178
 179   @Override
 180   public void deleteProcessArtifact(String vspId, Version version, String componentId,
 181                                     String processId) {
 182     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 183
 184     ProcessEntity retrieved = getValidatedProcessArtifact(vspId, version, componentId, processId);
 185
 186     processDao.deleteArtifact(retrieved);
 187
 188     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 189   }
 190
 191   @Override
 192   public void uploadProcessArtifact(InputStream artifactFile, String artifactFileName, String vspId,
 193                                     Version version, String componentId, String processId) {
 194     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 195
 196     ProcessEntity process = getProcess(vspId, version, componentId, processId);
 197     process.setArtifactName(artifactFileName);
 198     process.setArtifact(readArtifact(artifactFile));
 199     processDao.uploadArtifact(process);
 200
 201     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 202   }
 203
 204   private ProcessEntity getValidatedProcessArtifact(String vspId, Version version,
 205                                                     String componentId, String processId) {
 206     ProcessEntity retrieved =
 207         processDao.getArtifact(new ProcessEntity(vspId, version, componentId, processId));
 208     validateProcessArtifactExistence(vspId, version, componentId, processId, retrieved);
 209     return retrieved;
 210   }
 211
 212   private ByteBuffer readArtifact(InputStream artifactInputStream) {
 213     if (artifactInputStream == null) {
 214       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 215           LoggerTragetServiceName.UPLOAD_PROCESS_ARTIFACT, ErrorLevel.ERROR.name(),
 216           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't upload process artifact");
 217       throw new CoreException(new UploadInvalidErrorBuilder().build());
 218     }
 219     try {
 220       return ByteBuffer.wrap(FileUtils.toByteArray(artifactInputStream));
 221     } catch (RuntimeException exception) {
 222       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 223           LoggerTragetServiceName.UPLOAD_PROCESS_ARTIFACT, ErrorLevel.ERROR.name(),
 224           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't upload process artifact");
 225       throw new CoreException(new UploadInvalidErrorBuilder().build());
 226     }
 227   }
 228
 229
 230   private void validateProcessExistence(String vspId, Version version, String componentId,
 231                                         String processId, ProcessEntity retrieved) {
 232     VersioningUtil.validateEntityExistence(retrieved,
 233         new ProcessEntity(vspId, version, componentId, processId),
 234         VspDetails.ENTITY_TYPE);
 235   }
 236
 237   private void validateProcessArtifactExistence(String vspId, Version version, String componentId,
 238                                                 String processId, ProcessEntity retrieved) {
 239     ProcessEntity inputProcess = new ProcessEntity(vspId, version, componentId, processId);
 240     VersioningUtil.validateEntityExistence(retrieved, inputProcess, VspDetails.ENTITY_TYPE);
 241     if (retrieved.getArtifact() == null) {
 242       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 243           .withCategory(ErrorCategory.APPLICATION)
 244           .withId(VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND)
 245           .withMessage(String.format(PROCESS_ARTIFACT_NOT_EXIST_MSG,
 246               processId, VspDetails.ENTITY_TYPE, vspId, version)).build());
 247     }
 248   }
 249
 250
 251   protected void validateUniqueName(String vspId, Version version, String componentId,
 252                                     String processName) {
 253     UniqueValueUtil.validateUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME,
 254         vspId, version.getId(), componentId, processName);
 255   }
 256
 257   protected void createUniqueName(String vspId, Version version, String componentId,
 258                                   String processName) {
 259     UniqueValueUtil
 260         .createUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, vspId,
 261             version.getId(), componentId, processName);
 262   }
 263
 264   protected void updateUniqueName(String vspId, Version version, String componentId,
 265                                   String oldProcessName, String newProcessName) {
 266     UniqueValueUtil
 267         .updateUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, oldProcessName,
 268             newProcessName, vspId, version.getId(), componentId);
 269   }
 270
 271   protected void deleteUniqueValue(String vspId, Version version, String componentId,
 272                                    String processName) {
 273     if (componentId == null) {
 274       UniqueValueUtil
 275           .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, vspId,
 276               version.getId(), processName);
 277     }
 278     UniqueValueUtil
 279         .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, vspId,
 280             version.getId(), componentId, processName);
 281   }
 282 }