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 import javax.ws.rs.GET;
  25 import javax.ws.rs.POST;
  26 import javax.ws.rs.Path;
  27 import javax.ws.rs.PathParam;
  28 import javax.ws.rs.Produces;
  29 import javax.ws.rs.QueryParam;
  30 import javax.ws.rs.core.MediaType;
  31 import javax.ws.rs.core.Response;
  32 import javax.ws.rs.core.Response.Status;
  33 import org.onap.so.monitoring.db.service.DatabaseServiceProvider;
  34 import org.onap.so.monitoring.model.ActivityInstanceDetail;
  35 import org.onap.so.monitoring.model.ProcessDefinitionDetail;
  36 import org.onap.so.monitoring.model.ProcessInstanceDetail;
  37 import org.onap.so.monitoring.model.ProcessInstanceIdDetail;
  38 import org.onap.so.monitoring.model.ProcessInstanceVariableDetail;
  39 import org.onap.so.monitoring.model.SoInfraRequest;
  40 import org.onap.so.monitoring.rest.service.CamundaProcessDataServiceProvider;
  41 import org.onap.so.rest.exceptions.InvalidRestRequestException;
  42 import org.onap.so.rest.exceptions.RestProcessingException;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45 import org.springframework.beans.factory.annotation.Autowired;
  46 import org.springframework.stereotype.Component;
  47 import com.google.common.base.Optional;
  48
  49 /**
  50  * @author waqas.ikram@ericsson.com
  51  */
  52 @Component
  53 @Path("/")
  54 public class SoMonitoringController {
  55
  56     private static final String INVALID_PROCESS_INSTANCE_ERROR_MESSAGE = "Invalid process instance id: ";
  57
  58     private static final Logger LOGGER = LoggerFactory.getLogger(SoMonitoringController.class);
  59
  60     private final DatabaseServiceProvider databaseServiceProvider;
  61
  62     private final CamundaProcessDataServiceProvider camundaProcessDataServiceProvider;
  63
  64     @Autowired
  65     public SoMonitoringController(final DatabaseServiceProvider databaseServiceProvider,
  66             final CamundaProcessDataServiceProvider camundaProcessDataServiceProvider) {
  67         this.databaseServiceProvider = databaseServiceProvider;
  68         this.camundaProcessDataServiceProvider = camundaProcessDataServiceProvider;
  69     }
  70
  71     @GET
  72     @Path("/process-instance-id/{requestId}")
  73     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
  74     public Response getProcessInstanceId(final @PathParam("requestId") String requestId) {
  75         if (requestId == null || requestId.isEmpty()) {
  76             return Response.status(Status.BAD_REQUEST).entity("Invalid Request id: " + requestId).build();
  77         }
  78         try {
  79             final Optional<ProcessInstanceIdDetail> processInstanceId =
  80                     camundaProcessDataServiceProvider.getProcessInstanceIdDetail(requestId);
  81             if (processInstanceId.isPresent()) {
  82                 return Response.status(Status.OK).entity(processInstanceId.get()).build();
  83             }
  84
  85             LOGGER.error("Unable to find process instance id for : " + requestId);
  86             return Response.status(Status.NO_CONTENT).build();
  87
  88         } catch (final InvalidRestRequestException extensions) {
  89             final String message = "Unable to find process instance id for : " + requestId;
  90             LOGGER.error(message);
  91             return Response.status(Status.BAD_REQUEST).entity(message).build();
  92         } catch (final RestProcessingException restProcessingException) {
  93             final String message = "Unable to process request for id: " + requestId;
  94             LOGGER.error(message);
  95             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
  96         }
  97     }
  98
  99     @GET
 100     @Path("/process-instance/{processInstanceId}")
 101     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 102     public Response getSingleProcessInstance(final @PathParam("processInstanceId") String processInstanceId) {
 103         if (processInstanceId == null || processInstanceId.isEmpty()) {
 104             return Response.status(Status.BAD_REQUEST)
 105                     .entity(INVALID_PROCESS_INSTANCE_ERROR_MESSAGE + processInstanceId).build();
 106         }
 107         try {
 108             final Optional<ProcessInstanceDetail> processInstanceDetail =
 109                     camundaProcessDataServiceProvider.getSingleProcessInstanceDetail(processInstanceId);
 110             if (processInstanceDetail.isPresent()) {
 111                 return Response.status(Status.OK).entity(processInstanceDetail.get()).build();
 112             }
 113
 114             LOGGER.error("Unable to find process instance id for : " + processInstanceId);
 115             return Response.status(Status.NO_CONTENT).build();
 116
 117         } catch (final InvalidRestRequestException extensions) {
 118             final String message = "Unable to find process instance id for : " + processInstanceId;
 119             LOGGER.error(message);
 120             return Response.status(Status.BAD_REQUEST).entity(message).build();
 121         } catch (final RestProcessingException restProcessingException) {
 122             final String message = "Unable to process request for id: " + processInstanceId;
 123             LOGGER.error(message);
 124             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 125         }
 126     }
 127
 128     @GET
 129     @Path("/process-definition/{processDefinitionId}")
 130     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 131     public Response getProcessDefinitionXml(final @PathParam("processDefinitionId") String processDefinitionId) {
 132         if (processDefinitionId == null || processDefinitionId.isEmpty()) {
 133             return Response.status(Status.BAD_REQUEST).entity("Invalid process definition id: " + processDefinitionId)
 134                     .build();
 135         }
 136         try {
 137             final Optional<ProcessDefinitionDetail> response =
 138                     camundaProcessDataServiceProvider.getProcessDefinition(processDefinitionId);
 139             if (response.isPresent()) {
 140                 final ProcessDefinitionDetail definitionDetail = response.get();
 141                 return Response.status(Status.OK).entity(definitionDetail).build();
 142             }
 143             LOGGER.error("Unable to find process definition xml for processDefinitionId: " + processDefinitionId);
 144             return Response.status(Status.NO_CONTENT).build();
 145
 146         } catch (final InvalidRestRequestException extensions) {
 147             final String message =
 148                     "Unable to find process definition xml for processDefinitionId: {}" + processDefinitionId;
 149             return Response.status(Status.BAD_REQUEST).entity(message).build();
 150         } catch (final RestProcessingException restProcessingException) {
 151             final String message = "Unable to get process definition xml for id: " + processDefinitionId;
 152             LOGGER.error(message);
 153             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 154         }
 155     }
 156
 157     @GET
 158     @Path("/activity-instance/{processInstanceId}")
 159     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 160     public Response getActivityInstanceDetail(final @PathParam("processInstanceId") String processInstanceId) {
 161         if (processInstanceId == null || processInstanceId.isEmpty()) {
 162             return Response.status(Status.BAD_REQUEST)
 163                     .entity(INVALID_PROCESS_INSTANCE_ERROR_MESSAGE + processInstanceId).build();
 164         }
 165         try {
 166             final List<ActivityInstanceDetail> activityInstanceDetails =
 167                     camundaProcessDataServiceProvider.getActivityInstance(processInstanceId);
 168             return Response.status(Status.OK).entity(activityInstanceDetails).build();
 169         } catch (final InvalidRestRequestException extensions) {
 170             final String message = "Unable to find activity instance for processInstanceId: " + processInstanceId;
 171             LOGGER.error(message);
 172             return Response.status(Status.BAD_REQUEST).entity(message).build();
 173         } catch (final RestProcessingException restProcessingException) {
 174             final String message = "Unable to get activity instance detail for id: " + processInstanceId;
 175             LOGGER.error(message);
 176             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 177         }
 178     }
 179
 180     @GET
 181     @Path("/variable-instance/{processInstanceId}")
 182     @Produces(MediaType.APPLICATION_JSON)
 183     public Response getProcessInstanceVariables(final @PathParam("processInstanceId") String processInstanceId) {
 184         if (processInstanceId == null || processInstanceId.isEmpty()) {
 185             return Response.status(Status.BAD_REQUEST)
 186                     .entity(INVALID_PROCESS_INSTANCE_ERROR_MESSAGE + processInstanceId).build();
 187         }
 188         try {
 189             final List<ProcessInstanceVariableDetail> processInstanceVariable =
 190                     camundaProcessDataServiceProvider.getProcessInstanceVariable(processInstanceId);
 191             return Response.status(Status.OK).entity(processInstanceVariable).build();
 192         } catch (final InvalidRestRequestException extensions) {
 193             final String message =
 194                     "Unable to find process instance variables for processInstanceId: " + processInstanceId;
 195             LOGGER.error(message);
 196             return Response.status(Status.BAD_REQUEST).entity(message).build();
 197         } catch (final RestProcessingException restProcessingException) {
 198             final String message = "Unable to get process instance variables for id: " + processInstanceId;
 199             LOGGER.error(message);
 200             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 201         }
 202     }
 203
 204     @POST
 205     @Path("/v1/search")
 206     @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
 207     public Response getInfraActiveRequests(final Map<String, String[]> filters,
 208             @QueryParam("from") final long startTime, @QueryParam("to") final long endTime,
 209             @QueryParam("maxResult") final Integer maxResult) {
 210
 211         if (filters == null) {
 212             return Response.status(Status.BAD_REQUEST).entity("Invalid filters: " + filters).build();
 213         }
 214         try {
 215             final List<SoInfraRequest> requests =
 216                     databaseServiceProvider.getSoInfraRequest(filters, startTime, endTime, maxResult);
 217             LOGGER.info("result size: " + requests.size());
 218             return Response.status(Status.OK).entity(requests).build();
 219
 220         } catch (final InvalidRestRequestException extensions) {
 221             final String message = "Unable to search request for filters: " + filters + ", from: " + startTime
 222                     + ", to: " + endTime + ", maxResult: " + maxResult;
 223             LOGGER.error(message);
 224             return Response.status(Status.BAD_REQUEST).entity(message).build();
 225         } catch (final RestProcessingException restProcessingException) {
 226             final String message = "Unable to search request for filters: " + filters + ", from: " + startTime
 227                     + ", to: " + endTime + ", maxResult: " + maxResult;
 228             LOGGER.error(message);
 229             return Response.status(Status.INTERNAL_SERVER_ERROR).entity(message).build();
 230         }
 231     }
 232
 233 }