src/main/java/org/onap/crud/service/CrudAsyncGraphDataService.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * Gizmo
   4  * ================================================================================
   5  * Copyright © 2017 AT&T Intellectual Property.
   6  * Copyright © 2017 Amdocs
   7  * All rights reserved.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *    http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  *
  22  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  23  */
  24 package org.onap.crud.service;
  25
  26 import com.att.ecomp.event.api.EventConsumer;
  27 import com.att.ecomp.event.api.EventPublisher;
  28
  29 import org.onap.aai.cl.api.LogFields;
  30 import org.onap.aai.cl.api.Logger;
  31 import org.onap.aai.cl.eelf.LoggerFactory;
  32 import org.onap.aai.cl.mdc.MdcContext;
  33 import org.onap.aai.cl.mdc.MdcOverride;
  34 import org.onap.crud.dao.GraphDao;
  35 import org.onap.crud.entity.Edge;
  36 import org.onap.crud.entity.Vertex;
  37 import org.onap.crud.event.GraphEvent;
  38 import org.onap.crud.event.GraphEvent.GraphEventOperation;
  39 import org.onap.crud.event.GraphEvent.GraphEventResult;
  40 import org.onap.crud.event.GraphEventEdge;
  41 import org.onap.crud.event.GraphEventVertex;
  42 import org.onap.crud.exception.CrudException;
  43 import org.onap.crud.logging.CrudServiceMsgs;
  44 import org.onap.crud.parser.CrudResponseBuilder;
  45 import org.onap.crud.util.CrudProperties;
  46 import org.onap.crud.util.CrudServiceConstants;
  47 import org.onap.schema.OxmModelValidator;
  48 import org.onap.schema.RelationshipSchemaValidator;
  49
  50 import java.text.SimpleDateFormat;
  51 import java.util.Timer;
  52 import java.util.concurrent.Callable;
  53 import java.util.concurrent.CountDownLatch;
  54 import java.util.concurrent.ExecutionException;
  55 import java.util.concurrent.ExecutorService;
  56 import java.util.concurrent.Executors;
  57 import java.util.concurrent.Future;
  58 import java.util.concurrent.TimeUnit;
  59 import java.util.concurrent.TimeoutException;
  60 import javax.annotation.PreDestroy;
  61 import javax.ws.rs.core.Response.Status;
  62
  63 public class CrudAsyncGraphDataService extends AbstractGraphDataService {
  64
  65   private static Integer requestTimeOut;
  66
  67   private EventPublisher asyncRequestPublisher;
  68
  69   private Timer timer;
  70
  71   public static final Integer DEFAULT_REQUEST_TIMEOUT = 30000;
  72   private static final Integer DEFAULT_ASYNC_RESPONSE_PROCESS_POLL_INTERVAL = 1000;
  73
  74   private static Logger logger = LoggerFactory.getInstance()
  75     .getLogger(CrudAsyncGraphDataService.class.getName());
  76   private static Logger metricsLogger = LoggerFactory.getInstance()
  77     .getMetricsLogger(CrudAsyncGraphDataService.class.getName());
  78   private static LogFields OK_FIELDS = new LogFields();
  79
  80   static {
  81                 OK_FIELDS.setField(Status.OK, Status.OK.toString());
  82   }
  83
  84   public static Integer getRequestTimeOut() {
  85     return requestTimeOut;
  86   }
  87
  88   public CrudAsyncGraphDataService(GraphDao dao,
  89                   EventPublisher asyncRequestPublisher,
  90                   EventConsumer asyncResponseConsumer) throws CrudException {
  91
  92      super(dao);
  93
  94     requestTimeOut = DEFAULT_REQUEST_TIMEOUT;
  95     try {
  96       requestTimeOut
  97         = Integer.parseInt(CrudProperties.get(CrudServiceConstants.CRD_ASYNC_REQUEST_TIMEOUT));
  98     } catch (NumberFormatException ex) {
  99       // Leave it as the default
 100     }
 101
 102     Integer responsePollInterval = DEFAULT_ASYNC_RESPONSE_PROCESS_POLL_INTERVAL;
 103     try {
 104       responsePollInterval = Integer
 105         .parseInt(CrudProperties
 106                   .get(CrudServiceConstants.CRD_ASYNC_RESPONSE_PROCESS_POLL_INTERVAL));
 107     } catch (Exception ex) {
 108       logger.error(CrudServiceMsgs.ASYNC_DATA_SERVICE_ERROR, "Unable to parse "
 109                    + CrudServiceConstants.CRD_ASYNC_RESPONSE_PROCESS_POLL_INTERVAL
 110                    + " error: " + ex.getMessage());
 111     }
 112
 113     // Start the Response Consumer timer
 114     CrudAsyncResponseConsumer crudAsyncResponseConsumer
 115       = new CrudAsyncResponseConsumer(asyncResponseConsumer);
 116     timer = new Timer("crudAsyncResponseConsumer-1");
 117     timer.schedule(crudAsyncResponseConsumer, responsePollInterval, responsePollInterval);
 118
 119     this.asyncRequestPublisher = asyncRequestPublisher;
 120
 121     logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 122                 "CrudAsyncGraphDataService initialized SUCCESSFULLY!");
 123   }
 124
 125   public class CollectGraphResponse implements Callable<GraphEvent> {
 126     private volatile GraphEvent graphEvent;
 127     private volatile CountDownLatch latch = new CountDownLatch(1);
 128
 129     @Override
 130     public GraphEvent call() throws TimeoutException {
 131       try {
 132         // Wait until graphEvent is available
 133         latch.await(CrudAsyncGraphDataService.getRequestTimeOut(), TimeUnit.MILLISECONDS);
 134       } catch (InterruptedException e) {
 135         latch.countDown();
 136         if (this.graphEvent != null) {
 137           return this.graphEvent;
 138         } else {
 139           throw new TimeoutException();
 140         }
 141       }
 142       return this.graphEvent;
 143     }
 144
 145     public void populateGraphEvent(GraphEvent event) {
 146       this.graphEvent = event;
 147       latch.countDown();
 148     }
 149   }
 150
 151   private GraphEvent sendAndWait(GraphEvent event) throws CrudException {
 152
 153     long startTimeInMs = System.currentTimeMillis();
 154     SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
 155     MdcOverride override = new MdcOverride();
 156     override.addAttribute(MdcContext.MDC_START_TIME, formatter.format(startTimeInMs));
 157
 158     // publish to request queue
 159     try {
 160       asyncRequestPublisher.sendSync(event.toJson());
 161     } catch (Exception e) {
 162       throw new CrudException("Error publishing request " + event.getTransactionId() + "  Cause: " + e.getMessage(), Status.INTERNAL_SERVER_ERROR);
 163     }
 164
 165     logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 166                 "Event submitted of type: " + event.getObjectType() + " with key: " + event.getObjectKey()
 167                 + " , transaction-id: " + event.getTransactionId() + " , operation: "
 168                 + event.getOperation().toString());
 169
 170     ExecutorService executor = Executors
 171       .newSingleThreadExecutor(new CrudThreadFactory("TX-" + event.getTransactionId()));
 172     CollectGraphResponse collector = new CollectGraphResponse();
 173     CrudAsyncGraphEventCache.put(event.getTransactionId(), collector);
 174     GraphEvent response;
 175     Future<GraphEvent> future = executor.submit(collector);
 176     try {
 177       response = future.get(requestTimeOut, TimeUnit.MILLISECONDS);
 178
 179     } catch (InterruptedException | ExecutionException | TimeoutException e) {
 180       CrudAsyncGraphEventCache.invalidate(event.getTransactionId());
 181       logger.error(CrudServiceMsgs.ASYNC_DATA_SERVICE_ERROR,
 182                    "Request timed out for transactionId: " + event.getTransactionId());
 183       future.cancel(true);
 184       throw new CrudException("Timed out , transactionId: " + event.getTransactionId()
 185                               + " , operation: " + event.getOperation().toString(), Status.INTERNAL_SERVER_ERROR);
 186     } finally {
 187       //Kill the thread as the work is completed
 188       executor.shutdownNow();
 189     }
 190     metricsLogger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO, OK_FIELDS, override,
 191             "Total elapsed time for operation: " + event.getOperation().toString()
 192             + " , transactionId: " + event.getTransactionId() + " is "
 193             + Long.toString(System.currentTimeMillis() - startTimeInMs) + " ms");
 194     return response;
 195   }
 196
 197   public String addVertex(String version, String type, VertexPayload payload) throws CrudException {
 198     // Validate the incoming payload
 199     Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(null, version,
 200                                                                     type, payload.getProperties());
 201     // Create graph request event
 202     GraphEvent event = GraphEvent.builder(GraphEventOperation.CREATE)
 203       .vertex(GraphEventVertex.fromVertex(vertex, version)).build();
 204
 205     GraphEvent response = sendAndWait(event);
 206     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 207       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 208                   "Event response received: " + response.getObjectType() + " with key: "
 209                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 210                   + " , operation: " + event.getOperation().toString() + " , result: "
 211                   + response.getResult());
 212       return CrudResponseBuilder.buildUpsertVertexResponse(
 213                                                            OxmModelValidator.validateOutgoingPayload(version,
 214                                                                                                      response.getVertex().toVertex()), version);
 215     } else {
 216       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 217                   "Event response received: " + response.getObjectType() + " with key: "
 218                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 219                   + " , operation: " + event.getOperation().toString() + " , result: "
 220                   + response.getResult() + " , error: " + response.getErrorMessage());
 221       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 222                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 223     }
 224
 225   }
 226
 227   public String addEdge(String version, String type, EdgePayload payload) throws CrudException {
 228     Edge edge = RelationshipSchemaValidator.validateIncomingAddPayload(version, type, payload);
 229     // Create graph request event
 230     GraphEvent event = GraphEvent.builder(GraphEventOperation.CREATE)
 231       .edge(GraphEventEdge.fromEdge(edge, version)).build();
 232
 233     GraphEvent response = sendAndWait(event);
 234     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 235       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 236                   "Event response received: " + response.getObjectType() + " with key: "
 237                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 238                   + " , operation: " + event.getOperation().toString() + " , result: "
 239                   + response.getResult());
 240       return CrudResponseBuilder.buildUpsertEdgeResponse(
 241                                                          RelationshipSchemaValidator.validateOutgoingPayload(version, response.getEdge().toEdge()),
 242                                                          version);
 243     } else {
 244       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 245                   "Event response received: " + response.getObjectType() + " with key: "
 246                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 247                   + " , operation: " + event.getOperation().toString() + " , result: "
 248                   + response.getResult() + " , error: " + response.getErrorMessage());
 249       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 250                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 251     }
 252   }
 253
 254   public String updateVertex(String version, String id, String type, VertexPayload payload)
 255     throws CrudException {
 256     Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(id, version,
 257                                                                     type, payload.getProperties());
 258     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 259       .vertex(GraphEventVertex.fromVertex(vertex, version)).build();
 260
 261     GraphEvent response = sendAndWait(event);
 262     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 263       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 264                   "Event response received: " + response.getObjectType() + " with key: "
 265                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 266                   + " , operation: " + event.getOperation().toString() + " , result: "
 267                   + response.getResult());
 268       return CrudResponseBuilder.buildUpsertVertexResponse(
 269                                                            OxmModelValidator.validateOutgoingPayload(version, response.getVertex().toVertex()),
 270                                                            version);
 271     } else {
 272       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 273                   "Event response received: " + response.getObjectType() + " with key: "
 274                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 275                   + " , operation: " + event.getOperation().toString() + " , result: "
 276                   + response.getResult() + " , error: " + response.getErrorMessage());
 277       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 278                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 279     }
 280
 281   }
 282
 283   public String patchVertex(String version, String id, String type, VertexPayload payload)
 284     throws CrudException {
 285     Vertex existingVertex
 286       = dao.getVertex(id, OxmModelValidator.resolveCollectionType(version, type));
 287     Vertex patchedVertex = OxmModelValidator.validateIncomingPatchPayload(id, version,
 288                                                                           type, payload.getProperties(),
 289                                                                           existingVertex);
 290     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 291       .vertex(GraphEventVertex.fromVertex(patchedVertex, version)).build();
 292
 293     GraphEvent response = sendAndWait(event);
 294     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 295       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 296                   "Event response received: " + response.getObjectType() + " with key: "
 297                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 298                   + " , operation: " + event.getOperation().toString() + " , result: "
 299                   + response.getResult());
 300       return CrudResponseBuilder.buildUpsertVertexResponse(
 301                                                            OxmModelValidator.validateOutgoingPayload(version, response.getVertex().toVertex()),
 302                                                            version);
 303     } else {
 304       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 305                   "Event response received: " + response.getObjectType() + " with key: "
 306                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 307                   + " , operation: " + event.getOperation().toString() + " , result: "
 308                   + response.getResult() + " , error: " + response.getErrorMessage());
 309       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 310                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 311     }
 312
 313   }
 314
 315   public String deleteVertex(String version, String id, String type) throws CrudException {
 316     type = OxmModelValidator.resolveCollectionType(version, type);
 317     GraphEvent event = GraphEvent.builder(GraphEventOperation.DELETE)
 318       .vertex(new GraphEventVertex(id, version, type, null)).build();
 319
 320     GraphEvent response = sendAndWait(event);
 321     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 322       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 323                   "Event response received: " + response.getObjectType() + " with key: "
 324                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 325                   + " , operation: " + event.getOperation().toString() + " , result: "
 326                   + response.getResult());
 327       return "";
 328     } else {
 329       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 330                   "Event response received: " + response.getObjectType() + " with key: "
 331                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 332                   + " , operation: " + event.getOperation().toString() + " , result: "
 333                   + response.getResult() + " , error: " + response.getErrorMessage());
 334       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 335                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 336     }
 337
 338   }
 339
 340   public String deleteEdge(String version, String id, String type) throws CrudException {
 341     RelationshipSchemaValidator.validateType(version, type);
 342     GraphEvent event = GraphEvent.builder(GraphEventOperation.DELETE)
 343       .edge(new GraphEventEdge(id, version, type, null, null, null)).build();
 344
 345     GraphEvent response = sendAndWait(event);
 346     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 347       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 348                   "Event response received: " + response.getObjectType() + " with key: "
 349                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 350                   + " , operation: " + event.getOperation().toString() + " , result: "
 351                   + response.getResult());
 352       return "";
 353     } else {
 354       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 355                   "Event response received: " + response.getObjectType() + " with key: "
 356                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 357                   + " , operation: " + event.getOperation().toString() + " , result: "
 358                   + response.getResult() + " , error: " + response.getErrorMessage());
 359       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 360                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 361     }
 362
 363   }
 364
 365   public String updateEdge(String version, String id, String type, EdgePayload payload)
 366     throws CrudException {
 367     Edge edge = dao.getEdge(id, type);
 368     Edge validatedEdge = RelationshipSchemaValidator.validateIncomingUpdatePayload(edge, version,
 369                                                                                    payload);
 370     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 371       .edge(GraphEventEdge.fromEdge(validatedEdge, version)).build();
 372
 373     GraphEvent response = sendAndWait(event);
 374     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 375       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 376                   "Event response received: " + response.getObjectType() + " with key: "
 377                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 378                   + " , operation: " + event.getOperation().toString() + " , result: "
 379                   + response.getResult());
 380       return CrudResponseBuilder.buildUpsertEdgeResponse(
 381                                                          RelationshipSchemaValidator.validateOutgoingPayload(version,
 382                                                                                                              response.getEdge().toEdge()), version);
 383     } else {
 384       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 385                   "Event response received: " + response.getObjectType() + " with key: "
 386                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 387                   + " , operation: " + event.getOperation().toString() + " , result: "
 388                   + response.getResult() + " , error: " + response.getErrorMessage());
 389       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 390                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 391     }
 392
 393   }
 394
 395   public String patchEdge(String version, String id, String type, EdgePayload payload)
 396     throws CrudException {
 397     Edge edge = dao.getEdge(id, type);
 398     Edge patchedEdge = RelationshipSchemaValidator.validateIncomingPatchPayload(edge, version,
 399                                                                                 payload);
 400     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 401       .edge(GraphEventEdge.fromEdge(patchedEdge, version)).build();
 402
 403     GraphEvent response = sendAndWait(event);
 404     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 405       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 406                   "Event response received: " + response.getObjectType() + " with key: "
 407                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 408                   + " , operation: " + event.getOperation().toString() + " , result: "
 409                   + response.getResult());
 410       return CrudResponseBuilder.buildUpsertEdgeResponse(
 411                                                          RelationshipSchemaValidator.validateOutgoingPayload(version, response.getEdge().toEdge()),
 412                                                          version);
 413     } else {
 414       logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 415                   "Event response received: " + response.getObjectType() + " with key: "
 416                   + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 417                   + " , operation: " + event.getOperation().toString() + " , result: "
 418                   + response.getResult() + " , error: " + response.getErrorMessage());
 419       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 420                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 421     }
 422
 423   }
 424
 425   @PreDestroy
 426   protected void preShutdown() {
 427     timer.cancel();
 428
 429   }
 430
 431   @Override
 432   public String addBulk(String version, BulkPayload payload) throws CrudException {
 433     throw new CrudException("Bulk operation not supported in async mode", Status.BAD_REQUEST);
 434   }
 435
 436
 437 }