/*- * ============LICENSE_START======================================================= * SDC * ================================================================================ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ============LICENSE_END========================================================= */ package org.openecomp.sdc.be.model.jsonjanusgraph.operations; import fj.data.Either; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.MapUtils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.tinkerpop.gremlin.structure.Direction; import org.apache.tinkerpop.gremlin.structure.Edge; import org.openecomp.sdc.be.config.Configuration; import org.openecomp.sdc.be.config.ConfigurationManager; import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData; import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; import org.openecomp.sdc.be.datatypes.elements.*; import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; import org.openecomp.sdc.be.datatypes.enums.*; import org.openecomp.sdc.be.model.*; import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; import org.openecomp.sdc.be.model.CatalogUpdateTimestamp; import org.openecomp.sdc.be.model.catalog.CatalogComponent; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; import org.openecomp.sdc.be.model.operations.StorageException; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; import org.openecomp.sdc.be.model.utils.GroupUtils; import org.openecomp.sdc.be.resources.data.ComponentMetadataData; import org.openecomp.sdc.common.jsongraph.util.CommonUtility; import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; import org.openecomp.sdc.common.log.wrappers.Logger; import org.openecomp.sdc.common.util.ValidationUtils; import org.springframework.beans.factory.annotation.Autowired; import java.util.*; import java.util.Map.Entry; import java.util.function.BiPredicate; import java.util.stream.Collectors; import static java.util.Objects.requireNonNull; import static org.apache.commons.collections.CollectionUtils.isEmpty; import static org.apache.commons.collections.CollectionUtils.isNotEmpty; @org.springframework.stereotype.Component("tosca-operation-facade") public class ToscaOperationFacade { // region - Fields private static final String COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR = "Couldn't fetch a component with and UniqueId {}, error: {}"; private static final String FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS = "Failed to find recently added property {} on the resource {}. Status is {}. "; private static final String FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS = "Failed to get updated resource {}. Status is {}. "; private static final String FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS = "Failed to add the property {} to the resource {}. Status is {}. "; private static final String SERVICE = "service"; private static final String NOT_SUPPORTED_COMPONENT_TYPE = "Not supported component type {}"; private static final String COMPONENT_CREATED_SUCCESSFULLY = "Component created successfully!!!"; private static final String COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR = "Couldn't fetch component with and unique id {}, error: {}"; @Autowired private NodeTypeOperation nodeTypeOperation; @Autowired private TopologyTemplateOperation topologyTemplateOperation; @Autowired private NodeTemplateOperation nodeTemplateOperation; @Autowired private GroupsOperation groupsOperation; @Autowired private HealingJanusGraphDao janusGraphDao; @Autowired private ContainerInstanceTypesData containerInstanceTypesData; private static final Logger log = Logger.getLogger(ToscaOperationFacade.class.getName()); // endregion // region - ToscaElement - GetById public static final String PROXY_SUFFIX = "_proxy"; public Either getToscaFullElement(String componentId) { ComponentParametersView filters = new ComponentParametersView(); filters.setIgnoreCapabiltyProperties(false); filters.setIgnoreForwardingPath(false); return getToscaElement(componentId, filters); } public Either getToscaElement(String componentId) { return getToscaElement(componentId, JsonParseFlagEnum.ParseAll); } public Either getToscaElement(String componentId, ComponentParametersView filters) { Either getVertexEither = janusGraphDao .getVertexById(componentId, filters.detectParseFlag()); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } return getToscaElementByOperation(getVertexEither.left().value(), filters); } public Either getToscaElement(String componentId, JsonParseFlagEnum parseFlag) { Either getVertexEither = janusGraphDao .getVertexById(componentId, parseFlag); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } return getToscaElementByOperation(getVertexEither.left().value()); } public Either getToscaElement(GraphVertex componentVertex) { return getToscaElementByOperation(componentVertex); } public Either validateComponentExists(String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { JanusGraphOperationStatus status = getVertexEither.right().value(); if (status == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(false); } else { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } } return Either.left(true); } public Either findLastCertifiedToscaElementByUUID(T component) { Map props = new EnumMap<>(GraphPropertyEnum.class); props.put(GraphPropertyEnum.UUID, component.getUUID()); props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); Either, JanusGraphOperationStatus> getVertexEither = janusGraphDao .getByCriteria(ModelConverter.getVertexType(component), props); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, component.getUniqueId(), getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } return getToscaElementByOperation(getVertexEither.left().value().get(0)); } // endregion // region - ToscaElement - GetByOperation private Either getToscaElementByOperation(GraphVertex componentV) { return getToscaElementByOperation(componentV, new ComponentParametersView()); } private Either getToscaElementByOperation(GraphVertex componentV, ComponentParametersView filters) { if (componentV == null) { log.debug("Unexpected null value for `componentV`"); return Either.right(StorageOperationStatus.GENERAL_ERROR); } else { VertexTypeEnum label = componentV.getLabel(); ToscaElementOperation toscaOperation = getToscaElementOperation(componentV); if (toscaOperation != null) { log.debug("getToscaElementByOperation: toscaOperation={}", toscaOperation.getClass()); } Either toscaElement; String componentId = componentV.getUniqueId(); if (toscaOperation != null) { log.debug("Need to fetch tosca element for id {}", componentId); toscaElement = toscaOperation.getToscaElement(componentV, filters); } else { log.debug("not supported tosca type {} for id {}", label, componentId); toscaElement = Either.right(StorageOperationStatus.BAD_REQUEST); } return toscaElement.left().map(ModelConverter::convertFromToscaElement); } } // endregion private ToscaElementOperation getToscaElementOperation(GraphVertex componentV) { VertexTypeEnum label = componentV.getLabel(); switch (label) { case NODE_TYPE: return nodeTypeOperation; case TOPOLOGY_TEMPLATE: return topologyTemplateOperation; default: return null; } } public Either createToscaComponent(T resource) { ToscaElement toscaElement = ModelConverter.convertToToscaElement(resource); ToscaElementOperation toscaElementOperation = getToscaElementOperation(resource); Either createToscaElement = toscaElementOperation.createToscaElement(toscaElement); if (createToscaElement.isLeft()) { log.debug(COMPONENT_CREATED_SUCCESSFULLY); T dataModel = ModelConverter.convertFromToscaElement(createToscaElement.left().value()); return Either.left(dataModel); } return Either.right(createToscaElement.right().value()); } // region - ToscaElement Delete public StorageOperationStatus markComponentToDelete(Component componentToDelete) { if ((componentToDelete.getIsDeleted() != null) && componentToDelete.getIsDeleted() && !componentToDelete.isHighestVersion()) { // component already marked for delete return StorageOperationStatus.OK; } else { Either getResponse = janusGraphDao .getVertexById(componentToDelete.getUniqueId(), JsonParseFlagEnum.ParseAll); if (getResponse.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentToDelete.getUniqueId(), getResponse.right().value()); return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getResponse.right().value()); } GraphVertex componentV = getResponse.left().value(); // same operation for node type and topology template operations Either result = nodeTypeOperation.markComponentToDelete(componentV); if (result.isRight()) { return result.right().value(); } return StorageOperationStatus.OK; } } public Either deleteToscaComponent(String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.ParseAll); if (getVertexEither.isRight()) { log.debug("Couldn't fetch component vertex with and unique id {}, error: {}", componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } Either deleteElement = deleteToscaElement(getVertexEither.left().value()); if (deleteElement.isRight()) { log.debug("Failed to delete component with and unique id {}, error: {}", componentId, deleteElement.right().value()); return Either.right(deleteElement.right().value()); } T dataModel = ModelConverter.convertFromToscaElement(deleteElement.left().value()); return Either.left(dataModel); } private Either deleteToscaElement(GraphVertex componentV) { VertexTypeEnum label = componentV.getLabel(); Either toscaElement; Object componentId = componentV.getUniqueId(); switch (label) { case NODE_TYPE: log.debug("Need to fetch node type for id {}", componentId); toscaElement = nodeTypeOperation.deleteToscaElement(componentV); break; case TOPOLOGY_TEMPLATE: log.debug("Need to fetch topology template for id {}", componentId); toscaElement = topologyTemplateOperation.deleteToscaElement(componentV); break; default: log.debug("not supported tosca type {} for id {}", label, componentId); toscaElement = Either.right(StorageOperationStatus.BAD_REQUEST); break; } return toscaElement; } // endregion private ToscaElementOperation getToscaElementOperation(Component component) { return ModelConverter.isAtomicComponent(component) ? nodeTypeOperation : topologyTemplateOperation; } public Either getLatestByToscaResourceName(String toscaResourceName) { return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); } public Either getFullLatestComponentByToscaResourceName(String toscaResourceName) { ComponentParametersView fetchAllFilter = new ComponentParametersView(); fetchAllFilter.setIgnoreForwardingPath(true); fetchAllFilter.setIgnoreCapabiltyProperties(false); return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName, JsonParseFlagEnum.ParseAll, fetchAllFilter); } public Either getLatestByName(String resourceName) { return getLatestByName(GraphPropertyEnum.NAME, resourceName); } public StorageOperationStatus validateCsarUuidUniqueness(String csarUUID) { Map properties = new EnumMap<>(GraphPropertyEnum.class); properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID); Either, JanusGraphOperationStatus> resources = janusGraphDao .getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata); if (resources.isRight()) { if (resources.right().value() == JanusGraphOperationStatus.NOT_FOUND) { return StorageOperationStatus.OK; } else { log.debug("failed to get resources from graph with property name: {}", csarUUID); return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(resources.right().value()); } } return StorageOperationStatus.ENTITY_ALREADY_EXISTS; } public Either, StorageOperationStatus> getFollowed(String userId, Set lifecycleStates, Set lastStateStates, ComponentTypeEnum componentType) { Either, StorageOperationStatus> followedResources; if (componentType == ComponentTypeEnum.RESOURCE) { followedResources = nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType); } else { followedResources = topologyTemplateOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType); } Set components = new HashSet<>(); if (followedResources.isRight() && followedResources.right().value() != StorageOperationStatus.NOT_FOUND) { return Either.right(followedResources.right().value()); } if (followedResources.isLeft()) { List toscaElements = followedResources.left().value(); toscaElements.forEach(te -> { T component = ModelConverter.convertFromToscaElement(te); components.add(component); }); } return Either.left(components); } public Either getLatestCertifiedNodeTypeByToscaResourceName(String toscaResourceName) { return getLatestCertifiedByToscaResourceName(toscaResourceName, VertexTypeEnum.NODE_TYPE, JsonParseFlagEnum.ParseMetadata); } public Either getLatestCertifiedByToscaResourceName(String toscaResourceName, VertexTypeEnum vertexType, JsonParseFlagEnum parseFlag) { Map props = new EnumMap<>(GraphPropertyEnum.class); props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); Either, JanusGraphOperationStatus> getLatestRes = janusGraphDao .getByCriteria(vertexType, props, parseFlag); return getLatestRes .right().map( status -> { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch {} with name {}. status={} ", vertexType, toscaResourceName, status); return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); } ) .left().bind( resources -> { double version = 0.0; GraphVertex highestResource = null; for (GraphVertex resource : resources) { double resourceVersion = Double .parseDouble((String) resource.getJsonMetadataField(JsonPresentationFields.VERSION)); if (resourceVersion > version) { version = resourceVersion; highestResource = resource; } } if (highestResource != null) { return getToscaFullElement(highestResource.getUniqueId()); } else { log.debug("The vertex with the highest version could not be found for {}", toscaResourceName); return Either.right(StorageOperationStatus.GENERAL_ERROR); } } ); } public Either validateToscaResourceNameExists(String templateName) { Either validateUniquenessRes = validateToscaResourceNameUniqueness(templateName); if (validateUniquenessRes.isLeft()) { return Either.left(!validateUniquenessRes.left().value()); } return validateUniquenessRes; } public Either dissociateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) { return nodeTemplateOperation.dissociateResourceInstances(componentId, requirementDef); } /** * Allows to get fulfilled requirement by relation and received predicate */ public Either getFulfilledRequirementByRelation(String componentId, String instanceId, RequirementCapabilityRelDef relation, BiPredicate predicate) { return nodeTemplateOperation.getFulfilledRequirementByRelation(componentId, instanceId, relation, predicate); } /** * Allows to get fulfilled capability by relation and received predicate */ public Either getFulfilledCapabilityByRelation(String componentId, String instanceId, RequirementCapabilityRelDef relation, BiPredicate predicate) { return nodeTemplateOperation.getFulfilledCapabilityByRelation(componentId, instanceId, relation, predicate); } public Either, StorageOperationStatus> associateResourceInstances(Component component, String componentId, List relations) { Either, StorageOperationStatus> reqAndCapListEither = nodeTemplateOperation.associateResourceInstances(component, componentId, relations); if (component != null) { updateInstancesCapAndReqOnComponentFromDB(component); } return reqAndCapListEither; } protected Either validateToscaResourceNameUniqueness(String name) { Map properties = new EnumMap<>(GraphPropertyEnum.class); properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, name); Either, JanusGraphOperationStatus> resources = janusGraphDao .getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata); if (resources.isRight() && resources.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("failed to get resources from graph with property name: {}", name); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(resources.right().value())); } List resourceList = (resources.isLeft() ? resources.left().value() : null); if (isNotEmpty(resourceList)) { if (log.isDebugEnabled()) { StringBuilder builder = new StringBuilder(); for (GraphVertex resourceData : resourceList) { builder.append(resourceData.getUniqueId() + "|"); } log.debug("resources with property name:{} exists in graph. found {}", name, builder); } return Either.left(false); } else { log.debug("resources with property name:{} does not exists in graph", name); return Either.left(true); } } // region - Component Update public Either overrideComponent(Resource newComponent, Resource oldComponent) { copyArtifactsToNewComponent(newComponent, oldComponent); Either componentVEither = janusGraphDao .getVertexById(oldComponent.getUniqueId(), JsonParseFlagEnum.NoParse); if (componentVEither.isRight()) { log.debug("Failed to fetch component {} error {}", oldComponent.getUniqueId(), componentVEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(componentVEither.right().value())); } GraphVertex componentv = componentVEither.left().value(); Either parentVertexEither = janusGraphDao.getParentVertex(componentv, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); if (parentVertexEither.isRight() && parentVertexEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("Failed to fetch parent version for component {} error {}", oldComponent.getUniqueId(), parentVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentVertexEither.right().value())); } Either deleteToscaComponent = deleteToscaElement(componentv); if (deleteToscaComponent.isRight()) { log.debug("Failed to remove old component {} error {}", oldComponent.getUniqueId(), deleteToscaComponent.right().value()); return Either.right(deleteToscaComponent.right().value()); } Either createToscaComponent = createToscaComponent(newComponent); if (createToscaComponent.isRight()) { log.debug("Failed to create tosca element component {} error {}", newComponent.getUniqueId(), createToscaComponent.right().value()); return Either.right(createToscaComponent.right().value()); } Resource newElement = createToscaComponent.left().value(); Either newVersionEither = janusGraphDao .getVertexById(newElement.getUniqueId(), JsonParseFlagEnum.NoParse); if (newVersionEither.isRight()) { log.debug("Failed to fetch new tosca element component {} error {}", newComponent.getUniqueId(), newVersionEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(newVersionEither.right().value())); } if (parentVertexEither.isLeft()) { GraphVertex previousVersionV = parentVertexEither.left().value(); JanusGraphOperationStatus createEdge = janusGraphDao.createEdge(previousVersionV, newVersionEither.left().value(), EdgeLabelEnum.VERSION, null); if (createEdge != JanusGraphOperationStatus.OK) { log.debug("Failed to associate to previous version {} new version {} error {}", previousVersionV.getUniqueId(), newVersionEither.right().value(), createEdge); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdge)); } } return Either.left(newElement); } void copyArtifactsToNewComponent(Resource newComponent, Resource oldComponent) { // TODO - check if required Map toscaArtifacts = oldComponent.getToscaArtifacts(); if (toscaArtifacts != null && !toscaArtifacts.isEmpty()) { toscaArtifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); } newComponent.setToscaArtifacts(toscaArtifacts); Map artifacts = oldComponent.getArtifacts(); if (artifacts != null && !artifacts.isEmpty()) { artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); } newComponent.setArtifacts(artifacts); Map depArtifacts = oldComponent.getDeploymentArtifacts(); if (depArtifacts != null && !depArtifacts.isEmpty()) { depArtifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); } newComponent.setDeploymentArtifacts(depArtifacts); newComponent.setLastUpdateDate(null); newComponent.setHighestVersion(true); } public Either updateToscaElement(T componentToUpdate) { return updateToscaElement(componentToUpdate, new ComponentParametersView()); } public Either updateToscaElement(T componentToUpdate, ComponentParametersView filterResult) { String componentId = componentToUpdate.getUniqueId(); Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.ParseAll); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex elementV = getVertexEither.left().value(); ToscaElementOperation toscaElementOperation = getToscaElementOperation(elementV); ToscaElement toscaElementToUpdate = ModelConverter.convertToToscaElement(componentToUpdate); Either updateToscaElement = null; if (toscaElementOperation != null) { updateToscaElement = toscaElementOperation.updateToscaElement(toscaElementToUpdate, elementV, filterResult); } else { log.debug("Null value returned by `getToscaElementOperation` with value {}", elementV); updateToscaElement = Either.right(StorageOperationStatus.GENERAL_ERROR); } return updateToscaElement.bimap( ModelConverter::convertFromToscaElement, status -> { log.debug("Failed to update tosca element {} error {}", componentId, status); return status; }); } private Either getLatestByName(GraphPropertyEnum property, String nodeName, JsonParseFlagEnum parseFlag) { return getLatestByName(property, nodeName, parseFlag, new ComponentParametersView()); } private Either getLatestByName(GraphPropertyEnum property, String nodeName, JsonParseFlagEnum parseFlag, ComponentParametersView filter) { Either result; Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesToMatch.put(property, nodeName); propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); Either, JanusGraphOperationStatus> highestResources = janusGraphDao .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, parseFlag); if (highestResources.isRight()) { JanusGraphOperationStatus status = highestResources.right().value(); log.debug("failed to find resource with name {}. status={} ", nodeName, status); result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } List resources = highestResources.left().value(); double version = 0.0; GraphVertex highestResource = null; for (GraphVertex vertex : resources) { Object versionObj = vertex.getMetadataProperty(GraphPropertyEnum.VERSION); double resourceVersion = Double.parseDouble((String) versionObj); if (resourceVersion > version) { version = resourceVersion; highestResource = vertex; } } return getToscaElementByOperation(highestResource, filter); } // endregion // region - Component Get By .. private Either getLatestByName(GraphPropertyEnum property, String nodeName) { return getLatestByName(property, nodeName, JsonParseFlagEnum.ParseMetadata); } public Either, StorageOperationStatus> getBySystemName(ComponentTypeEnum componentType, String systemName) { Either, StorageOperationStatus> result = null; Either getComponentRes; List components = new ArrayList<>(); List componentVertices; Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, systemName); if (componentType != null) propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); Either, JanusGraphOperationStatus> getComponentsRes = janusGraphDao .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); if (getComponentsRes.isRight()) { JanusGraphOperationStatus status = getComponentsRes.right().value(); log.debug("Failed to fetch the component with system name {}. Status is {} ", systemName, status); result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } if (result == null) { componentVertices = getComponentsRes.left().value(); for (GraphVertex componentVertex : componentVertices) { getComponentRes = getToscaElementByOperation(componentVertex); if (getComponentRes.isRight()) { log.debug("Failed to get the component {}. Status is {} ", componentVertex.getJsonMetadataField(JsonPresentationFields.NAME), getComponentRes.right().value()); result = Either.right(getComponentRes.right().value()); break; } T componentBySystemName = getComponentRes.left().value(); log.debug("Found component, id: {}", componentBySystemName.getUniqueId()); components.add(componentBySystemName); } } if (result == null) { result = Either.left(components); } return result; } public Either getComponentByNameAndVersion(ComponentTypeEnum componentType, String name, String version) { return getComponentByNameAndVersion(componentType, name, version, JsonParseFlagEnum.ParseAll); } public Either getComponentByNameAndVersion(ComponentTypeEnum componentType, String name, String version, JsonParseFlagEnum parseFlag) { Either result; Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); hasProperties.put(GraphPropertyEnum.NAME, name); hasProperties.put(GraphPropertyEnum.VERSION, version); hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); if (componentType != null) { hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); } Either, JanusGraphOperationStatus> getResourceRes = janusGraphDao .getByCriteria(null, hasProperties, hasNotProperties, parseFlag); if (getResourceRes.isRight()) { JanusGraphOperationStatus status = getResourceRes.right().value(); log.debug("failed to find resource with name {}, version {}. Status is {} ", name, version, status); result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } return getToscaElementByOperation(getResourceRes.left().value().get(0)); } public Either, StorageOperationStatus> getCatalogOrArchiveComponents(boolean isCatalog, List excludeTypes) { List excludedResourceTypes = Optional.ofNullable(excludeTypes).orElse(Collections.emptyList()).stream().filter(type -> !type.equals(OriginTypeEnum.SERVICE)).map(type -> ResourceTypeEnum.getTypeByName(type.name())) .collect(Collectors.toList()); return topologyTemplateOperation.getElementCatalogData(isCatalog, excludedResourceTypes); } // endregion public Either, StorageOperationStatus> getCatalogComponents(ComponentTypeEnum componentType, List excludeTypes, boolean isHighestVersions) { List components = new ArrayList<>(); Either, StorageOperationStatus> catalogDataResult; List toscaElements = new ArrayList<>(); List excludedResourceTypes = Optional.ofNullable(excludeTypes).orElse(Collections.emptyList()).stream().filter(type -> !type.equals(OriginTypeEnum.SERVICE)).map(type -> ResourceTypeEnum.getTypeByName(type.name())) .collect(Collectors.toList()); switch (componentType) { case RESOURCE: catalogDataResult = nodeTypeOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, excludedResourceTypes, isHighestVersions); if (catalogDataResult.isRight()) { return Either.right(catalogDataResult.right().value()); } toscaElements = catalogDataResult.left().value(); break; case SERVICE: if (excludeTypes != null && excludeTypes.contains(OriginTypeEnum.SERVICE)) { break; } catalogDataResult = topologyTemplateOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, isHighestVersions); if (catalogDataResult.isRight()) { return Either.right(catalogDataResult.right().value()); } toscaElements = catalogDataResult.left().value(); break; default: log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); return Either.right(StorageOperationStatus.BAD_REQUEST); } toscaElements.forEach(te -> { T component = ModelConverter.convertFromToscaElement(te); components.add(component); }); return Either.left(components); } public Either, StorageOperationStatus> deleteMarkedElements(ComponentTypeEnum componentType) { Either, StorageOperationStatus> allComponentsMarkedForDeletion; switch (componentType) { case RESOURCE: allComponentsMarkedForDeletion = nodeTypeOperation.getAllComponentsMarkedForDeletion(componentType); break; case SERVICE: case PRODUCT: allComponentsMarkedForDeletion = topologyTemplateOperation.getAllComponentsMarkedForDeletion(componentType); break; default: log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); return Either.right(StorageOperationStatus.BAD_REQUEST); } if (allComponentsMarkedForDeletion.isRight()) { return Either.right(allComponentsMarkedForDeletion.right().value()); } List allMarked = allComponentsMarkedForDeletion.left().value(); return Either.left(checkIfInUseAndDelete(allMarked)); } private List checkIfInUseAndDelete(List allMarked) { final List forbiddenEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); List deleted = new ArrayList<>(); for (GraphVertex elementV : allMarked) { boolean isAllowedToDelete = true; for (EdgeLabelEnum edgeLabelEnum : forbiddenEdgeLabelEnums) { Either belongingEdgeByCriteria = janusGraphDao .getBelongingEdgeByCriteria(elementV, edgeLabelEnum, null); if (belongingEdgeByCriteria.isLeft()) { log.debug("Marked element {} in use. don't delete it", elementV.getUniqueId()); isAllowedToDelete = false; break; } } if (isAllowedToDelete) { Either deleteToscaElement = deleteToscaElement(elementV); if (deleteToscaElement.isRight()) { log.debug("Failed to delete marked element UniqueID {}, Name {}, error {}", elementV.getUniqueId(), elementV.getMetadataProperties().get(GraphPropertyEnum.NAME), deleteToscaElement.right().value()); continue; } deleted.add(elementV.getUniqueId()); } } return deleted; } public Either, StorageOperationStatus> getAllComponentsMarkedForDeletion(ComponentTypeEnum componentType) { Either, StorageOperationStatus> allComponentsMarkedForDeletion; switch (componentType) { case RESOURCE: allComponentsMarkedForDeletion = nodeTypeOperation.getAllComponentsMarkedForDeletion(componentType); break; case SERVICE: case PRODUCT: allComponentsMarkedForDeletion = topologyTemplateOperation.getAllComponentsMarkedForDeletion(componentType); break; default: log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); return Either.right(StorageOperationStatus.BAD_REQUEST); } if (allComponentsMarkedForDeletion.isRight()) { return Either.right(allComponentsMarkedForDeletion.right().value()); } return Either.left(allComponentsMarkedForDeletion.left().value().stream().map(GraphVertex::getUniqueId).collect(Collectors.toList())); } // region - Component Update public Either, StorageOperationStatus> addComponentInstanceToTopologyTemplate(Component containerComponent, Component origComponent, ComponentInstance componentInstance, boolean allowDeleted, User user) { Either, StorageOperationStatus> result = null; Either updateContainerComponentRes = null; if (StringUtils.isEmpty(componentInstance.getIcon())) { componentInstance.setIcon(origComponent.getIcon()); } String nameToFindForCounter = componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy ? ValidationUtils.normaliseComponentName(componentInstance.getSourceModelName()) + PROXY_SUFFIX : origComponent.getName(); String nextComponentInstanceCounter = getNextComponentInstanceCounter(containerComponent, nameToFindForCounter); Either, StorageOperationStatus> addResult = nodeTemplateOperation.addComponentInstanceToTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), ModelConverter.convertToToscaElement(origComponent), nextComponentInstanceCounter, componentInstance, allowDeleted, user); if (addResult.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the component instance {} to container component {}. ", componentInstance.getName(), containerComponent.getName()); result = Either.right(addResult.right().value()); } if (result == null) { updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponent.getUniqueId()); if (updateContainerComponentRes.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with updated component instance {}. ", containerComponent.getName(), componentInstance.getName()); result = Either.right(updateContainerComponentRes.right().value()); } } if (result == null) { Component updatedComponent = ModelConverter.convertFromToscaElement(updateContainerComponentRes.left().value()); String createdInstanceId = addResult.left().value().getRight(); CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The component instance {} has been added to container component {}. ", createdInstanceId, updatedComponent.getName()); result = Either.left(new ImmutablePair<>(updatedComponent, createdInstanceId)); } return result; } public void associateComponentInstancesToComponent(Component containerComponent, Map resourcesInstancesMap, boolean allowDeleted, boolean isUpdateCsar) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Going to add component instances to component {}", containerComponent.getUniqueId()); Either metadataVertex = janusGraphDao .getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.ParseAll); if (metadataVertex.isRight()) { JanusGraphOperationStatus status = metadataVertex.right().value(); if (status == JanusGraphOperationStatus.NOT_FOUND) { status = JanusGraphOperationStatus.INVALID_ID; } throw new StorageException(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } Map compnentInstancesMap = nodeTemplateOperation.associateComponentInstancesToComponent(containerComponent, resourcesInstancesMap, metadataVertex.left().value(), allowDeleted, isUpdateCsar); containerComponent.setComponentInstances(ModelConverter.getComponentInstancesFromMapObject(compnentInstancesMap, containerComponent)); } public Either, StorageOperationStatus> updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent, Component origComponent, ComponentInstance componentInstance) { Either, StorageOperationStatus> result = null; CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update the metadata of the component instance {} belonging to container component {}. ", componentInstance.getName(), containerComponent.getName()); componentInstance.setIcon(origComponent.getIcon()); Either, StorageOperationStatus> updateResult = nodeTemplateOperation.updateComponentInstanceMetadataOfTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), ModelConverter.convertToToscaElement(origComponent), componentInstance); if (updateResult.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the metadata of the component instance {} belonging to container component {}. ", componentInstance.getName(), containerComponent.getName()); result = Either.right(updateResult.right().value()); } if (result == null) { Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value().getLeft()); String createdInstanceId = updateResult.left().value().getRight(); CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The metadata of the component instance {} has been updated to container component {}. ", createdInstanceId, updatedComponent.getName()); result = Either.left(new ImmutablePair<>(updatedComponent, createdInstanceId)); } return result; } public Either updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent) { return updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, new ComponentParametersView()); } public Either updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent, ComponentParametersView filter) { Either result = null; CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update the metadata belonging to container component {}. ", containerComponent.getName()); Either updateResult = nodeTemplateOperation.updateComponentInstanceMetadataOfTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), filter); if (updateResult.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the metadata belonging to container component {}. ", containerComponent.getName()); result = Either.right(updateResult.right().value()); } if (result == null) { Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value()); CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The metadata has been updated to container component {}. ", updatedComponent.getName()); result = Either.left(updatedComponent); } return result; } // endregion public Either, StorageOperationStatus> deleteComponentInstanceFromTopologyTemplate(Component containerComponent, String resourceInstanceId) { Either, StorageOperationStatus> result = null; CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to delete the component instance {} belonging to container component {}. ", resourceInstanceId, containerComponent.getName()); Either, StorageOperationStatus> updateResult = nodeTemplateOperation.deleteComponentInstanceFromTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), resourceInstanceId); if (updateResult.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete the component instance {} belonging to container component {}. ", resourceInstanceId, containerComponent.getName()); result = Either.right(updateResult.right().value()); } if (result == null) { Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value().getLeft()); String deletedInstanceId = updateResult.left().value().getRight(); CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The component instance {} has been deleted from container component {}. ", deletedInstanceId, updatedComponent.getName()); result = Either.left(new ImmutablePair<>(updatedComponent, deletedInstanceId)); } return result; } private String getNextComponentInstanceCounter(Component containerComponent, String originResourceName) { Integer nextCounter = 0; if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstances())) { String normalizedName = ValidationUtils.normalizeComponentInstanceName(originResourceName); Integer maxCounter = getMaxCounterFromNamesAndIds(containerComponent, normalizedName); if (maxCounter != null) { nextCounter = maxCounter + 1; } } return nextCounter.toString(); } /** * @return max counter of component instance Id's, null if not found */ private Integer getMaxCounterFromNamesAndIds(Component containerComponent, String normalizedName) { List countersInNames = containerComponent.getComponentInstances().stream() .filter(ci -> ci.getNormalizedName() != null && ci.getNormalizedName().startsWith(normalizedName)) .map(ci -> ci.getNormalizedName().split(normalizedName)[1]) .collect(Collectors.toList()); List countersInIds = containerComponent.getComponentInstances().stream() .filter(ci -> ci.getUniqueId() != null && ci.getUniqueId().contains(normalizedName)) .map(ci -> ci.getUniqueId().split(normalizedName)[1]) .collect(Collectors.toList()); List namesAndIdsList = new ArrayList<>(countersInNames); namesAndIdsList.addAll(countersInIds); return getMaxInteger(namesAndIdsList); } private Integer getMaxInteger(List counters) { Integer maxCounter = 0; Integer currCounter = null; for (String counter : counters) { try { currCounter = Integer.parseInt(counter); if (maxCounter < currCounter) { maxCounter = currCounter; } } catch (NumberFormatException e) { continue; } } return currCounter == null ? null : maxCounter; } public Either associateResourceInstances(Component component, String componentId, RequirementCapabilityRelDef requirementDef) { return nodeTemplateOperation.associateResourceInstances(component, componentId, requirementDef); } public Either, StorageOperationStatus> createAndAssociateInputs(Map inputs, String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex vertex = getVertexEither.left().value(); Map inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDataDefinition(e.getValue()))); StorageOperationStatus status = topologyTemplateOperation.associateInputsToComponent(vertex, inputsMap, componentId); if (StorageOperationStatus.OK == status) { log.debug(COMPONENT_CREATED_SUCCESSFULLY); List inputsResList = null; if (inputsMap != null && !inputsMap.isEmpty()) { inputsResList = inputsMap.values().stream() .map(InputDefinition::new) .collect(Collectors.toList()); } return Either.left(inputsResList); } return Either.right(status); } public Either, StorageOperationStatus> addInputsToComponent(Map inputs, String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex vertex = getVertexEither.left().value(); Map inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDefinition(e.getValue()))); StorageOperationStatus status = topologyTemplateOperation.addToscaDataToToscaElement(vertex, EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputsMap, JsonPresentationFields.NAME); if (StorageOperationStatus.OK == status) { log.debug(COMPONENT_CREATED_SUCCESSFULLY); List inputsResList = null; if (inputsMap != null && !inputsMap.isEmpty()) { inputsResList = inputsMap.values().stream().map(InputDefinition::new).collect(Collectors.toList()); } return Either.left(inputsResList); } return Either.right(status); } /** * Add data types into a Component. * * @param dataTypes datatypes to be added. the key should be each name of data type. * @param componentId unique ID of Component. * @return list of data types. */ public Either, StorageOperationStatus> addDataTypesToComponent(Map dataTypes, String componentId) { log.trace("#addDataTypesToComponent - enter, componentId={}", componentId); /* get component vertex */ Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { /* not found / error */ log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex vertex = getVertexEither.left().value(); log.trace("#addDataTypesToComponent - get vertex ok"); // convert DataTypeDefinition to DataTypeDataDefinition Map dataTypeDataMap = dataTypes.entrySet().stream() .collect(Collectors.toMap(Map.Entry::getKey, e -> convertDataTypeToDataTypeData(e.getValue()))); // add datatype(s) to the Component. // if child vertex does not exist, it will be created. StorageOperationStatus status = topologyTemplateOperation.addToscaDataToToscaElement(vertex, EdgeLabelEnum.DATA_TYPES, VertexTypeEnum.DATA_TYPES, dataTypeDataMap, JsonPresentationFields.NAME); if (StorageOperationStatus.OK == status) { log.debug(COMPONENT_CREATED_SUCCESSFULLY); List inputsResList = null; if (!dataTypes.isEmpty()) { inputsResList = new ArrayList<>(dataTypes.values()); } return Either.left(inputsResList); } log.trace("#addDataTypesToComponent - leave"); return Either.right(status); } private DataTypeDataDefinition convertDataTypeToDataTypeData(DataTypeDefinition dataType) { DataTypeDataDefinition dataTypeData = new DataTypeDataDefinition(dataType); if (CollectionUtils.isNotEmpty(dataType.getProperties())) { List propertyDataList = dataType.getProperties().stream() .map(PropertyDataDefinition::new).collect(Collectors.toList()); dataTypeData.setPropertiesData(propertyDataList); } // if "derivedFrom" data_type exists, copy the name to "derivedFromName" if (dataType.getDerivedFrom() != null && StringUtils.isNotEmpty(dataType.getDerivedFrom().getName())) { // if names are different, log it if (!StringUtils.equals(dataTypeData.getDerivedFromName(), dataType.getDerivedFrom().getName())) { log.debug("#convertDataTypeToDataTypeData - derivedFromName(={}) overwritten by derivedFrom.name(={})", dataType.getDerivedFromName(), dataType.getDerivedFrom().getName()); } dataTypeData.setDerivedFromName(dataType.getDerivedFrom().getName()); } // supply "name" field to toscaPresentationValue in each datatype object for DAO operations dataTypeData.setToscaPresentationValue(JsonPresentationFields.NAME, dataType.getName()); return dataTypeData; } public Either, StorageOperationStatus> getComponentInputs(String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug("Couldn't fetch component with and unique id {}, error: {}", componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } Either toscaElement = topologyTemplateOperation.getToscaElement(componentId); if(toscaElement.isRight()) { return Either.right(toscaElement.right().value()); } TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement.left().value(); Map inputsMap = topologyTemplate.getInputs(); List inputs = new ArrayList<>(); if(MapUtils.isNotEmpty(inputsMap)) { inputs = inputsMap.values().stream().map(p -> new InputDefinition(p)).collect(Collectors.toList()); } return Either.left(inputs); } public Either, StorageOperationStatus> updateInputsToComponent(List inputs, String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex vertex = getVertexEither.left().value(); List inputsAsDataDef = inputs.stream().map(PropertyDataDefinition::new).collect(Collectors.toList()); StorageOperationStatus status = topologyTemplateOperation.updateToscaDataOfToscaElement(vertex, EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputsAsDataDef, JsonPresentationFields.NAME); if (StorageOperationStatus.OK == status) { log.debug(COMPONENT_CREATED_SUCCESSFULLY); List inputsResList = null; if (inputsAsDataDef != null && !inputsAsDataDef.isEmpty()) { inputsResList = inputsAsDataDef.stream().map(InputDefinition::new).collect(Collectors.toList()); } return Either.left(inputsResList); } return Either.right(status); } // region - ComponentInstance public Either>, StorageOperationStatus> associateComponentInstancePropertiesToComponent(Map> instProperties, String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex vertex = getVertexEither.left().value(); Map instPropsMap = new HashMap<>(); if (instProperties != null) { MapPropertiesDataDefinition propertiesMap; for (Entry> entry : instProperties.entrySet()) { propertiesMap = new MapPropertiesDataDefinition(); propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); instPropsMap.put(entry.getKey(), propertiesMap); } } StorageOperationStatus status = topologyTemplateOperation.associateInstPropertiesToComponent(vertex, instPropsMap); if (StorageOperationStatus.OK == status) { log.debug(COMPONENT_CREATED_SUCCESSFULLY); return Either.left(instProperties); } return Either.right(status); } /** * saves the instInputs as the updated instance inputs of the component container in DB */ public Either>, StorageOperationStatus> updateComponentInstanceInputsToComponent(Map> instInputs, String componentId) { if (instInputs == null || instInputs.isEmpty()) { return Either.left(instInputs); } StorageOperationStatus status; for (Entry> inputsPerIntance : instInputs.entrySet()) { List toscaDataListPerInst = inputsPerIntance.getValue(); List pathKeysPerInst = new ArrayList<>(); pathKeysPerInst.add(inputsPerIntance.getKey()); status = topologyTemplateOperation.updateToscaDataDeepElementsOfToscaElement(componentId, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.NAME); if (status != StorageOperationStatus.OK) { log.debug("Failed to update component instance inputs for instance {} in component {} edge type {} error {}", inputsPerIntance.getKey(), componentId, EdgeLabelEnum.INST_INPUTS, status); return Either.right(status); } } return Either.left(instInputs); } /** * saves the instProps as the updated instance properties of the component container in DB */ public Either>, StorageOperationStatus> updateComponentInstancePropsToComponent(Map> instProps, String componentId) { if (instProps == null || instProps.isEmpty()) { return Either.left(instProps); } StorageOperationStatus status; for (Entry> propsPerIntance : instProps.entrySet()) { List toscaDataListPerInst = propsPerIntance.getValue(); List pathKeysPerInst = new ArrayList<>(); pathKeysPerInst.add(propsPerIntance.getKey()); status = topologyTemplateOperation.updateToscaDataDeepElementsOfToscaElement(componentId, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.NAME); if (status != StorageOperationStatus.OK) { log.debug("Failed to update component instance inputs for instance {} in component {} edge type {} error {}", propsPerIntance.getKey(), componentId, EdgeLabelEnum.INST_PROPERTIES, status); return Either.right(status); } } return Either.left(instProps); } public Either>, StorageOperationStatus> associateComponentInstanceInputsToComponent(Map> instInputs, String componentId) { Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex vertex = getVertexEither.left().value(); Map instPropsMap = new HashMap<>(); if (instInputs != null) { MapPropertiesDataDefinition propertiesMap; for (Entry> entry : instInputs.entrySet()) { propertiesMap = new MapPropertiesDataDefinition(); propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); instPropsMap.put(entry.getKey(), propertiesMap); } } StorageOperationStatus status = topologyTemplateOperation.associateInstInputsToComponent(vertex, instPropsMap); if (StorageOperationStatus.OK == status) { log.debug(COMPONENT_CREATED_SUCCESSFULLY); return Either.left(instInputs); } return Either.right(status); } public Either>, StorageOperationStatus> addComponentInstanceInputsToComponent(Component containerComponent, Map> instProperties) { requireNonNull(instProperties); StorageOperationStatus status; for (Entry> entry : instProperties.entrySet()) { List props = entry.getValue(); String componentInstanceId = entry.getKey(); if (!isEmpty(props)) { for (ComponentInstanceInput property : props) { List componentInstancesInputs = containerComponent.getComponentInstancesInputs().get(componentInstanceId); Optional instanceProperty = componentInstancesInputs.stream() .filter(p -> p.getName().equals(property.getName())) .findAny(); if (instanceProperty.isPresent()) { status = updateComponentInstanceInput(containerComponent, componentInstanceId, property); } else { status = addComponentInstanceInput(containerComponent, componentInstanceId, property); } if (status != StorageOperationStatus.OK) { log.debug("Failed to update instance input {} for instance {} error {} ", property, componentInstanceId, status); return Either.right(status); } else { log.trace("instance input {} for instance {} updated", property, componentInstanceId); } } } } return Either.left(instProperties); } public Either>, StorageOperationStatus> addComponentInstancePropertiesToComponent(Component containerComponent, Map> instProperties) { requireNonNull(instProperties); for (Entry> entry : instProperties.entrySet()) { List props = entry.getValue(); String componentInstanceId = entry.getKey(); List originalComponentInstProps = containerComponent.getComponentInstancesProperties().get(componentInstanceId); Map> containerComponentCapabilities = containerComponent.getCapabilities(); if(isEmpty(props)) { continue; } for (ComponentInstanceProperty property : props) { StorageOperationStatus status = null; String propertyParentUniqueId = property.getParentUniqueId(); Optional capPropDefinition = getPropertyCapability(propertyParentUniqueId, containerComponent); if(capPropDefinition.isPresent() && MapUtils.isNotEmpty(containerComponentCapabilities)) { status = populateAndUpdateInstanceCapProperty(containerComponent, componentInstanceId, containerComponentCapabilities, property, capPropDefinition.get()); } if(status == null) { status = updateOrAddComponentInstanceProperty(containerComponent, componentInstanceId, originalComponentInstProps, property); } if(status != StorageOperationStatus.OK) { return Either.right(status); } } } return Either.left(instProperties); } private StorageOperationStatus populateAndUpdateInstanceCapProperty(Component containerComponent, String componentInstanceId, Map> containerComponentCapabilities, ComponentInstanceProperty property, CapabilityDefinition capabilityDefinition) { List capabilityDefinitions = containerComponentCapabilities.get(capabilityDefinition.getType()); if(CollectionUtils.isEmpty(capabilityDefinitions)) { return null; } Optional capDefToGetProp = capabilityDefinitions.stream() .filter(cap -> cap.getUniqueId().equals(capabilityDefinition.getUniqueId()) && cap.getPath().size() == 1).findAny(); if(capDefToGetProp.isPresent()) { return updateInstanceCapabilityProperty(containerComponent, componentInstanceId, property, capDefToGetProp.get()); } return null; } private static Optional getPropertyCapability(String propertyParentUniqueId, Component containerComponent) { Map> componentCapabilities = containerComponent.getCapabilities(); if(MapUtils.isEmpty(componentCapabilities)){ return Optional.empty(); } List capabilityDefinitionList = componentCapabilities.values() .stream().flatMap(Collection::stream).collect(Collectors.toList()); if(CollectionUtils.isEmpty(capabilityDefinitionList)){ return Optional.empty(); } return capabilityDefinitionList.stream() .filter(capabilityDefinition -> capabilityDefinition.getUniqueId().equals(propertyParentUniqueId)) .findAny(); } private StorageOperationStatus updateOrAddComponentInstanceProperty(Component containerComponent, String componentInstanceId, List originalComponentInstProps, ComponentInstanceProperty property) { StorageOperationStatus status; // check if the property already exists or not Optional instanceProperty = originalComponentInstProps.stream() .filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny(); if (instanceProperty.isPresent()) { status = updateComponentInstanceProperty(containerComponent, componentInstanceId, property); } else { status = addComponentInstanceProperty(containerComponent, componentInstanceId, property); } if (status != StorageOperationStatus.OK) { log.debug("Failed to update instance property {} for instance {} error {} ", property, componentInstanceId, status); } return status; } public StorageOperationStatus updateInstanceCapabilityProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property, CapabilityDefinition capabilityDefinition) { Optional fetchedCIOptional = containerComponent.getComponentInstanceById(componentInstanceId); if(!fetchedCIOptional.isPresent()) { return StorageOperationStatus.GENERAL_ERROR; } Either getComponentRes = getToscaFullElement(fetchedCIOptional.get().getComponentUid()); if(getComponentRes.isRight()) { return StorageOperationStatus.GENERAL_ERROR; } Optional componentOptional = isNodeServiceProxy(getComponentRes.left().value()); String propOwner; if(!componentOptional.isPresent()) { propOwner = componentInstanceId; } else { propOwner = fetchedCIOptional.get().getSourceModelUid(); } StorageOperationStatus status; StringBuilder sb = new StringBuilder(componentInstanceId); sb.append(ModelConverter.CAP_PROP_DELIM).append(propOwner).append(ModelConverter.CAP_PROP_DELIM) .append(capabilityDefinition.getType()).append(ModelConverter.CAP_PROP_DELIM).append(capabilityDefinition.getName()); String capKey = sb.toString(); status = updateComponentInstanceCapabiltyProperty(containerComponent, componentInstanceId, capKey, property); if (status != StorageOperationStatus.OK) { log.debug("Failed to update instance capability property {} for instance {} error {} ", property, componentInstanceId, status); return status; } return StorageOperationStatus.OK; } private Optional isNodeServiceProxy(Component component) { if (component.getComponentType().equals(ComponentTypeEnum.SERVICE)) { return Optional.empty(); } Resource resource = (Resource) component; ResourceTypeEnum resType = resource.getResourceType(); if(resType.equals(ResourceTypeEnum.ServiceProxy)) { return Optional.of(component); } return Optional.empty(); } public StorageOperationStatus associateDeploymentArtifactsToInstances(Map> instDeploymentArtifacts, Component component, User user) { Either getVertexEither = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, component.getUniqueId(), getVertexEither.right().value()); return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); } GraphVertex vertex = getVertexEither.left().value(); Map instArtMap = new HashMap<>(); if (instDeploymentArtifacts != null) { MapArtifactDataDefinition artifactsMap; for (Entry> entry : instDeploymentArtifacts.entrySet()) { Map artList = entry.getValue(); Map artifacts = artList.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); artifactsMap = nodeTemplateOperation.prepareInstDeploymentArtifactPerInstance(artifacts, entry.getKey(), user, NodeTemplateOperation.HEAT_VF_ENV_NAME); instArtMap.put(entry.getKey(), artifactsMap); } } ModelConverter.setComponentInstancesDeploymentArtifactsToComponent(instArtMap, component); return topologyTemplateOperation.associateInstDeploymentArtifactsToComponent(vertex, instArtMap); } public StorageOperationStatus associateArtifactsToInstances(Map> instArtifacts, Component component) { Either getVertexEither = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, component.getUniqueId(), getVertexEither.right().value()); return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); } GraphVertex vertex = getVertexEither.left().value(); Map instArtMap = new HashMap<>(); if (instArtifacts != null) { MapArtifactDataDefinition artifactsMap; for (Entry> entry : instArtifacts.entrySet()) { Map artList = entry.getValue(); Map artifacts = artList.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); artifactsMap = new MapArtifactDataDefinition(artifacts); instArtMap.put(entry.getKey(), artifactsMap); } } ModelConverter.setComponentInstancesInformationalArtifactsToComponent(instArtMap, component); return topologyTemplateOperation.associateInstArtifactsToComponent(vertex, instArtMap); } public StorageOperationStatus associateInstAttributeToComponentToInstances(Map> instArttributes, Component component) { Either getVertexEither = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, component.getUniqueId(), getVertexEither.right().value()); return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); } GraphVertex vertex = getVertexEither.left().value(); Map instAttr = new HashMap<>(); if (instArttributes != null) { MapPropertiesDataDefinition attributesMap; for (Entry> entry : instArttributes.entrySet()) { attributesMap = new MapPropertiesDataDefinition(); attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); instAttr.put(entry.getKey(), attributesMap); } } setComponentInstanceAttributesOnComponent(component, instAttr); return topologyTemplateOperation.associateInstAttributeToComponent(vertex, instAttr); } // endregion private void setComponentInstanceAttributesOnComponent(Component resource, Map instAttr) { Map> componentInstancesAttributes = resource.getComponentInstancesAttributes(); if (componentInstancesAttributes == null) componentInstancesAttributes = new HashMap<>(); componentInstancesAttributes.putAll(ModelConverter.getComponentInstancesAttributes(instAttr)); resource.setComponentInstancesAttributes(componentInstancesAttributes); } public StorageOperationStatus associateOrAddCalculatedCapReq(Map>> instCapabilties, Map>> instReg, Component component) { Either getVertexEither = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, component.getUniqueId(), getVertexEither.right().value()); return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); } GraphVertex vertex = getVertexEither.left().value(); Map calcRequirements = new HashMap<>(); Map calcCapabilty = new HashMap<>(); Map calculatedCapabilitiesProperties = new HashMap<>(); if (instCapabilties != null) { for (Entry>> entry : instCapabilties.entrySet()) { Map> caps = entry.getValue(); Map mapToscaDataDefinition = new HashMap<>(); for (Entry> instCapability : caps.entrySet()) { mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))); } ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(entry.getKey()); MapListCapabilityDataDefinition capMap = nodeTemplateOperation.prepareCalculatedCapabiltyForNodeType(mapToscaDataDefinition, componentInstance); MapCapabilityProperty mapCapabilityProperty = ModelConverter.convertToMapOfMapCapabiltyProperties(caps, componentInstance.getUniqueId(), true); calcCapabilty.put(entry.getKey().getUniqueId(), capMap); calculatedCapabilitiesProperties.put(entry.getKey().getUniqueId(), mapCapabilityProperty); } } if (instReg != null) { for (Entry>> entry : instReg.entrySet()) { Map> req = entry.getValue(); Map mapToscaDataDefinition = new HashMap<>(); for (Entry> instReq : req.entrySet()) { mapToscaDataDefinition.put(instReq.getKey(), new ListRequirementDataDefinition(instReq.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList()))); } MapListRequirementDataDefinition reqMap = nodeTemplateOperation.prepareCalculatedRequirementForNodeType(mapToscaDataDefinition, new ComponentInstanceDataDefinition(entry.getKey())); String componentInstanceId = entry.getKey().getUniqueId(); calcRequirements.put(componentInstanceId, reqMap); } } StorageOperationStatus storageOperationStatus = topologyTemplateOperation.associateOrAddCalcCapReqToComponent(vertex, calcRequirements, calcCapabilty, calculatedCapabilitiesProperties); updateInstancesCapAndReqOnComponentFromDB(component); return storageOperationStatus; } private void updateInstancesCapAndReqOnComponentFromDB(Component component) { ComponentParametersView componentParametersView = new ComponentParametersView(true); componentParametersView.setIgnoreCapabilities(false); componentParametersView.setIgnoreRequirements(false); componentParametersView.setIgnoreCapabiltyProperties(false); componentParametersView.setIgnoreComponentInstances(false); Either componentEither = getToscaElement(component.getUniqueId(), componentParametersView); if (componentEither.isRight()) { throw new StorageException(StorageOperationStatus.NOT_FOUND); } Component updatedComponent = componentEither.left().value(); component.setCapabilities(updatedComponent.getCapabilities()); component.setRequirements(updatedComponent.getRequirements()); component.setComponentInstances(updatedComponent.getComponentInstances()); } private Either, StorageOperationStatus> getLatestVersionNonCheckoutServicesMetadataOnly(Map hasProps, Map hasNotProps) { List services = new ArrayList<>(); List states = new ArrayList<>(); // include props hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); hasProps.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); // exclude props states.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); hasNotProps.put(GraphPropertyEnum.STATE, states); hasNotProps.put(GraphPropertyEnum.IS_DELETED, true); hasNotProps.put(GraphPropertyEnum.IS_ARCHIVED, true); return fetchServicesByCriteria(services, hasProps, hasNotProps); } private Either, StorageOperationStatus> getLatestVersionNotAbstractToscaElementsMetadataOnly(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType, VertexTypeEnum vertexType) { List services = null; Map hasProps = new EnumMap<>(GraphPropertyEnum.class); Map hasNotProps = new EnumMap<>(GraphPropertyEnum.class); fillPropsMap(hasProps, hasNotProps, internalComponentType, componentTypeEnum, isAbstract, vertexType); Either, JanusGraphOperationStatus> getRes = janusGraphDao .getByCriteria(vertexType, hasProps, hasNotProps, JsonParseFlagEnum.ParseMetadata); if (getRes.isRight()) { if (getRes.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) { return Either.left(new ArrayList<>()); } else { return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); } } // region -> Fetch non checked-out services if (internalComponentType != null && internalComponentType.toLowerCase().trim().equals(SERVICE) && VertexTypeEnum.NODE_TYPE == vertexType) { Either, StorageOperationStatus> result = getLatestVersionNonCheckoutServicesMetadataOnly(new EnumMap<>(GraphPropertyEnum.class), new EnumMap<>(GraphPropertyEnum.class)); if (result.isRight()) { log.debug("Failed to fetch services for"); return Either.right(result.right().value()); } services = result.left().value(); if (log.isTraceEnabled() && isEmpty(services)) log.trace("No relevant services available"); } // endregion List nonAbstractLatestComponents = new ArrayList<>(); ComponentParametersView params = new ComponentParametersView(true); params.setIgnoreAllVersions(false); for (GraphVertex vertexComponent : getRes.left().value()) { Either componentRes = topologyTemplateOperation.getLightComponent(vertexComponent, componentTypeEnum, params); if (componentRes.isRight()) { log.debug("Failed to fetch light element for {} error {}", vertexComponent.getUniqueId(), componentRes.right().value()); return Either.right(componentRes.right().value()); } else { Component component = ModelConverter.convertFromToscaElement(componentRes.left().value()); nonAbstractLatestComponents.add(component); } } if (CollectionUtils.isNotEmpty(services)) { nonAbstractLatestComponents.addAll(services); } return Either.left(nonAbstractLatestComponents); } public Either getLatestComponentMetadataByUuid(String componentUuid, JsonParseFlagEnum parseFlag, Boolean isHighest) { Either result; Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); hasProperties.put(GraphPropertyEnum.UUID, componentUuid); if (isHighest != null) { hasProperties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, isHighest); } Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); propertiesNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 Either, JanusGraphOperationStatus> getRes = janusGraphDao .getByCriteria(null, hasProperties, propertiesNotToMatch, parseFlag); if (getRes.isRight()) { result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); } else { List latestVersionList = getRes.left().value().stream().map(ModelConverter::convertToComponentMetadata).collect(Collectors.toList()); ComponentMetadataData latestVersion = latestVersionList.size() == 1 ? latestVersionList.get(0) : latestVersionList.stream().max((c1, c2) -> Double.compare(Double.parseDouble(c1.getMetadataDataDefinition().getVersion()), Double.parseDouble(c2.getMetadataDataDefinition().getVersion()))).get(); result = Either.left(latestVersion); } return result; } public Either getComponentMetadata(String componentId) { Either result; Either getRes = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); if (getRes.isRight()) { result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); } else { ComponentMetadataData componentMetadata = ModelConverter.convertToComponentMetadata(getRes.left().value()); result = Either.left(componentMetadata); } return result; } public Either, StorageOperationStatus> getLatestVersionNotAbstractComponents(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType, List componentUids) { List components = new ArrayList<>(); if (componentUids == null) { Either, StorageOperationStatus> componentUidsRes = getComponentUids(isAbstract, componentTypeEnum, internalComponentType); if (componentUidsRes.isRight()) { return Either.right(componentUidsRes.right().value()); } componentUids = componentUidsRes.left().value(); } if (!isEmpty(componentUids)) { for (String componentUid : componentUids) { ComponentParametersView componentParametersView = buildComponentViewForNotAbstract(); if ("vl".equalsIgnoreCase(internalComponentType)) { componentParametersView.setIgnoreCapabilities(false); componentParametersView.setIgnoreRequirements(false); } Either getToscaElementRes = nodeTemplateOperation.getToscaElementOperation(componentTypeEnum).getLightComponent(componentUid, componentTypeEnum, componentParametersView); if (getToscaElementRes.isRight()) { log.debug("Failed to fetch resource for error is {}", getToscaElementRes.right().value()); return Either.right(getToscaElementRes.right().value()); } Component component = ModelConverter.convertFromToscaElement(getToscaElementRes.left().value()); nullifySomeComponentProperties(component); components.add(component); } } return Either.left(components); } public void nullifySomeComponentProperties(Component component) { component.setContactId(null); component.setCreationDate(null); component.setCreatorUserId(null); component.setCreatorFullName(null); component.setLastUpdateDate(null); component.setLastUpdaterUserId(null); component.setLastUpdaterFullName(null); component.setNormalizedName(null); } private Either, StorageOperationStatus> getComponentUids(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType) { Either, StorageOperationStatus> getToscaElementsRes = getLatestVersionNotAbstractMetadataOnly(isAbstract, componentTypeEnum, internalComponentType); if (getToscaElementsRes.isRight()) { return Either.right(getToscaElementsRes.right().value()); } List collection = getToscaElementsRes.left().value(); List componentUids; if (collection == null) { componentUids = new ArrayList<>(); } else { componentUids = collection.stream() .map(Component::getUniqueId) .collect(Collectors.toList()); } return Either.left(componentUids); } private ComponentParametersView buildComponentViewForNotAbstract() { ComponentParametersView componentParametersView = new ComponentParametersView(); componentParametersView.disableAll(); componentParametersView.setIgnoreCategories(false); componentParametersView.setIgnoreAllVersions(false); return componentParametersView; } public Either validateComponentNameExists(String name, ResourceTypeEnum resourceType, ComponentTypeEnum componentType) { Either result = validateComponentNameUniqueness(name, resourceType, componentType); if (result.isLeft()) { result = Either.left(!result.left().value()); } return result; } public Either validateComponentNameUniqueness(String name, ResourceTypeEnum resourceType, ComponentTypeEnum componentType) { VertexTypeEnum vertexType = ModelConverter.isAtomicComponent(resourceType) ? VertexTypeEnum.NODE_TYPE : VertexTypeEnum.TOPOLOGY_TEMPLATE; String normalizedName = ValidationUtils.normaliseComponentName(name); Map properties = new EnumMap<>(GraphPropertyEnum.class); properties.put(GraphPropertyEnum.NORMALIZED_NAME, normalizedName); properties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); Either, JanusGraphOperationStatus> vertexEither = janusGraphDao .getByCriteria(vertexType, properties, JsonParseFlagEnum.NoParse); if (vertexEither.isRight() && vertexEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("failed to get vertex from graph with property normalizedName: {}", normalizedName); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); } List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; if (vertexList != null && !vertexList.isEmpty()) { return Either.left(false); } else { return Either.left(true); } } private void fillNodeTypePropsMap(final Map hasProps, final Map hasNotProps, final String internalComponentType) { final Configuration configuration = ConfigurationManager.getConfigurationManager().getConfiguration(); final List allowedTypes; if (ComponentTypeEnum.SERVICE.getValue().equalsIgnoreCase(internalComponentType)) { allowedTypes = containerInstanceTypesData.getComponentAllowedList(ComponentTypeEnum.SERVICE, null); } else { final ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeIgnoreCase(internalComponentType); allowedTypes = containerInstanceTypesData.getComponentAllowedList(ComponentTypeEnum.RESOURCE, resourceType); } final List allResourceTypes = configuration.getResourceTypes(); if (allowedTypes == null) { hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, allResourceTypes); return; } if (ResourceTypeEnum.VL.getValue().equalsIgnoreCase(internalComponentType)) { hasProps.put(GraphPropertyEnum.RESOURCE_TYPE, allowedTypes); } else { final List notAllowedTypes = allResourceTypes.stream().filter(s -> !allowedTypes.contains(s)) .collect(Collectors.toList()); hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, notAllowedTypes); } } private void fillTopologyTemplatePropsMap(Map hasProps, Map hasNotProps, ComponentTypeEnum componentTypeEnum) { switch (componentTypeEnum) { case RESOURCE: hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); break; case SERVICE: hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); break; default: break; } hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, ResourceTypeEnum.CVFC.name()); } private void fillPropsMap(Map hasProps, Map hasNotProps, String internalComponentType, ComponentTypeEnum componentTypeEnum, boolean isAbstract, VertexTypeEnum internalVertexType) { hasNotProps.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name()); hasNotProps.put(GraphPropertyEnum.IS_DELETED, true); hasNotProps.put(GraphPropertyEnum.IS_ARCHIVED, true); hasProps.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); if (VertexTypeEnum.NODE_TYPE == internalVertexType) { hasProps.put(GraphPropertyEnum.IS_ABSTRACT, isAbstract); if (internalComponentType != null) { fillNodeTypePropsMap(hasProps, hasNotProps, internalComponentType); } } else { fillTopologyTemplatePropsMap(hasProps, hasNotProps, componentTypeEnum); } } private List getInternalVertexTypes(ComponentTypeEnum componentTypeEnum, String internalComponentType) { List internalVertexTypes = new ArrayList<>(); if (ComponentTypeEnum.RESOURCE == componentTypeEnum) { internalVertexTypes.add(VertexTypeEnum.NODE_TYPE); } if (ComponentTypeEnum.SERVICE == componentTypeEnum || SERVICE.equalsIgnoreCase(internalComponentType)) { internalVertexTypes.add(VertexTypeEnum.TOPOLOGY_TEMPLATE); } return internalVertexTypes; } public Either, StorageOperationStatus> getLatestVersionNotAbstractMetadataOnly(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType) { List internalVertexTypes = getInternalVertexTypes(componentTypeEnum, internalComponentType); List result = new ArrayList<>(); for (VertexTypeEnum vertexType : internalVertexTypes) { Either, StorageOperationStatus> listByVertexType = getLatestVersionNotAbstractToscaElementsMetadataOnly(isAbstract, componentTypeEnum, internalComponentType, vertexType); if (listByVertexType.isRight()) { return listByVertexType; } result.addAll(listByVertexType.left().value()); } return Either.left(result); } private Either, StorageOperationStatus> getLatestComponentListByUuid(String componentUuid, Map additionalPropertiesToMatch) { Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); if (additionalPropertiesToMatch != null) { propertiesToMatch.putAll(additionalPropertiesToMatch); } propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); return getComponentListByUuid(componentUuid, propertiesToMatch); } public Either getComponentByUuidAndVersion(String componentUuid, String version) { Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesToMatch.put(GraphPropertyEnum.UUID, componentUuid); propertiesToMatch.put(GraphPropertyEnum.VERSION, version); Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); Either, JanusGraphOperationStatus> vertexEither = janusGraphDao .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); if (vertexEither.isRight()) { return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); } List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; if (vertexList == null || vertexList.isEmpty() || vertexList.size() > 1) { return Either.right(StorageOperationStatus.NOT_FOUND); } return getToscaElementByOperation(vertexList.get(0)); } public Either, StorageOperationStatus> getComponentListByUuid(String componentUuid, Map additionalPropertiesToMatch) { Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); if (additionalPropertiesToMatch != null) { propertiesToMatch.putAll(additionalPropertiesToMatch); } propertiesToMatch.put(GraphPropertyEnum.UUID, componentUuid); Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); propertiesNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 Either, JanusGraphOperationStatus> vertexEither = janusGraphDao .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); if (vertexEither.isRight()) { log.debug("Couldn't fetch metadata for component with uuid {}, error: {}", componentUuid, vertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); } List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; if (vertexList == null || vertexList.isEmpty()) { log.debug("Component with uuid {} was not found", componentUuid); return Either.right(StorageOperationStatus.NOT_FOUND); } ArrayList latestComponents = new ArrayList<>(); for (GraphVertex vertex : vertexList) { Either toscaElementByOperation = getToscaElementByOperation(vertex); if (toscaElementByOperation.isRight()) { log.debug("Could not fetch the following Component by UUID {}", vertex.getUniqueId()); return Either.right(toscaElementByOperation.right().value()); } latestComponents.add(toscaElementByOperation.left().value()); } if (latestComponents.size() > 1) { for (Component component : latestComponents) { if (component.isHighestVersion()) { LinkedList highestComponent = new LinkedList<>(); highestComponent.add(component); return Either.left(highestComponent); } } } return Either.left(latestComponents); } public Either getLatestServiceByUuid(String serviceUuid) { Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); return getLatestComponentByUuid(serviceUuid, propertiesToMatch); } public Either getLatestComponentByUuid(String componentUuid) { return getLatestComponentByUuid(componentUuid, null); } public Either getLatestComponentByUuid(String componentUuid, Map propertiesToMatch) { Either, StorageOperationStatus> latestVersionListEither = getLatestComponentListByUuid(componentUuid, propertiesToMatch); if (latestVersionListEither.isRight()) { return Either.right(latestVersionListEither.right().value()); } List latestVersionList = latestVersionListEither.left().value(); if (latestVersionList.isEmpty()) { return Either.right(StorageOperationStatus.NOT_FOUND); } Component component = latestVersionList.size() == 1 ? latestVersionList.get(0) : latestVersionList.stream().max((c1, c2) -> Double.compare(Double.parseDouble(c1.getVersion()), Double.parseDouble(c2.getVersion()))).get(); return Either.left(component); } public Either, StorageOperationStatus> getAllCertifiedResources(boolean isAbstract, Boolean isHighest) { List resources = new ArrayList<>(); Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesToMatch.put(GraphPropertyEnum.IS_ABSTRACT, isAbstract); if (isHighest != null) { propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, isHighest); } propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); Either, JanusGraphOperationStatus> getResourcesRes = janusGraphDao .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); if (getResourcesRes.isRight()) { log.debug("Failed to fetch all certified resources. Status is {}", getResourcesRes.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getResourcesRes.right().value())); } List resourceVerticies = getResourcesRes.left().value(); for (GraphVertex resourceV : resourceVerticies) { Either getResourceRes = getToscaElement(resourceV); if (getResourceRes.isRight()) { return Either.right(getResourceRes.right().value()); } resources.add(getResourceRes.left().value()); } return Either.left(resources); } public Either getLatestByNameAndVersion(String name, String version, JsonParseFlagEnum parseFlag) { Either result; Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); hasProperties.put(GraphPropertyEnum.NAME, name); hasProperties.put(GraphPropertyEnum.VERSION, version); hasProperties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); Either, JanusGraphOperationStatus> getResourceRes = janusGraphDao .getByCriteria(null, hasProperties, hasNotProperties, parseFlag); if (getResourceRes.isRight()) { JanusGraphOperationStatus status = getResourceRes.right().value(); log.debug("failed to find resource with name {}, version {}. Status is {} ", name, version, status); result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } return getToscaElementByOperation(getResourceRes.left().value().get(0)); } public Either getLatestComponentByCsarOrName(ComponentTypeEnum componentType, String csarUUID, String systemName) { return getLatestComponentByCsarOrName(componentType, csarUUID, systemName, JsonParseFlagEnum.ParseAll); } public Either getLatestComponentByCsarOrName(ComponentTypeEnum componentType, String csarUUID, String systemName, JsonParseFlagEnum parseFlag) { Map props = new EnumMap<>(GraphPropertyEnum.class); Map propsHasNot = new EnumMap<>(GraphPropertyEnum.class); props.put(GraphPropertyEnum.CSAR_UUID, csarUUID); props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); if (componentType != null) { props.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); } propsHasNot.put(GraphPropertyEnum.IS_DELETED, true); GraphVertex resourceMetadataData = null; List resourceMetadataDataList = null; Either, JanusGraphOperationStatus> byCsar = janusGraphDao .getByCriteria(null, props, propsHasNot, JsonParseFlagEnum.ParseMetadata); if (byCsar.isRight()) { if (JanusGraphOperationStatus.NOT_FOUND == byCsar.right().value()) { // Fix Defect DE256036 if (StringUtils.isEmpty(systemName)) { return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( JanusGraphOperationStatus.NOT_FOUND)); } props.clear(); props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); props.put(GraphPropertyEnum.SYSTEM_NAME, systemName); Either, JanusGraphOperationStatus> bySystemname = janusGraphDao .getByCriteria(null, props, JsonParseFlagEnum.ParseMetadata); if (bySystemname.isRight()) { log.debug("getLatestResourceByCsarOrName - Failed to find by system name {} error {} ", systemName, bySystemname.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(bySystemname.right().value())); } if (bySystemname.left().value().size() > 2) { log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) must return only 2 latest version, but was returned - {}", bySystemname.left().value().size()); return Either.right(StorageOperationStatus.GENERAL_ERROR); } resourceMetadataDataList = bySystemname.left().value(); if (resourceMetadataDataList.size() == 1) { resourceMetadataData = resourceMetadataDataList.get(0); } else { for (GraphVertex curResource : resourceMetadataDataList) { if (!((String) curResource.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals("CERTIFIED")) { resourceMetadataData = curResource; break; } } } if (resourceMetadataData == null) { log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) returned 2 latest CERTIFIED versions"); return Either.right(StorageOperationStatus.GENERAL_ERROR); } if (resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID) != null && !((String) resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID)).equals(csarUUID)) { log.debug("getLatestResourceByCsarOrName - same system name {} but different csarUUID. exist {} and new {} ", systemName, resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID), csarUUID); // correct error will be returned from create flow. with all // correct audit records!!!!! return Either.right(StorageOperationStatus.NOT_FOUND); } return getToscaElement((String) resourceMetadataData.getUniqueId()); } } else { resourceMetadataDataList = byCsar.left().value(); if (resourceMetadataDataList.size() > 2) { log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) must return only 2 latest version, but was returned - {}", byCsar.left().value().size()); return Either.right(StorageOperationStatus.GENERAL_ERROR); } if (resourceMetadataDataList.size() == 1) { resourceMetadataData = resourceMetadataDataList.get(0); } else { for (GraphVertex curResource : resourceMetadataDataList) { if (!((String) curResource.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals("CERTIFIED")) { resourceMetadataData = curResource; break; } } } if (resourceMetadataData == null) { log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) returned 2 latest CERTIFIED versions"); return Either.right(StorageOperationStatus.GENERAL_ERROR); } return getToscaElement((String) resourceMetadataData.getJsonMetadataField(JsonPresentationFields.UNIQUE_ID), parseFlag); } return null; } public Either validateToscaResourceNameExtends(String templateNameCurrent, String templateNameExtends) { String currentTemplateNameChecked = templateNameExtends; while (currentTemplateNameChecked != null && !currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)) { Either latestByToscaResourceName = getLatestByToscaResourceName(currentTemplateNameChecked); if (latestByToscaResourceName.isRight()) { return latestByToscaResourceName.right().value() == StorageOperationStatus.NOT_FOUND ? Either.left(false) : Either.right(latestByToscaResourceName.right().value()); } Resource value = latestByToscaResourceName.left().value(); if (value.getDerivedFrom() != null) { currentTemplateNameChecked = value.getDerivedFrom().get(0); } else { currentTemplateNameChecked = null; } } return (currentTemplateNameChecked != null && currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)) ? Either.left(true) : Either.left(false); } public Either, StorageOperationStatus> fetchMetaDataByResourceType(String resourceType, ComponentParametersView filterBy) { Map props = new EnumMap<>(GraphPropertyEnum.class); props.put(GraphPropertyEnum.RESOURCE_TYPE, resourceType); props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); Map propsHasNotToMatch = new EnumMap<>(GraphPropertyEnum.class); propsHasNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); Either, JanusGraphOperationStatus> resourcesByTypeEither = janusGraphDao .getByCriteria(null, props, propsHasNotToMatch, JsonParseFlagEnum.ParseMetadata); if (resourcesByTypeEither.isRight()) { return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(resourcesByTypeEither.right().value())); } List vertexList = resourcesByTypeEither.left().value(); List components = new ArrayList<>(); for (GraphVertex vertex : vertexList) { components.add(getToscaElementByOperation(vertex, filterBy).left().value()); } return Either.left(components); } public void commit() { janusGraphDao.commit(); } public Either updateDistributionStatus(Service service, User user, DistributionStatusEnum distributionStatus) { Either updateDistributionStatus = topologyTemplateOperation.updateDistributionStatus(service.getUniqueId(), user, distributionStatus); if (updateDistributionStatus.isRight()) { return Either.right(updateDistributionStatus.right().value()); } GraphVertex serviceV = updateDistributionStatus.left().value(); service.setDistributionStatus(distributionStatus); service.setLastUpdateDate((Long) serviceV.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE)); return Either.left(service); } public Either updateComponentLastUpdateDateOnGraph(Component component) { Either result = null; GraphVertex serviceVertex; Either updateRes = null; Either getRes = janusGraphDao .getVertexById(component.getUniqueId(), JsonParseFlagEnum.ParseMetadata); if (getRes.isRight()) { JanusGraphOperationStatus status = getRes.right().value(); log.error("Failed to fetch component {}. status is {}", component.getUniqueId(), status); result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } if (result == null) { serviceVertex = getRes.left().value(); long lastUpdateDate = System.currentTimeMillis(); serviceVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, lastUpdateDate); component.setLastUpdateDate(lastUpdateDate); updateRes = janusGraphDao.updateVertex(serviceVertex); if (updateRes.isRight()) { result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateRes.right().value())); } } if (result == null) { result = Either.left(ModelConverter.convertToComponentMetadata(updateRes.left().value())); } return result; } public HealingJanusGraphDao getJanusGraphDao() { return janusGraphDao; } public Either, StorageOperationStatus> getCertifiedServicesWithDistStatus(Set distStatus) { Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); return getServicesWithDistStatus(distStatus, propertiesToMatch); } public Either, StorageOperationStatus> getServicesWithDistStatus(Set distStatus, Map additionalPropertiesToMatch) { List servicesAll = new ArrayList<>(); Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); if (additionalPropertiesToMatch != null && !additionalPropertiesToMatch.isEmpty()) { propertiesToMatch.putAll(additionalPropertiesToMatch); } propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); if (distStatus != null && !distStatus.isEmpty()) { for (DistributionStatusEnum state : distStatus) { propertiesToMatch.put(GraphPropertyEnum.DISTRIBUTION_STATUS, state.name()); Either, StorageOperationStatus> fetchServicesByCriteria = fetchServicesByCriteria(servicesAll, propertiesToMatch, propertiesNotToMatch); if (fetchServicesByCriteria.isRight()) { return fetchServicesByCriteria; } else { servicesAll = fetchServicesByCriteria.left().value(); } } return Either.left(servicesAll); } else { return fetchServicesByCriteria(servicesAll, propertiesToMatch, propertiesNotToMatch); } } private Either, StorageOperationStatus> fetchServicesByCriteria(List servicesAll, Map propertiesToMatch, Map propertiesNotToMatch) { Either, JanusGraphOperationStatus> getRes = janusGraphDao .getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); if (getRes.isRight()) { if (getRes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch certified services by match properties {} not match properties {} . Status is {}. ", propertiesToMatch, propertiesNotToMatch, getRes.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); } } else { for (GraphVertex vertex : getRes.left().value()) { Either getServiceRes = topologyTemplateOperation.getLightComponent(vertex, ComponentTypeEnum.SERVICE, new ComponentParametersView(true)); if (getServiceRes.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch certified service {}. Status is {}. ", vertex.getJsonMetadataField(JsonPresentationFields.NAME), getServiceRes.right().value()); return Either.right(getServiceRes.right().value()); } else { servicesAll.add(ModelConverter.convertFromToscaElement(getServiceRes.left().value())); } } } return Either.left(servicesAll); } public void rollback() { janusGraphDao.rollback(); } public StorageOperationStatus addDeploymentArtifactsToInstance(String componentId, ComponentInstance componentInstance, Map finalDeploymentArtifacts) { Map instDeplArtifacts = finalDeploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); return nodeTemplateOperation.addDeploymentArtifactsToInstance(componentId, componentInstance.getUniqueId(), instDeplArtifacts); } public StorageOperationStatus addInformationalArtifactsToInstance(String componentId, ComponentInstance componentInstance, Map artifacts) { StorageOperationStatus status = StorageOperationStatus.OK; if (MapUtils.isNotEmpty(artifacts)) { Map instDeplArtifacts = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); status = nodeTemplateOperation.addInformationalArtifactsToInstance(componentId, componentInstance.getUniqueId(), instDeplArtifacts); } return status; } public StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId) { return nodeTemplateOperation.generateCustomizationUUIDOnInstance(componentId, instanceId); } public StorageOperationStatus generateCustomizationUUIDOnInstanceGroup(String componentId, String instanceId, List groupInstances) { return nodeTemplateOperation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances); } public Either addPropertyToComponent(String propertyName, PropertyDefinition newPropertyDefinition, Component component) { newPropertyDefinition.setName(propertyName); StorageOperationStatus status = getToscaElementOperation(component) .addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, newPropertyDefinition, JsonPresentationFields.NAME); if (status != StorageOperationStatus.OK) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the property {} to the component {}. Status is {}. ", propertyName, component.getName(), status); return Either.right(status); } ComponentParametersView filter = new ComponentParametersView(true); filter.setIgnoreProperties(false); filter.setIgnoreInputs(false); Either getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); if (getUpdatedComponentRes.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated component {}. Status is {}. ", component.getUniqueId(), getUpdatedComponentRes.right().value()); return Either.right(status); } PropertyDefinition newProperty = null; List properties = (getUpdatedComponentRes.left().value()).getProperties(); if (CollectionUtils.isNotEmpty(properties)) { Optional propertyOptional = properties.stream().filter( propertyEntry -> propertyEntry.getName().equals(propertyName)).findAny(); if (propertyOptional.isPresent()) { newProperty = propertyOptional.get(); } } if (newProperty == null) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently added property {} on the component {}. Status is {}. ", propertyName, component.getUniqueId(), StorageOperationStatus.NOT_FOUND); return Either.right(StorageOperationStatus.NOT_FOUND); } return Either.left(newProperty); } public StorageOperationStatus deletePropertyOfComponent(Component component, String propertyName) { return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, propertyName, JsonPresentationFields.NAME); } public StorageOperationStatus deleteAttributeOfResource(Component component, String attributeName) { return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, attributeName, JsonPresentationFields.NAME); } public StorageOperationStatus deleteInputOfResource(Component resource, String inputName) { return getToscaElementOperation(resource).deleteToscaDataElement(resource.getUniqueId(), EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputName, JsonPresentationFields.NAME); } /** * Deletes a data type from a component. * @param component the container which has the data type * @param dataTypeName the data type name to be deleted * @return Operation result. */ public StorageOperationStatus deleteDataTypeOfComponent(Component component, String dataTypeName) { return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.DATA_TYPES, VertexTypeEnum.DATA_TYPES, dataTypeName, JsonPresentationFields.NAME); } public Either updatePropertyOfComponent(Component component, PropertyDefinition newPropertyDefinition) { Either getUpdatedComponentRes = null; Either result = null; StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, newPropertyDefinition, JsonPresentationFields.NAME); if (status != StorageOperationStatus.OK) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the property {} to the resource {}. Status is {}. ", newPropertyDefinition.getName(), component.getName(), status); result = Either.right(status); } if (result == null) { ComponentParametersView filter = new ComponentParametersView(true); filter.setIgnoreProperties(false); getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); if (getUpdatedComponentRes.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated resource {}. Status is {}. ", component.getUniqueId(), getUpdatedComponentRes.right().value()); result = Either.right(status); } } if (result == null) { Optional newProperty = (getUpdatedComponentRes.left().value()) .getProperties().stream().filter(p -> p.getName().equals(newPropertyDefinition.getName())).findAny(); if (newProperty.isPresent()) { result = Either.left(newProperty.get()); } else { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently added property {} on the resource {}. Status is {}. ", newPropertyDefinition.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); result = Either.right(StorageOperationStatus.NOT_FOUND); } } return result; } public Either addAttributeOfResource(Component component, PropertyDefinition newAttributeDef) { Either getUpdatedComponentRes = null; Either result = null; if (newAttributeDef.getUniqueId() == null || newAttributeDef.getUniqueId().isEmpty()) { String attUniqueId = UniqueIdBuilder.buildAttributeUid(component.getUniqueId(), newAttributeDef.getName()); newAttributeDef.setUniqueId(attUniqueId); } StorageOperationStatus status = getToscaElementOperation(component).addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, newAttributeDef, JsonPresentationFields.NAME); if (status != StorageOperationStatus.OK) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getName(), status); result = Either.right(status); } if (result == null) { ComponentParametersView filter = new ComponentParametersView(true); filter.setIgnoreAttributesFrom(false); getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); if (getUpdatedComponentRes.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); result = Either.right(status); } } if (result == null) { Optional newAttribute = ((Resource) getUpdatedComponentRes.left().value()).getAttributes().stream().filter(p -> p.getName().equals(newAttributeDef.getName())).findAny(); if (newAttribute.isPresent()) { result = Either.left(newAttribute.get()); } else { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); result = Either.right(StorageOperationStatus.NOT_FOUND); } } return result; } public Either updateAttributeOfResource(Component component, PropertyDefinition newAttributeDef) { Either getUpdatedComponentRes = null; Either result = null; StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, newAttributeDef, JsonPresentationFields.NAME); if (status != StorageOperationStatus.OK) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getName(), status); result = Either.right(status); } if (result == null) { ComponentParametersView filter = new ComponentParametersView(true); filter.setIgnoreAttributesFrom(false); getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); if (getUpdatedComponentRes.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); result = Either.right(status); } } if (result == null) { Optional newProperty = ((Resource) getUpdatedComponentRes.left().value()).getAttributes().stream().filter(p -> p.getName().equals(newAttributeDef.getName())).findAny(); if (newProperty.isPresent()) { result = Either.left(newProperty.get()); } else { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); result = Either.right(StorageOperationStatus.NOT_FOUND); } } return result; } public Either updateInputOfComponent(Component component, InputDefinition newInputDefinition) { Either getUpdatedComponentRes = null; Either result = null; StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, newInputDefinition, JsonPresentationFields.NAME); if (status != StorageOperationStatus.OK) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the input {} to the component {}. Status is {}. ", newInputDefinition.getName(), component.getName(), status); result = Either.right(status); } if (result == null) { ComponentParametersView filter = new ComponentParametersView(true); filter.setIgnoreInputs(false); getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); if (getUpdatedComponentRes.isRight()) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); result = Either.right(status); } } if (result == null) { Optional updatedInput = getUpdatedComponentRes.left().value().getInputs().stream().filter(p -> p.getName().equals(newInputDefinition.getName())).findAny(); if (updatedInput.isPresent()) { result = Either.left(updatedInput.get()); } else { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently updated inputs {} on the resource {}. Status is {}. ", newInputDefinition.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); result = Either.right(StorageOperationStatus.NOT_FOUND); } } return result; } /** * method - ename the group instances after referenced container name renamed flow - VF rename -(triggers)-> Group rename * * @param containerComponent - container such as service * @param componentInstance - context component * @param componentInstanceId - id * @return - successfull/failed status **/ public Either cleanAndAddGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, String componentInstanceId) { String uniqueId = componentInstance.getUniqueId(); StorageOperationStatus status = nodeTemplateOperation.deleteToscaDataDeepElementsBlockOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, uniqueId); if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete group instances for container {}. error {] ", componentInstanceId, status); return Either.right(status); } if (componentInstance.getGroupInstances() != null) { status = addGroupInstancesToComponentInstance(containerComponent, componentInstance, componentInstance.getGroupInstances()); if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add group instances for container {}. error {] ", componentInstanceId, status); return Either.right(status); } } return Either.left(status); } public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groups, Map> groupInstancesArtifacts) { return nodeTemplateOperation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups, groupInstancesArtifacts); } public Either, StorageOperationStatus> updateGroupsOnComponent(Component component, List updatedGroups) { return groupsOperation.updateGroups(component, updatedGroups, PromoteVersionEnum.MINOR); } public Either, StorageOperationStatus> updateGroupInstancesOnComponent(Component component, String instanceId, List updatedGroupInstances) { return groupsOperation.updateGroupInstances(component, instanceId, updatedGroupInstances); } public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groupInstances) { return nodeTemplateOperation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groupInstances); } public StorageOperationStatus addDeploymentArtifactsToComponentInstance(Component containerComponent, ComponentInstance componentInstance, Map deploymentArtifacts) { return nodeTemplateOperation.addDeploymentArtifactsToComponentInstance(containerComponent, componentInstance, deploymentArtifacts); } public StorageOperationStatus updateComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { return nodeTemplateOperation.updateComponentInstanceProperty(containerComponent, componentInstanceId, property); } public StorageOperationStatus updateComponentInstanceProperties(Component containerComponent, String componentInstanceId, List properties) { return nodeTemplateOperation.updateComponentInstanceProperties(containerComponent, componentInstanceId, properties); } public StorageOperationStatus addComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { return nodeTemplateOperation.addComponentInstanceProperty(containerComponent, componentInstanceId, property); } public StorageOperationStatus updateComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ return nodeTemplateOperation.updateComponentInstanceAttribute(containerComponent, componentInstanceId, property); } public StorageOperationStatus addComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ return nodeTemplateOperation.addComponentInstanceAttribute(containerComponent, componentInstanceId, property); } public StorageOperationStatus updateComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { return nodeTemplateOperation.updateComponentInstanceInput(containerComponent, componentInstanceId, property); } public StorageOperationStatus updateComponentInstanceInputs(Component containerComponent, String componentInstanceId, List instanceInputs) { return nodeTemplateOperation.updateComponentInstanceInputs(containerComponent, componentInstanceId, instanceInputs); } public StorageOperationStatus addComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { return nodeTemplateOperation.addComponentInstanceInput(containerComponent, componentInstanceId, property); } public void setNodeTypeOperation(NodeTypeOperation nodeTypeOperation) { this.nodeTypeOperation = nodeTypeOperation; } public void setTopologyTemplateOperation(TopologyTemplateOperation topologyTemplateOperation) { this.topologyTemplateOperation = topologyTemplateOperation; } public StorageOperationStatus deleteComponentInstanceInputsFromTopologyTemplate(Component containerComponent, List inputsToDelete) { return topologyTemplateOperation.deleteToscaDataElements(containerComponent.getUniqueId(), EdgeLabelEnum.INPUTS, inputsToDelete.stream().map(PropertyDataDefinition::getName).collect(Collectors.toList())); } public StorageOperationStatus updateComponentInstanceCapabiltyProperty(Component containerComponent, String componentInstanceUniqueId, String capabilityPropertyKey, ComponentInstanceProperty property) { return nodeTemplateOperation.updateComponentInstanceCapabilityProperty(containerComponent, componentInstanceUniqueId, capabilityPropertyKey, property); } public StorageOperationStatus updateComponentInstanceCapabilityProperties(Component containerComponent, String componentInstanceUniqueId) { return convertComponentInstanceProperties(containerComponent, componentInstanceUniqueId) .map(instanceCapProps -> topologyTemplateOperation.updateComponentInstanceCapabilityProperties(containerComponent, componentInstanceUniqueId, instanceCapProps)) .orElse(StorageOperationStatus.NOT_FOUND); } public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, String componentInstanceUniqueId) { MapInterfaceDataDefinition mapInterfaceDataDefinition = convertComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId); return topologyTemplateOperation .updateComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId, mapInterfaceDataDefinition); } public StorageOperationStatus updateComponentCalculatedCapabilitiesProperties(Component containerComponent) { Map mapCapabiltyPropertyMap = convertComponentCapabilitiesProperties(containerComponent); return nodeTemplateOperation.overrideComponentCapabilitiesProperties(containerComponent, mapCapabiltyPropertyMap); } public StorageOperationStatus deleteAllCalculatedCapabilitiesRequirements(String topologyTemplateId) { StorageOperationStatus status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES); if (status == StorageOperationStatus.OK) { status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS); } if (status == StorageOperationStatus.OK) { status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES); } return status; } public Either shouldUpgradeToLatestDerived(Resource clonedResource) { String componentId = clonedResource.getUniqueId(); Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } GraphVertex nodeTypeV = getVertexEither.left().value(); ToscaElement toscaElementToUpdate = ModelConverter.convertToToscaElement(clonedResource); Either shouldUpdateDerivedVersion = nodeTypeOperation.shouldUpdateDerivedVersion(toscaElementToUpdate, nodeTypeV); if (shouldUpdateDerivedVersion.isRight() && StorageOperationStatus.OK != shouldUpdateDerivedVersion.right().value()) { log.debug("Failed to update derived version for node type {} derived {}, error: {}", componentId, clonedResource.getDerivedFrom().get(0), shouldUpdateDerivedVersion.right().value()); return Either.right(shouldUpdateDerivedVersion.right().value()); } if (shouldUpdateDerivedVersion.isLeft()) { return Either.left(ModelConverter.convertFromToscaElement(shouldUpdateDerivedVersion.left().value())); } return Either.left(clonedResource); } /** * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId */ public Either, StorageOperationStatus> getComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityName, String capabilityType, String ownerId) { return topologyTemplateOperation.getComponentInstanceCapabilityProperties(componentId, instanceId, capabilityName, capabilityType, ownerId); } private MapInterfaceDataDefinition convertComponentInstanceInterfaces(Component currComponent, String componentInstanceId) { MapInterfaceDataDefinition mapInterfaceDataDefinition = new MapInterfaceDataDefinition(); List componentInterface = currComponent.getComponentInstancesInterfaces().get(componentInstanceId); if(CollectionUtils.isNotEmpty(componentInterface)) { componentInterface.stream().forEach(interfaceDef -> mapInterfaceDataDefinition.put (interfaceDef.getUniqueId(), interfaceDef)); } return mapInterfaceDataDefinition; } private Map convertComponentCapabilitiesProperties(Component currComponent) { Map map = ModelConverter.extractCapabilityPropertiesFromGroups(currComponent.getGroups(), true); map.putAll(ModelConverter.extractCapabilityProperteisFromInstances(currComponent.getComponentInstances(), true)); return map; } private Optional convertComponentInstanceProperties(Component component, String instanceId) { return component.fetchInstanceById(instanceId) .map(ci -> ModelConverter.convertToMapOfMapCapabilityProperties(ci.getCapabilities(), instanceId, ci.getOriginType().isAtomicType())); } public Either associatePolicyToComponent(String componentId, PolicyDefinition policyDefinition, int counter) { Either result = null; Either getVertexEither; getVertexEither = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); if (getVertexEither.isRight()) { log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } else { if (getVertexEither.left().value().getLabel() != VertexTypeEnum.TOPOLOGY_TEMPLATE) { log.error("Policy association to component of Tosca type {} is not allowed. ", getVertexEither.left().value().getLabel()); result = Either.right(StorageOperationStatus.BAD_REQUEST); } } if (result == null) { StorageOperationStatus status = topologyTemplateOperation.addPolicyToToscaElement(getVertexEither.left().value(), policyDefinition, counter); if (status != StorageOperationStatus.OK) { return Either.right(status); } } if (result == null) { result = Either.left(policyDefinition); } return result; } public StorageOperationStatus associatePoliciesToComponent(String componentId, List policies) { log.debug("#associatePoliciesToComponent - associating policies for component {}.", componentId); return janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata) .either(containerVertex -> topologyTemplateOperation.addPoliciesToToscaElement(containerVertex, policies), DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } public Either updatePolicyOfComponent(String componentId, PolicyDefinition policyDefinition, PromoteVersionEnum promoteVersionEnum) { Either result = null; Either getVertexEither; getVertexEither = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); } if (result == null) { policyDefinition.setVersion(GroupUtils.updateVersion(promoteVersionEnum, policyDefinition.getVersion())); StorageOperationStatus status = topologyTemplateOperation.updatePolicyOfToscaElement(getVertexEither.left().value(), policyDefinition); if (status != StorageOperationStatus.OK) { return Either.right(status); } } if (result == null) { result = Either.left(policyDefinition); } return result; } public StorageOperationStatus updatePoliciesOfComponent(String componentId, List policyDefinition) { log.debug("#updatePoliciesOfComponent - updating policies for component {}", componentId); return janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) .right() .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .either(containerVertex -> topologyTemplateOperation.updatePoliciesOfToscaElement(containerVertex, policyDefinition), err -> err); } public StorageOperationStatus removePolicyFromComponent(String componentId, String policyId) { StorageOperationStatus status = null; Either getVertexEither = janusGraphDao .getVertexById(componentId, JsonParseFlagEnum.NoParse); if (getVertexEither.isRight()) { log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); status = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); } if (status == null) { status = topologyTemplateOperation.removePolicyFromToscaElement(getVertexEither.left().value(), policyId); } return status; } public boolean canAddGroups(String componentId) { GraphVertex vertex = janusGraphDao.getVertexById(componentId) .left() .on(this::onJanusGraphError); return topologyTemplateOperation.hasEdgeOfType(vertex, EdgeLabelEnum.GROUPS); } GraphVertex onJanusGraphError(JanusGraphOperationStatus toe) { throw new StorageException( DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toe)); } public CatalogUpdateTimestamp updateCatalogTimes() { long now = System.currentTimeMillis(); GraphVertex catalogRoot = janusGraphDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT) .left() .on(this::onJanusGraphError); Long currentTime = (Long) catalogRoot.getMetadataProperty(GraphPropertyEnum.CURRENT_CATALOG_UPDATE_TIME); catalogRoot.addMetadataProperty(GraphPropertyEnum.PREV_CATALOG_UPDATE_TIME, currentTime); catalogRoot.addMetadataProperty(GraphPropertyEnum.CURRENT_CATALOG_UPDATE_TIME, now); janusGraphDao.updateVertex(catalogRoot).left().on(this::onJanusGraphError); return new CatalogUpdateTimestamp(currentTime, now); } public CatalogUpdateTimestamp getCatalogTimes() { GraphVertex catalogRoot = janusGraphDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT) .left() .on(this::onJanusGraphError); Long currentTime = (Long) catalogRoot.getMetadataProperty(GraphPropertyEnum.CURRENT_CATALOG_UPDATE_TIME); Long prevTime = (Long) catalogRoot.getMetadataProperty(GraphPropertyEnum.PREV_CATALOG_UPDATE_TIME); return new CatalogUpdateTimestamp(prevTime == null ? 0 : prevTime.longValue(), currentTime == null ? 0 : currentTime.longValue()); } public void updateNamesOfCalculatedCapabilitiesRequirements(String componentId) { topologyTemplateOperation .updateNamesOfCalculatedCapabilitiesRequirements(componentId, getTopologyTemplate(componentId)); } public void revertNamesOfCalculatedCapabilitiesRequirements(String componentId) { topologyTemplateOperation .revertNamesOfCalculatedCapabilitiesRequirements(componentId, getTopologyTemplate(componentId)); } private TopologyTemplate getTopologyTemplate(String componentId) { return (TopologyTemplate) topologyTemplateOperation .getToscaElement(componentId, getFilterComponentWithCapProperties()) .left() .on(this::throwStorageException); } private ComponentParametersView getFilterComponentWithCapProperties() { ComponentParametersView filter = new ComponentParametersView(); filter.setIgnoreCapabiltyProperties(false); return filter; } private ToscaElement throwStorageException(StorageOperationStatus status) { throw new StorageException(status); } public Either isComponentInUse(String componentId) { final List forbiddenEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); Either vertexById = janusGraphDao.getVertexById(componentId); if (vertexById.isLeft()) { for (EdgeLabelEnum edgeLabelEnum : forbiddenEdgeLabelEnums) { Iterator edgeItr = vertexById.left().value().getVertex().edges(Direction.IN, edgeLabelEnum.name()); if(edgeItr != null && edgeItr.hasNext()){ return Either.left(true); } } } return Either.left(false); } public Either, StorageOperationStatus> getComponentListByInvariantUuid (String componentInvariantUuid, Map additionalPropertiesToMatch) { Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); if (MapUtils.isNotEmpty(additionalPropertiesToMatch)) { propertiesToMatch.putAll(additionalPropertiesToMatch); } propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, componentInvariantUuid); Either, JanusGraphOperationStatus> vertexEither = janusGraphDao .getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata); if (vertexEither.isRight()) { log.debug("Couldn't fetch metadata for component with type {} and invariantUUId {}, error: {}", componentInvariantUuid, vertexEither.right().value()); return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); } List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; if (vertexList == null || vertexList.isEmpty()) { log.debug("Component with invariantUUId {} was not found", componentInvariantUuid); return Either.right(StorageOperationStatus.NOT_FOUND); } ArrayList components = new ArrayList<>(); for (GraphVertex vertex : vertexList) { Either toscaElementByOperation = getToscaElementByOperation(vertex); if (toscaElementByOperation.isRight()) { log.debug("Could not fetch the following Component by Invariant UUID {}", vertex.getUniqueId()); return Either.right(toscaElementByOperation.right().value()); } components.add(toscaElementByOperation.left().value()); } return Either.left(components); } public Either, StorageOperationStatus> getParentComponents(String componentId) { List parentComponents = new ArrayList<>(); final List relationEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF); Either vertexById = janusGraphDao.getVertexById(componentId); if (vertexById.isLeft()) { for (EdgeLabelEnum edgeLabelEnum : relationEdgeLabelEnums) { Either parentVertexEither = janusGraphDao .getParentVertex(vertexById.left().value(), edgeLabelEnum, JsonParseFlagEnum.ParseJson); if(parentVertexEither.isLeft()){ Either componentEither = getToscaElement(parentVertexEither.left().value().getUniqueId()); if(componentEither.isLeft()){ parentComponents.add(componentEither.left().value()); } } } } return Either.left(parentComponents); } public void updateCapReqPropertiesOwnerId(String componentId) { topologyTemplateOperation .updateCapReqPropertiesOwnerId(componentId, getTopologyTemplate(componentId)); } }