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.debug(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO, "Event Sent ="+event.toJson());
 166
 167     logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 168                 "Event submitted of type: " + event.getObjectType() + " with key: " + event.getObjectKey()
 169                 + " , transaction-id: " + event.getTransactionId() + " , operation: "
 170                 + event.getOperation().toString());
 171
 172     ExecutorService executor = Executors
 173       .newSingleThreadExecutor(new CrudThreadFactory("TX-" + event.getTransactionId()));
 174     CollectGraphResponse collector = new CollectGraphResponse();
 175     CrudAsyncGraphEventCache.put(event.getTransactionId(), collector);
 176     GraphEvent response;
 177     Future<GraphEvent> future = executor.submit(collector);
 178     try {
 179       response = future.get(requestTimeOut, TimeUnit.MILLISECONDS);
 180
 181     } catch (InterruptedException | ExecutionException | TimeoutException e) {
 182       CrudAsyncGraphEventCache.invalidate(event.getTransactionId());
 183       logger.error(CrudServiceMsgs.ASYNC_DATA_SERVICE_ERROR,
 184                    "Request timed out for transactionId: " + event.getTransactionId());
 185       future.cancel(true);
 186       throw new CrudException("Timed out , transactionId: " + event.getTransactionId()
 187                               + " , operation: " + event.getOperation().toString(), Status.INTERNAL_SERVER_ERROR);
 188     } finally {
 189       //Kill the thread as the work is completed
 190       executor.shutdownNow();
 191     }
 192     metricsLogger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO, OK_FIELDS, override,
 193             "Total elapsed time for operation: " + event.getOperation().toString()
 194             + " , transactionId: " + event.getTransactionId() + " is "
 195             + Long.toString(System.currentTimeMillis() - startTimeInMs) + " ms");
 196     return response;
 197   }
 198
 199   public String addVertex(String version, String type, VertexPayload payload) throws CrudException {
 200     // Validate the incoming payload
 201     Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(null, version,
 202                                                                     type, payload.getProperties());
 203     // Create graph request event
 204     GraphEvent event = GraphEvent.builder(GraphEventOperation.CREATE)
 205       .vertex(GraphEventVertex.fromVertex(vertex, version)).build();
 206
 207     GraphEvent response = sendAndWait(event);
 208     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 209       logSuccessResponse(event, response);
 210       return CrudResponseBuilder.buildUpsertVertexResponse(
 211                                                            OxmModelValidator.validateOutgoingPayload(version,
 212                                                                                                      response.getVertex().toVertex()), version);
 213     } else {
 214       logErrorResponse(event, response);
 215       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 216                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 217     }
 218
 219   }
 220
 221   public String addEdge(String version, String type, EdgePayload payload) throws CrudException {
 222     Edge edge = RelationshipSchemaValidator.validateIncomingAddPayload(version, type, payload);
 223     // Create graph request event
 224     GraphEvent event = GraphEvent.builder(GraphEventOperation.CREATE)
 225       .edge(GraphEventEdge.fromEdge(edge, version)).build();
 226
 227     GraphEvent response = sendAndWait(event);
 228     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 229       logSuccessResponse(event, response);
 230       return CrudResponseBuilder.buildUpsertEdgeResponse(
 231                                                          RelationshipSchemaValidator.validateOutgoingPayload(version, response.getEdge().toEdge()),
 232                                                          version);
 233     } else {
 234       logErrorResponse(event, response);
 235       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 236                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 237     }
 238   }
 239
 240   public String updateVertex(String version, String id, String type, VertexPayload payload)
 241     throws CrudException {
 242     Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(id, version,
 243                                                                     type, payload.getProperties());
 244     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 245       .vertex(GraphEventVertex.fromVertex(vertex, version)).build();
 246
 247     GraphEvent response = sendAndWait(event);
 248     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 249       logSuccessResponse(event, response);
 250       return CrudResponseBuilder.buildUpsertVertexResponse(
 251                                                            OxmModelValidator.validateOutgoingPayload(version, response.getVertex().toVertex()),
 252                                                            version);
 253     } else {
 254       logErrorResponse(event, response);
 255       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 256                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 257     }
 258
 259   }
 260
 261   public String patchVertex(String version, String id, String type, VertexPayload payload)
 262     throws CrudException {
 263     Vertex existingVertex
 264       = dao.getVertex(id, OxmModelValidator.resolveCollectionType(version, type), version);
 265     Vertex patchedVertex = OxmModelValidator.validateIncomingPatchPayload(id, version,
 266                                                                           type, payload.getProperties(),
 267                                                                           existingVertex);
 268     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 269       .vertex(GraphEventVertex.fromVertex(patchedVertex, version)).build();
 270
 271     GraphEvent response = sendAndWait(event);
 272     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 273       logSuccessResponse(event, response);
 274       return CrudResponseBuilder.buildUpsertVertexResponse(
 275                                                            OxmModelValidator.validateOutgoingPayload(version, response.getVertex().toVertex()),
 276                                                            version);
 277     } else {
 278       logErrorResponse(event, response);
 279       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 280                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 281     }
 282
 283   }
 284
 285   public String deleteVertex(String version, String id, String type) throws CrudException {
 286     type = OxmModelValidator.resolveCollectionType(version, type);
 287     GraphEvent event = GraphEvent.builder(GraphEventOperation.DELETE)
 288       .vertex(new GraphEventVertex(id, version, type, null)).build();
 289
 290     GraphEvent response = sendAndWait(event);
 291     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 292       logSuccessResponse(event, response);
 293       return "";
 294     } else {
 295       logErrorResponse(event, response);
 296       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 297                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 298     }
 299
 300   }
 301
 302   public String deleteEdge(String version, String id, String type) throws CrudException {
 303     RelationshipSchemaValidator.validateType(version, type);
 304     GraphEvent event = GraphEvent.builder(GraphEventOperation.DELETE)
 305       .edge(new GraphEventEdge(id, version, type, null, null, null)).build();
 306
 307     GraphEvent response = sendAndWait(event);
 308     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 309       logSuccessResponse(event, response);
 310       return "";
 311     } else {
 312       logErrorResponse(event, response);
 313       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 314                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 315     }
 316
 317   }
 318
 319   public String updateEdge(String version, String id, String type, EdgePayload payload)
 320     throws CrudException {
 321     Edge edge = dao.getEdge(id, type);
 322     Edge validatedEdge = RelationshipSchemaValidator.validateIncomingUpdatePayload(edge, version,
 323                                                                                    payload);
 324     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 325       .edge(GraphEventEdge.fromEdge(validatedEdge, version)).build();
 326
 327     GraphEvent response = sendAndWait(event);
 328     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 329       logSuccessResponse(event, response);
 330       return CrudResponseBuilder.buildUpsertEdgeResponse(
 331                                                          RelationshipSchemaValidator.validateOutgoingPayload(version,
 332                                                                                                              response.getEdge().toEdge()), version);
 333     } else {
 334       logErrorResponse(event, response);
 335       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 336                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 337     }
 338
 339   }
 340
 341   public String patchEdge(String version, String id, String type, EdgePayload payload)
 342     throws CrudException {
 343     Edge edge = dao.getEdge(id, type);
 344     Edge patchedEdge = RelationshipSchemaValidator.validateIncomingPatchPayload(edge, version,
 345                                                                                 payload);
 346     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 347       .edge(GraphEventEdge.fromEdge(patchedEdge, version)).build();
 348
 349     GraphEvent response = sendAndWait(event);
 350     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 351       logSuccessResponse(event, response);
 352       return CrudResponseBuilder.buildUpsertEdgeResponse(
 353                                                          RelationshipSchemaValidator.validateOutgoingPayload(version, response.getEdge().toEdge()),
 354                                                          version);
 355     } else {
 356       logErrorResponse(event, response);
 357       throw new CrudException("Operation Failed with transaction-id: " + response.getTransactionId()
 358                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 359     }
 360
 361   }
 362
 363   @PreDestroy
 364   protected void preShutdown() {
 365     timer.cancel();
 366
 367   }
 368
 369   @Override
 370   protected Vertex addBulkVertex(Vertex vertex, String version, String dbTransId) throws CrudException {
 371     GraphEvent event = GraphEvent.builder(GraphEventOperation.CREATE)
 372         .vertex(GraphEventVertex.fromVertex(vertex, version)).build();
 373     event.setDbTransactionId(dbTransId);
 374     GraphEvent response = publishEvent(event);
 375     return response.getVertex().toVertex();
 376   }
 377
 378   @Override
 379   protected Vertex updateBulkVertex(Vertex vertex, String id, String version, String dbTransId) throws CrudException {
 380     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE)
 381         .vertex(GraphEventVertex.fromVertex(vertex, version)).build();
 382     event.setDbTransactionId(dbTransId);
 383     GraphEvent response = publishEvent(event);
 384     return response.getVertex().toVertex();
 385   }
 386
 387   @Override
 388   protected void deleteBulkVertex(String id, String version, String type, String dbTransId) throws CrudException {
 389     GraphEvent event = GraphEvent.builder(GraphEventOperation.DELETE).vertex(new GraphEventVertex(id, version, type, null)).build();
 390     event.setDbTransactionId(dbTransId);
 391     publishEvent(event);
 392   }
 393
 394   @Override
 395   protected Edge addBulkEdge(Edge edge, String version, String dbTransId) throws CrudException {
 396     GraphEvent event = GraphEvent.builder(GraphEventOperation.CREATE).edge(GraphEventEdge.fromEdge(edge, version)).build();
 397     event.setDbTransactionId(dbTransId);
 398     GraphEvent response = publishEvent(event);
 399     return response.getEdge().toEdge();
 400   }
 401
 402   @Override
 403   protected Edge updateBulkEdge(Edge edge, String version, String dbTransId) throws CrudException {
 404     GraphEvent event = GraphEvent.builder(GraphEventOperation.UPDATE).edge(GraphEventEdge.fromEdge(edge, version)).build();
 405     event.setDbTransactionId(dbTransId);
 406     GraphEvent response = publishEvent(event);
 407     return response.getEdge().toEdge();
 408   }
 409
 410   @Override
 411   protected void deleteBulkEdge(String id, String version, String type, String dbTransId) throws CrudException {
 412     GraphEvent event = GraphEvent.builder(GraphEventOperation.DELETE)
 413         .edge(new GraphEventEdge(id, version, type, null, null, null)).build();
 414     event.setDbTransactionId(dbTransId);
 415     publishEvent(event);
 416   }
 417
 418   private GraphEvent publishEvent(GraphEvent event) throws CrudException {
 419     GraphEvent response = sendAndWait(event);
 420     if (response.getResult().equals(GraphEventResult.SUCCESS)) {
 421       logSuccessResponse(event, response);
 422     } else {
 423       logErrorResponse(event, response);
 424       throw new CrudException("Operation failed with transaction-id: " + response.getTransactionId()
 425                               + " Error: " + response.getErrorMessage(), response.getHttpErrorStatus());
 426     }
 427
 428     return response;
 429   }
 430
 431   private void logSuccessResponse(GraphEvent event, GraphEvent response) {
 432     logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 433         "Event response received: " + response.getObjectType() + " with key: "
 434         + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 435         + " , operation: " + event.getOperation().toString() + " , result: "
 436         + response.getResult());
 437   }
 438
 439   private void logErrorResponse(GraphEvent event, GraphEvent response) {
 440     logger.info(CrudServiceMsgs.ASYNC_DATA_SERVICE_INFO,
 441         "Event response received: " + response.getObjectType() + " with key: "
 442         + response.getObjectKey() + " , transaction-id: " + response.getTransactionId()
 443         + " , operation: " + event.getOperation().toString() + " , result: "
 444         + response.getResult() + " , error: " + response.getErrorMessage());
 445   }
 446
 447 }