diff options
Diffstat (limited to 'catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperation.java')
| -rw-r--r-- | catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperation.java | 1566 |
1 files changed, 1566 insertions, 0 deletions
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperation.java new file mode 100644 index 0000000000..18229f9245 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperation.java @@ -0,0 +1,1566 @@ +/*- + * ============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.operations.impl; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Predicate; +import java.util.stream.Collectors; + +import javax.annotation.Resource; + +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.graph.datatype.RelationEndPoint; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.FilterKeyEnum; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.model.AdditionalInformationDefinition; +import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentInstance; +import org.openecomp.sdc.be.model.ComponentInstanceInput; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.DistributionStatusEnum; +import org.openecomp.sdc.be.model.InputDefinition; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.ServiceMetadataDefinition; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.category.CategoryDefinition; +import org.openecomp.sdc.be.model.operations.api.IArtifactOperation; +import org.openecomp.sdc.be.model.operations.api.IElementOperation; +import org.openecomp.sdc.be.model.operations.api.IServiceOperation; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.resources.data.ComponentMetadataData; +import org.openecomp.sdc.be.resources.data.PropertyData; +import org.openecomp.sdc.be.resources.data.ServiceMetadataData; +import org.openecomp.sdc.be.resources.data.UserData; +import org.openecomp.sdc.be.resources.data.category.CategoryData; +import org.openecomp.sdc.common.util.ValidationUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.thinkaurelius.titan.core.TitanGraph; + +import fj.data.Either; + +@org.springframework.stereotype.Component("service-operation") +public class ServiceOperation extends ComponentOperation implements IServiceOperation { + + private static Logger log = LoggerFactory.getLogger(ServiceOperation.class.getName()); + + @Resource + private IArtifactOperation artifactOperation; + + @Resource + private IElementOperation elementOperation; + + public ServiceOperation() { + log.debug("ServiceOperation created"); + } + + @Override + public Either<Service, StorageOperationStatus> createService(Service service) { + return createService(service, false); + } + + @Override + public Either<Service, StorageOperationStatus> createService(Service service, boolean inTransaction) { + Either<Service, StorageOperationStatus> result = null; + + try { + + ServiceMetadataData serviceData = getServiceMetaDataFromService(service); + addComponentInternalFields(serviceData); + String uniqueId = (String) serviceData.getUniqueId(); + generateUUID(service); + + String userId = service.getCreatorUserId(); + + Either<UserData, TitanOperationStatus> findUser = findUser(userId); + + if (findUser.isRight()) { + TitanOperationStatus status = findUser.right().value(); + log.error("Cannot find user " + userId + " in the graph. status is " + status); + return sendError(status, StorageOperationStatus.USER_NOT_FOUND); + } + + UserData creatorUserData = findUser.left().value(); + UserData updaterUserData = creatorUserData; + String updaterUserId = service.getLastUpdaterUserId(); + if (updaterUserId != null && !updaterUserId.equals(userId)) { + findUser = findUser(updaterUserId); + if (findUser.isRight()) { + TitanOperationStatus status = findUser.right().value(); + log.error("Cannot find user " + userId + " in the graph. status is " + status); + return sendError(status, StorageOperationStatus.USER_NOT_FOUND); + } else { + updaterUserData = findUser.left().value(); + } + } + + // get category + List<CategoryDefinition> categories = service.getCategories(); + CategoryData categoryData = null; + + String categoryName = categories.get(0).getName(); + if (categoryName != null) { + Either<CategoryData, StorageOperationStatus> categoryResult = elementOperation + .getNewCategoryData(categoryName, NodeTypeEnum.ServiceNewCategory, CategoryData.class); + if (categoryResult.isRight()) { + StorageOperationStatus status = categoryResult.right().value(); + /* + * TitanOperationStatus titanStatus = null; + * if(ActionStatus.CATEGORY_NOT_FOUND.equals(status)){ + * titanStatus = TitanOperationStatus.NOT_FOUND; }else{ + * titanStatus = TitanOperationStatus.GENERAL_ERROR; } + */ + log.error("Cannot find category " + categoryName + " in the graph. status is " + status); + return Either.right(status); + } + + categoryData = categoryResult.left().value(); + } + + StorageOperationStatus storageOperationStatus = createTagsForComponent(service); + if (storageOperationStatus != StorageOperationStatus.OK) { + return Either.right(storageOperationStatus); + } + + log.debug("try to create service node on graph for id " + serviceData.getUniqueId()); + Either<ServiceMetadataData, TitanOperationStatus> createNode = titanGenericDao.createNode(serviceData, + ServiceMetadataData.class); + if (createNode.isRight()) { + TitanOperationStatus status = createNode.right().value(); + log.error("Error returned after creating service data node " + serviceData + ". status returned is " + + status); + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + log.debug("create service node created on graph for id " + serviceData.getUniqueId()); + + TitanOperationStatus associateMetadata = associateMetadataToComponent(serviceData, creatorUserData, + updaterUserData, null, null); + if (associateMetadata != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateMetadata)); + return result; + } + TitanOperationStatus associateCategory = associateMetadataCategoryToComponent(serviceData, categoryData); + if (associateCategory != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateCategory)); + return result; + } + + Map<String, ArtifactDefinition> allArtifacts = new HashMap<String, ArtifactDefinition>(); + if (service.getArtifacts() != null) { + allArtifacts.putAll(service.getArtifacts()); + } + if (service.getDeploymentArtifacts() != null) { + allArtifacts.putAll(service.getDeploymentArtifacts()); + } + if (service.getServiceApiArtifacts() != null) { + allArtifacts.putAll(service.getServiceApiArtifacts()); + } + if (service.getToscaArtifacts() != null) { + allArtifacts.putAll(service.getToscaArtifacts()); + } + + StorageOperationStatus associateArtifacts = associateArtifactsToComponent(NodeTypeEnum.Service, serviceData, + allArtifacts); + if (associateArtifacts != StorageOperationStatus.OK) { + result = Either.right(associateArtifacts); + return result; + } + + TitanOperationStatus associateInputs = associateInputsToComponent(NodeTypeEnum.Service, serviceData, + service.getInputs()); + if (associateInputs != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateInputs)); + return result; + } + + List<AdditionalInformationDefinition> additionalInformation = service.getAdditionalInformation(); + StorageOperationStatus addAdditionalInformation = addAdditionalInformationToService(uniqueId, + additionalInformation); + if (addAdditionalInformation != StorageOperationStatus.OK) { + result = Either.right(addAdditionalInformation); + return result; + } + + result = this.getService(uniqueId, true); + if (result.isRight()) { + log.error("Cannot get full service from the graph. status is " + result.right().value()); + return Either.right(result.right().value()); + } + + if (log.isDebugEnabled()) { + String json = prettyJson.toJson(result.left().value()); + log.debug("Service retrieved is " + json); + } + + return result; + + } finally { + if (false == inTransaction) { + if (result == null || result.isRight()) { + log.debug("Going to execute rollback on graph."); + titanGenericDao.rollback(); + } else { + log.debug("Going to execute commit on graph."); + titanGenericDao.commit(); + } + } + } + } + + private TitanOperationStatus associateMetadataCategoryToComponent(ServiceMetadataData serviceData, + CategoryData categoryData) { + Either<GraphRelation, TitanOperationStatus> result; + if (categoryData != null) { + result = titanGenericDao.createRelation(serviceData, categoryData, GraphEdgeLabels.CATEGORY, null); + log.debug("After associating component " + serviceData.getUniqueId() + " to category " + categoryData + + ". Edge type is " + GraphEdgeLabels.CATEGORY); + if (result.isRight()) { + log.error("Faield to associate component " + serviceData.getUniqueId() + " to category " + categoryData + + ". Edge type is " + GraphEdgeLabels.CATEGORY); + return result.right().value(); + } + } + return TitanOperationStatus.OK; + } + + private StorageOperationStatus addAdditionalInformationToService(String resourceUniqueId, + List<AdditionalInformationDefinition> additionalInformation) { + + StorageOperationStatus result = null; + + if (additionalInformation == null || true == additionalInformation.isEmpty()) { + result = super.addAdditionalInformation(NodeTypeEnum.Service, resourceUniqueId, null); + } else { + if (additionalInformation.size() == 1) { + result = super.addAdditionalInformation(NodeTypeEnum.Service, resourceUniqueId, + additionalInformation.get(0)); + } else { + result = StorageOperationStatus.BAD_REQUEST; + log.info( + "Cannot create resource with more than one additional information object. The number of received object is " + + additionalInformation.size()); + } + } + return result; + } + + public Either<Service, StorageOperationStatus> cloneService(Service other, String version, boolean inTransaction) { + return cloneService(other, version, null, inTransaction); + } + + public Either<Service, StorageOperationStatus> cloneService(Service other, String version, + LifecycleStateEnum targetLifecycle, boolean inTransaction) { + Either<Service, StorageOperationStatus> result = null; + + try { + String origServiceId = other.getUniqueId(); + other.setVersion(version); + other.setUniqueId(null); + + Either<Integer, StorageOperationStatus> counterStatus = getComponentInstanceCoutner(origServiceId, + NodeTypeEnum.Service); + if (counterStatus.isRight()) { + StorageOperationStatus status = counterStatus.right().value(); + log.error("failed to get resource instance counter on service {}. status={}", origServiceId, + counterStatus); + result = Either.right(status); + return result; + } + Map<String, List<ComponentInstanceInput>> inputsValuesMap = new HashMap<String, List<ComponentInstanceInput>>(); + List<InputDefinition> inputs = other.getInputs(); + if(inputs != null){ + for(InputDefinition input: inputs){ + + Either<List<ComponentInstanceInput>, TitanOperationStatus> inputStatus = inputOperation.getComponentInstanceInputsByInputId(input.getUniqueId()); + + if(inputStatus.isLeft()){ + if(inputStatus.left().value() != null) + inputsValuesMap.put(input.getName(), inputStatus.left().value()); + } + } + } + + Either<Service, StorageOperationStatus> createServiceMD = createService(other, true); + + if (createServiceMD.isRight()) { + StorageOperationStatus status = createServiceMD.right().value(); + log.error("failed to clone service. status= {}", status); + result = Either.right(status); + return result; + } + + Service service = createServiceMD.left().value(); + + Either<ImmutablePair<List<ComponentInstance>, Map<String, String>>, StorageOperationStatus> cloneInstances = componentInstanceOperation.cloneAllComponentInstancesFromContainerComponent(origServiceId, service, + NodeTypeEnum.Service, NodeTypeEnum.Resource, targetLifecycle, inputsValuesMap); + if (cloneInstances.isRight()) { + result = Either.right(cloneInstances.right().value()); + return result; + } + + Either<Integer, StorageOperationStatus> setResourceInstanceCounter = setComponentInstanceCounter( + service.getUniqueId(), NodeTypeEnum.Service, counterStatus.left().value(), true); + if (setResourceInstanceCounter.isRight()) { + StorageOperationStatus status = setResourceInstanceCounter.right().value(); + log.error("failed to set resource instance counter on service {}. status={}", service.getUniqueId(), + setResourceInstanceCounter); + result = Either.right(status); + return result; + } + + result = this.getService(service.getUniqueId(), true); + if (result.isRight()) { + log.error("Cannot get full service from the graph. status is " + result.right().value()); + return Either.right(result.right().value()); + } + + if (log.isTraceEnabled()) { + String json = prettyJson.toJson(result.left().value()); + log.trace("Resource retrieved is {}", json); + } + + return result; + } finally { + if (false == inTransaction) { + if (result == null || result.isRight()) { + log.debug("Going to execute rollback on graph."); + titanGenericDao.rollback(); + } else { + log.debug("Going to execute commit on graph."); + titanGenericDao.commit(); + } + } + } + } + + private ServiceMetadataData getServiceMetaDataFromService(Service service) { + ServiceMetadataData serviceData = new ServiceMetadataData( + (ServiceMetadataDataDefinition) service.getComponentMetadataDefinition().getMetadataDataDefinition()); + if (service.getNormalizedName() == null || service.getNormalizedName().isEmpty()) { + serviceData.getMetadataDataDefinition() + .setNormalizedName(ValidationUtils.normaliseComponentName(service.getName())); + } + if (service.getSystemName() == null || service.getSystemName().isEmpty()) { + serviceData.getMetadataDataDefinition() + .setSystemName(ValidationUtils.convertToSystemName(service.getName())); + } + + return serviceData; + } + + private Either<Service, StorageOperationStatus> sendError(TitanOperationStatus status, + StorageOperationStatus statusIfNotFound) { + Either<Service, StorageOperationStatus> result; + if (status == TitanOperationStatus.NOT_FOUND) { + result = Either.right(statusIfNotFound); + return result; + } else { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + } + + /** + * + */ + public Either<Service, StorageOperationStatus> getService(String uniqueId) { + return getService(uniqueId, false); + } + + public Either<Service, StorageOperationStatus> getService(String uniqueId, boolean inTransaction) { + ComponentParametersView componentParametersView = new ComponentParametersView(); + return getService(uniqueId, componentParametersView, inTransaction); + } + // public Either<Service, StorageOperationStatus> getService(String + // uniqueId, boolean inTransaction) { + // + // Service service = null; + // Either<Service, StorageOperationStatus> result = null; + // try { + // + // NodeTypeEnum serviceNodeType = NodeTypeEnum.Service; + // NodeTypeEnum compInstNodeType = NodeTypeEnum.Resource; + // + // Either<ServiceMetadataData, StorageOperationStatus> getComponentByLabel = + // getComponentByLabelAndId(uniqueId, serviceNodeType, + // ServiceMetadataData.class); + // if (getComponentByLabel.isRight()) { + // result = Either.right(getComponentByLabel.right().value()); + // return result; + // } + // ServiceMetadataData serviceData = getComponentByLabel.left().value(); + // service = convertServiceDataToService(serviceData); + // + // TitanOperationStatus status = setComponentCreatorFromGraph(service, + // uniqueId, serviceNodeType); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setComponentLastModifierFromGraph(service, uniqueId, + // serviceNodeType); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // + // } + // status = setComponentCategoriesFromGraph(service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // + // } + // + // // status = setServicePropertiesFromGraph(uniqueId, resource, vertex); + // // if (status != TitanOperationStatus.OK) { + // // return + // Either.right(TitanStatusConverter.convertTitanStatusToStorageStatus(status)); + // // } + // + // StorageOperationStatus storageStatus = setArtifactFromGraph(uniqueId, + // service, serviceNodeType, artifactOperation); + // if (storageStatus != StorageOperationStatus.OK) { + // result = Either.right(storageStatus); + // return result; + // } + // + // status = setComponentInstancesFromGraph(uniqueId, service, + // serviceNodeType, compInstNodeType); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // + // } + // + // status = setComponentInstancesPropertiesFromGraph(uniqueId, service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setCapabilitiesFromGraph(uniqueId, service, + // NodeTypeEnum.Service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setRequirementsFromGraph( uniqueId, service, + // NodeTypeEnum.Service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setAllVersions(service); + // if (status != TitanOperationStatus.OK) { + // return + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // } + // + // status = setServiceAdditionalInformationFromGraph(uniqueId, service); + // if (status != TitanOperationStatus.OK) { + // return + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // } + // + // status = setGroupsFromGraph(uniqueId, service, NodeTypeEnum.Resource); + // if (status != TitanOperationStatus.OK) { + // return + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // } + // + // result = Either.left(service); + // return result; + // } finally { + // if (false == inTransaction) { + // if (result == null || result.isRight()) { + // titanGenericDao.rollback(); + // } else { + // titanGenericDao.commit(); + // } + // } + // } + // } + + public Either<Service, StorageOperationStatus> getService(String uniqueId, + ComponentParametersView componentParametersView, boolean inTransaction) { + + Service service = null; + Either<Service, StorageOperationStatus> result = null; + try { + + NodeTypeEnum serviceNodeType = NodeTypeEnum.Service; + NodeTypeEnum compInstNodeType = NodeTypeEnum.Resource; + + Either<ServiceMetadataData, StorageOperationStatus> getComponentByLabel = getComponentByLabelAndId(uniqueId, + serviceNodeType, ServiceMetadataData.class); + if (getComponentByLabel.isRight()) { + result = Either.right(getComponentByLabel.right().value()); + return result; + } + ServiceMetadataData serviceData = getComponentByLabel.left().value(); + // Try to fetch resource from the cache. The resource will be + // fetched only if the time on the cache equals to + // the time on the graph. + Either<Service, ActionStatus> componentFromCacheIfUpToDate = this.getComponentFromCacheIfUpToDate(uniqueId, + serviceData, componentParametersView, Service.class, ComponentTypeEnum.SERVICE); + if (componentFromCacheIfUpToDate.isLeft()) { + Service cachedService = componentFromCacheIfUpToDate.left().value(); + log.debug("Service {} with uid {} was fetched from cache.", cachedService.getName(), + cachedService.getUniqueId()); + return Either.left(cachedService); + } + + service = convertServiceDataToService(serviceData); + TitanOperationStatus status = null; + if (false == componentParametersView.isIgnoreUsers()) { + status = setComponentCreatorFromGraph(service, uniqueId, serviceNodeType); + if (status != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + + status = setComponentLastModifierFromGraph(service, uniqueId, serviceNodeType); + if (status != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + + } + } + if (false == componentParametersView.isIgnoreCategories()) { + status = setComponentCategoriesFromGraph(service); + if (status != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + + } + } + + // status = setServicePropertiesFromGraph(uniqueId, resource, + // vertex); + // if (status != TitanOperationStatus.OK) { + // return + // Either.right(TitanStatusConverter.convertTitanStatusToStorageStatus(status)); + // } + + if (false == componentParametersView.isIgnoreArtifacts()) { + StorageOperationStatus storageStatus = setArtifactFromGraph(uniqueId, service, serviceNodeType, + artifactOperation); + if (storageStatus != StorageOperationStatus.OK) { + result = Either.right(storageStatus); + return result; + } + } + + if (false == componentParametersView.isIgnoreComponentInstances() + || false == componentParametersView.isIgnoreComponentInstancesProperties() + || false == componentParametersView.isIgnoreCapabilities() + || false == componentParametersView.isIgnoreRequirements()) { + status = setComponentInstancesFromGraph(uniqueId, service, serviceNodeType, compInstNodeType); + if (status != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + + } + } + if (false == componentParametersView.isIgnoreComponentInstancesProperties()) { + status = setComponentInstancesPropertiesFromGraph(uniqueId, service); + if (status != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + } + if (false == componentParametersView.isIgnoreCapabilities()) { + status = setCapabilitiesFromGraph(uniqueId, service, NodeTypeEnum.Service); + if (status != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + } + if (false == componentParametersView.isIgnoreRequirements()) { + status = setRequirementsFromGraph(uniqueId, service, NodeTypeEnum.Service); + if (status != TitanOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + } + if (false == componentParametersView.isIgnoreAllVersions()) { + status = setAllVersions(service); + if (status != TitanOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + } + } + if (false == componentParametersView.isIgnoreAdditionalInformation()) { + status = setServiceAdditionalInformationFromGraph(uniqueId, service); + if (status != TitanOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + } + } + + if (false == componentParametersView.isIgnoreGroups()) { + status = setGroupsFromGraph(uniqueId, service, NodeTypeEnum.Resource); + if (status != TitanOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + } + } + if (false == componentParametersView.isIgnoreInputs()) { + status = setComponentInputsFromGraph(uniqueId, service, true); + if (status != TitanOperationStatus.OK) { + log.error("Failed to set inputs of resource " + uniqueId + ". status is " + status); + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + } + + } + + if (false == componentParametersView.isIgnoreComponentInstancesInputs()) { + status = setComponentInstancesInputsFromGraph(uniqueId, service); + if (status != TitanOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + + } + } + + result = Either.left(service); + return result; + } finally { + if (false == inTransaction) { + if (result == null || result.isRight()) { + titanGenericDao.rollback(); + } else { + titanGenericDao.commit(); + } + } + } + } + + // public Either<Service, StorageOperationStatus> getService_tx(String + // uniqueId, boolean inTransaction) { + // + // Service service = null; + // Either<Service, StorageOperationStatus> result = null; + // try { + // + // NodeTypeEnum serviceNodeType = NodeTypeEnum.Service; + // NodeTypeEnum compInstNodeType = NodeTypeEnum.Resource; + // + // Either<ServiceMetadataData, StorageOperationStatus> getComponentByLabel = + // getComponentByLabelAndId_tx(uniqueId, serviceNodeType, + // ServiceMetadataData.class); + // if (getComponentByLabel.isRight()) { + // result = Either.right(getComponentByLabel.right().value()); + // return result; + // } + // ServiceMetadataData serviceData = getComponentByLabel.left().value(); + // service = convertServiceDataToService(serviceData); + // + // TitanOperationStatus status = setComponentCreatorFromGraph(service, + // uniqueId, serviceNodeType); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setComponentLastModifierFromGraph(service, uniqueId, + // serviceNodeType); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // + // } + // status = setComponentCategoriesFromGraph(service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // + // } + // + // // status = setServicePropertiesFromGraph(uniqueId, resource, vertex); + // // if (status != TitanOperationStatus.OK) { + // // return + // Either.right(TitanStatusConverter.convertTitanStatusToStorageStatus(status)); + // // } + // + // StorageOperationStatus storageStatus = setArtifactFromGraph(uniqueId, + // service, serviceNodeType, artifactOperation); + // if (storageStatus != StorageOperationStatus.OK) { + // result = Either.right(storageStatus); + // return result; + // } + // + // status = setComponentInstancesFromGraph(uniqueId, service, + // serviceNodeType, compInstNodeType); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // + // } + // + // status = setComponentInstancesPropertiesFromGraph(uniqueId, service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setCapabilitiesFromGraph(uniqueId, service, + // NodeTypeEnum.Service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setRequirementsFromGraph( uniqueId, service, + // NodeTypeEnum.Service); + // if (status != TitanOperationStatus.OK) { + // result = + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // return result; + // } + // + // status = setAllVersions(service); + // if (status != TitanOperationStatus.OK) { + // return + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // } + // + // status = setServiceAdditionalInformationFromGraph(uniqueId, service); + // if (status != TitanOperationStatus.OK) { + // return + // Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + // } + // + // result = Either.left(service); + // return result; + // } finally { + // if (false == inTransaction) { + // if (result == null || result.isRight()) { + // titanGenericDao.rollback(); + // } else { + // titanGenericDao.commit(); + // } + // } + // } + // } + + @Override + TitanOperationStatus setComponentCategoriesFromGraph(Component service) { + + String uniqueId = service.getUniqueId(); + Either<List<ImmutablePair<CategoryData, GraphEdge>>, TitanOperationStatus> parentNode = titanGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), uniqueId, + GraphEdgeLabels.CATEGORY, NodeTypeEnum.ServiceNewCategory, CategoryData.class); + if (parentNode.isRight()) { + return parentNode.right().value(); + } + + List<ImmutablePair<CategoryData, GraphEdge>> listValue = parentNode.left().value(); + if (log.isDebugEnabled()) + log.debug("Result after looking for category nodes pointed by service {}. status is {}", uniqueId, + listValue); + if (listValue.size() > 1) { + log.error("Multiple edges foud between resource " + uniqueId + " to category nodes."); + } + ImmutablePair<CategoryData, GraphEdge> value = listValue.get(0); + if (log.isDebugEnabled()) + log.debug("Found parent node {}", value); + + CategoryData categoryData = value.getKey(); + CategoryDefinition categoryDefinition = new CategoryDefinition(categoryData.getCategoryDataDefinition()); + + List<CategoryDefinition> categories = new ArrayList<>(); + categories.add(categoryDefinition); + service.setCategories(categories); + return TitanOperationStatus.OK; + + } + + @Override + public Either<Service, StorageOperationStatus> deleteService(String serviceId) { + return deleteService(serviceId, false); + } + + @Override + public Either<Service, StorageOperationStatus> deleteService(String serviceId, boolean inTransaction) { + + Either<Service, StorageOperationStatus> result = Either.right(StorageOperationStatus.GENERAL_ERROR); + try { + + Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph(); + if (graphResult.isRight()) { + result = Either + .right(DaoStatusConverter.convertTitanStatusToStorageStatus(graphResult.right().value())); + return result; + } + + Either<ServiceMetadataData, TitanOperationStatus> serviceNode = titanGenericDao.getNode( + UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), serviceId, ServiceMetadataData.class); + if (serviceNode.isRight()) { + TitanOperationStatus status = serviceNode.right().value(); + log.error("Failed to find service " + serviceId + ". status is " + status); + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + } + + Either<Service, StorageOperationStatus> serviceRes = getService(serviceId, true); + if (serviceRes.isRight()) { + StorageOperationStatus status = serviceRes.right().value(); + log.error("Failed to find sevice " + serviceId + ".status is " + status); + result = Either.right(status); + return result; + } + Service service = serviceRes.left().value(); + + Either<List<ComponentInstance>, StorageOperationStatus> deleteAllResourceInstancesRes = componentInstanceOperation + .deleteAllComponentInstances(serviceId, NodeTypeEnum.Service, true); + log.debug("After deleting resource instances under service " + serviceId + ".Result is " + + deleteAllResourceInstancesRes); + if (deleteAllResourceInstancesRes.isRight()) { + StorageOperationStatus status = deleteAllResourceInstancesRes.right().value(); + if (status != StorageOperationStatus.NOT_FOUND) { + log.error( + "Failed to delete resource instances under service " + serviceId + " .status is " + status); + result = Either.right(status); + return result; + } + } + StorageOperationStatus removeArtifactsFromResource = removeArtifactsFromComponent(service, + NodeTypeEnum.Service); + log.debug("After deleting artifacts nodes in the graph. status is " + removeArtifactsFromResource); + if (!removeArtifactsFromResource.equals(StorageOperationStatus.OK)) { + result = Either.right(removeArtifactsFromResource); + return result; + } + + StorageOperationStatus removeInputsFromResource = removeInputsFromComponent(NodeTypeEnum.Service, service); + log.debug("After deleting requirements nodes in the graph. status is " + removeInputsFromResource); + if (removeInputsFromResource != StorageOperationStatus.OK) { + result = Either.right(removeInputsFromResource); + return result; + } + + Either<List<ImmutablePair<PropertyData, GraphEdge>>, TitanOperationStatus> deleteChildrenNodesRes = titanGenericDao + .deleteChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), serviceId, + GraphEdgeLabels.PROPERTY, NodeTypeEnum.Property, PropertyData.class); + + if (deleteChildrenNodesRes.isRight()) { + TitanOperationStatus status = deleteChildrenNodesRes.right().value(); + if (status != TitanOperationStatus.NOT_FOUND) { + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + } + + StorageOperationStatus removeAdditionalInformationFromService = super.deleteAdditionalInformation( + NodeTypeEnum.Service, serviceId); + log.debug("After deleting additional information node in the graph. status is " + + removeAdditionalInformationFromService); + if (!removeAdditionalInformationFromService.equals(StorageOperationStatus.OK)) { + result = Either.right(removeAdditionalInformationFromService); + return result; + } + + StorageOperationStatus removeGroupsFromService = super.deleteGroups(NodeTypeEnum.Service, serviceId); + log.debug("After deleting group nodes in the graph. status is " + removeGroupsFromService); + if (!removeGroupsFromService.equals(StorageOperationStatus.OK)) { + result = Either.right(removeGroupsFromService); + return result; + } + + Either<ServiceMetadataData, TitanOperationStatus> deleteServiceNodeRes = titanGenericDao + .deleteNode(serviceNode.left().value(), ServiceMetadataData.class); + if (deleteServiceNodeRes.isRight()) { + TitanOperationStatus status = deleteServiceNodeRes.right().value(); + log.error("Failed to delete service node " + serviceId + ". status is " + status); + result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return result; + } + + result = Either.left(service); + + return result; + } finally { + if (false == inTransaction) { + if (result == null || result.isRight()) { + log.debug("deleteService operation : Going to execute rollback on graph."); + titanGenericDao.rollback(); + } else { + log.debug("deleteService operation : Going to execute commit on graph."); + titanGenericDao.commit(); + } + } + } + + } + + @Override + public Either<Boolean, StorageOperationStatus> validateServiceNameExists(String serviceName) { + return validateServiceNameUniqueness(serviceName, titanGenericDao); + } + + private Service convertServiceDataToService(ServiceMetadataData serviceData) { + ServiceMetadataDefinition serviceMetadataDefinition = new ServiceMetadataDefinition( + (ServiceMetadataDataDefinition) serviceData.getMetadataDataDefinition()); + + Service service = new Service(serviceMetadataDefinition); + + return service; + } + + @Override + public <T extends Component> Either<T, StorageOperationStatus> getComponent(String id, Class<T> clazz) { + + Either<Service, StorageOperationStatus> component = getService(id); + if (component.isRight()) { + return Either.right(component.right().value()); + } + return Either.left(clazz.cast(component.left().value())); + } + + @SuppressWarnings("unchecked") + public Either<List<Service>, StorageOperationStatus> getFollowed(String userId, + Set<LifecycleStateEnum> lifecycleStates, Set<LifecycleStateEnum> lastStateStates, boolean inTransaction) { + + return (Either<List<Service>, StorageOperationStatus>) (Either<?, StorageOperationStatus>) getFollowedComponent( + userId, lifecycleStates, lastStateStates, inTransaction, titanGenericDao, NodeTypeEnum.Service); + } + + @SuppressWarnings("unchecked") + @Override + public <T> Either<T, StorageOperationStatus> getComponent(String id, boolean inTransaction) { + return (Either<T, StorageOperationStatus>) getService(id, inTransaction); + } + + // @Override + // public <T> Either<T, StorageOperationStatus> getComponent_tx(String id, + // boolean inTransaction) { + // return (Either<T, StorageOperationStatus>) getService_tx(id, + // inTransaction); + // } + + @Override + public Either<Set<Service>, StorageOperationStatus> getCatalogData(Map<String, Object> propertiesToMatch, + boolean inTransaction) { + return getComponentCatalogData(NodeTypeEnum.Service, propertiesToMatch, Service.class, + ServiceMetadataData.class, inTransaction); + } + + @Override + public Either<Service, StorageOperationStatus> updateService(Service service, boolean inTransaction) { + Either<Service, StorageOperationStatus> result = updateComponent(service, inTransaction, titanGenericDao, + Service.class, NodeTypeEnum.Service); + return result; + } + + @SuppressWarnings("unchecked") + @Override + public <T> Either<T, StorageOperationStatus> updateComponent(T component, boolean inTransaction) { + return (Either<T, StorageOperationStatus>) updateService((Service) component, inTransaction); + } + + @SuppressWarnings("unchecked") + @Override + public Either<Component, StorageOperationStatus> deleteComponent(String id, boolean inTransaction) { + return (Either<Component, StorageOperationStatus>) (Either<?, StorageOperationStatus>) deleteService(id, + inTransaction); + } + + @Override + protected ComponentMetadataData getMetaDataFromComponent(Component component) { + return getServiceMetaDataFromService((Service) component); + } + + @Override + public <T> Either<T, StorageOperationStatus> getLightComponent(String id, boolean inTransaction) { + return getLightComponent(id, NodeTypeEnum.Service, inTransaction); + } + + @Override + public <T> Either<List<T>, StorageOperationStatus> getFilteredComponents(Map<FilterKeyEnum, String> filters, + boolean inTransaction) { + Either<List<T>, StorageOperationStatus> components = null; + + String categoryName = filters.get(FilterKeyEnum.CATEGORY); + String distributionStatus = filters.get(FilterKeyEnum.DISTRIBUTION_STATUS); + DistributionStatusEnum distEnum = DistributionStatusEnum.findState(distributionStatus); + if (distributionStatus != null && distEnum == null) { + filters.remove(FilterKeyEnum.CATEGORY); + return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND); + } + + if (categoryName != null) { // primary filter + components = fetchByCategoryOrSubCategoryName(categoryName, NodeTypeEnum.ServiceNewCategory, + GraphEdgeLabels.CATEGORY.getProperty(), NodeTypeEnum.Service, inTransaction, + ServiceMetadataData.class); + if (components.isLeft() && distEnum != null) {// secondary filter + Predicate<T> statusFilter = p -> ((Service) p).getDistributionStatus().equals(distEnum); + return Either + .left(components.left().value().stream().filter(statusFilter).collect(Collectors.toList())); + } + filters.remove(FilterKeyEnum.DISTRIBUTION_STATUS); + return components; + } + components = fetchByDistributionStatus(distEnum.name(), inTransaction); + if (components.isRight()) { // not found == empty list + return Either.left(new ArrayList<>()); + } + return components; + } + + private <T> Either<List<T>, StorageOperationStatus> fetchByDistributionStatus(String status, + boolean inTransaction) { + Map<String, Object> props = new HashMap<String, Object>(); + props.put(GraphPropertiesDictionary.DISTRIBUTION_STATUS.getProperty(), status); + props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true); + return (Either<List<T>, StorageOperationStatus>) (Either<?, StorageOperationStatus>) getServiceListByCriteria( + props, inTransaction); + } + + @SuppressWarnings("unchecked") + @Override + public Either<List<Service>, StorageOperationStatus> getTesterFollowed(String userId, + Set<LifecycleStateEnum> lifecycleStates, boolean inTransaction) { + return (Either<List<Service>, StorageOperationStatus>) (Either<?, StorageOperationStatus>) getTesterFollowedComponent( + userId, lifecycleStates, inTransaction, NodeTypeEnum.Service); + } + + public Either<Service, StorageOperationStatus> updateDestributionStatus(Service service, User user, + DistributionStatusEnum distributionStatus) { + String userId = user.getUserId(); + Either<UserData, TitanOperationStatus> findUser = findUser(userId); + if (findUser.isRight()) { + TitanOperationStatus status = findUser.right().value(); + log.error("Cannot find user " + userId + " in the graph. status is " + status); + return sendError(status, StorageOperationStatus.USER_NOT_FOUND); + } + UserData userData = findUser.left().value(); + + Either<ServiceMetadataData, TitanOperationStatus> serviceMetadataDataRequeset = titanGenericDao.getNode( + UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), service.getUniqueId(), + ServiceMetadataData.class); + if (serviceMetadataDataRequeset.isRight()) { + TitanOperationStatus status = serviceMetadataDataRequeset.right().value(); + log.error("Cannot find service " + service.getUniqueId() + " in the graph. status is " + status); + return sendError(status, StorageOperationStatus.NOT_FOUND); + } + ServiceMetadataData serviceMetadataData = serviceMetadataDataRequeset.left().value(); + + StorageOperationStatus result = StorageOperationStatus.OK; + + Either<GraphRelation, TitanOperationStatus> deleteIncomingRelation = deleteLastDistributionModifierRelation( + service); + if (deleteIncomingRelation.isRight() + && deleteIncomingRelation.right().value() != TitanOperationStatus.NOT_FOUND) { + log.error("Failed to delete user from component " + service.getUniqueId() + ". Edge type is " + + GraphEdgeLabels.LAST_DISTRIBUTION_STATE_MODIFAIER); + result = DaoStatusConverter.convertTitanStatusToStorageStatus(deleteIncomingRelation.right().value()); + return Either.right(result); + } + + Either<GraphRelation, TitanOperationStatus> createRelation = titanGenericDao.createRelation(userData, + serviceMetadataData, GraphEdgeLabels.LAST_DISTRIBUTION_STATE_MODIFAIER, null); + log.debug("After associating user " + userData + " to component " + serviceMetadataData.getUniqueId() + + ". Edge type is " + GraphEdgeLabels.LAST_DISTRIBUTION_STATE_MODIFAIER); + if (createRelation.isRight()) { + log.error("Failed to associate user " + userData + " to component " + serviceMetadataData.getUniqueId() + + ". Edge type is " + GraphEdgeLabels.LAST_DISTRIBUTION_STATE_MODIFAIER); + result = DaoStatusConverter.convertTitanStatusToStorageStatus(createRelation.right().value()); + return Either.right(result); + } + service.setDistributionStatus(distributionStatus); + Either<Service, StorageOperationStatus> updateResponse = updateComponent(service, true, titanGenericDao, + Service.class, NodeTypeEnum.Service); + + return updateResponse; + + } + + private Either<GraphRelation, TitanOperationStatus> deleteLastDistributionModifierRelation(Service service) { + GraphRelation lastDistributionStateModifaierRelation = new GraphRelation(); + lastDistributionStateModifaierRelation.setType(GraphEdgeLabels.LAST_DISTRIBUTION_STATE_MODIFAIER.getProperty()); + RelationEndPoint relationEndPoint = new RelationEndPoint(NodeTypeEnum.Service, + UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), service.getUniqueId()); + lastDistributionStateModifaierRelation.setTo(relationEndPoint); + Either<GraphRelation, TitanOperationStatus> deleteIncomingRelation = titanGenericDao + .deleteIncomingRelation(lastDistributionStateModifaierRelation); + return deleteIncomingRelation; + } + + @Override + public Either<Set<Service>, StorageOperationStatus> getCertifiedServicesWithDistStatus( + Map<String, Object> propertiesToMatch, Set<DistributionStatusEnum> distStatus, boolean inTransaction) { + log.debug("Start getCertifiedServicesWithDistStatus."); + Set<Service> servicesSet = new HashSet<Service>(); + if (distStatus != null && !distStatus.isEmpty()) { + for (DistributionStatusEnum status : distStatus) { + Map<String, Object> props = new HashMap<>(); + props.putAll(propertiesToMatch); + props.put(GraphPropertiesDictionary.DISTRIBUTION_STATUS.getProperty(), status.name()); + Either<Set<Service>, StorageOperationStatus> services = retrieveCertifiedServicesWithStatus( + inTransaction, servicesSet, props); + if (services.isRight()) { + return services; + } else { + servicesSet.addAll(services.left().value()); + } + } + return Either.left(servicesSet); + } else { + return retrieveCertifiedServicesWithStatus(inTransaction, servicesSet, propertiesToMatch); + } + } + + private Either<Set<Service>, StorageOperationStatus> retrieveCertifiedServicesWithStatus(boolean inTransaction, + Set<Service> servicesSet, Map<String, Object> props) { + Either<List<ServiceMetadataData>, TitanOperationStatus> criteriaRes = titanGenericDao + .getByCriteria(NodeTypeEnum.Service, props, ServiceMetadataData.class); + return retrieveComponentsFromNodes(criteriaRes, inTransaction); + } + + public Either<List<Service>, StorageOperationStatus> getServiceCatalogData(boolean inTransaction) { + + long start = System.currentTimeMillis(); + + try { + /* + * Map<String, Object> propertiesToMatch = new HashMap<>(); + * propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty + * (), LifecycleStateEnum.CERTIFIED.name()); + * Either<List<ServiceMetadataData>, TitanOperationStatus> + * lastVersionNodes = getLastVersion(NodeTypeEnum.Service, + * propertiesToMatch, ServiceMetadataData.class); if + * (lastVersionNodes.isRight() && lastVersionNodes.right().value() + * != TitanOperationStatus.NOT_FOUND) { return + * Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus + * (lastVersionNodes.right().value())); } List<ServiceMetadataData> + * notCertifiedHighest = (lastVersionNodes.isLeft() ? + * lastVersionNodes.left().value() : new + * ArrayList<ServiceMetadataData>()); + * + * propertiesToMatch.put(GraphPropertiesDictionary. + * IS_HIGHEST_VERSION.getProperty(), true); + * Either<List<ServiceMetadataData>, TitanOperationStatus> + * componentsNodes = + * titanGenericDao.getByCriteria(NodeTypeEnum.Service, + * propertiesToMatch, ServiceMetadataData.class); if + * (componentsNodes.isRight() && componentsNodes.right().value() != + * TitanOperationStatus.NOT_FOUND) { return + * Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus + * (componentsNodes.right().value())); } List<ServiceMetadataData> + * certifiedHighest = (componentsNodes.isLeft() ? + * componentsNodes.left().value() : new + * ArrayList<ServiceMetadataData>()); + */ + + Either<List<ServiceMetadataData>, TitanOperationStatus> listOfHighestComponents = this + .getListOfHighestComponents(NodeTypeEnum.Service, ServiceMetadataData.class); + if (listOfHighestComponents.isRight() + && listOfHighestComponents.right().value() != TitanOperationStatus.NOT_FOUND) { + return Either.right( + DaoStatusConverter.convertTitanStatusToStorageStatus(listOfHighestComponents.right().value())); + } + + List<ServiceMetadataData> notCertifiedHighest = listOfHighestComponents.left().value(); + + List<Service> result = new ArrayList<>(); + + if (notCertifiedHighest != null && false == notCertifiedHighest.isEmpty()) { + + // fetch from cache + long startFetchAllFromCache = System.currentTimeMillis(); + + Map<String, Long> components = notCertifiedHighest.stream() + .collect(Collectors.toMap(p -> p.getMetadataDataDefinition().getUniqueId(), + p -> p.getMetadataDataDefinition().getLastUpdateDate())); + + Either<ImmutablePair<List<Component>, Set<String>>, ActionStatus> componentsFromCacheForCatalog = this + .getComponentsFromCacheForCatalog(components, ComponentTypeEnum.SERVICE); + if (componentsFromCacheForCatalog.isLeft()) { + ImmutablePair<List<Component>, Set<String>> immutablePair = componentsFromCacheForCatalog.left() + .value(); + List<Component> list = immutablePair.getLeft(); + if (list != null) { + for (Component component : list) { + result.add((Service) component); + } + List<String> addedUids = list.stream() + .map(p -> p.getComponentMetadataDefinition().getMetadataDataDefinition().getUniqueId()) + .collect(Collectors.toList()); + notCertifiedHighest = notCertifiedHighest.stream() + .filter(p -> false == addedUids.contains(p.getMetadataDataDefinition().getUniqueId())) + .collect(Collectors.toList()); + } + } + long endFetchAllFromCache = System.currentTimeMillis(); + log.debug("Fetch all catalog services metadata from cache took {} ms", + (endFetchAllFromCache - startFetchAllFromCache)); + log.debug("The number of services added to catalog from cache is {}", result.size()); + + log.debug("The number of services needed to be fetch as light component is {}", + notCertifiedHighest.size()); + for (ServiceMetadataData data : notCertifiedHighest) { + Either<Service, StorageOperationStatus> component = getLightComponent( + data.getMetadataDataDefinition().getUniqueId(), inTransaction); + if (component.isRight()) { + log.debug("Failed to get Service for id = {}, error : {}. Skip service", data.getUniqueId(), + component.right().value()); + } else { + result.add(component.left().value()); + } + } + } + return Either.left(result); + } finally { + if (false == inTransaction) { + titanGenericDao.commit(); + } + log.debug("Fetch all catalog services took " + (System.currentTimeMillis() - start) + " ms"); + } + + } + + public Either<List<Service>, StorageOperationStatus> getServiceCatalogDataLatestCertifiedAndNotCertified( + boolean inTransaction) { + Map<String, Object> properties = new HashMap<>(); + + properties.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true); + List<Service> result = new ArrayList<>(); + Either<List<ServiceMetadataData>, TitanOperationStatus> lastVersionNodes = titanGenericDao + .getByCriteria(NodeTypeEnum.Service, properties, ServiceMetadataData.class); + + if (lastVersionNodes.isRight() && lastVersionNodes.right().value() != TitanOperationStatus.NOT_FOUND) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(lastVersionNodes.right().value())); + } + + List<ServiceMetadataData> latestServices; + + if (lastVersionNodes.isLeft()) { + latestServices = lastVersionNodes.left().value(); + } else { + return Either.left(result); + } + + for (ServiceMetadataData data : latestServices) { + Either<Service, StorageOperationStatus> component = getLightComponent( + data.getMetadataDataDefinition().getUniqueId(), inTransaction); + if (component.isRight()) { + log.debug("Failed to get Service for id = " + data.getUniqueId() + " error : " + + component.right().value() + " skip resource"); + } else { + result.add(component.left().value()); + } + } + + return Either.left(result); + + } + + private Either<List<Service>, StorageOperationStatus> getServiceListByCriteria(Map<String, Object> props, + boolean inTransaction) { + props.put(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Service.getName()); + Either<List<ServiceMetadataData>, TitanOperationStatus> byCriteria = titanGenericDao + .getByCriteria(NodeTypeEnum.Service, props, ServiceMetadataData.class); + + if (byCriteria.isRight()) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value())); + } + List<Service> services = new ArrayList<Service>(); + List<ServiceMetadataData> servicesDataList = byCriteria.left().value(); + for (ServiceMetadataData data : servicesDataList) { + Either<Service, StorageOperationStatus> service = getService(data.getMetadataDataDefinition().getUniqueId(), + inTransaction); + if (service.isLeft()) { + services.add(service.left().value()); + } else { + log.debug("Failed to fetch resource for name = " + data.getMetadataDataDefinition().getName() + + " and id = " + data.getUniqueId()); + } + } + return Either.left(services); + } + + public Either<List<Service>, StorageOperationStatus> getServiceListByUuid(String uuid, boolean inTransaction) { + return getLatestServiceByUuid(uuid, false, inTransaction); + } + + public Either<List<Service>, StorageOperationStatus> getLatestServiceByUuid(String uuid, boolean inTransaction) { + return getLatestServiceByUuid(uuid, true, inTransaction); + } + + private Either<List<Service>, StorageOperationStatus> getLatestServiceByUuid(String uuid, boolean isLatest, + boolean inTransaction) { + Map<String, Object> props = new HashMap<String, Object>(); + + if (isLatest) { + props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), isLatest); + } + + props.put(GraphPropertiesDictionary.UUID.getProperty(), uuid); + return getServiceListByCriteria(props, inTransaction); + } + + public Either<List<Service>, StorageOperationStatus> getServiceListBySystemName(String systemName, + boolean inTransaction) { + Map<String, Object> props = new HashMap<String, Object>(); + props.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), systemName); + return getServiceListByCriteria(props, inTransaction); + } + + public Either<Service, StorageOperationStatus> getServiceByNameAndVersion(String name, String version, + Map<String, Object> additionalParams, boolean inTransaction) { + return getByNamesAndVersion(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), + ValidationUtils.normaliseComponentName(name), version, additionalParams, inTransaction); + } + + @Override + public Either<Service, StorageOperationStatus> getServiceByNameAndVersion(String name, String version) { + return getServiceByNameAndVersion(name, version, null, false); + } + + protected Either<Service, StorageOperationStatus> getByNamesAndVersion(String nameKey, String nameValue, + String version, Map<String, Object> additionalParams, boolean inTransaction) { + Map<String, Object> props = new HashMap<String, Object>(); + props.put(nameKey, nameValue); + props.put(GraphPropertiesDictionary.VERSION.getProperty(), version); + props.put(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Service.getName()); + if (additionalParams != null && !additionalParams.isEmpty()) { + props.putAll(additionalParams); + } + + Either<List<ServiceMetadataData>, TitanOperationStatus> byCriteria = titanGenericDao + .getByCriteria(NodeTypeEnum.Service, props, ServiceMetadataData.class); + + if (byCriteria.isRight()) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value())); + } + List<ServiceMetadataData> dataList = byCriteria.left().value(); + if (dataList != null && !dataList.isEmpty()) { + if (dataList.size() > 1) { + log.debug("More that one instance of resource for name =" + nameValue + " and version = " + version); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + ServiceMetadataData serviceData = dataList.get(0); + Either<Service, StorageOperationStatus> service = getService( + serviceData.getMetadataDataDefinition().getUniqueId(), inTransaction); + if (service.isRight()) { + log.debug("Failed to fetch resource for name = " + serviceData.getMetadataDataDefinition().getName() + + " and id = " + serviceData.getMetadataDataDefinition().getUniqueId()); + } + return service; + } + return Either.right(StorageOperationStatus.NOT_FOUND); + } + + protected <T> Either<T, StorageOperationStatus> getComponentByNameAndVersion(String name, String version, + Map<String, Object> additionalParams, boolean inTransaction) { + return (Either<T, StorageOperationStatus>) getServiceByNameAndVersion(name, version, additionalParams, + inTransaction); + } + + @Override + public Either<Service, StorageOperationStatus> getServiceBySystemNameAndVersion(String name, String version, + boolean inTransaction) { + return getByNamesAndVersion(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), name, version, null, + inTransaction); + } + + private TitanOperationStatus setServiceAdditionalInformationFromGraph(String uniqueId, Service service) { + + List<AdditionalInformationDefinition> additionalInformation = new ArrayList<>(); + + Either<AdditionalInformationDefinition, TitanOperationStatus> either = additionalInformationOperation + .getAllAdditionalInformationParameters(NodeTypeEnum.Service, uniqueId, true); + + if (either.isRight()) { + TitanOperationStatus status = either.right().value(); + if (status == TitanOperationStatus.NOT_FOUND) { + return TitanOperationStatus.OK; + } + return status; + } + + AdditionalInformationDefinition additionalInformationDefinition = either.left().value(); + additionalInformation.add(additionalInformationDefinition); + + service.setAdditionalInformation(additionalInformation); + + return TitanOperationStatus.OK; + + } + + private TitanOperationStatus setAllVersions(Service service) { + Either<Map<String, String>, TitanOperationStatus> res = getVersionList(NodeTypeEnum.Service, + service.getVersion(), service, ServiceMetadataData.class); + if (res.isRight()) { + return res.right().value(); + } + service.setAllVersions(res.left().value()); + return TitanOperationStatus.OK; + } + + public Either<List<ArtifactDefinition>, StorageOperationStatus> getAdditionalArtifacts(String resourceId, + boolean recursively, boolean inTransaction) { + List<ArtifactDefinition> artifacts = new ArrayList<>(); + return Either.left(artifacts); + } + + @Override + public boolean isComponentExist(String serviceId) { + return isComponentExist(serviceId, NodeTypeEnum.Service); + } + + // @SuppressWarnings("unchecked") + // @Override + // public <T> Either<T, StorageOperationStatus> cloneComponent(T other, + // String version, boolean inTransaction) { + // return (Either<T, StorageOperationStatus>) cloneService((Service)other, + // version, inTransaction); + // } + + @SuppressWarnings("unchecked") + @Override + public <T> Either<T, StorageOperationStatus> cloneComponent(T other, String version, + LifecycleStateEnum targetLifecycle, boolean inTransaction) { + return (Either<T, StorageOperationStatus>) cloneService((Service) other, version, targetLifecycle, + inTransaction); + } + + @Override + public Either<Integer, StorageOperationStatus> increaseAndGetComponentInstanceCounter(String componentId, + boolean inTransaction) { + return increaseAndGetComponentInstanceCounter(componentId, NodeTypeEnum.Service, inTransaction); + } + + @Override + protected StorageOperationStatus validateCategories(Component currentComponent, Component component, + ComponentMetadataData componentData, NodeTypeEnum type) { + List<CategoryDefinition> newcategories = component.getCategories(); + CategoryDefinition newCat = newcategories.get(0); + CategoryDefinition currentCategory = currentComponent.getCategories().get(0); + + StorageOperationStatus status = StorageOperationStatus.OK; + if (newCat != null && newCat.getName() != null && false == newCat.getName().equals(currentCategory.getName())) { + log.debug( + "Going to update the category of the resource from " + currentCategory + " to " + newCat.getName()); + + status = moveCategoryEdge(component, componentData, newCat, type); + log.debug("Going to update the category of the resource from " + currentCategory + " to " + newCat.getName() + + ". status is " + status); + } + return status; + } + + @Override + protected <T extends Component> StorageOperationStatus updateDerived(Component component, + Component currentComponent, ComponentMetadataData componentData, Class<T> clazz) { + log.debug("Derived class isn't supported for resource"); + return null; + } + + @Override + public Service getDefaultComponent() { + return new Service(); + } + + @Override + public Either<Component, StorageOperationStatus> getMetadataComponent(String id, boolean inTransaction) { + return getMetadataComponent(id, NodeTypeEnum.Service, inTransaction); + } + + @Override + Component convertComponentMetadataDataToComponent(ComponentMetadataData componentMetadataData) { + return convertServiceDataToService((ServiceMetadataData) componentMetadataData); + } + + @Override + public Either<Boolean, StorageOperationStatus> validateComponentNameExists(String componentName) { + return validateComponentNameUniqueness(componentName, titanGenericDao, NodeTypeEnum.Service); + } + + @Override + public Either<Component, StorageOperationStatus> markComponentToDelete(Component componentToDelete, + boolean inTransaction) { + return internalMarkComponentToDelete(componentToDelete, inTransaction); + } + + @Override + public Either<Boolean, StorageOperationStatus> isComponentInUse(String componentId) { + return isComponentInUse(componentId, NodeTypeEnum.Service); + } + + @Override + public Either<List<String>, StorageOperationStatus> getAllComponentsMarkedForDeletion() { + return getAllComponentsMarkedForDeletion(NodeTypeEnum.Service); + } + + @SuppressWarnings("unchecked") + @Override + public <T> Either<T, StorageOperationStatus> getComponent(String id, + ComponentParametersView componentParametersView, boolean inTransaction) { + + Either<Service, StorageOperationStatus> component = getService(id, componentParametersView, inTransaction); + if (component.isRight()) { + return Either.right(component.right().value()); + } + return (Either<T, StorageOperationStatus>) component; + } + + public Either<Service, StorageOperationStatus> updateService(Service service, boolean inTransaction, + ComponentParametersView filterResultView) { + return (Either<Service, StorageOperationStatus>) updateComponentFilterResult(service, inTransaction, + titanGenericDao, service.getClass(), NodeTypeEnum.Service, filterResultView); + } + + @Override + protected <T> Either<T, StorageOperationStatus> updateComponentFilterResult(T component, boolean inTransaction, + ComponentParametersView filterResultView) { + return (Either<T, StorageOperationStatus>) updateService((Service) component, inTransaction, filterResultView); + } +} |