--- /dev/null
+package org.akraino.validation.ui.service;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+import org.akraino.validation.ui.dao.BlueprintDAO;
+import org.akraino.validation.ui.dao.BlueprintInstanceDAO;
+import org.akraino.validation.ui.dao.BlueprintLayerDAO;
+import org.akraino.validation.ui.dao.LabDAO;
+import org.akraino.validation.ui.dao.TimeslotDAO;
+import org.akraino.validation.ui.dao.ValidationTestResultDAO;
+import org.akraino.validation.ui.dao.WRobotTestResultDAO;
+import org.akraino.validation.ui.data.JnksJobNotify;
+import org.akraino.validation.ui.entity.Blueprint;
+import org.akraino.validation.ui.entity.BlueprintInstance;
+import org.akraino.validation.ui.entity.BlueprintLayer;
+import org.akraino.validation.ui.entity.LabInfo;
+import org.akraino.validation.ui.entity.Submission;
+import org.akraino.validation.ui.entity.Timeslot;
+import org.akraino.validation.ui.entity.ValidationDbTestResult;
+import org.akraino.validation.ui.entity.WRobotDbTestResult;
+import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+@Service
+@Transactional
+public class DbAdapter {
+
+ private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(DbAdapter.class);
+ private static final Object LOCK = new Object();
+
+ @Autowired
+ private ValidationTestResultDAO vTestResultDAO;
+
+ @Autowired
+ private WRobotTestResultDAO wRobotDAO;
+
+ @Autowired
+ private LabDAO labDAO;
+
+ @Autowired
+ private BlueprintLayerDAO layerDAO;
+
+ @Autowired
+ private BlueprintInstanceDAO bluInstDao;
+
+ @Autowired
+ private BlueprintDAO blueprintDAO;
+
+ @Autowired
+ private TimeslotDAO timeslotDAO;
+
+ @Autowired
+ DbSubmissionAdapter subService;
+
+ public void associateSubmissionWithValidationResult(Submission submission)
+ throws JsonParseException, JsonMappingException, IOException {
+ synchronized (LOCK) {
+ if (!compareBluInstances(submission.getValidationDbTestResult().getBlueprintInstance(),
+ bluInstDao.getBlueprintInstance(
+ submission.getValidationDbTestResult().getBlueprintInstance().getBlueprintInstanceId()))) {
+ throw new RuntimeException("Blueprint instance data changed.");
+ }
+ if (!compareTimeslots(submission.getTimeslot(),
+ timeslotDAO.getTimeslot(submission.getTimeslot().getTimeslotId()))) {
+ throw new RuntimeException("Timeslot data changed.");
+ }
+
+ boolean canContinue = false;
+ for (Timeslot timeslot : bluInstDao
+ .getBlueprintInstance(
+ submission.getValidationDbTestResult().getBlueprintInstance().getBlueprintInstanceId())
+ .getTimeslots()) {
+ if (compareTimeslots(timeslot, submission.getTimeslot())) {
+ canContinue = true;
+ break;
+ }
+ }
+ if (!canContinue) {
+ throw new RuntimeException("Configured timeslot is no longer assigned to the blueprint instance.");
+ }
+ submission.getValidationDbTestResult().setSubmission(submission);
+ vTestResultDAO.saveOrUpdate(submission.getValidationDbTestResult());
+ if (submission.getValidationDbTestResult().getWRobotDbTestResults() != null) {
+ for (WRobotDbTestResult vRobotDbResult : submission.getValidationDbTestResult()
+ .getWRobotDbTestResults()) {
+ vRobotDbResult.setValidationDbTestResult(submission.getValidationDbTestResult());
+ wRobotDAO.saveOrUpdate(vRobotDbResult);
+ }
+ }
+ }
+ }
+
+ public void storeResultsInDb(List<ValidationDbTestResult> vNexusResults) {
+ synchronized (LOCK) {
+ if (vNexusResults == null || vNexusResults.size() < 1) {
+ return;
+ }
+ for (ValidationDbTestResult vNexusResult : vNexusResults) {
+ if (vNexusResult.getWRobotDbTestResults() == null) {
+ continue;
+ }
+ if (!checkValidityOfNexusResult(vNexusResult)) {
+ continue;
+ }
+ LabInfo labInfo = labDAO.getLabBasedOnSilo(vNexusResult.getLab().getSilo());
+ ValidationDbTestResult vDbResult = vTestResultDAO.getValidationTestResult(labInfo,
+ vNexusResult.getTimestamp());
+ if (vDbResult == null) {
+ vDbResult = vNexusResult;
+ vDbResult.setLab(labInfo);
+ Blueprint blueprint = blueprintDAO
+ .getBlueprint(vNexusResult.getBlueprintInstance().getBlueprint().getBlueprintName());
+ if (blueprint == null) {
+ blueprint = vNexusResult.getBlueprintInstance().getBlueprint();
+ blueprintDAO.saveOrUpdate(blueprint);
+ }
+ BlueprintInstance blueprintInst = bluInstDao.getBlueprintInstance(blueprint,
+ (vNexusResult.getBlueprintInstance().getVersion()));
+ if (blueprintInst == null) {
+ blueprintInst = vNexusResult.getBlueprintInstance();
+ blueprintInst.setBlueprint(blueprint);
+ bluInstDao.saveOrUpdate(blueprintInst);
+ }
+ vDbResult.setBlueprintInstance(blueprintInst);
+ }
+ updateBlueInstLayers(vNexusResult);
+ vDbResult.setResult(vNexusResult.getResult());
+ vDbResult.setDateStorage(vNexusResult.getDateStorage());
+ LOGGER.debug(EELFLoggerDelegate.debugLogger,
+ "Storing validation test result with keys: blueprint name: "
+ + vNexusResult.getBlueprintInstance().getBlueprint().getBlueprintName() + ", version: "
+ + vNexusResult.getBlueprintInstance().getVersion() + ", lab: "
+ + vNexusResult.getLab().getSilo() + ", timestamp: " + vNexusResult.getTimestamp());
+ vTestResultDAO.saveOrUpdate(vDbResult);
+ List<org.akraino.validation.ui.entity.WRobotDbTestResult> wRobotDbResults = wRobotDAO
+ .getWRobotTestResult(vDbResult);
+ if (wRobotDbResults == null) {
+ // Store the new wrapper robot rest results in db
+ for (WRobotDbTestResult wNexusResult : vNexusResult.getWRobotDbTestResults()) {
+ wNexusResult.setValidationDbTestResult(vDbResult);
+ wRobotDAO.saveOrUpdate(wNexusResult);
+ }
+ } else if (vDbResult.getSubmission() != null) {
+ // update validation result related to submission
+ for (WRobotDbTestResult wNexusResult : vNexusResult.getWRobotDbTestResults()) {
+ WRobotDbTestResult wRobotDbResult = wRobotDAO.getWRobotTestResult(wNexusResult.getLayer(),
+ vDbResult);
+ wRobotDbResult.setRobotTestResults(wNexusResult.getRobotTestResults());
+ wRobotDAO.saveOrUpdate(wRobotDbResult);
+ }
+ }
+ }
+ }
+ }
+
+ public void updateTimestamp(JnksJobNotify jnksJobNotify) {
+ synchronized (LOCK) {
+ if (!checkValidityOfJenkinsNotification(jnksJobNotify)) {
+ return;
+ }
+ ValidationDbTestResult vDbSubmission = vTestResultDAO
+ .getValidationTestResult(subService.getSubmission(String.valueOf(jnksJobNotify.getSubmissionId())));
+ ValidationDbTestResult vDbTimestamp = vTestResultDAO.getValidationTestResult(vDbSubmission.getLab(),
+ jnksJobNotify.getTimestamp());
+ if (vDbTimestamp == null) {
+ vDbSubmission.setTimestamp(jnksJobNotify.getTimestamp());
+ vTestResultDAO.saveOrUpdate(vDbSubmission);
+ return;
+ }
+ // Delete the wrobot results associated with submission validation result
+ List<WRobotDbTestResult> wRobotResults = wRobotDAO.getWRobotTestResult(vDbSubmission);
+ if (wRobotResults != null && wRobotResults.size() > 0) {
+ for (WRobotDbTestResult wRobotResult : wRobotResults) {
+ wRobotDAO.deleteWRobotTestResult(wRobotResult.getWRobotResultId());
+ }
+ }
+ // Change the timestamp wrobot results to point to submission validation result
+ wRobotResults = wRobotDAO.getWRobotTestResult(vDbTimestamp);
+ if (wRobotResults != null && wRobotResults.size() > 0) {
+ for (WRobotDbTestResult wRobotResult : wRobotResults) {
+ wRobotResult.setValidationDbTestResult(vDbSubmission);
+ wRobotDAO.saveOrUpdate(wRobotResult);
+ }
+ }
+ vTestResultDAO.deleteValidationTestResult(vDbTimestamp);
+ // Now vDbSubmission can be updated
+ vDbSubmission.setDateStorage(vDbTimestamp.getDateStorage());
+ vDbSubmission.setResult(vDbTimestamp.getResult());
+ vDbSubmission.setTimestamp(vDbTimestamp.getTimestamp());
+ vTestResultDAO.saveOrUpdate(vDbSubmission);
+ }
+ }
+
+ public List<ValidationDbTestResult> readResultFromDb(String blueprintName, String version, String lab,
+ List<String> layers, Boolean allLayers, Boolean optional, Boolean outcome)
+ throws JsonParseException, JsonMappingException, IOException {
+ synchronized (LOCK) {
+ LabInfo actualLabInfo = null;
+ if (lab != null) {
+ actualLabInfo = labDAO.getLab(lab);
+ if (actualLabInfo == null) {
+ return null;
+ }
+ }
+ Blueprint blueprint = null;
+ if (blueprintName != null) {
+ blueprint = blueprintDAO.getBlueprint(blueprintName);
+ if (blueprint == null) {
+ return null;
+ }
+ }
+ BlueprintInstance blueprintInst = bluInstDao.getBlueprintInstance(blueprint, version);
+ if (blueprintInst == null) {
+ return null;
+ }
+ List<ValidationDbTestResult> vDbResults = vTestResultDAO.getValidationTestResults(blueprintInst,
+ actualLabInfo, allLayers, optional, outcome);
+ if (vDbResults == null || vDbResults.size() < 1) {
+ return null;
+ }
+ List<ValidationDbTestResult> actualResults = new ArrayList<ValidationDbTestResult>();
+ for (ValidationDbTestResult vDbResult : vDbResults) {
+ if (layers != null && layers.size() > 0) {
+ List<String> storedLayers = new ArrayList<String>();
+ List<WRobotDbTestResult> wDbResults = wRobotDAO.getWRobotTestResult(vDbResult);
+ if (wDbResults == null || wDbResults.size() < 1) {
+ continue;
+ }
+ for (WRobotDbTestResult wRobot : wDbResults) {
+ storedLayers.add(wRobot.getLayer());
+ }
+ if (!new HashSet<>(storedLayers).equals(new HashSet<>(layers))) {
+ continue;
+ }
+ }
+ actualResults.add(vDbResult);
+ }
+ return actualResults;
+ }
+ }
+
+ public ValidationDbTestResult readResultFromDb(@Nonnull String lab, @Nonnull String timestamp)
+ throws JsonParseException, JsonMappingException, IOException {
+ synchronized (LOCK) {
+ LabInfo actualLabInfo = labDAO.getLab(lab);
+ ValidationDbTestResult vDbResult = vTestResultDAO.getValidationTestResult(actualLabInfo, timestamp);
+ if (vDbResult == null) {
+ return null;
+ }
+ return vDbResult;
+ }
+ }
+
+ public ValidationDbTestResult readResultFromDb(@Nonnull String submissionId)
+ throws JsonParseException, JsonMappingException, IOException {
+ synchronized (LOCK) {
+ return vTestResultDAO.getValidationTestResult(subService.getSubmission(submissionId));
+ }
+ }
+
+ public void deleteUnreferencedEntries(List<ValidationDbTestResult> vNexusResults) {
+ synchronized (LOCK) {
+ if (vNexusResults == null || vNexusResults.size() < 1) {
+ return;
+ }
+ LabInfo labInfo = labDAO.getLabBasedOnSilo(vNexusResults.get(0).getLab().getSilo());
+ if (labInfo == null) {
+ return;
+ }
+ Blueprint blueprint = blueprintDAO
+ .getBlueprint(vNexusResults.get(0).getBlueprintInstance().getBlueprint().getBlueprintName());
+ if (blueprint == null) {
+ return;
+ }
+ BlueprintInstance blueInst = bluInstDao.getBlueprintInstance(blueprint,
+ vNexusResults.get(0).getBlueprintInstance().getVersion());
+ if (blueInst == null) {
+ return;
+ }
+ List<ValidationDbTestResult> vDbResults = vTestResultDAO.getValidationTestResults(blueInst, labInfo, null,
+ null, null);
+ if (vDbResults == null || vDbResults.size() < 1) {
+ return;
+ }
+ for (ValidationDbTestResult vDbResult : vDbResults) {
+ if (vDbResult.getSubmission() != null) {
+ continue;
+ }
+ boolean deletion = true;
+ String dbTimestamp = vDbResult.getTimestamp();
+ LabInfo dbLabInfo = vDbResult.getLab();
+ for (ValidationDbTestResult vNexusResult : vNexusResults) {
+ LabInfo nexusLabInfo = labDAO.getLabBasedOnSilo(vNexusResult.getLab().getSilo());
+ if (nexusLabInfo == null) {
+ continue;
+ }
+ if (vNexusResult.getTimestamp().equals(dbTimestamp) && nexusLabInfo.equals(dbLabInfo)) {
+ deletion = false;
+ break;
+ }
+ }
+ if (deletion) {
+ LOGGER.debug(EELFLoggerDelegate.debugLogger,
+ "Deleting unreferenced validation result with id: " + vDbResult.getResultId());
+ // Delete old associated wrapper robot rest results from db
+ for (WRobotDbTestResult wRobotDbResult : wRobotDAO.getWRobotTestResult(vDbResult)) {
+ wRobotDAO.deleteWRobotTestResult(wRobotDbResult.getWRobotResultId());
+ }
+ vTestResultDAO.deleteValidationTestResult(vDbResult);
+ }
+ }
+ }
+ }
+
+ public List<ValidationDbTestResult> getValidationTestResults() {
+ synchronized (LOCK) {
+ return vTestResultDAO.getValidationTestResults();
+ }
+ }
+
+ public ValidationDbTestResult getValidationTestResult(Integer resultId) {
+ synchronized (LOCK) {
+ return vTestResultDAO.getValidationTestResult(resultId);
+ }
+ }
+
+ public List<ValidationDbTestResult> getValidationTestResults(String blueprintName, @Nonnull String version,
+ LabInfo labInfo, Boolean allLayers, Boolean optional, Boolean outcome) {
+ synchronized (LOCK) {
+ Blueprint blueprint = null;
+ if (blueprintName != null) {
+ blueprint = blueprintDAO.getBlueprint(blueprintName);
+ if (blueprint == null) {
+ return null;
+ }
+ }
+ BlueprintInstance bluInst = bluInstDao.getBlueprintInstance(blueprint, version);
+ if (bluInst == null) {
+ return null;
+ }
+ return vTestResultDAO.getValidationTestResults(bluInst, labInfo, allLayers, optional, outcome);
+ }
+ }
+
+ public ValidationDbTestResult getValidationTestResult(LabInfo labInfo, String timestamp) {
+ synchronized (LOCK) {
+ return vTestResultDAO.getValidationTestResult(labInfo, timestamp);
+ }
+ }
+
+ public ValidationDbTestResult getValidationTestResult(String labSilo, String timestamp) {
+ synchronized (LOCK) {
+ return vTestResultDAO.getValidationTestResult(labDAO.getLabBasedOnSilo(labSilo), timestamp);
+ }
+ }
+
+ public ValidationDbTestResult getValidationTestResult(@Nonnull Submission submission) {
+ synchronized (LOCK) {
+ return vTestResultDAO.getValidationTestResult(submission);
+ }
+ }
+
+ public List<WRobotDbTestResult> getWRobotTestResults() {
+ synchronized (LOCK) {
+ return wRobotDAO.getWRobotTestResults();
+ }
+ }
+
+ public WRobotDbTestResult getWRobotTestResult(Integer wRobotResultId) {
+ synchronized (LOCK) {
+ return wRobotDAO.getWRobotTestResult(wRobotResultId);
+ }
+ }
+
+ public List<WRobotDbTestResult> getWRobotTestResult(ValidationDbTestResult vResult) {
+ synchronized (LOCK) {
+ return wRobotDAO.getWRobotTestResult(vResult);
+ }
+ }
+
+ public void saveLab(LabInfo lab) {
+ synchronized (LOCK) {
+ labDAO.saveOrUpdate(lab);
+ }
+ }
+
+ public void deleteLab(LabInfo lab) {
+ synchronized (LOCK) {
+ labDAO.deleteLab(lab);
+ }
+ }
+
+ public LabInfo getLab(String lab) {
+ synchronized (LOCK) {
+ return labDAO.getLab(lab);
+ }
+ }
+
+ public LabInfo getLabBasedOnSilo(String silo) {
+ synchronized (LOCK) {
+ return labDAO.getLabBasedOnSilo(silo);
+ }
+ }
+
+ public List<LabInfo> getLabs() {
+ synchronized (LOCK) {
+ return labDAO.getLabs();
+ }
+ }
+
+ public void deleteLabAll() {
+ synchronized (LOCK) {
+ labDAO.deleteAll();
+ }
+ }
+
+ public void saveBlueprintInstance(BlueprintInstance blueprintIns) {
+ synchronized (LOCK) {
+ Set<Timeslot> timeslots = blueprintIns.getTimeslots();
+ if (timeslots != null && timeslots.size() > 1) {
+ for (Timeslot timeslot : timeslots) {
+ if (!compareTimeslots(timeslot, timeslotDAO.getTimeslot(timeslot.getTimeslotId()))) {
+ throw new RuntimeException("Timeslot instance data changed.");
+ }
+ }
+ bluInstDao.merge(blueprintIns);
+ return;
+ }
+ bluInstDao.saveOrUpdate(blueprintIns);
+ }
+ }
+
+ public List<BlueprintInstance> getBlueprintInstances() {
+ synchronized (LOCK) {
+ return bluInstDao.getBlueprintInstances();
+ }
+ }
+
+ public BlueprintInstance getBlueprintInstance(int instId) {
+ synchronized (LOCK) {
+ return bluInstDao.getBlueprintInstance(instId);
+ }
+ }
+
+ public BlueprintInstance getBlueprintInstance(Blueprint blueprint, String version) {
+ synchronized (LOCK) {
+ return bluInstDao.getBlueprintInstance(blueprint, version);
+ }
+ }
+
+ public void deleteBlueprintInstance(BlueprintInstance blueprintIns) {
+ synchronized (LOCK) {
+ bluInstDao.deleteBlueprintInstance(blueprintIns);
+ }
+ }
+
+ public void deleteBluInstAll() {
+ synchronized (LOCK) {
+ bluInstDao.deleteAll();
+ }
+ }
+
+ public void saveBlueprintLayer(BlueprintLayer layer) {
+ synchronized (LOCK) {
+ layerDAO.saveOrUpdate(layer);
+ }
+ }
+
+ public BlueprintLayer getBlueprintLayer(Integer layerId) {
+ synchronized (LOCK) {
+ return layerDAO.getBlueprintLayer(layerId);
+ }
+ }
+
+ public BlueprintLayer getBlueprintLayer(String layerData) {
+ synchronized (LOCK) {
+ return layerDAO.getBlueprintLayer(layerData);
+ }
+ }
+
+ public List<BlueprintLayer> getBlueprintLayers() {
+ synchronized (LOCK) {
+ return layerDAO.getBlueprintLayers();
+ }
+ }
+
+ public void deleteBlueprintLayer(BlueprintLayer layer) {
+ synchronized (LOCK) {
+ layerDAO.deleteBlueprintLayer(layer);
+ }
+ }
+
+ public void deleteBluLayersAll() {
+ synchronized (LOCK) {
+ layerDAO.deleteAll();
+ }
+ }
+
+ public void saveBlueprint(Blueprint blueprint) {
+ synchronized (LOCK) {
+ blueprintDAO.saveOrUpdate(blueprint);
+ }
+ }
+
+ public Blueprint getBlueprint(String name) {
+ synchronized (LOCK) {
+ return blueprintDAO.getBlueprint(name);
+ }
+ }
+
+ public List<Blueprint> getBlueprints() {
+ synchronized (LOCK) {
+ return blueprintDAO.getBlueprints();
+ }
+ }
+
+ public void deleteBlueprint(Blueprint blueprint) {
+ synchronized (LOCK) {
+ blueprintDAO.deleteBlueprint(blueprint);
+ }
+ }
+
+ public void deleteBluAll() {
+ synchronized (LOCK) {
+ blueprintDAO.deleteAll();
+ }
+ }
+
+ public void saveTimeslot(Timeslot timeslot) {
+ synchronized (LOCK) {
+ LabInfo labInfo = timeslot.getLabInfo();
+ if (labInfo != null) {
+ if (!compareLabInfos(labInfo, labDAO.getLab(labInfo.getLabId()))) {
+ throw new RuntimeException("Lab data changed.");
+ }
+ }
+ timeslotDAO.saveOrUpdate(timeslot);
+ }
+ }
+
+ public List<Timeslot> getTimeslots() {
+ synchronized (LOCK) {
+ return timeslotDAO.getTimeslots();
+ }
+ }
+
+ public void deleteTimeslot(Timeslot timeslot) {
+ synchronized (LOCK) {
+ timeslotDAO.deleteTimeslot(timeslot);
+ }
+ }
+
+ public void deleteTimeslotAll() {
+ synchronized (LOCK) {
+ timeslotDAO.deleteAll();
+ }
+ }
+
+ public boolean checkValidityOfNexusResult(ValidationDbTestResult vNexusResult) {
+ if (vNexusResult == null) {
+ return true;
+ }
+ LabInfo labInfo = labDAO.getLabBasedOnSilo(vNexusResult.getLab().getSilo());
+ if (labInfo == null) {
+ throw new RuntimeException("Lab silo : " + vNexusResult.getLab().getSilo() + " not found");
+ }
+ ValidationDbTestResult vDbResult = vTestResultDAO.getValidationTestResult(
+ labDAO.getLabBasedOnSilo(vNexusResult.getLab().getSilo()), vNexusResult.getTimestamp());
+ Blueprint blueprint = null;
+ BlueprintInstance bluInst = null;
+ List<WRobotDbTestResult> wRobotDbResults = null;
+ if (vDbResult != null) {
+ blueprint = vDbResult.getBlueprintInstance().getBlueprint();
+ labInfo = vDbResult.getLab();
+ wRobotDbResults = wRobotDAO.getWRobotTestResult(vDbResult);
+ } else {
+ blueprint = blueprintDAO
+ .getBlueprint(vNexusResult.getBlueprintInstance().getBlueprint().getBlueprintName());
+ }
+ if (blueprint != null) {
+ if (vDbResult != null) {
+ bluInst = vDbResult.getBlueprintInstance();
+ } else {
+ bluInst = bluInstDao.getBlueprintInstance(blueprint, vNexusResult.getBlueprintInstance().getVersion());
+ }
+ }
+ // Start comparison, be elastic with allLayers and optional
+ if (!labInfo.getSilo().equals(vNexusResult.getLab().getSilo())) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger,
+ "Nexus has different data for blueprint : "
+ + vDbResult.getBlueprintInstance().getBlueprint().getBlueprintName() + ", version: "
+ + vDbResult.getBlueprintInstance().getVersion() + " and lab: " + vDbResult.getLab().getLab()
+ + ". Lab inconsistency : " + vDbResult.getLab() + " " + labInfo);
+ return false;
+ }
+ if (blueprint != null) {
+ if (!blueprint.getBlueprintName()
+ .equals(vNexusResult.getBlueprintInstance().getBlueprint().getBlueprintName())) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger,
+ "Nexus has different data for blueprint : " + blueprint.getBlueprintName()
+ + ". Name inconsistency : " + blueprint.getBlueprintName() + " "
+ + vNexusResult.getBlueprintInstance().getBlueprint().getBlueprintName());
+ return false;
+ }
+ }
+ if (bluInst != null) {
+ if (!bluInst.getVersion().equals(vNexusResult.getBlueprintInstance().getVersion())) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger,
+ "Nexus has different data for blueprint : " + bluInst.getBlueprint().getBlueprintName()
+ + ", version: " + bluInst.getVersion() + ". Version inconsistency : "
+ + bluInst.getVersion() + " " + vNexusResult.getBlueprintInstance().getVersion());
+ return false;
+ }
+ }
+ if (wRobotDbResults != null) {
+ List<String> storedLayers1 = new ArrayList<String>();
+ for (WRobotDbTestResult wNexusResult : vNexusResult.getWRobotDbTestResults()) {
+ storedLayers1.add(wNexusResult.getLayer());
+ }
+ List<String> storedLayers2 = new ArrayList<String>();
+ for (WRobotDbTestResult wDbResult : wRobotDbResults) {
+ storedLayers2.add(wDbResult.getLayer());
+ }
+ if (!new HashSet<>(storedLayers1).equals(new HashSet<>(storedLayers2))) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger,
+ "Nexus has different layer results for validation result id: " + vDbResult.getResultId());
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean checkValidityOfJenkinsNotification(JnksJobNotify jnksJobNotify) {
+ ValidationDbTestResult vDbSubmission = vTestResultDAO
+ .getValidationTestResult(subService.getSubmission(String.valueOf(jnksJobNotify.getSubmissionId())));
+ if (vDbSubmission == null) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger, "Received timestamp for submission id : "
+ + jnksJobNotify.getSubmissionId() + " which has not validation result associated with it");
+ return false;
+ }
+ if (!vDbSubmission.getAllLayers() && (vDbSubmission.getWRobotDbTestResults() == null
+ || vDbSubmission.getWRobotDbTestResults().size() < 1)) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger, "Received timestamp for submission id : "
+ + jnksJobNotify.getSubmissionId() + " which is not stored correctly");
+ return false;
+ }
+ ValidationDbTestResult vDbTimestamp = vTestResultDAO.getValidationTestResult(vDbSubmission.getLab(),
+ jnksJobNotify.getTimestamp());
+ if (vDbTimestamp == null) {
+ return true;
+ }
+ if (vDbTimestamp.equals(vDbSubmission) || (vDbTimestamp.getSubmission() != null
+ && !jnksJobNotify.getSubmissionId().equals(vDbTimestamp.getSubmission().getSubmissionId()))) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger, "Received same timestamp: " + jnksJobNotify.getTimestamp()
+ + " from nexus for submission id: " + jnksJobNotify.getSubmissionId());
+ return false;
+ }
+ if (!vDbSubmission.getAllLayers()) {
+ if (wRobotDAO.getWRobotTestResult(vDbSubmission).size() != wRobotDAO.getWRobotTestResult(vDbTimestamp)
+ .size()) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger, "No consistency exists in stored layers records.");
+ return false;
+ }
+ List<String> storedLayers1 = new ArrayList<String>();
+ List<String> storedLayers2 = new ArrayList<String>();
+ List<WRobotDbTestResult> wDbResults = wRobotDAO.getWRobotTestResult(vDbSubmission);
+ for (WRobotDbTestResult wRobot : wDbResults) {
+ storedLayers1.add(wRobot.getLayer());
+ }
+ wDbResults = wRobotDAO.getWRobotTestResult(vDbTimestamp);
+ for (WRobotDbTestResult wRobot : wDbResults) {
+ storedLayers2.add(wRobot.getLayer());
+ }
+ if (!new HashSet<>(storedLayers1).equals(new HashSet<>(storedLayers2))) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger, "No consistency exists in stored layers records.");
+ return false;
+ }
+ }
+ // Be elastic with allLayers and optional
+ if (!vDbSubmission.getBlueprintInstance().getBlueprint().getBlueprintName()
+ .equals(vDbTimestamp.getBlueprintInstance().getBlueprint().getBlueprintName())
+ || !vDbSubmission.getBlueprintInstance().getVersion()
+ .equals(vDbTimestamp.getBlueprintInstance().getVersion())
+ || !compareLabInfos(vDbSubmission.getLab(), vDbTimestamp.getLab())) {
+ LOGGER.error(EELFLoggerDelegate.errorLogger, "No consistency exists in database records.");
+ return false;
+ }
+ return true;
+ }
+
+ private void updateBlueInstLayers(ValidationDbTestResult vNexusResult) {
+ for (BlueprintInstance blueprintInst : bluInstDao.getBlueprintInstances()) {
+ if (!blueprintInst.getBlueprint().getBlueprintName()
+ .equals(vNexusResult.getBlueprintInstance().getBlueprint().getBlueprintName())) {
+ continue;
+ }
+ Set<BlueprintLayer> blueprintLayers = blueprintInst.getBlueprintLayers();
+ if (blueprintLayers == null) {
+ blueprintLayers = new HashSet<BlueprintLayer>();
+ }
+ for (WRobotDbTestResult nexusResult : vNexusResult.getWRobotDbTestResults()) {
+ BlueprintLayer layer = layerDAO.getBlueprintLayer(nexusResult.getLayer());
+ if (layer == null) {
+ layer = new BlueprintLayer();
+ layer.setLayer(nexusResult.getLayer());
+ layerDAO.saveOrUpdate(layer);
+ }
+ if (!blueprintLayers.contains(layer)) {
+ blueprintLayers.add(layer);
+ }
+ }
+ blueprintInst.setBlueprintLayers(blueprintLayers);
+ bluInstDao.saveOrUpdate(blueprintInst);
+ }
+ }
+
+ private boolean compareBluInstances(BlueprintInstance inst1, BlueprintInstance inst2) {
+ if (!inst1.getVersion().equals(inst2.getVersion())) {
+ return false;
+ }
+ if (inst1.getBlueprintInstanceId() != inst2.getBlueprintInstanceId()) {
+ return false;
+ }
+ Set<BlueprintLayer> layers1 = inst1.getBlueprintLayers();
+ Set<BlueprintLayer> layers2 = inst2.getBlueprintLayers();
+ if (!(layers1 == null && layers2 == null)) {
+ if (layers1 != null && layers2 == null) {
+ return false;
+ }
+ if (layers1 == null && layers2 != null) {
+ return false;
+ }
+ if (!(layers1.size() == layers2.size())) {
+ return false;
+ }
+ boolean overallLayerEquality = true;
+ for (BlueprintLayer blulayer1 : layers1) {
+ boolean layerEquality = false;
+ for (BlueprintLayer blulayer2 : layers2) {
+ if (blulayer1.getLayer().equals(blulayer2.getLayer())) {
+ layerEquality = true;
+ }
+ }
+ if (!layerEquality) {
+ overallLayerEquality = false;
+ break;
+ }
+ }
+ if (!overallLayerEquality) {
+ return false;
+ }
+ }
+ if (!compareBlueprints(inst1.getBlueprint(), inst2.getBlueprint())) {
+ return false;
+ }
+ return true;
+ }
+
+ private boolean compareTimeslots(Timeslot timeslot1, Timeslot timeslot2) {
+ if (!timeslot1.getStartDateTime().equals(timeslot2.getStartDateTime())
+ || timeslot1.getTimeslotId() != timeslot2.getTimeslotId()) {
+ return false;
+ }
+ if (!compareLabInfos(timeslot1.getLabInfo(), timeslot2.getLabInfo())) {
+ return false;
+ }
+ return true;
+ }
+
+ private boolean compareBlueprints(Blueprint blueprint1, Blueprint blueprint2) {
+ if (blueprint1 != null || blueprint2 != null) {
+ if (blueprint1 != null && blueprint2 == null) {
+ return false;
+ }
+ if (blueprint1 == null && blueprint2 != null) {
+ return false;
+ }
+ if (blueprint1.getBlueprintId() != blueprint2.getBlueprintId()) {
+ return false;
+ }
+ if (!blueprint1.getBlueprintName().equals(blueprint2.getBlueprintName())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean compareLabInfos(LabInfo labInfo1, LabInfo labInfo2) {
+ if (labInfo1 != null || labInfo2 != null) {
+ if (labInfo1 != null && labInfo2 == null) {
+ return false;
+ }
+ if (labInfo1 == null && labInfo2 != null) {
+ return false;
+ }
+ if (labInfo1.getLabId() != labInfo2.getLabId()) {
+ return false;
+ }
+ if (!labInfo1.getSilo().equals(labInfo2.getSilo())) {
+ return false;
+ }
+ if (!labInfo1.getLab().equals(labInfo2.getLab())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+}
Code Review / validation.git / blobdiff