protected void handleRequestDispatchException(BaseMessageContextImpl ctx, Throwable e) { Object soapFault = ctx.getProperty(BaseSOAPProtocolProcessor.SOAP_FAULT_OBJECT); if (soapFault != null) { ctx.addError(new Exception("Received Soap Fault: " + soapFault)); } ctx.addError(e); }
/** * Invoke handlers, protocol processor and dispatchers for the given context NOTE: async * processing logic has been removed for SOA 2.0. Async processing logic will be reintroduced post * SOA 2.0. */ @SuppressWarnings("unchecked") public final void processMessageInternal(BaseMessageContextImpl ctx, boolean useAsync) { MessageContextAccessorImpl.blockPreviousContext(); try { long processingStartTime = System.nanoTime(); // Pass the start time into ctx for later reference recordMessageProcessingStartTime(ctx, processingStartTime); // run request pipeline runRequestSequence(ctx); // give it to request dispatcher if (!ctx.hasErrors() && !ctx.hasResponseResidentErrors()) { try { dispatchInternal(ctx, useAsync); } catch (Throwable e) { handleRequestDispatchException(ctx, e); handleAbortedRequestDispatch(ctx); } } else { handleAbortedRequestDispatch(ctx); } if (!useAsync) { // run response pipeline in case of sync executions or pipeline // errors runResponseSequence(ctx); updateMonitoringAfterProcessing(ctx, processingStartTime); } } finally { MessageContextAccessorImpl.resetContext(); } }
void updateMonitoringAfterProcessing(BaseMessageContextImpl ctx, long processingStartTime) { long duration = System.nanoTime() - processingStartTime; ctx.updateSvcAndOpMetric(SystemMetricDefs.OP_TIME_TOTAL, duration); if (shouldCountAsFailedRequest(ctx)) { ctx.incrementSvcAndOpMetric(SystemMetricDefs.OP_ERR_FAILED_CALLS); } }
protected boolean shouldCountAsFailedRequest(BaseMessageContextImpl ctx) { if (ctx.hasErrors()) return true; if (!ctx.hasResponseResidentErrors()) return false; /** RRE's only count as failed requests if the severity was severe enough */ List<ErrorData> errorDataList = ctx.getResponseResidentErrorList(); for (ErrorData errorData : errorDataList) if (isError(errorData)) return true; return false; }
private void recordMessageProcessingStartTime( BaseMessageContextImpl ctx, long processingStartTime) { try { ctx.setProperty( SystemMetricDefs.CTX_KEY_MSG_PROCESSING_STARTED, new Long(processingStartTime)); } catch (ServiceException e) { handleRequestProcessingException(ctx, e); } }
public final void processResponseInternal(BaseMessageContextImpl ctx) { MessageContextAccessorImpl.blockPreviousContext(); try { ServiceDesc serviceDesc = ctx.getServiceDesc(); try { Dispatcher requestDispatcher = serviceDesc.getRequestDispatcher(); requestDispatcher.retrieve(ctx, ctx.getFutureResponse()); } catch (Throwable e) { handleRequestDispatchException(ctx, e); handleAbortedRequestDispatch(ctx); } runResponseSequence(ctx); Long processingStartTime = (Long) ctx.getProperty(SystemMetricDefs.CTX_KEY_MSG_PROCESSING_STARTED); updateMonitoringAfterProcessing(ctx, processingStartTime.longValue()); } finally { MessageContextAccessorImpl.resetContext(); } }
private void runRequestSequence(BaseMessageContextImpl ctx) { ServiceDesc serviceDesc = ctx.getServiceDesc(); // flip the processing stage ctx.changeProcessingStage(MessageProcessingStage.REQUEST_PIPELINE); // first set up logging handler ctx.runLoggingHandlerStage(LoggingHandlerStage.REQUEST_STARTED); long startTime = System.nanoTime(); // run the protocol processor try { ProtocolProcessor protocol = ctx.getProtocolProcessor(); protocol.beforeRequestPipeline(ctx); } catch (Throwable e) { handleRequestProtocolProcessingException(ctx, e); } // run any logic that has to run before pipeline (e.g. version checks) try { beforeRequestPipeline(ctx); } catch (Throwable e) { handleRequestProcessingException(ctx, e); } // run the pipeline try { Pipeline requestPipeline = serviceDesc.getRequestPipeline(); requestPipeline.invoke(ctx); } catch (Throwable e) { handleRequestProcessingException(ctx, e); } // run the protocol processor try { ProtocolProcessor protocol = ctx.getProtocolProcessor(); protocol.beforeRequestDispatch(ctx); } catch (Throwable e) { handleRequestProtocolProcessingException(ctx, e); } // flip the processing stage ctx.changeProcessingStage(MessageProcessingStage.REQUEST_DISPATCH); ctx.runLoggingHandlerStage(LoggingHandlerStage.BEFORE_REQUEST_DISPATCH); long duration = System.nanoTime() - startTime; ctx.updateSvcAndOpMetric(SystemMetricDefs.OP_TIME_PIPELINE_REQUEST, startTime, duration); }
protected void handlePostResponseDispatchException(BaseMessageContextImpl ctx, Throwable e) { ctx.addError(e); }
protected void handleResponseProcessingException(BaseMessageContextImpl ctx, Throwable e) { ctx.addError(e); }
void runResponseSequence(BaseMessageContextImpl ctx) { ServiceDesc serviceDesc = ctx.getServiceDesc(); long startTime = System.nanoTime(); // flip the processing stage ctx.changeProcessingStage(MessageProcessingStage.RESPONSE_PIPELINE); ctx.runLoggingHandlerStage(LoggingHandlerStage.RESPONSE_STARTED); // run the protocol processor try { ProtocolProcessor protocol = ctx.getProtocolProcessor(); protocol.beforeResponsePipeline(ctx); } catch (Throwable e) { handleResponseProtocolProcessingException(ctx, e); } // run the pipeline try { Pipeline responsePipeline = serviceDesc.getResponsePipeline(); responsePipeline.invoke(ctx); } catch (Throwable e) { handleResponseProcessingException(ctx, e); } // run the protocol processor try { ProtocolProcessor protocol = ctx.getProtocolProcessor(); protocol.beforeResponseDispatch(ctx); } catch (Throwable e) { handleResponseProtocolProcessingException(ctx, e); } // flip the processing stage ctx.changeProcessingStage(MessageProcessingStage.RESPONSE_DISPATCH); boolean canProcessResponse = true; try { processPreResponseDispatchErrors(ctx); } catch (Throwable e) { // cannot do anything if errors are not processed canProcessResponse = false; handlePostResponseDispatchException(ctx, e); } long duration = System.nanoTime() - startTime; ctx.updateSvcAndOpMetric(SystemMetricDefs.OP_TIME_PIPELINE_RESPONSE, startTime, duration); if (canProcessResponse) { /* * Returning response is a seperate step. It is also abstracted out * through a dispatcher. In the case of a servlet, the * responseDispatcher is simply writing the data to the * HTTPResponse's outputstream. In the case of a Loaclbinding and * client cases, the response dispatcher simply returns and does * nothing. In the case of an asynchronous model, the response * dispatcher may use a connection and send the response back. */ // TODO: add timing for response dispatcher on server (both sync and // async cases) // TO DO: fix async case - we should use callback and uplink here as // we cannot call logger yet try { // run through the response dispatcher. Dispatcher responseDispatcher = serviceDesc.getResponseDispatcher(); responseDispatcher.dispatchSynchronously(ctx); } catch (Throwable e) { handlePostResponseDispatchException(ctx, e); } } ctx.changeProcessingStage(MessageProcessingStage.RESPONSE_COMPLETE); ctx.runLoggingHandlerStage(LoggingHandlerStage.RESPONSE_COMPLETE); }