2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.model.operations.impl;
23 import fj.data.Either;
24 import org.apache.commons.lang3.tuple.ImmutablePair;
25 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
26 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
27 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
28 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
29 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
30 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
31 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
32 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
34 import org.openecomp.sdc.be.model.ArtifactDefinition;
35 import org.openecomp.sdc.be.model.InterfaceDefinition;
36 import org.openecomp.sdc.be.model.Operation;
37 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
38 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
39 import org.openecomp.sdc.be.resources.data.ArtifactData;
40 import org.openecomp.sdc.be.resources.data.InterfaceData;
41 import org.openecomp.sdc.be.resources.data.OperationData;
42 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
43 import org.openecomp.sdc.common.log.wrappers.Logger;
44 import org.springframework.stereotype.Component;
47 import java.util.Map.Entry;
48 import java.util.List;
50 import java.util.Map.Entry;
53 @Component("interface-operation")
54 public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation {
56 private static final Logger log = Logger.getLogger(InterfaceLifecycleOperation.class.getName());
58 public InterfaceLifecycleOperation() {
62 @javax.annotation.Resource
63 private ArtifactOperation artifactOperation;
65 @javax.annotation.Resource
66 private TitanGenericDao titanGenericDao;
69 public Either<InterfaceDefinition, StorageOperationStatus> addInterfaceToResource(InterfaceDefinition interf, String resourceId, String interfaceName, boolean inTransaction) {
71 return createInterfaceOnResource(interf, resourceId, interfaceName, true, inTransaction);
75 private Either<OperationData, TitanOperationStatus> addOperationToGraph(InterfaceDefinition interf, String opName, Operation op, InterfaceData interfaceData) {
77 op.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId((String) interfaceData.getUniqueId(), opName));
78 OperationData operationData = new OperationData(op);
80 log.debug("Before adding operation to graph {}", operationData);
81 Either<OperationData, TitanOperationStatus> createOpNodeResult = titanGenericDao.createNode(operationData, OperationData.class);
82 log.debug("After adding operation to graph {}", operationData);
84 if (createOpNodeResult.isRight()) {
85 TitanOperationStatus opStatus = createOpNodeResult.right().value();
86 log.error("Failed to add operation {} to graph. status is {}", opName, opStatus);
87 return Either.right(opStatus);
90 Map<String, Object> props = new HashMap<>();
91 props.put(GraphPropertiesDictionary.NAME.getProperty(), opName);
92 Either<GraphRelation, TitanOperationStatus> createRelResult = titanGenericDao.createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props);
94 if (createRelResult.isRight()) {
95 TitanOperationStatus operationStatus = createOpNodeResult.right().value();
96 log.error("Failed to associate operation {} to property {} in graph. status is {}", interfaceData.getUniqueId(), opName, operationStatus);
98 return Either.right(operationStatus);
101 return Either.left(createOpNodeResult.left().value());
105 private InterfaceDefinition convertInterfaceDataToInterfaceDefinition(InterfaceData interfaceData) {
107 log.debug("The object returned after create interface is {}", interfaceData);
109 return new InterfaceDefinition(interfaceData.getInterfaceDataDefinition());
113 private Operation convertOperationDataToOperation(OperationData operationData) {
115 log.debug("The object returned after create operation is {}", operationData);
117 return new Operation(operationData.getOperationDataDefinition());
121 private Either<InterfaceData, TitanOperationStatus> addInterfaceToGraph(InterfaceDefinition interfaceInfo, String interfaceName, String resourceId) {
123 InterfaceData interfaceData = new InterfaceData(interfaceInfo);
125 ResourceMetadataData resourceData = new ResourceMetadataData();
126 resourceData.getMetadataDataDefinition().setUniqueId(resourceId);
128 String interfaceNameSplitted = getShortInterfaceName(interfaceInfo);
130 interfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted));
132 Either<InterfaceData, TitanOperationStatus> existInterface = titanGenericDao.getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class);
134 if (existInterface.isRight()) {
136 return createInterfaceNodeAndRelation(interfaceNameSplitted, resourceId, interfaceData, resourceData);
138 log.debug("Interface {} already exist", interfaceData.getUniqueId());
139 return Either.right(TitanOperationStatus.ALREADY_EXIST);
143 private Either<InterfaceData, TitanOperationStatus> createInterfaceNodeAndRelation(String interfaceName, String resourceId, InterfaceData interfaceData, ResourceMetadataData resourceData) {
144 log.debug("Before adding interface to graph {}", interfaceData);
145 Either<InterfaceData, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(interfaceData, InterfaceData.class);
146 log.debug("After adding property to graph {}", interfaceData);
148 if (createNodeResult.isRight()) {
149 TitanOperationStatus operationStatus = createNodeResult.right().value();
150 log.error("Failed to add interface {} to graph. status is {}", interfaceName, operationStatus);
151 return Either.right(operationStatus);
154 Map<String, Object> props = new HashMap<>();
155 props.put(GraphPropertiesDictionary.NAME.getProperty(), interfaceName);
156 Either<GraphRelation, TitanOperationStatus> createRelResult = titanGenericDao.createRelation(resourceData, interfaceData, GraphEdgeLabels.INTERFACE, props);
157 if (createRelResult.isRight()) {
158 TitanOperationStatus operationStatus = createNodeResult.right().value();
159 log.error("Failed to associate resource {} to property {} in graph. status is {}", resourceId, interfaceName, operationStatus);
161 return Either.right(operationStatus);
164 return Either.left(createNodeResult.left().value());
167 private Either<OperationData, TitanOperationStatus> createOperationNodeAndRelation(String operationName, OperationData operationData, InterfaceData interfaceData) {
168 log.debug("Before adding operation to graph {}", operationData);
169 Either<OperationData, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(operationData, OperationData.class);
170 log.debug("After adding operation to graph {}", interfaceData);
172 if (createNodeResult.isRight()) {
173 TitanOperationStatus operationStatus = createNodeResult.right().value();
174 log.error("Failed to add interfoperationce {} to graph. status is {}", operationName, operationStatus);
175 return Either.right(operationStatus);
178 Map<String, Object> props = new HashMap<>();
179 props.put(GraphPropertiesDictionary.NAME.getProperty(), operationName);
180 Either<GraphRelation, TitanOperationStatus> createRelResult = titanGenericDao.createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props);
181 if (createRelResult.isRight()) {
182 TitanOperationStatus operationStatus = createNodeResult.right().value();
183 log.error("Failed to associate operation {} to interface {} in graph. status is {}", operationName, interfaceData.getUniqueId(), operationStatus);
185 return Either.right(operationStatus);
188 return Either.left(createNodeResult.left().value());
192 public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfacesOfResource(String resourceIdn, boolean recursively) {
193 return getAllInterfacesOfResource(resourceIdn, recursively, false);
197 public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfacesOfResource(String resourceId, boolean recursively, boolean inTransaction) {
199 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> result = null;
200 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
202 if ((resourceId == null) || resourceId.isEmpty()) {
203 log.error("resourceId is empty");
204 result = Either.right(StorageOperationStatus.INVALID_ID);
208 TitanOperationStatus findInterfacesRes = TitanOperationStatus.GENERAL_ERROR;
210 findInterfacesRes = findAllInterfacesRecursively(resourceId, interfaces);
212 findInterfacesRes = findAllInterfacesNotRecursively(resourceId, interfaces);
214 if (!findInterfacesRes.equals(TitanOperationStatus.OK)) {
215 log.error("Failed to get all interfaces of resource {}. status is {}", resourceId, findInterfacesRes);
216 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(findInterfacesRes));
219 result = Either.left(interfaces);
222 if (!inTransaction) {
223 if (result == null || result.isRight()) {
224 log.error("Going to execute rollback on graph.");
225 titanGenericDao.rollback();
227 log.debug("Going to execute commit on graph.");
228 titanGenericDao.commit();
234 private TitanOperationStatus findAllInterfacesNotRecursively(String resourceId, Map<String, InterfaceDefinition> interfaces) {
236 Either<List<ImmutablePair<InterfaceData, GraphEdge>>, TitanOperationStatus> interfaceNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.INTERFACE,
237 NodeTypeEnum.Interface, InterfaceData.class);
239 if (interfaceNodes.isRight()) {
240 TitanOperationStatus status = interfaceNodes.right().value();
241 if (status != TitanOperationStatus.NOT_FOUND) {
245 List<ImmutablePair<InterfaceData, GraphEdge>> interfaceList = interfaceNodes.left().value();
246 if (interfaceList != null) {
247 for (ImmutablePair<InterfaceData, GraphEdge> interfacePair : interfaceList) {
248 String interfaceUniqueId = (String) interfacePair.getKey().getUniqueId();
249 Either<String, TitanOperationStatus> interfaceNameRes = getPropertyValueFromEdge(interfacePair.getValue(), GraphPropertiesDictionary.NAME);
250 if (interfaceNameRes.isRight()) {
251 log.error("The requirement name is missing on the edge of requirement {}", interfaceUniqueId);
252 return interfaceNameRes.right().value();
254 String interfaceName = interfaceNameRes.left().value();
255 Either<InterfaceDefinition, TitanOperationStatus> interfaceDefRes = getNonRecursiveInterface(interfacePair.getKey());
256 if (interfaceDefRes.isRight()) {
257 TitanOperationStatus status = interfaceDefRes.right().value();
258 log.error("Failed to get interface actions of interface {}", interfaceUniqueId);
262 InterfaceDefinition interfaceDefinition = interfaceDefRes.left().value();
263 if (interfaces.containsKey(interfaceName)) {
264 log.debug("The interface {} was already defined in dervied resource. add not overriden operations", interfaceName);
265 InterfaceDefinition existInterface = interfaces.get(interfaceName);
266 addMissingOperationsToInterface(interfaceDefinition, existInterface);
268 interfaces.put(interfaceName, interfaceDefinition);
274 return TitanOperationStatus.OK;
277 public TitanOperationStatus findAllInterfacesRecursively(String resourceId, Map<String, InterfaceDefinition> interfaces) {
279 TitanOperationStatus findAllInterfacesNotRecursively = findAllInterfacesNotRecursively(resourceId, interfaces);
280 if (!findAllInterfacesNotRecursively.equals(TitanOperationStatus.OK)) {
281 log.error("failed to get interfaces for resource {}. status is {}", resourceId, findAllInterfacesNotRecursively);
284 Either<ImmutablePair<ResourceMetadataData, GraphEdge>, TitanOperationStatus> parentNodes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
285 ResourceMetadataData.class);
287 if (parentNodes.isRight()) {
288 TitanOperationStatus parentNodesStatus = parentNodes.right().value();
289 if (parentNodesStatus == TitanOperationStatus.NOT_FOUND) {
290 log.debug("Finish to lookup for parnet interfaces");
291 return TitanOperationStatus.OK;
293 log.error("Failed to find parent interfaces of resource {}. status is {}", resourceId, parentNodesStatus);
294 return parentNodesStatus;
297 ImmutablePair<ResourceMetadataData, GraphEdge> parnetNodePair = parentNodes.left().value();
298 String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId();
299 TitanOperationStatus addParentIntStatus = findAllInterfacesRecursively(parentUniqueId, interfaces);
301 if (addParentIntStatus != TitanOperationStatus.OK) {
302 log.error("Failed to fetch all interfaces of resource {}", parentUniqueId);
303 return addParentIntStatus;
306 return TitanOperationStatus.OK;
309 private Either<String, TitanOperationStatus> getPropertyValueFromEdge(GraphEdge edge, GraphPropertiesDictionary property) {
310 Map<String, Object> edgeProps = edge.getProperties();
311 String interfaceName = null;
312 if (edgeProps != null) {
313 interfaceName = (String) edgeProps.get(property.getProperty());
314 if (interfaceName == null) {
315 return Either.right(TitanOperationStatus.INVALID_ELEMENT);
318 return Either.right(TitanOperationStatus.INVALID_ELEMENT);
320 return Either.left(interfaceName);
323 private Either<InterfaceDefinition, TitanOperationStatus> getNonRecursiveInterface(InterfaceData interfaceData) {
325 log.debug("Going to fetch the operations associate to interface {}", interfaceData.getUniqueId());
326 InterfaceDefinition interfaceDefinition = new InterfaceDefinition(interfaceData.getInterfaceDataDefinition());
328 String interfaceId = interfaceData.getUniqueId();
329 Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> operationsRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceId, GraphEdgeLabels.INTERFACE_OPERATION,
330 NodeTypeEnum.InterfaceOperation, OperationData.class);
332 if (operationsRes.isRight()) {
333 TitanOperationStatus status = operationsRes.right().value();
334 if (status != TitanOperationStatus.NOT_FOUND) {
335 return Either.right(status);
337 return Either.left(interfaceDefinition);
341 List<ImmutablePair<OperationData, GraphEdge>> operationList = operationsRes.left().value();
342 if (operationList != null && !operationList.isEmpty()) {
343 for (ImmutablePair<OperationData, GraphEdge> operationPair : operationList) {
344 Operation operation = new Operation(operationPair.getKey().getOperationDataDefinition());
345 Either<String, TitanOperationStatus> operationNameRes = getPropertyValueFromEdge(operationPair.getValue(), GraphPropertiesDictionary.NAME);
346 if (operationNameRes.isRight()) {
347 log.error("The operation name is missing on the edge of operation {}", operationPair.getKey().getUniqueId());
348 return Either.right(operationNameRes.right().value());
350 String operationName = operationNameRes.left().value();
351 findOperationImplementation(operation);
352 interfaceDefinition.getOperations().put(operationName, operation);
356 return Either.left(interfaceDefinition);
359 private StorageOperationStatus findOperationImplementation(Operation operation) {
361 String operationId = operation.getUniqueId();
362 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifactsRes = artifactOperation.getArtifacts(operationId, NodeTypeEnum.InterfaceOperation, true);
363 if (artifactsRes.isRight() || artifactsRes.left().value() == null) {
364 log.error("failed to get artifact from graph for operation id {}. status is {}", operationId, artifactsRes.right().value());
365 return artifactsRes.right().value();
367 Map<String, ArtifactDefinition> artifacts = artifactsRes.left().value();
368 Iterator<String> iter = artifacts.keySet().iterator();
370 if (iter.hasNext()) {
371 operation.setImplementation(artifacts.get(iter.next()));
374 return StorageOperationStatus.OK;
377 private StorageOperationStatus addMissingOperationsToInterface(InterfaceDefinition interfaceDefinition, InterfaceDefinition existInterface) {
378 Map<String, Operation> existOperations = existInterface.getOperationsMap();
379 Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
380 if (operations != null && !operations.isEmpty()) {
381 Set<Entry<String, Operation>> operationsSet = operations.entrySet();
382 for (Entry<String, Operation> operation : operationsSet) {
383 if (!existOperations.containsKey(operation.getKey())) {
384 existOperations.put(operation.getKey(), operation.getValue());
388 return StorageOperationStatus.OK;
392 public Either<Operation, StorageOperationStatus> updateInterfaceOperation(String resourceId, String interfaceName, String operationName, Operation interf) {
394 return updateInterfaceOperation(resourceId, interfaceName, operationName, interf, false);
398 public Either<Operation, StorageOperationStatus> updateInterfaceOperation(String resourceId, String interfaceName, String operationName, Operation operation, boolean inTransaction) {
399 return updateOperationOnGraph(operation, resourceId, interfaceName, operationName);
402 private Either<Operation, StorageOperationStatus> updateOperationOnGraph(Operation operation, String resourceId, String interfaceName, String operationName) {
404 Either<List<ImmutablePair<InterfaceData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface,
405 InterfaceData.class);
407 if (childrenNodes.isRight()) {
408 return updateOperationFromParentNode(operation, resourceId, interfaceName, operationName);
411 return updateExistingOperation(resourceId, operation, interfaceName, operationName, childrenNodes);
417 private Either<Operation, StorageOperationStatus> updateExistingOperation(String resourceId, Operation operation, String interfaceName, String operationName,
418 Either<List<ImmutablePair<InterfaceData, GraphEdge>>, TitanOperationStatus> childrenNodes) {
419 Operation newOperation = null;
420 StorageOperationStatus storageOperationStatus = StorageOperationStatus.GENERAL_ERROR;
422 for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
424 GraphEdge interfaceEdge = interfaceDataNode.getRight();
425 Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
426 InterfaceData interfaceData = interfaceDataNode.getKey();
428 if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceName)) {
429 Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> operationRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(),
430 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
431 if (operationRes.isRight()) {
432 log.error("Failed to find operation {} on interface {}", operationName, interfaceName);
433 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value()));
435 List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
436 for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
437 GraphEdge opEdge = operationPairEdge.getRight();
438 OperationData opData = operationPairEdge.getLeft();
439 Map<String, Object> opEdgeProp = opEdge.getProperties();
440 if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
441 ArtifactDefinition artifact = operation.getImplementationArtifact();
442 Either<ImmutablePair<ArtifactData, GraphEdge>, TitanOperationStatus> artifactRes = titanGenericDao.getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) opData.getUniqueId(), GraphEdgeLabels.ARTIFACT_REF,
443 NodeTypeEnum.ArtifactRef, ArtifactData.class);
444 Either<ArtifactDefinition, StorageOperationStatus> artStatus;
445 if (artifactRes.isRight()) {
446 artStatus = artifactOperation.addArifactToComponent(artifact, (String) operationPairEdge.getLeft().getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true);
448 artStatus = artifactOperation.updateArifactOnResource(artifact, (String) operationPairEdge.getLeft().getUniqueId(), (String) artifactRes.left().value().getLeft().getUniqueId(), NodeTypeEnum.InterfaceOperation, true);
450 if (artStatus.isRight()) {
451 titanGenericDao.rollback();
452 log.error("Failed to add artifact {} to interface {}", operationName, interfaceName);
453 return Either.right(artStatus.right().value());
455 newOperation = this.convertOperationDataToOperation(opData);
456 newOperation.setImplementation(artStatus.left().value());
463 if (newOperation == null) {
464 Either<InterfaceData, TitanOperationStatus> parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName);
465 if (parentInterfaceStatus.isRight()) {
466 log.debug("Interface {} not exist", interfaceName);
467 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(parentInterfaceStatus.right().value()));
470 InterfaceData parentInterfaceData = parentInterfaceStatus.left().value();
471 Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> opRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) parentInterfaceData.getUniqueId(),
472 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
473 if (opRes.isRight()) {
474 log.error("Failed to find operation {} on interface {}", operationName, interfaceName);
475 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value()));
478 List<ImmutablePair<OperationData, GraphEdge>> parentOperations = opRes.left().value();
479 for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : parentOperations) {
480 GraphEdge opEdge = operationPairEdge.getRight();
481 OperationData opData = operationPairEdge.getLeft();
482 Map<String, Object> opEdgeProp = opEdge.getProperties();
483 if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
484 return copyAndCreateNewOperation(operation, interfaceName, operationName, null, interfaceData, operationRes, opData);
495 storageOperationStatus = StorageOperationStatus.ARTIFACT_NOT_FOUND;
499 if (newOperation == null)
500 return Either.right(storageOperationStatus);
502 return Either.left(newOperation);
505 private Either<Operation, StorageOperationStatus> copyAndCreateNewOperation(Operation operation, String interfaceName, String operationName, Operation newOperation, InterfaceData interfaceData,
506 Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> operationRes, OperationData opData) {
507 OperationDataDefinition opDataInfo = opData.getOperationDataDefinition();
508 OperationDataDefinition newOperationInfo = new OperationDataDefinition(opDataInfo);
509 newOperationInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(interfaceData.getUniqueId(), operationName.toLowerCase()));
510 OperationData newopData = new OperationData(newOperationInfo);
511 Either<OperationData, TitanOperationStatus> operationStatus = createOperationNodeAndRelation(operationName, newopData, interfaceData);
512 if (operationStatus.isRight()) {
513 log.error("Failed to create operation {} on interface {}", operationName, interfaceName);
514 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value()));
516 ArtifactDefinition artifact = operation.getImplementationArtifact();
517 if (artifact != null) {
518 Either<ArtifactDefinition, StorageOperationStatus> artStatus = artifactOperation.addArifactToComponent(artifact, (String) operationStatus.left().value().getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true);
519 if (artStatus.isRight()) {
520 titanGenericDao.rollback();
521 log.error("Failed to add artifact {} to interface {}", operationName, interfaceName);
523 newOperation = this.convertOperationDataToOperation(opData);
524 newOperation.setImplementation(artStatus.left().value());
528 return Either.left(newOperation);
531 private Either<Operation, StorageOperationStatus> updateOperationFromParentNode(Operation operation, String resourceId, String interfaceName, String operationName) {
532 // Operation newOperation = null;
533 ResourceMetadataData resourceData = new ResourceMetadataData();
534 resourceData.getMetadataDataDefinition().setUniqueId(resourceId);
535 Either<InterfaceData, TitanOperationStatus> parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName);
536 if (parentInterfaceStatus.isRight()) {
537 log.debug("Interface {} not exist", interfaceName);
538 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(parentInterfaceStatus.right().value()));
541 InterfaceData interfaceData = parentInterfaceStatus.left().value();
542 InterfaceDataDefinition intDataDefinition = interfaceData.getInterfaceDataDefinition();
543 InterfaceDataDefinition newInterfaceInfo = new InterfaceDataDefinition(intDataDefinition);
545 String interfaceNameSplitted = getShortInterfaceName(intDataDefinition);
547 newInterfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted));
548 InterfaceData updatedInterfaceData = new InterfaceData(newInterfaceInfo);
549 Either<InterfaceData, TitanOperationStatus> createStatus = createInterfaceNodeAndRelation(interfaceName, resourceId, updatedInterfaceData, resourceData);
550 if (createStatus.isRight()) {
551 log.debug("failed to create interface node {} on resource {}", interfaceName, resourceId);
552 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createStatus.right().value()));
555 InterfaceData newInterfaceNode = createStatus.left().value();
556 Either<GraphRelation, TitanOperationStatus> createRelResult = titanGenericDao.createRelation(newInterfaceNode, interfaceData, GraphEdgeLabels.DERIVED_FROM, null);
557 if (createRelResult.isRight()) {
558 TitanOperationStatus operationStatus = createRelResult.right().value();
559 log.error("Failed to associate interface {} to interface {} in graph. status is {}", interfaceData.getUniqueId(), newInterfaceNode.getUniqueId(), operationStatus);
561 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus));
563 Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> operationRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceData.getUniqueId(),
564 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
565 if (operationRes.isRight()) {
566 log.error("Failed to find operation {} on interface {}", operationName, interfaceName);
567 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value()));
570 List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
571 for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
572 GraphEdge opEdge = operationPairEdge.getRight();
573 OperationData opData = operationPairEdge.getLeft();
574 Map<String, Object> opEdgeProp = opEdge.getProperties();
575 if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
577 return copyAndCreateNewOperation(operation, interfaceName, operationName, null, // changed
580 newInterfaceNode, operationRes, opData);
585 return Either.right(StorageOperationStatus.GENERAL_ERROR);
588 private Either<InterfaceData, TitanOperationStatus> findInterfaceOnParentNode(String resourceId, String interfaceName) {
590 Either<ImmutablePair<ResourceMetadataData, GraphEdge>, TitanOperationStatus> parentRes = titanGenericDao.getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
591 ResourceMetadataData.class);
592 if (parentRes.isRight()) {
593 log.debug("interface {} not found ", interfaceName);
594 return Either.right(parentRes.right().value());
596 ImmutablePair<ResourceMetadataData, GraphEdge> parenNode = parentRes.left().value();
598 Either<List<ImmutablePair<InterfaceData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), parenNode.getKey().getMetadataDataDefinition().getUniqueId(),
599 GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, InterfaceData.class);
600 if (childrenNodes.isRight()) {
601 return findInterfaceOnParentNode(parenNode.getKey().getMetadataDataDefinition().getUniqueId(), interfaceName);
604 for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
606 GraphEdge interfaceEdge = interfaceDataNode.getRight();
607 Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
609 if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceName)) {
610 return Either.left(interfaceDataNode.getKey());
614 return findInterfaceOnParentNode(parenNode.getKey().getMetadataDataDefinition().getUniqueId(), interfaceName);
620 public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceOnResource(InterfaceDefinition interf, String resourceId, String interfaceName, boolean failIfExist, boolean inTransaction) {
622 Either<InterfaceData, TitanOperationStatus> status = addInterfaceToGraph(interf, interfaceName, resourceId);
624 if (status.isRight()) {
625 titanGenericDao.rollback();
626 log.error("Failed to add interface {} to resource {}", interfaceName, resourceId);
627 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status.right().value()));
630 if (!inTransaction) {
631 titanGenericDao.commit();
633 InterfaceData interfaceData = status.left().value();
635 InterfaceDefinition interfaceDefResult = convertInterfaceDataToInterfaceDefinition(interfaceData);
636 Map<String, Operation> operations = interf.getOperationsMap();
637 if (operations != null && !operations.isEmpty()) {
638 Set<String> opNames = operations.keySet();
639 Map<String, Operation> newOperations = new HashMap<>();
640 for (String operationName : opNames) {
642 Operation op = operations.get(operationName);
643 Either<OperationData, TitanOperationStatus> opStatus = addOperationToGraph(interf, operationName, op, interfaceData);
644 if (status.isRight()) {
645 titanGenericDao.rollback();
646 log.error("Failed to add operation {} to interface {}", operationName, interfaceName);
647 } else if (status.isLeft()) {
648 if (!inTransaction) {
649 titanGenericDao.commit();
651 OperationData opData = opStatus.left().value();
652 Operation newOperation = this.convertOperationDataToOperation(opData);
654 ArtifactDefinition art = op.getImplementationArtifact();
656 Either<ArtifactDefinition, StorageOperationStatus> artRes = artifactOperation.addArifactToComponent(art, (String) opData.getUniqueId(), NodeTypeEnum.InterfaceOperation, failIfExist, true);
657 if (artRes.isRight()) {
658 titanGenericDao.rollback();
659 log.error("Failed to add artifact {} to interface {}", operationName, interfaceName);
661 newOperation.setImplementation(artRes.left().value());
663 newOperations.put(operationName, newOperation);
667 interfaceDefResult.setOperationsMap(newOperations);
669 log.debug("The returned InterfaceDefintion is {}", interfaceDefResult);
670 return Either.left(interfaceDefResult);
676 public Either<Operation, StorageOperationStatus> deleteInterfaceOperation(String resourceId, String interfaceName, String operationId, boolean inTransaction) {
678 Either<Operation, TitanOperationStatus> status = removeOperationOnGraph(resourceId, interfaceName, operationId);
679 if (status.isRight()) {
680 if (!inTransaction) {
681 titanGenericDao.rollback();
683 log.error("Failed to delete operation {} of interface {} resource {}", operationId, interfaceName, resourceId);
684 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status.right().value()));
686 if (!inTransaction) {
687 titanGenericDao.commit();
690 Operation opDefResult = status.left().value();// convertOperationDataToOperation(operationData);
691 log.debug("The returned Operation is {}", opDefResult);
692 return Either.left(opDefResult);
697 private Either<Operation, TitanOperationStatus> removeOperationOnGraph(String resourceId, String interfaceName, String operationId) {
698 log.debug("Before deleting operation from graph {}", operationId);
700 Either<List<ImmutablePair<InterfaceData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface,
701 InterfaceData.class);
703 if (childrenNodes.isRight()) {
704 log.debug("Not found interface {}", interfaceName);
705 return Either.right(childrenNodes.right().value());
707 OperationData opData = null;
708 for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
710 GraphEdge interfaceEdge = interfaceDataNode.getRight();
711 Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
713 String interfaceSplitedName = splitType(interfaceName);
715 if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceSplitedName)) {
716 Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> operationRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(),
717 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
718 if (operationRes.isRight()) {
719 log.error("Failed to find operation {} on interface {}", operationId, interfaceName);
720 return Either.right(operationRes.right().value());
722 List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
724 for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
726 opData = operationPairEdge.getLeft();
727 if (opData.getUniqueId().equals(operationId)) {
729 Either<ImmutablePair<ArtifactData, GraphEdge>, TitanOperationStatus> artifactRes = titanGenericDao.getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) operationPairEdge.getLeft().getUniqueId(),
730 GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class);
731 Either<ArtifactDefinition, StorageOperationStatus> arStatus = null;
732 if (artifactRes.isLeft()) {
733 ArtifactData arData = artifactRes.left().value().getKey();
734 arStatus = artifactOperation.removeArifactFromResource((String) operationPairEdge.getLeft().getUniqueId(), (String) arData.getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true);
735 if (arStatus.isRight()) {
736 log.debug("failed to delete artifact {}", arData.getUniqueId());
737 return Either.right(TitanOperationStatus.INVALID_ID);
740 Either<OperationData, TitanOperationStatus> deleteOpStatus = titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InterfaceOperation), opData.getUniqueId(), OperationData.class);
741 if (deleteOpStatus.isRight()) {
742 log.debug("failed to delete operation {}", opData.getUniqueId());
743 return Either.right(TitanOperationStatus.INVALID_ID);
745 opData = deleteOpStatus.left().value();
746 Operation operation = new Operation(opData.getOperationDataDefinition());
747 if (arStatus != null) {
748 operation.setImplementation(arStatus.left().value());
750 if (operations.size() <= 1) {
751 Either<InterfaceData, TitanOperationStatus> deleteInterfaceStatus = titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceDataNode.left.getUniqueId(), InterfaceData.class);
752 if (deleteInterfaceStatus.isRight()) {
753 log.debug("failed to delete interface {}", interfaceDataNode.left.getUniqueId());
754 return Either.right(TitanOperationStatus.INVALID_ID);
759 return Either.left(operation);
766 log.debug("Not found operation {}", interfaceName);
767 return Either.right(TitanOperationStatus.INVALID_ID);
770 private String splitType(String interfaceName) {
771 String interfaceSplittedName;
772 String[] packageName = interfaceName.split("\\.");
774 if (packageName.length == 0) {
775 interfaceSplittedName = interfaceName;
777 interfaceSplittedName = packageName[packageName.length - 1];
780 return interfaceSplittedName.toLowerCase();
786 * @param titanGenericDao
788 public void setTitanGenericDao(TitanGenericDao titanGenericDao) {
789 this.titanGenericDao = titanGenericDao;
792 public void setArtifactOperation(ArtifactOperation artifactOperation) {
793 this.artifactOperation = artifactOperation;
797 public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceType(InterfaceDefinition interf, boolean inTransaction) {
798 Either<InterfaceDefinition, StorageOperationStatus> result = null;
801 InterfaceData interfaceData = new InterfaceData(interf);
802 interf.setUniqueId(interf.getType().toLowerCase());
804 Either<InterfaceData, TitanOperationStatus> existInterface = titanGenericDao.getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class);
806 if (existInterface.isLeft()) {
808 log.debug("Interface type already exist {}", interfaceData);
809 result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS);
813 log.debug("Before adding interface type to graph {}", interfaceData);
814 Either<InterfaceData, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(interfaceData, InterfaceData.class);
815 log.debug("After adding property type to graph {}", interfaceData);
817 if (createNodeResult.isRight()) {
818 TitanOperationStatus operationStatus = createNodeResult.right().value();
819 log.error("Failed to add interface {} to graph. status is {}", interf.getType(), operationStatus);
820 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus));
824 InterfaceDefinition interfaceDefResult = convertInterfaceDataToInterfaceDefinition(interfaceData);
825 Map<String, Operation> operations = interf.getOperationsMap();
827 if (operations != null && !operations.isEmpty()) {
828 Map<String, Operation> newOperations = new HashMap<>();
830 for (Map.Entry<String, Operation> operation : operations.entrySet()) {
831 Either<OperationData, TitanOperationStatus> opStatus = addOperationToGraph(interf, operation.getKey(), operation.getValue(), interfaceData);
832 if (opStatus.isRight()) {
833 titanGenericDao.rollback();
834 log.error("Failed to add operation {} to interface {}", operation.getKey(), interf.getType());
836 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(opStatus.right().value()));
839 OperationData opData = opStatus.left().value();
840 Operation newOperation = this.convertOperationDataToOperation(opData);
841 newOperations.put(operation.getKey(), newOperation);
844 interfaceDefResult.setOperationsMap(newOperations);
846 result = Either.left(interfaceDefResult);
849 if (!inTransaction) {
850 if (result == null || result.isRight()) {
851 log.error("Going to execute rollback on graph.");
852 titanGenericDao.rollback();
854 log.debug("Going to execute commit on graph.");
855 titanGenericDao.commit();
863 public Either<InterfaceDefinition, StorageOperationStatus> getInterface(String interfaceId) {
864 Either<InterfaceData, TitanOperationStatus> getResult = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceId, InterfaceData.class);
865 if (getResult.isLeft()) {
866 InterfaceData interfaceData = getResult.left().value();
867 return Either.left(convertInterfaceDataToInterfaceDefinition(interfaceData));
869 TitanOperationStatus titanStatus = getResult.right().value();
870 log.debug("Node with id {} was not found in the graph. status: {}", interfaceId, titanStatus);
871 StorageOperationStatus storageOperationStatus = DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus);
872 return Either.right(storageOperationStatus);
876 public String getShortInterfaceName(InterfaceDataDefinition interfaceDefinition) {
877 String[] packageName = interfaceDefinition.getType().split("\\.");
878 String interfaceName;
879 if (packageName.length == 0) {
880 interfaceName = interfaceDefinition.getType();
882 interfaceName = packageName[packageName.length - 1];
884 return interfaceName.toLowerCase();
890 public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceType(InterfaceDefinition interf) {
891 return createInterfaceType(interf, false);