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