gerrit.onap Code Review - so.git/blob

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