asdctool/src/main/java/org/openecomp/sdc/asdctool/impl/migration/v1702/Migration1702.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.asdctool.impl.migration.v1702;
  22
  23 import java.io.BufferedWriter;
  24 import java.io.FileOutputStream;
  25 import java.io.IOException;
  26 import java.io.InputStream;
  27 import java.io.OutputStreamWriter;
  28 import java.io.Writer;
  29 import java.nio.charset.StandardCharsets;
  30 import java.util.ArrayList;
  31 import java.util.HashMap;
  32 import java.util.HashSet;
  33 import java.util.Iterator;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Map.Entry;
  37 import java.util.Optional;
  38 import java.util.Set;
  39 import java.util.UUID;
  40 import java.util.regex.Matcher;
  41 import java.util.regex.Pattern;
  42 import java.util.stream.Collectors;
  43
  44 import org.apache.commons.collections.CollectionUtils;
  45 import org.apache.commons.io.IOUtils;
  46 import org.apache.commons.lang3.tuple.ImmutablePair;
  47 import org.apache.commons.math3.analysis.solvers.RiddersSolver;
  48 import org.apache.tinkerpop.gremlin.structure.Direction;
  49 import org.apache.tinkerpop.gremlin.structure.Edge;
  50 import org.apache.tinkerpop.gremlin.structure.Vertex;
  51 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
  52 import org.openecomp.sdc.be.components.impl.ImportUtils;
  53 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  54 import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaTagNamesEnum;
  55 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
  56 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  57 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  58 import org.openecomp.sdc.be.config.Configuration.VfModuleProperty;
  59 import org.openecomp.sdc.be.config.ConfigurationManager;
  60 import org.openecomp.sdc.be.dao.api.ActionStatus;
  61 import org.openecomp.sdc.be.dao.graph.GraphElementFactory;
  62 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  63 import org.openecomp.sdc.be.dao.graph.datatype.GraphElementTypeEnum;
  64 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  65 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  66 import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
  67 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  68 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  69 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  70 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  71 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  72 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  73 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  74 import org.openecomp.sdc.be.impl.ComponentsUtils;
  75 import org.openecomp.sdc.be.model.ArtifactDefinition;
  76 import org.openecomp.sdc.be.model.Component;
  77 import org.openecomp.sdc.be.model.ComponentInstance;
  78 import org.openecomp.sdc.be.model.ComponentParametersView;
  79 import org.openecomp.sdc.be.model.DataTypeDefinition;
  80 import org.openecomp.sdc.be.model.GroupDefinition;
  81 import org.openecomp.sdc.be.model.GroupInstance;
  82 import org.openecomp.sdc.be.model.GroupProperty;
  83 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  84 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  85 import org.openecomp.sdc.be.model.Operation;
  86 import org.openecomp.sdc.be.model.PropertyDefinition;
  87 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  88 import org.openecomp.sdc.be.model.Resource;
  89 import org.openecomp.sdc.be.model.ResourceMetadataDefinition;
  90 import org.openecomp.sdc.be.model.User;
  91 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  92 import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
  93 import org.openecomp.sdc.be.model.operations.impl.ComponentOperation;
  94 import org.openecomp.sdc.be.model.operations.impl.GroupOperation;
  95 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
  96 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  97 import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
  98 import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
  99 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
 100 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
 101 import org.openecomp.sdc.be.resources.data.ArtifactData;
 102 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
 103 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
 104 import org.openecomp.sdc.be.resources.data.DataTypeData;
 105 import org.openecomp.sdc.be.resources.data.GroupData;
 106 import org.openecomp.sdc.be.resources.data.PropertyData;
 107 import org.openecomp.sdc.be.resources.data.PropertyValueData;
 108 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
 109 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
 110 import org.openecomp.sdc.be.user.UserBusinessLogic;
 111 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 112 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
 113 import org.openecomp.sdc.common.api.Constants;
 114 import org.openecomp.sdc.common.util.ValidationUtils;
 115 import org.openecomp.sdc.exception.ResponseFormat;
 116 import org.slf4j.Logger;
 117 import org.slf4j.LoggerFactory;
 118 import org.springframework.beans.factory.annotation.Autowired;
 119 import org.yaml.snakeyaml.Yaml;
 120
 121 import com.thinkaurelius.titan.core.TitanGraph;
 122 import com.thinkaurelius.titan.core.TitanGraphQuery;
 123 import com.thinkaurelius.titan.core.TitanVertex;
 124
 125 import fj.data.Either;
 126
 127 public class Migration1702 {
 128         private static final String CONFIG_GROUP_TYPES_YML = "/config/groupTypes.yml";
 129
 130         private static final String CONFIG_DATA_TYPES_YML = "/config/dataTypes.yml";
 131
 132         private static Logger log = LoggerFactory.getLogger(Migration1702.class.getName());
 133
 134         @Autowired
 135         protected TitanGenericDao titanGenericDao;
 136         @Autowired
 137         protected ResourceOperation resourceOperation;
 138         @Autowired
 139         protected ServiceOperation serviceOperation;
 140         @Autowired
 141         private ServiceBusinessLogic serviceBusinessLogic;
 142         @Autowired
 143         private GroupTypeOperation groupTypeOperation;
 144         @Autowired
 145         private PropertyOperation propertyOperation;
 146         @Autowired
 147         private ComponentsUtils componentsUtils;
 148         @Autowired
 149         private GroupOperation groupOperation;
 150
 151         @Autowired
 152         private ArtifactsBusinessLogic artifactsBusinessLogic;
 153
 154         @Autowired
 155         private UserBusinessLogic userAdminManager;
 156
 157         @Autowired
 158         private ComponentInstanceOperation componentInstanceOperation;
 159
 160         public boolean migrate(String appConfigDir) {
 161                 boolean result = true;
 162                 String methodName = "alignCustomizationUUID";
 163
 164                 try {
 165                         if (!alignCustomizationUUID()) {
 166                                 log.error("Failed to align customization UUID");
 167                                 result = false;
 168                                 return result;
 169                         }
 170                         methodName = "alignGroupDataType";
 171                         if (!alignGroupDataType()) {
 172                                 log.error("Failed to align Group data type");
 173                                 result = false;
 174                                 return result;
 175                         }
 176                         methodName = "alignVfModuleProperties";
 177                         if (!alignVfModuleProperties()) {
 178                                 log.error("Failed to align Vf Module Properties");
 179                                 result = false;
 180                                 return result;
 181                         }
 182                         methodName = "alignDataType";
 183                         if (!alignDataType()) {
 184                                 log.error("Failed to align data type");
 185                                 result = false;
 186                                 return result;
 187                         }
 188                         methodName = "alignHeatEnv";
 189                         if (!alignHeatEnv()) {
 190                                 log.error("Failed to align heat env on VF level");
 191                                 result = false;
 192                                 return result;
 193                         }
 194                         methodName = "alignModuleInstances";
 195                         if (!alignModuleInstances()) {
 196                                 log.error("Failed to align module instances");
 197                                 result = false;
 198                                 return result;
 199                         }
 200
 201                 } catch (Exception e) {
 202                         log.error("Failed {} with exception: ", methodName, e);
 203                         result = false;
 204                 }
 205                 return result;
 206         }
 207
 208         private boolean alignModuleInstances() {
 209                 log.info(" Align Module Instances");
 210                 boolean result = true;
 211                 boolean statusToReturn = true;
 212
 213                 Writer writer = null;
 214
 215                 try {
 216                         long time = System.currentTimeMillis();
 217                         writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("runstatusModules_" + time + ".csv"), "utf-8"));
 218
 219                         writer.write("resource id, instance id, group id, status\n");
 220
 221                         Either<List<ServiceMetadataData>, TitanOperationStatus> allServices = titanGenericDao.getByCriteria(NodeTypeEnum.Service, null, ServiceMetadataData.class);
 222                         if (allServices.isRight()) {
 223                                 if (allServices.right().value() != TitanOperationStatus.NOT_FOUND) {
 224                                         log.error("Align heat env on Vf  - Failed to fetch services {}", allServices.right().value());
 225                                         result = false;
 226                                         statusToReturn = false;
 227                                         return statusToReturn;
 228                                 } else {
 229                                         log.debug("No Services. ");
 230                                         return statusToReturn;
 231                                 }
 232                         }
 233                         log.info("Need to handle {} services", allServices.left().value().size());
 234                         long handledServices = 0;
 235                         for (ServiceMetadataData metadata : allServices.left().value()) {
 236                                 String serviceId = metadata.getMetadataDataDefinition().getUniqueId();
 237                                 Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, TitanOperationStatus> riRes = componentInstanceOperation.getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource);
 238                                 if (riRes.isRight()) {
 239                                         if (riRes.right().value() == TitanOperationStatus.NOT_FOUND) {
 240                                                 log.info("No instancces for service {}", serviceId);
 241                                         } else {
 242                                                 log.info("Align vf modules - failed to fetch component instances for service {} error {}", riRes.right().value());
 243                                                 writeModuleResultToFile(writer, serviceId, null, null, riRes.right().value());
 244                                                 statusToReturn = false;
 245                                         }
 246                                         ++handledServices;
 247                                         continue;
 248                                 }
 249                                 List<ComponentInstance> componentInstances = riRes.left().value().left;
 250                                 for (ComponentInstance ci : componentInstances) {
 251                                         Either<TitanVertex, TitanOperationStatus> ciVertexRes = titanGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), ci.getUniqueId());
 252                                         if (ciVertexRes.isRight()) {
 253                                                 log.info("Failed to fetch vertex for component instance {}, error {}", ci.getUniqueId(), ciVertexRes.right().value());
 254                                                 writeModuleResultToFile(writer, serviceId, ci.getUniqueId(), null, ciVertexRes.right().value());
 255                                                 statusToReturn = false;
 256                                                 continue;
 257                                         }
 258                                         TitanVertex ciVertex = ciVertexRes.left().value();
 259                                         if (createGroupInstancesOnComponentInstance(writer, ci, ciVertex, serviceId) == false) {
 260                                                 statusToReturn = false;
 261                                                 continue;
 262                                         }
 263                                 }
 264                                 writer.flush();
 265                                 ++handledServices;
 266                         }
 267
 268                         log.info("Handled {} services", handledServices);
 269                 } catch (Exception e) {
 270                         log.error("Failed {} with exception: ", "alignModuleInstances", e);
 271                         result = false;
 272                         statusToReturn = false;
 273                 } finally {
 274
 275                         log.info(" Align Module Instances finished");
 276                         if (!result) {
 277                                 log.info("Doing rollback");
 278                                 titanGenericDao.rollback();
 279                         } else {
 280                                 log.info("Doing commit");
 281                                 titanGenericDao.commit();
 282                         }
 283                         try {
 284                                 writer.flush();
 285                                 writer.close();
 286                         } catch (Exception ex) {
 287                                 /* ignore */}
 288                 }
 289                 return statusToReturn;
 290         }
 291
 292         private boolean createGroupInstancesOnComponentInstance(Writer writer, ComponentInstance ci, TitanVertex ciVertex, String serviceId) {
 293                 boolean statusToReturn = true;
 294
 295                 Map<String, Object> properties = titanGenericDao.getProperties(ciVertex);
 296                 ComponentInstanceData createdComponentInstance = GraphElementFactory.createElement(NodeTypeEnum.ResourceInstance.getName(), GraphElementTypeEnum.Node, properties, ComponentInstanceData.class);
 297
 298                 Either<List<GroupDefinition>, TitanOperationStatus> groupEither = groupOperation.getAllGroupsFromGraph(ci.getComponentUid(), NodeTypeEnum.Resource);
 299                 if (groupEither.isRight()) {
 300                         if (groupEither.right().value() != TitanOperationStatus.OK && groupEither.right().value() != TitanOperationStatus.NOT_FOUND) {
 301                                 TitanOperationStatus status = groupEither.right().value();
 302                                 log.error("Failed to associate group instances to component instance {}. Status is {}", ci.getUniqueId(), status);
 303                                 writeModuleResultToFile(writer, serviceId, ci.getUniqueId(), null, status);
 304                                 return false;
 305                         } else {
 306                                 log.debug("No groups for component instance {}. ", ci.getUniqueId());
 307
 308                                 writeModuleResultToFile(writer, serviceId, ci.getUniqueId(), null, "No groups");
 309                                 return true;
 310                         }
 311                 }
 312                 List<GroupDefinition> groupsIמResource = groupEither.left().value();
 313                 if (groupsIמResource != null && !groupsIמResource.isEmpty()) {
 314                         List<GroupDefinition> vfGroupsListInResource = groupsIמResource.stream().filter(p -> p.getType().equals("org.openecomp.groups.VfModule")).collect(Collectors.toList());
 315
 316                         for (GroupDefinition groupInResource : vfGroupsListInResource) {
 317                                 Iterator<Edge> edgesToInstances = ciVertex.edges(Direction.OUT, GraphEdgeLabels.GROUP_INST.getProperty());
 318                                 boolean exist = false;
 319                                 String normalizedName = ValidationUtils.normalizeComponentInstanceName(ci.getNormalizedName() + ".." + groupInResource.getName());
 320                                 String grInstId = UniqueIdBuilder.buildResourceInstanceUniuqeId(ci.getUniqueId(), groupInResource.getUniqueId(), normalizedName);
 321
 322
 323                                 while (edgesToInstances.hasNext()) {
 324                                         Edge edgeToInst = edgesToInstances.next();
 325                                         Vertex grInstVertex = edgeToInst.inVertex();
 326                                         String grId = (String) titanGenericDao.getProperty((TitanVertex) grInstVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 327                                         if (grId.equals(grInstId)) {
 328                                                 exist = true;
 329                                                 break;
 330                                         }
 331                                 }
 332                                 if (!exist) {
 333                                         Either<GroupInstance, StorageOperationStatus> status = componentInstanceOperation.createGroupInstance(ciVertex, groupInResource, ci);
 334                                         if (status.isRight()) {
 335                                                 log.error("Failed to create group instance {} in component instance {}. Status is {}", grInstId, ci.getUniqueId(), status.right().value());
 336                                                 statusToReturn = false;
 337                                                 writeModuleResultToFile(writer, serviceId, ci.getUniqueId(), grInstId, status.right().value());
 338                                         } else {
 339                                                 writeModuleResultToFile(writer, serviceId, ci.getUniqueId(), grInstId, "OK");
 340                                         }
 341                                 } else {
 342                                         writeModuleResultToFile(writer, serviceId, ci.getUniqueId(), grInstId, "Exist");
 343                                 }
 344
 345                         }
 346                 }
 347                 return statusToReturn;
 348         }
 349
 350         @SuppressWarnings("resource")
 351         private boolean alignHeatEnv() {
 352                 Writer writer = null;
 353                 log.info(" Align heat env on Vf level");
 354                 boolean statusToReturn = true;
 355
 356                 boolean result = true;
 357                 try {
 358                         long time = System.currentTimeMillis();
 359                         writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("runstatusEnv_" + time + ".csv"), "utf-8"));
 360
 361                         writer.write("resource id, operation, artifact id, status\n");
 362                         User user = buildDummyUser();
 363
 364                         Map<String, Object> props = new HashMap<String, Object>();
 365                         props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
 366
 367                         Either<List<ResourceMetadataData>, TitanOperationStatus> allResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
 368                         if (allResources.isRight()) {
 369                                 if (allResources.right().value() != TitanOperationStatus.NOT_FOUND) {
 370                                         log.error("Align heat env on Vf  - Failed to fetch resources {}", allResources.right().value());
 371                                         statusToReturn = false;
 372                                         result = false;
 373                                         return statusToReturn;
 374                                 } else {
 375                                         log.debug("No VF resources. ");
 376                                         return result;
 377                                 }
 378                         }
 379                         List<ResourceMetadataData> resources = allResources.left().value();
 380                         log.debug("Need to handle {} resources", resources.size());
 381
 382                         long totalHandledArtifacts = 0;
 383                         for (ResourceMetadataData metadata : resources) {
 384                                 Either<List<ImmutablePair<ArtifactData, GraphEdge>>, TitanOperationStatus> artifactNodesRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) metadata.getUniqueId(),
 385                                                 GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class);
 386                                 if (artifactNodesRes.isRight()) {
 387                                         if (artifactNodesRes.right().value() != TitanOperationStatus.NOT_FOUND) {
 388                                                 log.error("Align heat env on Vf  - Failed to fetch artifacts for resources {}", metadata.getUniqueId(), artifactNodesRes.right().value());
 389                                                 writer.write(metadata.getUniqueId() + ",get artifacts, ,Failed to fetch artifacts " + artifactNodesRes.right().value() + "\n");
 390                                                 statusToReturn = false;
 391                                                 continue;
 392                                         } else {
 393                                                 log.debug("No artifact for resource {} . ", metadata.getUniqueId());
 394                                                 writer.write(metadata.getUniqueId() + ",get artifacts, ,No artfacts\n");
 395                                                 continue;
 396                                         }
 397                                 }
 398                                 List<ImmutablePair<ArtifactData, GraphEdge>> artifacts = artifactNodesRes.left().value();
 399
 400                                 for (ImmutablePair<ArtifactData, GraphEdge> pair : artifacts) {
 401                                         ArtifactData artifactData = pair.left;
 402                                         if (isNeedCreatePlaceHolder(artifactData)) {
 403                                                 // check if exist heat env - if not -> create
 404                                                 String heatEnvId = (String) artifactData.getUniqueId() + "env";
 405                                                 if (validateOrCreateHeatEnv(user, metadata, artifactData, heatEnvId, writer) == false) {
 406                                                         statusToReturn = false;
 407                                                 }
 408                                                 // check if connected to group - if not -> connect
 409                                                 if (validateOrAssociateHeatAnv(metadata, artifactData, heatEnvId, writer) == false) {
 410                                                         statusToReturn = false;
 411                                                 }
 412                                                 ++totalHandledArtifacts;
 413                                                 writer.flush();
 414                                         }
 415
 416                                 }
 417                         }
 418                         log.debug("Total handled {}  artifacts", totalHandledArtifacts);
 419                 } catch (Exception e) {
 420                         log.error("Failed {} with exception: ", "alignHeatEnv", e);
 421                         result = false;
 422                 } finally {
 423
 424                         log.info("Aling heat env on VF level finished ");
 425                         if (!result) {
 426                                 log.info("Doing rollback");
 427                                 titanGenericDao.rollback();
 428                         } else {
 429                                 log.info("Doing commit");
 430                                 titanGenericDao.commit();
 431                         }
 432                         try {
 433                                 writer.flush();
 434                                 writer.close();
 435                         } catch (Exception ex) {
 436                                 /* ignore */}
 437                 }
 438                 return statusToReturn;
 439         }
 440
 441         private boolean validateOrAssociateHeatAnv(ResourceMetadataData metadata, ArtifactData artifactData, String heatEnvId, Writer writer) {
 442                 boolean statusToReturn = true;
 443
 444                 String resourceId = (String) metadata.getUniqueId();
 445                 Either<ArtifactData, TitanOperationStatus> heatEnvArtifactRes = titanGenericDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId, ArtifactData.class);
 446                 if (heatEnvArtifactRes.isRight()) {
 447                         log.error("Align heat env on Vf  - Failed to fetch heat env node for id {}  {}", heatEnvId, heatEnvArtifactRes.right().value());
 448                         writeResultToFile(writer, "get artifact node for relation", resourceId, heatEnvId, heatEnvArtifactRes.right().value());
 449                         return false;
 450                 }
 451                 ArtifactData heatEnvArtifact = heatEnvArtifactRes.left().value();
 452
 453                 Either<List<ImmutablePair<GroupData, GraphEdge>>, TitanOperationStatus> groupsForHeatRes = titanGenericDao.getParentNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) artifactData.getUniqueId(),
 454                                 GraphEdgeLabels.GROUP_ARTIFACT_REF, NodeTypeEnum.Group, GroupData.class);
 455                 if (groupsForHeatRes.isRight()) {
 456                         writeResultToFile(writer, "getChildrenNodes groups for heat", resourceId, (String) artifactData.getUniqueId(), groupsForHeatRes.right().value());
 457                         if (groupsForHeatRes.right().value() != TitanOperationStatus.NOT_FOUND) {
 458                                 log.error("Align heat env on Vf  - Failed to fetch groups for heat artifact {} in resources {} : {}", artifactData.getUniqueId(), metadata.getUniqueId(), groupsForHeatRes.right().value());
 459                                 return false;
 460                         } else {
 461                                 log.debug("Align heat env on Vf  - No groups for heat artifact {} in resources {} : {}", artifactData.getUniqueId(), metadata.getUniqueId(), groupsForHeatRes.right().value());
 462                                 return true;
 463                         }
 464                 }
 465                 List<ImmutablePair<GroupData, GraphEdge>> groupsForHeat = groupsForHeatRes.left().value();
 466                 Either<List<ImmutablePair<GroupData, GraphEdge>>, TitanOperationStatus> groupsForHeatEnvRes = titanGenericDao.getParentNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId, GraphEdgeLabels.GROUP_ARTIFACT_REF, NodeTypeEnum.Group,
 467                                 GroupData.class);
 468                 List<ImmutablePair<GroupData, GraphEdge>> groupsForHeatEnv;
 469                 if (groupsForHeatEnvRes.isRight()) {
 470                         if (groupsForHeatEnvRes.right().value() != TitanOperationStatus.NOT_FOUND) {
 471                                 log.error("Align heat env on Vf  - Failed to fetch groups for heat env artifact {} in resources {} : ", artifactData.getUniqueId(), metadata.getUniqueId(), groupsForHeatEnvRes.right().value());
 472                                 writeResultToFile(writer, "getChildrenNodes groups for heat env", resourceId, heatEnvId, groupsForHeatEnvRes.right().value());
 473                                 return false;
 474                         } else {
 475                                 groupsForHeatEnv = new ArrayList<>();
 476                         }
 477                 } else {
 478                         groupsForHeatEnv = groupsForHeatEnvRes.left().value();
 479                 }
 480
 481                 for (ImmutablePair<GroupData, GraphEdge> heatGroup : groupsForHeat) {
 482                         // check if exist
 483                         boolean exist = false;
 484                         GroupDataDefinition groupDataDefinition = heatGroup.left.getGroupDataDefinition();
 485                         for (ImmutablePair<GroupData, GraphEdge> heatEnvGroup : groupsForHeatEnv) {
 486                                 if (groupDataDefinition.getName().equals(heatEnvGroup.left.getGroupDataDefinition().getName())) {
 487                                         exist = true;
 488                                         break;
 489                                 }
 490                         }
 491                         String groupId = (String) heatGroup.left.getUniqueId();
 492                         if (!exist) {
 493                                 // need associate
 494
 495                                 Map<String, Object> properties = new HashMap<String, Object>();
 496                                 properties.put(GraphPropertiesDictionary.NAME.getProperty(), heatEnvArtifact.getLabel());
 497                                 Either<GraphRelation, TitanOperationStatus> createRelation = titanGenericDao.createRelation(heatGroup.left, heatEnvArtifact, GraphEdgeLabels.GROUP_ARTIFACT_REF, properties);
 498                                 log.trace("After associate group {} to artifact {}", groupDataDefinition.getName(), heatEnvArtifact.getUniqueIdKey());
 499                                 if (createRelation.isRight()) {
 500                                         log.error("Align heat env on Vf  - Failed to associate heat env artifact {} to group {} : {}", artifactData.getUniqueId(), groupDataDefinition.getUniqueId(), createRelation.right().value());
 501
 502                                         writeResultToFile(writer, "associate to group- relation" + groupId, resourceId, heatEnvId, groupsForHeatRes.right().value());
 503                                         statusToReturn = false;
 504                                 } else {
 505                                         writeResultToFile(writer, "associate to group " + groupId, resourceId, heatEnvId, "OK");
 506                                 }
 507                         } else {
 508                                 writeResultToFile(writer, "associate group " + groupId, resourceId, heatEnvId, "Exist");
 509                         }
 510                 }
 511                 return statusToReturn;
 512         }
 513
 514         private boolean validateOrCreateHeatEnv(User user, ResourceMetadataData metadata, ArtifactData artifactData, String heatEnvId, Writer writer) {
 515                 String resourceId = metadata.getMetadataDataDefinition().getUniqueId();
 516                 boolean statusToReturn = true;
 517                 Either<ArtifactData, TitanOperationStatus> node = titanGenericDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId, ArtifactData.class);
 518                 boolean isContinue = true;
 519                 if (node.isRight()) {
 520                         if (TitanOperationStatus.NOT_FOUND == node.right().value()) {
 521                                 // create
 522                                 ArtifactDefinition heatArtifact = new ArtifactDefinition(artifactData.getArtifactDataDefinition());
 523                                 ResourceMetadataDefinition resourceMetadataDataDefinition = new ResourceMetadataDefinition((ResourceMetadataDataDefinition) metadata.getMetadataDataDefinition());
 524
 525                                 Resource resource = new Resource(resourceMetadataDataDefinition);
 526
 527                                 String heatUpdater = heatArtifact.getUserIdLastUpdater();
 528                                 Either<User, ActionStatus> userHeat = userAdminManager.getUser(heatUpdater, true);
 529
 530                                 Either<ArtifactDefinition, ResponseFormat> createHeatEnvPlaceHolder = artifactsBusinessLogic.createHeatEnvPlaceHolder(heatArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME, (String) metadata.getUniqueId(), NodeTypeEnum.Resource,
 531                                                 metadata.getMetadataDataDefinition().getName(), userHeat.left().value(), resource, null, false);
 532                                 if (createHeatEnvPlaceHolder.isRight()) {
 533                                         log.error("Align heat env on Vf  - Failed to create  heat env {} for heat {} : {}", heatEnvId, heatArtifact.getUniqueId(), createHeatEnvPlaceHolder.right().value().getText());
 534                                         writeResultToFile(writer, "create placeholder", resourceId, heatEnvId, createHeatEnvPlaceHolder.right().value().getText());
 535                                         isContinue = false;
 536                                         statusToReturn = false;
 537                                 } else {
 538                                         writeResultToFile(writer, "create placeholder", resourceId, heatEnvId, "OK");
 539                                 }
 540                         } else {
 541                                 log.error("Align heat env on Vf  - Failed to fetch heat env node for id {}  {}", heatEnvId, node.right().value());
 542                                 writeResultToFile(writer, "create placeholder - get", resourceId, heatEnvId, node.right().value());
 543                                 isContinue = false;
 544                                 statusToReturn = false;
 545                         }
 546                 } else {
 547                         writeResultToFile(writer, "create placeholder - get", resourceId, heatEnvId, "Exist");
 548                 }
 549                 if (isContinue) {
 550                         log.debug("associate heat env artifact to all resources ");
 551                         String heatUniqueId = (String) artifactData.getUniqueId();
 552                         Either<TitanVertex, TitanOperationStatus> heatVertexRes = titanGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatUniqueId);
 553                         if (heatVertexRes.isRight()) {
 554                                 log.debug("Failed to fetch vertex for heat {} error {}", heatUniqueId, heatVertexRes.right().value());
 555                                 writeResultToFile(writer, "create placeholder - get heat vertex", resourceId, heatEnvId, heatVertexRes.right().value());
 556                                 statusToReturn = false;
 557                                 return statusToReturn;
 558                         }
 559                         TitanVertex heatVertex = heatVertexRes.left().value();
 560                         Either<TitanVertex, TitanOperationStatus> heatEnvVertexRes = titanGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId);
 561                         if (heatEnvVertexRes.isRight()) {
 562                                 log.debug("Failed to fetch vertex for heat env {} error {}", heatEnvId, heatEnvVertexRes.right().value());
 563                                 writeResultToFile(writer, "create placeholder - get heat env vertex", resourceId, heatEnvId, heatEnvVertexRes.right().value());
 564                                 statusToReturn = false;
 565                                 return statusToReturn;
 566                         }
 567
 568                         Vertex heatEnvVertex = heatEnvVertexRes.left().value();
 569                         Iterator<Edge> edgesToHeat = heatVertex.edges(Direction.IN, GraphEdgeLabels.ARTIFACT_REF.name());
 570                         while (edgesToHeat.hasNext()) {
 571                                 Edge edgeToHeat = edgesToHeat.next();
 572                                 boolean exist = false;
 573                                 Vertex outVertexHeat = edgeToHeat.outVertex();
 574                                 Map<String, Object> outVertexProps = titanGenericDao.getProperties(outVertexHeat);
 575
 576                                 String resIdToHeat = (String) outVertexProps.get(GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 577
 578                                 Iterator<Edge> edgesToEnv = heatEnvVertex.edges(Direction.IN, GraphEdgeLabels.ARTIFACT_REF.name());
 579                                 while (edgesToEnv.hasNext()) {
 580                                         Edge edgeToEnv = edgesToEnv.next();
 581                                         Vertex outVertexEnv = edgeToEnv.outVertex();
 582                                         String resIdToEnv = (String) titanGenericDao.getProperty((TitanVertex) outVertexEnv, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 583                                         if (resIdToHeat.equals(resIdToEnv)) {
 584                                                 exist = true;
 585                                                 break;
 586                                         }
 587                                 }
 588                                 if (!exist) {
 589                                         Map<String, Object> properties = titanGenericDao.getProperties(edgeToHeat);
 590                                         // need to associate additional resource to heat env
 591                                         // update artifact label on edge
 592                                         String heatEnvLabel = (String) titanGenericDao.getProperty((TitanVertex) heatEnvVertex, GraphPropertiesDictionary.ARTIFACT_LABEL.getProperty());
 593                                         properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), heatEnvLabel);
 594
 595                                         TitanOperationStatus createEdge = titanGenericDao.createEdge(outVertexHeat, heatEnvVertex, GraphEdgeLabels.ARTIFACT_REF, properties);
 596                                         if (createEdge == TitanOperationStatus.OK) {
 597                                                 writeResultToFile(writer, "associate to resource " + resIdToHeat, resourceId, heatEnvId, "OK");
 598                                         } else {
 599                                                 writeResultToFile(writer, "associate to resource " + resIdToHeat, resourceId, heatEnvId, createEdge);
 600                                                 statusToReturn = false;
 601                                         }
 602                                 } else {
 603                                         writeResultToFile(writer, "associate to resource " + resIdToHeat, resourceId, heatEnvId, "Exist");
 604                                 }
 605                         }
 606                 }
 607                 return statusToReturn;
 608         }
 609
 610         private void writeResultToFile(Writer writer, String op, String resourceId, String artifactD, Object status) {
 611                 try {
 612                         StringBuffer sb = new StringBuffer(resourceId);
 613                         sb.append(",").append(op).append(",").append(artifactD).append(",").append(status).append("\n");
 614                         writer.write(sb.toString());
 615                 } catch (IOException e) {
 616                         // TODO Auto-generated catch block
 617                         e.printStackTrace();
 618                 }
 619         }
 620
 621         private void writeModuleResultToFile(Writer writer, String resourceId, String instanceId, String groupId, Object status) {
 622                 try {
 623                         StringBuffer sb = new StringBuffer(resourceId);
 624                         sb.append(",").append(instanceId).append(",").append(groupId).append(",").append(status).append("\n");
 625                         writer.write(sb.toString());
 626                 } catch (IOException e) {
 627                         // TODO Auto-generated catch block
 628                         e.printStackTrace();
 629                 }
 630         }
 631
 632         private boolean isNeedCreatePlaceHolder(ArtifactData artifactData) {
 633                 String artifactType = artifactData.getArtifactDataDefinition().getArtifactType();
 634                 ArtifactTypeEnum type = ArtifactTypeEnum.findType(artifactType);
 635                 if (ArtifactGroupTypeEnum.DEPLOYMENT == artifactData.getArtifactDataDefinition().getArtifactGroupType() && (ArtifactTypeEnum.HEAT == type || ArtifactTypeEnum.HEAT_NET == type || ArtifactTypeEnum.HEAT_VOL == type)) {
 636                         return true;
 637                 }
 638                 return false;
 639         }
 640
 641         private boolean alignVfModuleProperties() {
 642                 boolean result = true;
 643                 try {
 644                         log.info(" Align Vf module properties");
 645
 646                         final Pattern pattern = Pattern.compile("\\..(.*?)\\..");
 647                         final String LABEL_NAME = "vf_module_label";
 648                         final String VOLUME_GROUP_NAME = "volume_group";
 649
 650                         Either<TitanGraph, TitanOperationStatus> graph = titanGenericDao.getGraph();
 651                         if (graph.isRight()) {
 652                                 log.error("Align Vf module properties - Failed to get graph {}", graph.right().value());
 653                                 result = false;
 654                                 return result;
 655                         }
 656
 657                         Map<String, Object> props = new HashMap<String, Object>();
 658                         props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
 659
 660                         Either<List<ResourceMetadataData>, TitanOperationStatus> allResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
 661
 662                         if (allResources.isRight()) {
 663                                 if (allResources.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
 664                                         log.debug("Align Vf module properties - no VF resources");
 665                                         result = true;
 666                                         return result;
 667                                 } else {
 668                                         log.error("Align Vf module properties - generateTosca failed fetch all resources,error {}", allResources.right().value());
 669                                         result = false;
 670                                         return result;
 671                                 }
 672                         }
 673
 674                         List<ResourceMetadataData> listAllVFs = allResources.left().value();
 675
 676                         ComponentParametersView componentParametersView = new ComponentParametersView(true);
 677                         componentParametersView.setIgnoreGroups(false);
 678                         componentParametersView.setIgnoreArtifacts(false);
 679
 680                         log.info("Align Vf module properties - Starting to update the VF's");
 681                         Map<String, VfModuleProperty> vfModuleProperties = ConfigurationManager.getConfigurationManager().getConfiguration().getVfModuleProperties();
 682                         for (ResourceMetadataData resourceMetadataData : listAllVFs) {
 683                                 String uniqueId = (String) resourceMetadataData.getUniqueId();
 684
 685                                 Either<Resource, StorageOperationStatus> resourceResponse = resourceOperation.getResource(uniqueId, componentParametersView, true);
 686
 687                                 if (resourceResponse.isRight()) {
 688                                         log.error("Align Vf module properties - failed resource with UniqueID: {} , error {}", uniqueId, resourceResponse.right().value());
 689                                         result = false;
 690                                         return result;
 691                                 }
 692
 693                                 Resource resource = resourceResponse.left().value();
 694                                 List<GroupDefinition> groups = resource.getGroups();
 695
 696                                 if (groups == null || groups.isEmpty()) {
 697                                         log.debug("Align Vf module properties - resource UniqueID: {} does not contain groups", resource.getUniqueId());
 698                                         continue;
 699                                 } else {
 700
 701                                         for (GroupDefinition groupDefinition : groups) {
 702
 703                                                 if (groupDefinition.getType().equals(Constants.DEFAULT_GROUP_VF_MODULE)) {
 704                                                         log.info("update vf module proerties for group {} ", groupDefinition.getUniqueId());
 705
 706                                                         List<GroupProperty> properties = groupDefinition.convertToGroupProperties();
 707                                                         if (properties == null) {
 708                                                                 properties = new ArrayList<>();
 709                                                         }
 710                                                         Boolean isBase = false;
 711                                                         List<String> artifacts = groupDefinition.getArtifacts();
 712                                                         if (artifacts == null) {
 713                                                                 artifacts = new ArrayList<>();
 714                                                         }
 715                                                         Boolean isVolumeGroup = false;
 716                                                         for (String artifactId : artifacts) {
 717                                                                 ArtifactDefinition artifactDef = null;
 718                                                                 Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
 719                                                                 artifactDef = findArtifactInList(deploymentArtifacts, artifactId);
 720                                                                 if (artifactDef != null && artifactDef.getArtifactType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType())) {
 721                                                                         isVolumeGroup = true;
 722                                                                         break;
 723                                                                 }
 724                                                         }
 725                                                         for (GroupProperty groupProperty : properties) {
 726                                                                 if (groupProperty.getName().equals(Constants.IS_BASE)) {
 727                                                                         isBase = Boolean.valueOf(groupProperty.getValue());
 728                                                                         break;
 729                                                                 }
 730                                                         }
 731
 732                                                         if (null == isBase) {
 733                                                                 log.error("Align Vf module properties - isBase not found in DEFAULT_GROUP_VF_MODULE");
 734                                                                 result = false;
 735                                                                 return result;
 736                                                         }
 737
 738                                                         String vfModuleLabel = null;
 739                                                         String moduleName = groupDefinition.getName();
 740                                                         Matcher matcher = pattern.matcher(moduleName);
 741
 742                                                         if (matcher.find()) {
 743                                                                 vfModuleLabel = matcher.group(1);
 744                                                         } else {
 745                                                                 vfModuleLabel = moduleName;
 746                                                         }
 747
 748                                                         boolean isBasePrimitive = isBase;
 749                                                         boolean isVolumeGroupPrimitive = isVolumeGroup;
 750                                                         String vfModuleLabelFinal = vfModuleLabel;
 751                                                         List<GroupProperty> propertiesToAdd = new ArrayList<>();
 752                                                         properties.stream().forEach(p -> {
 753                                                                 if (p.getValueUniqueUid() == null) {
 754                                                                         if (vfModuleProperties.containsKey(p.getName())) {
 755                                                                                 if (isBasePrimitive) {
 756                                                                                         p.setValue(vfModuleProperties.get(p.getName()).getForBaseModule());
 757                                                                                 } else {
 758                                                                                         p.setValue(vfModuleProperties.get(p.getName()).getForNonBaseModule());
 759                                                                                 }
 760                                                                         } else if (p.getName().equals(VOLUME_GROUP_NAME)) {
 761                                                                                 p.setValue(String.valueOf(isVolumeGroupPrimitive));
 762                                                                         } else if (p.getName().equals(LABEL_NAME)) {
 763                                                                                 p.setValue(vfModuleLabelFinal);
 764                                                                         }
 765                                                                         propertiesToAdd.add(p);
 766                                                                 }
 767
 768                                                         });
 769
 770                                                         List<GroupProperty> propertiesAlreadyExistOnGraph = properties.stream().filter(p -> !(p.getValueUniqueUid() == null || p.getValueUniqueUid().isEmpty())).collect(Collectors.toList());
 771                                                         int numOfPropertiesAlreadyExist = propertiesAlreadyExistOnGraph.size();
 772
 773                                                         log.debug("Need to update default values vfModule {} properties {} ", properties.size(), properties);
 774
 775                                                         Either<GroupTypeDefinition, TitanOperationStatus> groupTypeRes = groupTypeOperation.getGroupTypeByUid(groupDefinition.getTypeUid());
 776                                                         if (groupTypeRes.isRight()) {
 777                                                                 TitanOperationStatus operationStatus = groupTypeRes.right().value();
 778                                                                 log.debug("Failed to find group type {}",groupDefinition.getTypeUid());
 779                                                                 if (operationStatus == TitanOperationStatus.NOT_FOUND) {
 780                                                                         result = false;
 781                                                                         return result;
 782                                                                 }
 783                                                         }
 784
 785                                                         GroupTypeDefinition groupTypeDefinition = groupTypeRes.left().value();
 786                                                         List<PropertyDefinition> groupTypeProperties = groupTypeDefinition.getProperties();
 787                                                         Map<String, PropertyDefinition> groupTypePropertiesMap = groupTypeProperties.stream().collect(Collectors.toMap(p -> p.getName(), p -> p));
 788
 789                                                         int i = numOfPropertiesAlreadyExist + 1;
 790                                                         for (GroupProperty prop : propertiesToAdd) {
 791                                                                 if (prop.getUniqueId() == null || prop.getUniqueId().isEmpty()) {
 792                                                                         continue;
 793                                                                 }
 794                                                                 GroupData groupData = new GroupData(groupDefinition);
 795
 796                                                                 Either<PropertyValueData, TitanOperationStatus> addPropertyToGroup = groupOperation.addPropertyToGroup(groupData, prop, groupTypePropertiesMap.get(prop.getName()), i);
 797                                                                 if (addPropertyToGroup.isRight()) {
 798                                                                         log.info("Failed to add properties {}  to group type :{} error {} ", prop.getName(), groupData.getUniqueId(), addPropertyToGroup.right().value());
 799                                                                         result = false;
 800                                                                         return result;
 801                                                                 }
 802                                                                 ++i;
 803                                                         }
 804                                                 }
 805                                         }
 806                                 }
 807                         }
 808                 } catch (Exception e) {
 809                         log.error("Failed {} with exception: ", "alignVfModuleProperties", e);
 810                         result = false;
 811                 } finally {
 812                         log.info(" Align Vf module properties finished");
 813                         if (!result) {
 814                                 log.info("Doing rollback");
 815                                 titanGenericDao.rollback();
 816                         } else {
 817                                 log.info("Doing commit");
 818                                 titanGenericDao.commit();
 819                         }
 820                 }
 821                 return true;
 822         }
 823
 824         private ArtifactDefinition findArtifactInList(Map<String, ArtifactDefinition> deploymentArtifacts, String artifactId) {
 825                 Optional<ArtifactDefinition> op = deploymentArtifacts.values().stream().filter(p -> p.getUniqueId().equals(artifactId)).findAny();
 826                 if (op.isPresent())
 827                         return op.get();
 828                 return null;
 829         }
 830
 831         private boolean generateTosca() {
 832                 log.info("Regenerate  Tosca and CSAR for VFs and Services");
 833                 Either<TitanGraph, TitanOperationStatus> graph = titanGenericDao.getGraph();
 834                 if (graph.isRight()) {
 835                         log.error("Failed to get graph {}", graph.right().value());
 836                         return false;
 837                 }
 838                 Map<String, Object> props = new HashMap<String, Object>();
 839                 props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
 840
 841                 User user = buildDummyUser();
 842
 843                 Map<String, Object> propsHasNot = new HashMap<String, Object>();
 844                 propsHasNot.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 845                 propsHasNot.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 846
 847                 Either<List<ResourceMetadataData>, TitanOperationStatus> allResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, propsHasNot, ResourceMetadataData.class);
 848                 if (allResources.isRight()) {
 849                         if (allResources.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
 850                                 log.debug("generateTosca - no VF resources");
 851                         } else {
 852                                 log.info("generateTosca failed fetch all resources,error {}", allResources.right().value());
 853                                 return false;
 854                         }
 855                 } else {
 856                         if (!handleComponents(user, allResources.left().value(), resourceOperation)) {
 857                                 log.info("generateTosca failed generate tosca artifacts for resources");
 858                                 return false;
 859
 860                         }
 861                 }
 862                 Either<List<ServiceMetadataData>, TitanOperationStatus> allServices = titanGenericDao.getByCriteria(NodeTypeEnum.Service, null, propsHasNot, ServiceMetadataData.class);
 863                 if (allServices.isRight()) {
 864                         if (allServices.right().value() == TitanOperationStatus.NOT_FOUND) {
 865                                 log.debug("generateTosca - no services");
 866
 867                         } else {
 868                                 log.debug("generateTosca failed fetch all services,error {}",allServices.right().value());
 869                                 return false;
 870                         }
 871                 } else {
 872                         if (!handleComponents(user, allServices.left().value(), serviceOperation)) {
 873                                 log.info("generateTosca failed generate tosca artifacts for services");
 874                                 return false;
 875
 876                         }
 877                 }
 878                 log.info("Regenerate  Tosca and CSAR for VFs and Services finished");
 879                 return true;
 880         }
 881
 882         private <T extends ComponentMetadataData> boolean handleComponents(User user, List<T> allResources, ComponentOperation operation) {
 883                 for (ComponentMetadataData resource : allResources) {
 884                         if (resource.getMetadataDataDefinition().isDeleted() == null || !resource.getMetadataDataDefinition().isDeleted()) {
 885                                 Either<Component, StorageOperationStatus> component = operation.getComponent((String) resource.getUniqueId(), true);
 886                                 if (component.isRight()) {
 887                                         log.info("generateTosca failed fetch component with id {} , error {}", (String) resource.getUniqueId(), component.right().value());
 888                                         return false;
 889                                 }
 890                                 if (populateToscaArtifactsWithLog(component.left().value(), user) != ActionStatus.OK) {
 891                                         return false;
 892                                 }
 893                         }
 894                 }
 895                 return true;
 896         }
 897
 898         private boolean alignCustomizationUUID() {
 899                 boolean result = true;
 900                 try {
 901                         log.info("Update customization UUID for all component instances on graph");
 902                         Either<TitanGraph, TitanOperationStatus> graph = titanGenericDao.getGraph();
 903                         if (graph.isRight()) {
 904                                 log.error("Failed to get graph {}", graph.right().value());
 905                                 return result;
 906                         }
 907                         TitanGraph tGraph = graph.left().value();
 908                         TitanGraphQuery<? extends TitanGraphQuery> query = tGraph.query();
 909                         query = query.has(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.ResourceInstance.getName());
 910                         Iterable<TitanVertex> vertices = query.vertices();
 911                         if (vertices == null) {
 912                                 log.info("No component instances on graph");
 913                                 return result;
 914                         }
 915                         Iterator<TitanVertex> iterator = vertices.iterator();
 916                         if (!iterator.hasNext()) {
 917                                 log.info("No component instances on graph");
 918                         }
 919                         while (iterator.hasNext()) {
 920                                 TitanVertex vertex = iterator.next();
 921                                 String property = (String) titanGenericDao.getProperty(vertex, GraphPropertiesDictionary.CUSTOMIZATION_UUID.getProperty());
 922                                 if (!ValidationUtils.validateStringNotEmpty(property)) {
 923                                         UUID uuid = UUID.randomUUID();
 924                                         vertex.property(GraphPropertiesDictionary.CUSTOMIZATION_UUID.getProperty(), uuid.toString());
 925                                 }
 926                         }
 927                 } catch (Exception e) {
 928                         log.error("Failed {} with exception: ", "alignCustomizationUUID", e);
 929                         result = false;
 930                 } finally {
 931                         log.info("Update customization UUID finished ");
 932                         if (!result) {
 933                                 log.info("Doing rollback");
 934                                 titanGenericDao.rollback();
 935                         } else {
 936                                 log.info("Doing commit");
 937                                 titanGenericDao.commit();
 938                         }
 939                 }
 940                 return result;
 941         }
 942
 943         private ActionStatus populateToscaArtifactsWithLog(Component component, User user) {
 944                 ActionStatus ret = ActionStatus.OK;
 945                 LifecycleStateEnum lifecycleState = component.getLifecycleState();
 946                 if (!needRegenarateTosca(lifecycleState)) {
 947                         log.debug("Component {} is in state {}, don't generatate Tosca", component.getUniqueId(), lifecycleState);
 948                         return ret;
 949                 }
 950
 951                 try {
 952                         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> populateToscaArtifacts = serviceBusinessLogic.populateToscaArtifacts(component, user, true, false, true, true);
 953                         if (populateToscaArtifacts.isLeft()) {
 954                                 log.debug("Added payload to tosca artifacts of component {} of type:{} with uniqueId:{}", component.getName(), component.getComponentType().getValue(), component.getUniqueId());
 955                         } else {
 956                                 log.error("Failed to generate TOSCA artifacts for component {} of type:{} with uniqueId:{}", component.getName(), component.getComponentType().name(), component.getUniqueId());
 957                                 return ActionStatus.GENERAL_ERROR;
 958                         }
 959                         return ret;
 960                 } catch (Exception e) {
 961                         log.error("Exception Occured When filling tosca artifact payload for component {} of type:{} with uniqueId:{}", component.getName(), component.getComponentType().name(), component.getUniqueId(), e);
 962                         return ActionStatus.GENERAL_ERROR;
 963                 }
 964         }
 965
 966         private boolean needRegenarateTosca(LifecycleStateEnum lifecycleState) {
 967                 if (lifecycleState == LifecycleStateEnum.READY_FOR_CERTIFICATION || lifecycleState == LifecycleStateEnum.CERTIFICATION_IN_PROGRESS || lifecycleState == LifecycleStateEnum.CERTIFIED) {
 968                         return true;
 969                 }
 970                 return false;
 971         }
 972
 973         private User buildDummyUser() {
 974                 User user = new User();
 975                 user.setUserId("migrationTask");
 976                 return user;
 977         }
 978
 979         private boolean alignGroupDataType() {
 980                 boolean result = true;
 981                 try {
 982                         log.info(" Align group data type properties");
 983                         String categoryMigrationFile = CONFIG_GROUP_TYPES_YML;
 984                         String yamlAsString;
 985                         try {
 986
 987                                 InputStream inputStream = getClass().getResourceAsStream(categoryMigrationFile);
 988                                 if (inputStream == null) {
 989                                         log.info("Failed to load input file : {}", categoryMigrationFile);
 990                                         result = false;
 991                                         return result;
 992                                 }
 993                                 yamlAsString = IOUtils.toString(inputStream, StandardCharsets.UTF_8.name());
 994
 995                         } catch (Exception e) {
 996                                 log.info("Failed to load group types file exception : ", e);
 997                                 result = false;
 998                                 return result;
 999                         }
1000
1001                         log.debug("received yaml: {}", yamlAsString);
1002
1003                         Map<String, Object> toscaJson = (Map<String, Object>) new Yaml().load(yamlAsString);
1004
1005                         if (toscaJson == null || toscaJson.isEmpty()) {
1006                                 log.info("group types file is empty");
1007                                 result = false;
1008                                 return result;
1009                         }
1010
1011                         Map<String, Object> vfModule = (Map<String, Object>) toscaJson.get("org.openecomp.groups.VfModule");
1012                         if (vfModule == null || vfModule.isEmpty()) {
1013                                 log.info("No vfModule in group types file");
1014                                 result = false;
1015                                 return result;
1016                         }
1017                         Map<String, Object> properties = (Map<String, Object>) vfModule.get("properties");
1018                         if (properties == null || properties.isEmpty()) {
1019                                 log.info("No properties for vfModule in group types file");
1020                                 result = false;
1021                                 return result;
1022                         }
1023                         Either<GroupTypeDefinition, StorageOperationStatus> latestGroupTypeByType = groupTypeOperation.getLatestGroupTypeByType("org.openecomp.groups.VfModule", true);
1024                         if (latestGroupTypeByType.isRight()) {
1025                                 log.info("Failed to fetch org.openecomp.groups.VfModule group type, error :{}", latestGroupTypeByType.right().value());
1026                                 result = false;
1027                                 return result;
1028                         }
1029                         GroupTypeDefinition groupTypeInGraph = latestGroupTypeByType.left().value();
1030                         List<PropertyDefinition> propertiesInGraph = groupTypeInGraph.getProperties();
1031
1032                         List<PropertyDefinition> propertiesToAdd = new ArrayList<>();
1033
1034                         properties.entrySet().stream().filter(e -> !ifExistOnGraph(e.getKey(), propertiesInGraph)).forEach(fe -> {
1035                                 PropertyDefinition property = new PropertyDefinition();
1036                                 property.setName(fe.getKey());
1037                                 Map<String, Object> definitionInYaml = (Map<String, Object>) fe.getValue();
1038                                 property.setType((String) definitionInYaml.get("type"));
1039                                 property.setRequired((Boolean) definitionInYaml.get("required"));
1040                                 property.setDescription((String) definitionInYaml.get("description"));
1041                                 String defaultValue = definitionInYaml.get("default") == null ? null : definitionInYaml.get("default").toString();
1042                                 if (defaultValue != null) {
1043                                         property.setDefaultValue(defaultValue);
1044                                 }
1045                                 propertiesToAdd.add(property);
1046                         });
1047
1048                         if (!propertiesToAdd.isEmpty()) {
1049                                 log.debug("Need to add to vfModule {} properties {} ", propertiesToAdd.size(), propertiesToAdd);
1050
1051                                 Either<Map<String, PropertyData>, TitanOperationStatus> addPropertiesToCapablityType = propertyOperation.addPropertiesToElementType(groupTypeInGraph.getUniqueId(), NodeTypeEnum.GroupType, propertiesToAdd);
1052                                 if (addPropertiesToCapablityType.isRight()) {
1053                                         log.info("Failed to add properties to group type :{}", addPropertiesToCapablityType.right().value());
1054                                         result = false;
1055                                         return result;
1056                                 }
1057                         } else {
1058                                 log.debug("No properties to add to vfModule");
1059                         }
1060
1061                 } catch (Exception e) {
1062                         log.error("Failed {} with exception: ", "alignGroupDataType", e);
1063                         result = false;
1064                 } finally {
1065                         log.info(" Align group data type properties finished");
1066                         if (!result) {
1067                                 log.info("Doing rollback");
1068                                 titanGenericDao.rollback();
1069                         } else {
1070                                 log.info("Doing commit");
1071                                 titanGenericDao.commit();
1072                         }
1073                 }
1074                 return result;
1075         }
1076
1077         private boolean ifExistOnGraph(String name, List<PropertyDefinition> propertiesInGraph) {
1078                 for (PropertyDefinition pd : propertiesInGraph) {
1079                         if (pd.getName().equals(name)) {
1080                                 return true;
1081                         }
1082                 }
1083                 return false;
1084         }
1085
1086         public boolean alignDataType() {
1087
1088                 log.info(" Align data type properties");
1089
1090                 boolean isSuccessful = true;
1091                 List<DataTypeDefinition> dataTypes = extractDataTypesFromYaml();
1092
1093                 if (CollectionUtils.isEmpty(dataTypes)) {
1094                         isSuccessful = false;
1095                 }
1096
1097                 List<ImmutablePair<DataTypeDefinition, Boolean>> createdElementTypes = new ArrayList<>();
1098
1099                 Iterator<DataTypeDefinition> elementTypeItr = dataTypes.iterator();
1100                 if (isSuccessful) {
1101                         try {
1102                                 while (elementTypeItr.hasNext()) {
1103                                         DataTypeDefinition elementType = elementTypeItr.next();
1104                                         String elementName = elementType.getName();
1105                                         Either<ActionStatus, ResponseFormat> validateElementType = validateDataType(elementType);
1106                                         if (validateElementType.isRight()) {
1107                                                 log.debug("Failed to validate data type {}. Status is {}. ", elementName, validateElementType.right().value());
1108                                                 isSuccessful = false;
1109                                                 break;
1110                                         }
1111                                         log.debug("Going to get data type by name {}. ", elementName);
1112                                         Either<DataTypeDefinition, StorageOperationStatus> findElementType = propertyOperation.getDataTypeByNameWithoutDerived(elementName);
1113                                         if (findElementType.isRight()) {
1114                                                 StorageOperationStatus status = findElementType.right().value();
1115                                                 if (status != StorageOperationStatus.NOT_FOUND) {
1116                                                         log.debug("Failed to fetch data type {}. Status is {}. ", elementName, validateElementType.right().value());
1117                                                         isSuccessful = false;
1118                                                         break;
1119                                                 } else {
1120                                                         log.debug("Going to add data type with name {}. ", elementName);
1121                                                         Either<DataTypeDefinition, StorageOperationStatus> dataModelResponse = propertyOperation.addDataType(elementType);
1122
1123                                                         if (dataModelResponse.isRight()) {
1124                                                                 if (dataModelResponse.right().value() != StorageOperationStatus.SCHEMA_VIOLATION) {
1125                                                                         log.debug("Failed to add data type {}. Status is {}. ", elementName, dataModelResponse.right().value());
1126                                                                         isSuccessful = false;
1127                                                                         break;
1128                                                                 } else {
1129                                                                         createdElementTypes.add(new ImmutablePair<DataTypeDefinition, Boolean>(elementType, false));
1130                                                                 }
1131                                                         } else {
1132                                                                 createdElementTypes.add(new ImmutablePair<DataTypeDefinition, Boolean>(dataModelResponse.left().value(), true));
1133                                                         }
1134
1135                                                 }
1136                                         } else {
1137                                                 DataTypeDefinition dataTypeDefinition = findElementType.left().value();
1138                                                 log.debug("Going to update data type with name {}. ", elementName);
1139                                                 Either<Map<String, PropertyDefinition>, StorageOperationStatus> deleteDataTypeRes = propertyOperation.deleteAllPropertiesAssociatedToNode(NodeTypeEnum.DataType, dataTypeDefinition.getUniqueId());
1140                                                 if (deleteDataTypeRes.isRight()) {
1141                                                         StorageOperationStatus status = deleteDataTypeRes.right().value();
1142                                                         if (status != StorageOperationStatus.OK) {
1143
1144                                                                 log.debug("Failed to update data type {}. Status is {}. ", elementName, deleteDataTypeRes.right().value());
1145                                                                 isSuccessful = false;
1146                                                                 break;
1147                                                         }
1148                                                 }
1149
1150                                                 Either<Map<String, PropertyData>, TitanOperationStatus> updateDataTypeRes = propertyOperation.addPropertiesToElementType(dataTypeDefinition.getUniqueId(), NodeTypeEnum.DataType, elementType.getProperties());
1151
1152                                                 if (updateDataTypeRes.isRight()) {
1153                                                         TitanOperationStatus status = updateDataTypeRes.right().value();
1154
1155                                                         log.debug("Failed to update data type {}. Status is {}. ", elementName, updateDataTypeRes.right().value());
1156                                                         isSuccessful = false;
1157                                                         break;
1158
1159                                                 } else {
1160                                                         createdElementTypes.add(new ImmutablePair<DataTypeDefinition, Boolean>(elementType, true));
1161                                                 }
1162
1163                                                 DataTypeData dataTypeData = new DataTypeData();
1164                                                 dataTypeData.setDataTypeDataDefinition(elementType);
1165                                                 dataTypeData.getDataTypeDataDefinition().setUniqueId(dataTypeDefinition.getUniqueId());
1166                                                 long modificationTime = System.currentTimeMillis();
1167                                                 dataTypeData.getDataTypeDataDefinition().setModificationTime(modificationTime);
1168
1169                                                 Either<DataTypeData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(dataTypeData, DataTypeData.class);
1170                                                 if (updateNode.isRight()) {
1171                                                         TitanOperationStatus operationStatus = updateNode.right().value();
1172                                                         log.debug("Failed to update modification time data type {} from graph. status is {}",
1173                                                                         dataTypeDefinition.getUniqueId() ,operationStatus);
1174                                                         BeEcompErrorManager.getInstance().logInternalFlowError("AddPropertyToDataType", "Failed to fetch data type. Status is " + operationStatus, ErrorSeverity.ERROR);
1175                                                         isSuccessful = false;
1176                                                         break;
1177                                                 } else {
1178                                                         log.debug("Update data type uid {}. Set modification time to {}", dataTypeDefinition.getUniqueId(), modificationTime);
1179                                                         isSuccessful = true;
1180                                                 }
1181                                         }
1182                                 }
1183                         } finally {
1184                                 log.info(" Finish to align data type properties");
1185                                 if (isSuccessful) {
1186                                         propertyOperation.getTitanGenericDao().commit();
1187                                 } else {
1188                                         propertyOperation.getTitanGenericDao().rollback();
1189                                 }
1190                         }
1191                 }
1192                 return isSuccessful;
1193         }
1194
1195         @SuppressWarnings("unchecked")
1196         private List<DataTypeDefinition> extractDataTypesFromYaml() {
1197                 String dataTypeYmlFilePath = CONFIG_DATA_TYPES_YML;
1198                 String yamlAsString;
1199                 try {
1200
1201                         InputStream inputStream = getClass().getResourceAsStream(dataTypeYmlFilePath);
1202                         if (inputStream == null) {
1203                                 log.info("Failed to load input file : {}", dataTypeYmlFilePath);
1204                                 return null;
1205                         }
1206                         yamlAsString = IOUtils.toString(inputStream, StandardCharsets.UTF_8.name());
1207
1208                 } catch (Exception e) {
1209                         log.info("Failed to load group types file exception : ", e);
1210                         return null;
1211                 }
1212
1213                 log.debug("received yaml: {}", yamlAsString);
1214
1215                 String dataTypeName;
1216                 List<DataTypeDefinition> dataTypes = new ArrayList<>();
1217
1218                 Map<String, Object> toscaJson = (Map<String, Object>) new Yaml().load(yamlAsString);
1219                 Iterator<Entry<String, Object>> elementTypesEntryItr = toscaJson.entrySet().iterator();
1220                 while (elementTypesEntryItr.hasNext()) {
1221                         Entry<String, Object> elementTypeNameDataEntry = elementTypesEntryItr.next();
1222                         dataTypeName = elementTypeNameDataEntry.getKey();
1223                         Map<String, Object> elementTypeJsonData = (Map<String, Object>) elementTypeNameDataEntry.getValue();
1224
1225                         DataTypeDefinition dataType = new DataTypeDefinition();
1226                         dataType.setName(dataTypeName);
1227
1228                         if (elementTypeJsonData != null) {
1229
1230                                 if (elementTypeJsonData.containsKey(ToscaTagNamesEnum.DESCRIPTION.getElementName())) {
1231                                         dataType.setDescription((String) elementTypeJsonData.get(ToscaTagNamesEnum.DESCRIPTION.getElementName()));
1232                                 }
1233                                 if (elementTypeJsonData.containsKey(ToscaTagNamesEnum.DERIVED_FROM.getElementName())) {
1234                                         dataType.setDerivedFromName((String) elementTypeJsonData.get(ToscaTagNamesEnum.DERIVED_FROM.getElementName()));
1235                                 }
1236                                 List<PropertyDefinition> properties = getProperties(elementTypeJsonData);
1237                                 if (elementTypeJsonData.containsKey(ToscaTagNamesEnum.PROPERTIES.getElementName())) {
1238                                         dataType.setProperties(properties);
1239                                 }
1240                         }
1241                         dataTypes.add(dataType);
1242                 }
1243
1244                 return dataTypes;
1245         }
1246
1247         private List<PropertyDefinition> getProperties(Map<String, Object> toscaJson) {
1248                 List<PropertyDefinition> values = null;
1249                 Either<Map<String, PropertyDefinition>, ResultStatusEnum> properties = ImportUtils.getProperties(toscaJson);
1250
1251                 if (properties.isLeft()) {
1252                         values = new ArrayList<>();
1253                         Map<String, PropertyDefinition> propertiesMap = properties.left().value();
1254                         if (propertiesMap != null && propertiesMap.isEmpty() == false) {
1255
1256                                 for (Entry<String, PropertyDefinition> entry : propertiesMap.entrySet()) {
1257                                         String propName = entry.getKey();
1258                                         PropertyDefinition propertyDefinition = entry.getValue();
1259                                         PropertyDefinition newPropertyDefinition = new PropertyDefinition(propertyDefinition);
1260                                         newPropertyDefinition.setName(propName);
1261                                         values.add(newPropertyDefinition);
1262                                 }
1263                         }
1264                 }
1265
1266                 return values;
1267         }
1268
1269         private Either<ActionStatus, ResponseFormat> validateDataType(DataTypeDefinition dataType) {
1270
1271                 String dataTypeName = dataType.getName();
1272                 List<PropertyDefinition> properties = dataType.getProperties();
1273                 if (properties == null) {
1274                         // At least one parameter should be defined either in the properties
1275                         // section or at one of the parents
1276                         String derivedDataType = dataType.getDerivedFromName();
1277                         // If there are no properties, then we can create a data type if it
1278                         // is an abstract one or it derives from non abstract data type
1279                         if ((derivedDataType == null || derivedDataType.isEmpty())) {
1280                                 if (false == isAbstract(dataType.getName())) {
1281                                         if (false == ToscaPropertyType.isScalarType(dataTypeName)) {
1282                                                 log.debug("Data type {} must have properties unless it derives from non abstract data type",dataType.getName());
1283                                                 ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_NOR_PROPERTIES_NEITHER_DERIVED_FROM, dataType, null);
1284
1285                                                 return Either.right(responseFormat);
1286                                         }
1287                                 }
1288                         } else {
1289                                 // if it is not a scalar data type and it derives from abstract
1290                                 // data type, we should reject the request.
1291                                 if (false == ToscaPropertyType.isScalarType(dataTypeName) && true == isAbstract(derivedDataType)) {
1292                                         log.debug("Data type {} which derived from abstract data type must have at least one property",dataType.getName());
1293                                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_NOR_PROPERTIES_NEITHER_DERIVED_FROM, dataType, null);
1294
1295                                         return Either.right(responseFormat);
1296                                 }
1297                         }
1298                 } else {
1299                         // properties tag cannot be empty
1300                         if (properties.isEmpty()) {
1301                                 ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_PROPERTIES_CANNOT_BE_EMPTY, dataType, null);
1302
1303                                 return Either.right(responseFormat);
1304                         }
1305
1306                         // check no duplicates
1307                         Set<String> collect = properties.stream().map(p -> p.getName()).collect(Collectors.toSet());
1308                         if (collect != null) {
1309                                 if (properties.size() != collect.size()) {
1310                                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_DUPLICATE_PROPERTY, dataType, null);
1311
1312                                         return Either.right(responseFormat);
1313                                 }
1314                         }
1315
1316                         List<String> propertiesWithSameTypeAsDataType = properties.stream().filter(p -> p.getType().equals(dataType.getName())).map(p -> p.getName()).collect(Collectors.toList());
1317                         if (propertiesWithSameTypeAsDataType != null && propertiesWithSameTypeAsDataType.isEmpty() == false) {
1318                                 log.debug("The data type contains properties with the type {}",dataType.getName(),dataType.getName());
1319                                 ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_PROEPRTY_CANNOT_HAVE_SAME_TYPE_OF_DATA_TYPE, dataType, propertiesWithSameTypeAsDataType);
1320
1321                                 return Either.right(responseFormat);
1322                         }
1323                 }
1324
1325                 String derivedDataType = dataType.getDerivedFromName();
1326                 if (derivedDataType != null) {
1327                         Either<DataTypeDefinition, StorageOperationStatus> derivedDataTypeByName = propertyOperation.getDataTypeByName(derivedDataType, true);
1328                         if (derivedDataTypeByName.isRight()) {
1329                                 StorageOperationStatus status = derivedDataTypeByName.right().value();
1330                                 if (status == StorageOperationStatus.NOT_FOUND) {
1331                                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_DERIVED_IS_MISSING, dataType, null);
1332
1333                                         return Either.right(responseFormat);
1334                                 } else {
1335                                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.GENERAL_ERROR, dataType, null);
1336
1337                                         return Either.right(responseFormat);
1338
1339                                 }
1340                         } else {
1341
1342                                 DataTypeDefinition derivedDataTypeDef = derivedDataTypeByName.left().value();
1343                                 if (properties != null && properties.isEmpty() == false) {
1344
1345                                         if (true == isScalarType(derivedDataTypeDef)) {
1346                                                 ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_CANNOT_HAVE_PROPERTIES, dataType, null);
1347
1348                                                 return Either.right(responseFormat);
1349                                         }
1350
1351                                         Set<String> allParentsProps = new HashSet<>();
1352                                         do {
1353                                                 List<PropertyDefinition> currentParentsProps = derivedDataTypeDef.getProperties();
1354                                                 if (currentParentsProps != null) {
1355                                                         for (PropertyDefinition propertyDefinition : currentParentsProps) {
1356                                                                 allParentsProps.add(propertyDefinition.getName());
1357                                                         }
1358                                                 }
1359                                                 derivedDataTypeDef = derivedDataTypeDef.getDerivedFrom();
1360                                         } while (derivedDataTypeDef != null);
1361
1362                                         // Check that no property is already defined in one of the
1363                                         // ancestors
1364                                         Set<String> alreadyExistPropsCollection = properties.stream().filter(p -> allParentsProps.contains(p.getName())).map(p -> p.getName()).collect(Collectors.toSet());
1365                                         if (alreadyExistPropsCollection != null && alreadyExistPropsCollection.isEmpty() == false) {
1366                                                 List<String> duplicateProps = new ArrayList<>();
1367                                                 duplicateProps.addAll(alreadyExistPropsCollection);
1368                                                 ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_PROPERTY_ALREADY_DEFINED_IN_ANCESTOR, dataType, duplicateProps);
1369
1370                                                 return Either.right(responseFormat);
1371                                         }
1372
1373                                 }
1374                         }
1375                 }
1376                 return Either.left(ActionStatus.OK);
1377         }
1378
1379         private boolean isAbstract(String dataTypeName) {
1380
1381                 ToscaPropertyType isPrimitiveToscaType = ToscaPropertyType.isValidType(dataTypeName);
1382
1383                 return isPrimitiveToscaType != null && isPrimitiveToscaType.isAbstract() == true;
1384
1385         }
1386
1387         private boolean isScalarType(DataTypeDefinition dataTypeDef) {
1388
1389                 boolean isScalar = false;
1390                 DataTypeDefinition dataType = dataTypeDef;
1391
1392                 while (dataType != null) {
1393
1394                         String name = dataType.getName();
1395                         if (ToscaPropertyType.isScalarType(name)) {
1396                                 isScalar = true;
1397                                 break;
1398                         }
1399
1400                         dataType = dataType.getDerivedFrom();
1401                 }
1402
1403                 return isScalar;
1404         }
1405
1406 }