so-monitoring/so-monitoring-service/src/main/java/org/onap/so/monitoring/rest/api/SoMonitoringController.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.so.monitoring.rest.api;
  21
  22 import java.util.List;
  23 import java.util.Map;
  24
  25 import javax.ws.rs.GET;
  26 import javax.ws.rs.POST;
  27 import javax.ws.rs.Path;
  28 import javax.ws.rs.PathParam;
  29 import javax.ws.rs.Produces;
  30 import javax.ws.rs.QueryParam;
  31 import javax.ws.rs.core.MediaType;
  32 import javax.ws.rs.core.Response;
  33 import javax.ws.rs.core.Response.Status;
  34
  35 import org.onap.so.montoring.db.service.DatabaseServiceProvider;
  36 import org.onap.so.montoring.exception.InvalidRestRequestException;
  37 import org.onap.so.montoring.exception.RestProcessingException;
  38 import org.onap.so.montoring.model.ActivityInstanceDetail;
  39 import org.onap.so.montoring.model.ProcessDefinitionDetail;
  40 import org.onap.so.montoring.model.ProcessInstanceDetail;
  41 import org.onap.so.montoring.model.ProcessInstanceIdDetail;
  42 import org.onap.so.montoring.model.ProcessInstanceVariableDetail;
  43 import org.onap.so.montoring.model.SoInfraRequest;
  44 import org.onap.so.montoring.rest.service.CamundaProcessDataServiceProvider;
  45 import org.springframework.beans.factory.annotation.Autowired;
  46 import org.springframework.stereotype.Component;
  47
  48 import com.google.common.base.Optional;
  49
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 /**
  54  * @author waqas.ikram@ericsson.com
  55  */
  56 @Component
  57 @Path("/")
  58 public class SoMonitoringController {
  59
  60     private static final String INVALID_PROCESS_INSTANCE_ERROR_MESSAGE = "Invalid process instance id: ";
  61
  62     private static final Logger LOGGER = LoggerFactory.getLogger(SoMonitoringController.class);
  63
  64     private final DatabaseServiceProvider databaseServiceProvider;
  65
  66     private final CamundaProcessDataServiceProvider camundaProcessDataServiceProvider;
  67
  68     @Autowired
  69     public SoMonitoringController(final DatabaseServiceProvider databaseServiceProvider,
  70             final CamundaProcessDataServiceProvider camundaProcessDataServiceProvider) {
  71         this.databaseServiceProvider = databaseServiceProvider;
  72         this.camundaProcessDataServiceProvider = camundaProcessDataServiceProvider;
  73     }
  74
  75     @GET
  76     @Path("/process-instance-id/{requestId}")
  77     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
  78     public Response getProcessInstanceId(final @PathParam("requestId") String requestId) {
  79         if (requestId == null || requestId.isEmpty()) {
  80             return Response.status(Status.BAD_REQUEST).entity("Invalid Request id: " + requestId).build();
  81         }
  82         try {
  83             final Optional<ProcessInstanceIdDetail> processInstanceId =
  84                     camundaProcessDataServiceProvider.getProcessInstanceIdDetail(requestId);
  85             if (processInstanceId.isPresent()) {
  86                 return Response.status(Status.OK).entity(processInstanceId.get()).build();
  87             }
  88
  89             LOGGER.error("Unable to find process instance id for : " + requestId);
  90             return Response.status(Status.NO_CONTENT).build();
  91
  92         } catch (final InvalidRestRequestException extensions) {
  93             final String message = "Unable to find process instance id for : " + requestId;
  94             LOGGER.error(message);
  95             return Response.status(Status.BAD_REQUEST).entity(message).build();
  96         } catch (final RestProcessingException restProcessingException) {
  97             final String message = "Unable to process request for id: " + requestId;
  98             LOGGER.error(message);
  99             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 100         }
 101     }
 102
 103     @GET
 104     @Path("/process-instance/{processInstanceId}")
 105     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 106     public Response getSingleProcessInstance(final @PathParam("processInstanceId") String processInstanceId) {
 107         if (processInstanceId == null || processInstanceId.isEmpty()) {
 108             return Response.status(Status.BAD_REQUEST)
 109                     .entity(INVALID_PROCESS_INSTANCE_ERROR_MESSAGE + processInstanceId).build();
 110         }
 111         try {
 112             final Optional<ProcessInstanceDetail> processInstanceDetail =
 113                     camundaProcessDataServiceProvider.getSingleProcessInstanceDetail(processInstanceId);
 114             if (processInstanceDetail.isPresent()) {
 115                 return Response.status(Status.OK).entity(processInstanceDetail.get()).build();
 116             }
 117
 118             LOGGER.error("Unable to find process instance id for : " + processInstanceId);
 119             return Response.status(Status.NO_CONTENT).build();
 120
 121         } catch (final InvalidRestRequestException extensions) {
 122             final String message = "Unable to find process instance id for : " + processInstanceId;
 123             LOGGER.error(message);
 124             return Response.status(Status.BAD_REQUEST).entity(message).build();
 125         } catch (final RestProcessingException restProcessingException) {
 126             final String message = "Unable to process request for id: " + processInstanceId;
 127             LOGGER.error(message);
 128             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 129         }
 130     }
 131
 132     @GET
 133     @Path("/process-definition/{processDefinitionId}")
 134     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 135     public Response getProcessDefinitionXml(final @PathParam("processDefinitionId") String processDefinitionId) {
 136         if (processDefinitionId == null || processDefinitionId.isEmpty()) {
 137             return Response.status(Status.BAD_REQUEST).entity("Invalid process definition id: " +
 138                                                               processDefinitionId)
 139                     .build();
 140         }
 141         try {
 142             final Optional<ProcessDefinitionDetail> response =
 143                     camundaProcessDataServiceProvider.getProcessDefinition(processDefinitionId);
 144             if (response.isPresent()) {
 145                 final ProcessDefinitionDetail definitionDetail = response.get();
 146                 return Response.status(Status.OK).entity(definitionDetail).build();
 147             }
 148             LOGGER.error("Unable to find process definition xml for processDefinitionId: " +
 149                          processDefinitionId);
 150             return Response.status(Status.NO_CONTENT).build();
 151
 152         } catch (final InvalidRestRequestException extensions) {
 153             final String message =
 154                     "Unable to find process definition xml for processDefinitionId: {}" +
 155                 processDefinitionId;
 156             return Response.status(Status.BAD_REQUEST).entity(message).build();
 157         } catch (final RestProcessingException restProcessingException) {
 158             final String message = "Unable to get process definition xml for id: " +
 159                 processDefinitionId;
 160             LOGGER.error(message);
 161             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 162         }
 163     }
 164
 165     @GET
 166     @Path("/activity-instance/{processInstanceId}")
 167     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 168     public Response getActivityInstanceDetail(final @PathParam("processInstanceId") String processInstanceId) {
 169         if (processInstanceId == null || processInstanceId.isEmpty()) {
 170             return Response.status(Status.BAD_REQUEST)
 171                     .entity(INVALID_PROCESS_INSTANCE_ERROR_MESSAGE + processInstanceId).build();
 172         }
 173         try {
 174             final List<ActivityInstanceDetail> activityInstanceDetails =
 175                     camundaProcessDataServiceProvider.getActivityInstance(processInstanceId);
 176             return Response.status(Status.OK).entity(activityInstanceDetails).build();
 177         } catch (final InvalidRestRequestException extensions) {
 178             final String message = "Unable to find activity instance for processInstanceId: " +
 179                 processInstanceId;
 180             LOGGER.error(message);
 181             return Response.status(Status.BAD_REQUEST).entity(message).build();
 182         } catch (final RestProcessingException restProcessingException) {
 183             final String message = "Unable to get activity instance detail for id: " +
 184                 processInstanceId;
 185             LOGGER.error(message);
 186             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 187         }
 188     }
 189
 190     @GET
 191     @Path("/variable-instance/{processInstanceId}")
 192     @Produces(MediaType.APPLICATION_JSON)
 193     public Response getProcessInstanceVariables(final @PathParam("processInstanceId") String processInstanceId) {
 194         if (processInstanceId == null || processInstanceId.isEmpty()) {
 195             return Response.status(Status.BAD_REQUEST)
 196                     .entity(INVALID_PROCESS_INSTANCE_ERROR_MESSAGE + processInstanceId).build();
 197         }
 198         try {
 199             final List<ProcessInstanceVariableDetail> processInstanceVariable =
 200                     camundaProcessDataServiceProvider.getProcessInstanceVariable(processInstanceId);
 201             return Response.status(Status.OK).entity(processInstanceVariable).build();
 202         } catch (final InvalidRestRequestException extensions) {
 203             final String message =
 204                     "Unable to find process instance variables for processInstanceId: " +
 205                 processInstanceId;
 206             LOGGER.error(message);
 207             return Response.status(Status.BAD_REQUEST).entity(message).build();
 208         } catch (final RestProcessingException restProcessingException) {
 209             final String message = "Unable to get process instance variables for id: " +
 210                 processInstanceId;
 211             LOGGER.error(message);
 212             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 213         }
 214     }
 215
 216     @POST
 217     @Path("/v1/search")
 218     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 219     public Response getInfraActiveRequests(final Map<String, String[]> filters,
 220             @QueryParam("from") final long startTime, @QueryParam("to") final long endTime,
 221             @QueryParam("maxResult") final Integer maxResult) {
 222
 223         if (filters == null) {
 224             return Response.status(Status.BAD_REQUEST).entity("Invalid filters: " + filters).build();
 225         }
 226         try {
 227             final List<SoInfraRequest> requests =
 228                     databaseServiceProvider.getSoInfraRequest(filters, startTime, endTime, maxResult);
 229             LOGGER.info("result size: " + requests.size());
 230             return Response.status(Status.OK).entity(requests).build();
 231
 232         } catch (final InvalidRestRequestException extensions) {
 233             final String message = "Unable to search request for filters: " + filters + ", from: " +
 234                 startTime + ", to: " + endTime + ", maxResult: " + maxResult;
 235             LOGGER.error(message);
 236             return Response.status(Status.BAD_REQUEST).entity(message).build();
 237         } catch (final RestProcessingException restProcessingException) {
 238             final String message = "Unable to search request for filters: " + filters + ", from: " +
 239                 startTime + ", to: " + endTime + ", maxResult: " + maxResult;
 240             LOGGER.error(message);
 241             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 242         }
 243     }
 244
 245 }