private static object ManagedServiceExec( ServiceExecFn serviceExec, object service, IRequestContext requestContext, object dto) { try { InjectRequestContext(service, requestContext); try { //Executes the service and returns the result var response = serviceExec(requestContext, dto); return(response); } finally { if (EndpointHost.AppHost != null) { //Gets disposed by AppHost or ContainerAdapter if set EndpointHost.AppHost.Release(service); } else { using (service as IDisposable) {} } } } catch (TargetInvocationException tex) { //Mono invokes using reflection throw tex.InnerException ?? tex; } }
private object ManagedServiceExec(ServiceExecFn serviceExec, IService service, IRequest request, object requestDto) { try { InjectRequestContext(service, request); try { request.Dto = requestDto; requestDto = appHost.OnPreExecuteServiceFilter(service, requestDto, request, request.Response); request.Dto = requestDto; //Executes the service and returns the result var response = serviceExec(request, requestDto); response = appHost.OnPostExecuteServiceFilter(service, response, request, request.Response); return(response); } finally { //Gets disposed by AppHost or ContainerAdapter if set appHost.Release(service); } } catch (TargetInvocationException tex) { //Mono invokes using reflection throw tex.InnerException ?? tex; } }
private void AddToRequestExecMap(Type requestType, Type serviceType, ServiceExecFn handlerFn) { if (requestExecMap.ContainsKey(requestType)) { throw new AmbiguousMatchException( string.Format( "Could not register Request '{0}' with service '{1}' as it has already been assigned to another service.\n" + "Each Request DTO can only be handled by 1 service.", requestType.FullName, serviceType.FullName)); } requestExecMap.Add(requestType, handlerFn); var requestAttrs = requestType.AllAttributes <RestrictAttribute>(); if (requestAttrs.Length > 0) { requestServiceAttrs[requestType] = requestAttrs[0]; } else { var serviceAttrs = serviceType.AllAttributes <RestrictAttribute>(); if (serviceAttrs.Length > 0) { requestServiceAttrs[requestType] = serviceAttrs[0]; } } }
public void RegisterService(Type serviceType, ITypeFactory serviceFactoryFn) { if (!Service.IsServiceType(serviceType)) { throw new ArgumentException($"{serviceType.FullName} is not a service type that implements IService."); } if (!serviceActionMap.TryGetValue(serviceType, out Dictionary <Type, List <ActionContext> > actionMap)) { var serviceExecDef = typeof(ServiceExec <>).MakeGenericType(serviceType); var iserviceExec = (IServiceExec)serviceExecDef.CreateInstance(); iserviceExec.Reset(AppHost); actionMap = iserviceExec.ActionMap; foreach (var requestType in actionMap.Keys) { ServiceExecFn handlerFn = (req, dto) => { var service = (serviceFactoryFn ?? typeFactory).CreateInstance(req, serviceType) as IService; ServiceExecFn serviceExec = (reqCtx, requestDto) => iserviceExec.Execute(reqCtx, service, requestDto); return(ManagedServiceExec(serviceExec, service, req, dto)); }; AddToRequestExecMap(requestType, serviceType, handlerFn); foreach (var item in actionMap[requestType]) { AppHost.Metadata.Add(serviceType, requestType, item.ResponseType); if (Logger.IsDebugEnabled) { Logger.DebugFormat("Registering {0} service '{1}' with request '{2}'", item.ResponseType != null ? "Reply" : "OneWay", serviceType.GetOperationName(), requestType.GetOperationName()); } } RegisterRestPaths(requestType); if (typeof(IRequiresRequestStream).IsAssignableFrom(requestType)) { this.RequestTypeFactoryMap[requestType] = req => { var restPath = req.GetRoute(); var request = restPath != null ? RestHandler.CreateRequest(req, restPath, req.GetRequestParams(), requestType.CreateInstance()) : KeyValueDataContractDeserializer.Instance.Parse(req.QueryString, requestType); var rawReq = (IRequiresRequestStream)request; rawReq.RequestStream = req.InputStream; return(rawReq); }; } } serviceActionMap[serviceType] = actionMap; AppHost.Container.RegisterAutoWiredType(serviceType); } }
/// <summary> /// 注册action /// </summary> /// <param name="servicePath"></param> /// <param name="serviceName"></param> /// <param name="serviceType"></param> /// <param name="mi"></param> /// <param name="serviceFactoryFn"></param> public void RegisterGServiceMethodExecutor(string servicePath, string serviceName, Type serviceType, MethodInfo mi, ITypeFactory serviceFactoryFn) { //构造执行方法 var serviceMethodExecFn = BuildServiceMethodExecutor(mi, serviceType); //返回类型 var responseType = mi.ReturnType; //是否是异步的 bool isAsync = responseType.FullName.StartsWith("System.Threading.Tasks.Task`1"); if (isAsync) { responseType = responseType.GetGenericArguments()[0];//如果是异步的 返回类型是拿 泛型的定义 } if (responseType == typeof(void)) { responseType = null;//判断是否没有返回类型 } ServiceExecFn handlerFn = null; if (isAsync) { //如果是异步的 Func <object, object> getResult = mi.ReturnType.GetProperty("Result").CreateGetter(); handlerFn = (requestContext, dto) => { var service = serviceFactoryFn.CreateInstance(serviceType); ServiceExecFn serviceExec = (reqCtx, req) => serviceMethodExecFn(req, service); return(ManagedAsyncServiceMethodExec(serviceExec, service, requestContext, dto, responseType, getResult)); }; } else { //同步 handlerFn = (requestContext, dto) => { var service = serviceFactoryFn.CreateInstance(serviceType); ServiceExecFn serviceExec = (reqCtx, req) => serviceMethodExecFn(req, service); try { return(ManagedServiceMethodExec(serviceExec, service, requestContext, dto, responseType)); } finally { } }; } AddToMethodExecMap(servicePath, mi, serviceType, handlerFn); }
public void Register <TReq>(Func <IService <TReq> > invoker) { var requestType = typeof(TReq); ServiceExecFn handlerFn = (requestContext, dto) => { var service = invoker(); InjectRequestContext(service, requestContext); return(ServiceExec <TReq> .Execute( service, (TReq)dto, requestContext != null?requestContext.EndpointAttributes : EndpointAttributes.None)); }; requestExecMap.Add(requestType, handlerFn); }
public void RegisterNServiceExecutor(Type requestType, Type serviceType, ITypeFactory serviceFactoryFn) { var serviceExecDef = typeof(NServiceRequestExec <,>).MakeGenericType(serviceType, requestType); var iserviceExec = (INServiceExec)serviceExecDef.CreateInstance(); ServiceExecFn handlerFn = (requestContext, dto) => { var service = serviceFactoryFn.CreateInstance(serviceType); ServiceExecFn serviceExec = (reqCtx, req) => iserviceExec.Execute(reqCtx, service, req); return(ManagedServiceExec(serviceExec, service, requestContext, dto)); }; AddToRequestExecMap(requestType, serviceType, handlerFn); }
public void RegisterGServiceExecutor(Type requestType, Type serviceType, ITypeFactory serviceFactoryFn) { var typeFactoryFn = CallServiceExecuteGeneric(requestType, serviceType); ServiceExecFn handlerFn = (requestContext, dto) => { var service = serviceFactoryFn.CreateInstance(serviceType); var endpointAttrs = requestContext != null ? requestContext.EndpointAttributes : EndpointAttributes.None; ServiceExecFn serviceExec = (reqCtx, req) => typeFactoryFn(req, service, endpointAttrs); return(ManagedServiceExec(serviceExec, service, requestContext, dto)); }; AddToRequestExecMap(requestType, serviceType, handlerFn); }
private object ManagedServiceExec(ServiceExecFn serviceExec, IService service, IRequest request, object requestDto) { try { InjectRequestContext(service, request); object response = null; try { requestDto = appHost.OnPreExecuteServiceFilter(service, requestDto, request, request.Response); if (request.Dto == null) // Don't override existing batched DTO[] { request.Dto = requestDto; } //Executes the service and returns the result response = serviceExec(request, requestDto); response = appHost.OnPostExecuteServiceFilter(service, response, request, request.Response); return(response); } finally { //Gets disposed by AppHost or ContainerAdapter if set var taskResponse = response as Task; if (taskResponse != null) { taskResponse.ContinueWith(task => appHost.Release(service)); } else { appHost.Release(service); } } } catch (TargetInvocationException tex) { //Mono invokes using reflection throw tex.InnerException ?? tex; } }
public void RegisterServiceExecutor(Type requestType, Type serviceType, ITypeFactory serviceFactoryFn) { ResetServiceExecCachesIfNeeded(serviceType, requestType); var serviceExecDef = typeof(ServiceRequestExec <,>).MakeGenericType(serviceType, requestType); var iserviceExec = (IServiceExec)serviceExecDef.CreateInstance(); ServiceExecFn handlerFn = (req, dto) => { var service = serviceFactoryFn.CreateInstance(serviceType); ServiceExecFn serviceExec = (reqCtx, requestDto) => iserviceExec.Execute(reqCtx, service, requestDto); return(ManagedServiceExec(serviceExec, (IService)service, req, dto)); }; AddToRequestExecMap(requestType, serviceType, handlerFn); }
private void AddToRequestExecMap(Type requestType, Type serviceType, ServiceExecFn handlerFn) { try { requestExecMap.Add(requestType, handlerFn); } catch (ArgumentException) { throw new AmbiguousMatchException( string.Format( "Could not register the service '{0}' as another service with the definition of type 'IService<{1}>' already exists.", serviceType.FullName, requestType.Name)); } var serviceAttrs = requestType.GetCustomAttributes(typeof(ServiceAttribute), false); if (serviceAttrs.Length > 0) { requestServiceAttrs.Add(requestType, (ServiceAttribute)serviceAttrs[0]); } }
public Task <object> ExecuteAsync(object requestDto, IRequest request) { var requestType = requestDto.GetType(); if (appHost.Config.EnableAccessRestrictions) { AssertServiceRestrictions(requestType, request != null ? request.RequestAttributes : RequestAttributes.None); } ServiceExecFn handlerFn = GetService(requestType); var response = handlerFn(request, requestDto); var taskResponse = response as Task; if (taskResponse != null) { return(taskResponse.ContinueWith(x => x.GetResult())); } return(response.AsTaskResult()); }
private static ServiceExecFn CreateAutoBatchServiceExec(ServiceExecFn handlerFn) { return((req, dtos) => { var dtosList = ((IEnumerable)dtos).Map(x => x); if (dtosList.Count == 0) { return TypeConstants.EmptyObjectArray; } var firstDto = dtosList[0]; req.Items[Keywords.AutoBatchIndex] = 0; var firstResponse = handlerFn(req, firstDto); if (firstResponse is Exception) { req.SetAutoBatchCompletedHeader(0); return firstResponse; } //sync if (!(firstResponse is Task asyncResponse)) { var ret = firstResponse != null ? (object[])Array.CreateInstance(firstResponse.GetType(), dtosList.Count) : new object[dtosList.Count]; ret[0] = firstResponse; //don't re-execute first request for (var i = 1; i < dtosList.Count; i++) { var dto = dtosList[i]; req.Items[Keywords.AutoBatchIndex] = i; var response = handlerFn(req, dto); //short-circuit on first error if (response is Exception) { req.SetAutoBatchCompletedHeader(i); return response; } ret[i] = response; } req.Items.Remove(Keywords.AutoBatchIndex); req.SetAutoBatchCompletedHeader(dtosList.Count); return ret; } //async var asyncResponses = new Task[dtosList.Count]; Task firstAsyncError = null; //execute each async service sequentially var task = dtosList.EachAsync((dto, i) => { //short-circuit on first error and don't exec any more handlers if (firstAsyncError != null) { return firstAsyncError; } req.Items[Keywords.AutoBatchIndex] = i; asyncResponses[i] = i == 0 ? asyncResponse //don't re-execute first request : (Task)handlerFn(req, dto); var asyncResult = asyncResponses[i].GetResult(); if (asyncResult is Exception) { req.SetAutoBatchCompletedHeader(i); return firstAsyncError = asyncResponses[i]; } return asyncResponses[i]; }); var batchResponse = HostContext.Async.ContinueWith(req, task, x => { if (firstAsyncError != null) { return (object)firstAsyncError; } req.Items.Remove(Keywords.AutoBatchIndex); req.SetAutoBatchCompletedHeader(dtosList.Count); return (object)asyncResponses; }); //return error or completed responses return batchResponse; }); }
/// <summary> /// 加入到operationExecMap集合 key为:servicePath /// </summary> /// <param name="servicePath"></param> /// <param name="methodInfo"></param> /// <param name="serviceType"></param> /// <param name="handlerFn"></param> private void AddToMethodExecMap(string servicePath, MethodInfo methodInfo, Type serviceType, ServiceExecFn handlerFn) { if (!operationExecMap.ContainsKey(servicePath)) { operationExecMap[servicePath] = new Dictionary <string, ServiceExecFn>(); } //同一个servicePath(指的是二级目录) 如果有多个同样名称的方法 会报错 if (operationExecMap[servicePath].ContainsKey(methodInfo.Name.ToLower())) { throw new AmbiguousMatchException( string.Format( "Could not register method name '{0}' with service '{1}' as it has already been registered.\n" + "Each method name can only be registered once by a service, method name overloading is not allowed by AntServiceStack.", methodInfo.Name, serviceType.FullName)); } operationExecMap[servicePath].Add(methodInfo.Name.ToLower(), handlerFn); // RestrictAttribute attributes are only annotated on methods of service implementation MethodInfo methodInfoImpl = serviceType.GetMethod(methodInfo.Name, BindingFlags.Public | BindingFlags.Instance); //查看是否有限制条件(比如是否限制只能localhost访问之类的) var serviceAttrs = methodInfoImpl.GetCustomAttributes(typeof(RestrictAttribute), false); if (serviceAttrs.Length > 0) { operationServiceAttrs.Add(methodInfo.Name.ToLower(), (RestrictAttribute)serviceAttrs[0]); } }
private static ServiceExecFn CreateAutoBatchServiceExec(ServiceExecFn handlerFn) { return((req, dtos) => { var dtosList = ((IEnumerable)dtos).Map(x => x); if (dtosList.Count == 0) { return new object[0]; } var firstDto = dtosList[0]; var firstResponse = handlerFn(req, firstDto); if (firstResponse is Exception) { req.SetAutoBatchCompletedHeader(0); return firstResponse; } var asyncResponse = firstResponse as Task; //sync if (asyncResponse == null) { var ret = firstResponse != null ? (object[])Array.CreateInstance(firstResponse.GetType(), dtosList.Count) : new object[dtosList.Count]; ret[0] = firstResponse; //don't re-execute first request for (var i = 1; i < dtosList.Count; i++) { var dto = dtosList[i]; var response = handlerFn(req, dto); //short-circuit on first error if (response is Exception) { req.SetAutoBatchCompletedHeader(i); return response; } ret[i] = response; } req.SetAutoBatchCompletedHeader(dtosList.Count); return ret; } //async var asyncResponses = new Task[dtosList.Count]; Task firstAsyncError = null; //execute each async service sequentially return dtosList.EachAsync((dto, i) => { //short-circuit on first error and don't exec any more handlers if (firstAsyncError != null) { return firstAsyncError; } asyncResponses[i] = i == 0 ? asyncResponse //don't re-execute first request : (Task)handlerFn(req, dto); if (asyncResponses[i].GetResult() is Exception) { req.SetAutoBatchCompletedHeader(i); return firstAsyncError = asyncResponses[i]; } return asyncResponses[i]; }) .ContinueWith(x => { if (firstAsyncError != null) { return (object)firstAsyncError; } req.SetAutoBatchCompletedHeader(dtosList.Count); return (object)asyncResponses; }); //return error or completed responses }); }
private static ServiceExecFn CreateAutoBatchServiceExec(ServiceExecFn handlerFn) { return (req, dtos) => { var dtosList = ((IEnumerable) dtos).Map(x => x); if (dtosList.Count == 0) return new object[0]; var firstDto = dtosList[0]; var firstResponse = handlerFn(req, firstDto); if (firstResponse is Exception) { req.SetAutoBatchCompletedHeader(0); return firstResponse; } var asyncResponse = firstResponse as Task; //sync if (asyncResponse == null) { var ret = firstResponse != null ? (object[])Array.CreateInstance(firstResponse.GetType(), dtosList.Count) : new object[dtosList.Count]; ret[0] = firstResponse; //don't re-execute first request for (var i = 1; i < dtosList.Count; i++) { var dto = dtosList[i]; var response = handlerFn(req, dto); //short-circuit on first error if (response is Exception) { req.SetAutoBatchCompletedHeader(i); return response; } ret[i] = response; } req.SetAutoBatchCompletedHeader(dtosList.Count); return ret; } //async var asyncResponses = new Task[dtosList.Count]; Task firstAsyncError = null; //execute each async service sequentially return dtosList.EachAsync((dto, i) => { //short-circuit on first error and don't exec any more handlers if (firstAsyncError != null) return firstAsyncError; asyncResponses[i] = i == 0 ? asyncResponse //don't re-execute first request : (Task) handlerFn(req, dto); var asyncResult = asyncResponses[i].GetResult(); if (asyncResult is Exception) { req.SetAutoBatchCompletedHeader(i); return firstAsyncError = asyncResponses[i]; } return asyncResponses[i]; }) .ContinueWith(x => { if (firstAsyncError != null) return (object)firstAsyncError; req.SetAutoBatchCompletedHeader(dtosList.Count); return (object) asyncResponses; }); //return error or completed responses }; }
private object ManagedServiceExec(ServiceExecFn serviceExec, IService service, IRequest request, object requestDto) { try { InjectRequestContext(service, request); object response = null; try { requestDto = appHost.OnPreExecuteServiceFilter(service, requestDto, request, request.Response); if (request.Dto == null) // Don't override existing batched DTO[] request.Dto = requestDto; //Executes the service and returns the result response = serviceExec(request, requestDto); response = appHost.OnPostExecuteServiceFilter(service, response, request, request.Response); return response; } finally { //Gets disposed by AppHost or ContainerAdapter if set var taskResponse = response as Task; if (taskResponse != null) { taskResponse.ContinueWith(task => appHost.Release(service)); } else { appHost.Release(service); } } } catch (TargetInvocationException tex) { //Mono invokes using reflection throw tex.InnerException ?? tex; } }
private void AddToRequestExecMap(Type requestType, Type serviceType, ServiceExecFn handlerFn) { if (requestExecMap.ContainsKey(requestType)) { throw new AmbiguousMatchException( string.Format( "Could not register Request '{0}' with service '{1}' as it has already been assigned to another service.\n" + "Each Request DTO can only be handled by 1 service.", requestType.FullName, serviceType.FullName)); } requestExecMap.Add(requestType, handlerFn); var requestAttrs = requestType.AllAttributes<RestrictAttribute>(); if (requestAttrs.Length > 0) { requestServiceAttrs[requestType] = requestAttrs[0]; } else { var serviceAttrs = serviceType.AllAttributes<RestrictAttribute>(); if (serviceAttrs.Length > 0) { requestServiceAttrs[requestType] = serviceAttrs[0]; } } }
private static object ManagedServiceMethodExec( ServiceExecFn serviceExec, object service, IRequestContext requestContext, object dto, Type responseType) { InjectRequestContext(service, requestContext); Stopwatch stopwatch = new Stopwatch(); var httpRequest = requestContext != null?requestContext.Get <IHttpRequest>() : null; var httpResponse = requestContext != null?requestContext.Get <IHttpResponse>() : null; try { if (EndpointHost.Config != null && EndpointHost.Config.PreExecuteServiceFilter != null) { EndpointHost.Config.PreExecuteServiceFilter(service, httpRequest, httpResponse); } string identity = null; if (EndpointHost.ServiceManager != null && EndpointHost.MetadataMap != null && httpRequest != null) { identity = EndpointHost.Config.MetadataMap[httpRequest.ServicePath].GetOperationByOpName(httpRequest.OperationName).Key; } object response; //Executes the service and returns the result stopwatch.Start(); try { response = serviceExec(requestContext, dto); } catch (Exception) { throw; } finally { } stopwatch.Stop(); // Record service execution time if (httpResponse != null) { httpResponse.ResponseObject = response; if (httpResponse.ExecutionResult != null) { httpResponse.ExecutionResult.ServiceExecutionTime = stopwatch.ElapsedMilliseconds; } } if (response == null) // null response { throw new NullReferenceException("Null response returned by service call"); } if (EndpointHost.Config != null && EndpointHost.Config.PostExecuteServiceFilter != null) { EndpointHost.Config.PostExecuteServiceFilter(service, httpRequest, httpResponse); } IHasResponseStatus hasResponseStatus = response as IHasResponseStatus; if (hasResponseStatus != null && hasResponseStatus.ResponseStatus != null && hasResponseStatus.ResponseStatus.Ack == AckCodeType.Failure) { if (hasResponseStatus.ResponseStatus.Errors.Count > 0) { ErrorUtils.LogError("Internal handled Service Error", httpRequest, hasResponseStatus.ResponseStatus, false, "FXD300003"); } else { ErrorUtils.LogError("Internal handled Service Error. But no error data in ResponseStatus.Errors. QA please fire bug to dev and let dev fix it.", httpRequest, hasResponseStatus.ResponseStatus, true, "FXD300028"); } } return(response); } catch (Exception ex) { var errorResponse = ErrorUtils.CreateServiceErrorResponse(httpRequest, ex, responseType); if (httpResponse != null) { httpResponse.ResponseObject = errorResponse; if (httpResponse.ExecutionResult != null) { httpResponse.ExecutionResult.ExceptionCaught = ex; // Mark service excution throws exception httpResponse.ExecutionResult.ServiceExceptionThrown = true; // take service execution time into accout even the service execution throws excetpion if (stopwatch.IsRunning) { stopwatch.Stop(); } httpResponse.ExecutionResult.ServiceExecutionTime = stopwatch.ElapsedMilliseconds; } } return(errorResponse); } finally { if (EndpointHost.AppHost != null) { //Gets disposed by AppHost or ContainerAdapter if set EndpointHost.AppHost.Release(service); } else { using (service as IDisposable) { } } } }
/// <summary> /// 构造异步的执行action /// </summary> /// <param name="serviceExec"></param> /// <param name="service"></param> /// <param name="requestContext"></param> /// <param name="dto"></param> /// <param name="responseType"></param> /// <param name="getResult"></param> /// <returns></returns> private static Task <object> ManagedAsyncServiceMethodExec( ServiceExecFn serviceExec, object service, IRequestContext requestContext, object dto, Type responseType, Func <object, object> getResult) { Stopwatch stopwatch = new Stopwatch(); var httpRequest = requestContext != null?requestContext.Get <IHttpRequest>() : null; var httpResponse = requestContext != null?requestContext.Get <IHttpResponse>() : null; string identity = null; if (EndpointHost.ServiceManager != null && EndpointHost.MetadataMap != null && httpRequest != null) { identity = EndpointHost.Config.MetadataMap[httpRequest.ServicePath].GetOperationByOpName(httpRequest.OperationName).Key; } Task serviceTask = null; try { InjectRequestContext(service, requestContext); if (EndpointHost.Config != null && EndpointHost.Config.PreExecuteServiceFilter != null) { EndpointHost.Config.PreExecuteServiceFilter(service, httpRequest, httpResponse); } //Executes the async service and returns the task stopwatch.Start(); try { serviceTask = serviceExec(requestContext, dto) as Task; } catch (Exception) { object startTimeObject; if (httpRequest.Items.TryGetValue(ServiceCatConstants.SOA2AsyncServiceStartTimeKey, out startTimeObject)) { var startTime = (DateTime)startTimeObject; } throw; } finally { } if (serviceTask == null) // null task { throw new InvalidOperationException(ServiceUtils.AsyncOperationReturnedNullTask); } if (serviceTask.Status == TaskStatus.Created) { throw new InvalidAsynchronousStateException("Service task status is invalid: TaskStatus.Created"); } } catch (Exception ex) { TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(); try { if (stopwatch.IsRunning) { stopwatch.Stop(); } var response = ErrorUtils.CreateServiceErrorResponse(httpRequest, ex, responseType); if (httpResponse != null) { httpResponse.ResponseObject = response; if (httpResponse.ExecutionResult != null) { httpResponse.ExecutionResult.ExceptionCaught = ex; httpResponse.ExecutionResult.ServiceExceptionThrown = true; httpResponse.ExecutionResult.ServiceExecutionTime = stopwatch.ElapsedMilliseconds; } } tcs.TrySetResult(response); } catch (Exception ex1) { tcs.TrySetException(ex1); } return(tcs.Task); } return(serviceTask.ContinueWith(t => { try { Exception taskException = t.Exception; stopwatch.Stop(); if (taskException != null) // handler service exception { Exception ex = taskException.InnerException ?? taskException; var responseObject = ErrorUtils.CreateServiceErrorResponse(httpRequest, ex, responseType); if (httpResponse != null) { if (httpResponse.ExecutionResult != null) { httpResponse.ExecutionResult.ExceptionCaught = ex; // Mark service execution throws exception httpResponse.ExecutionResult.ServiceExceptionThrown = true; httpResponse.ExecutionResult.ServiceExecutionTime = stopwatch.ElapsedMilliseconds; } httpResponse.ResponseObject = responseObject; } return responseObject; } object response = getResult(serviceTask); // get the real response if (response == null) // null response, create service error response { var ex = new InvalidOperationException("Null response returned by service call"); var responseObject = ErrorUtils.CreateServiceErrorResponse(httpRequest, ex, responseType); if (httpResponse != null) { httpResponse.ResponseObject = responseObject; if (httpResponse.ExecutionResult != null) { httpResponse.ExecutionResult.ExceptionCaught = ex; httpResponse.ExecutionResult.ServiceExceptionThrown = true; httpResponse.ExecutionResult.ServiceExecutionTime = stopwatch.ElapsedMilliseconds; } } return responseObject; } if (EndpointHost.Config != null && EndpointHost.Config.PostExecuteServiceFilter != null) { EndpointHost.Config.PostExecuteServiceFilter(service, httpRequest, httpResponse); } IHasResponseStatus hasResponseStatus = response as IHasResponseStatus; if (hasResponseStatus != null && hasResponseStatus.ResponseStatus != null && hasResponseStatus.ResponseStatus.Ack == AckCodeType.Failure) { if (hasResponseStatus.ResponseStatus.Errors.Count > 0) { ErrorUtils.LogError("Internal handled Service Error", httpRequest, hasResponseStatus.ResponseStatus, false, "FXD300003"); } else { ErrorUtils.LogError("Internal handled Service Error. But no error data in ResponseStatus.Errors. QA please fire bug to dev and let dev fix it.", httpRequest, hasResponseStatus.ResponseStatus, true, "FXD300028"); } } if (httpResponse != null) { httpResponse.ResponseObject = response; if (httpResponse.ExecutionResult != null) { httpResponse.ExecutionResult.ServiceExecutionTime = stopwatch.ElapsedMilliseconds; } } return response; } catch (Exception ex) // catch unexpected framework exception { var responseObject = ErrorUtils.CreateFrameworkErrorResponse(httpRequest, ex, responseType); if (httpResponse != null) { httpResponse.ResponseObject = responseObject; if (httpResponse.ExecutionResult != null) { httpResponse.ExecutionResult.ExceptionCaught = ex; // Mark framework excution throws exception httpResponse.ExecutionResult.FrameworkExceptionThrown = true; httpResponse.ExecutionResult.ServiceExecutionTime = stopwatch.ElapsedMilliseconds; } } return responseObject; } finally { if (EndpointHost.AppHost != null) { //Gets disposed by AppHost or ContainerAdapter if set EndpointHost.AppHost.Release(service); } else { using (service as IDisposable) { } } } })); }
private object ManagedServiceExec(ServiceExecFn serviceExec, IService service, IRequest request, object requestDto) { try { InjectRequestContext(service, request); try { request.Dto = requestDto; requestDto = appHost.OnPreExecuteServiceFilter(service, requestDto, request, request.Response); request.Dto = requestDto; //Executes the service and returns the result var response = serviceExec(request, requestDto); response = appHost.OnPostExecuteServiceFilter(service, response, request, request.Response); return response; } finally { //Gets disposed by AppHost or ContainerAdapter if set appHost.Release(service); } } catch (TargetInvocationException tex) { //Mono invokes using reflection throw tex.InnerException ?? tex; } }