public override void ProcessRequest(IServiceRequest request, IServiceResponse response, IResourceRepository resourceRepository)
{
EAEPMessages messages = new EAEPMessages(request.Body);
monitorStore.PushMessages(messages);
response.StatusCode = Constants.HTTP_200_OK;
response.StatusDescription = "OK";
}
/// <summary>
/// 得到操作元数据
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public virtual IOperationDescriptor GetOperationDescriptor(IServiceRequest req)
{
Guard.NotNull(req, "req");
var serviceDescriptor = DescriptorManager.GetServiceDescriptor(req.ServiceName);
if (serviceDescriptor == null)
throw new ServiceDispatcherException(
ServiceDispatcherExceptionCode.ServiceNotFound)
{
ServiceName = req.ServiceName
,
OperationName = req.OperationName
};
//得到领域Action元数据
var operationDesc = serviceDescriptor[req.OperationName];
if (operationDesc == null)
throw new ServiceDispatcherException(
ServiceDispatcherExceptionCode.OperationNotFound)
{
ServiceName = req.ServiceName
,
OperationName = req.OperationName
};
return operationDesc;
}
/// <summary>
/// Injects the given factory into the target container.
/// </summary>
/// <param name="request">The <see cref="IServiceRequest"/> instance that describes the service that is currently being requested.</param>
public void Preprocess(IServiceRequest request)
{
// Inject the custom factory if no other
// replacement exists
if (request.ActualFactory != null)
return;
var serviceType = request.ServiceType;
// Skip any service requests for types that are generic type definitions
if (serviceType.IsGenericTypeDefinition)
return;
// If the current service type is a generic type,
// its type definition must match the given service type
if (serviceType.IsGenericType && serviceType.GetGenericTypeDefinition() != _serviceType)
return;
// The service types must match
if (!serviceType.IsGenericType && serviceType != _serviceType)
return;
// Inject the custom factory itself
request.ActualFactory = _factory;
}
public override void ProcessRequest(IServiceRequest request, IServiceResponse response, IResourceRepository resourceRepository)
{
response.ContentType = Constants.CONTENT_TYPE_JSON;
EAEPMessages messages = null;
if (request.GetParameter(Constants.QUERY_STRING_FROM) != null)
{
DateTime from = DateTime.ParseExact(request.GetParameter(Constants.QUERY_STRING_FROM), Constants.FORMAT_DATETIME, CultureInfo.InvariantCulture);
if (request.GetParameter(Constants.QUERY_STRING_TO) != null)
{
messages = monitor.GetMessages(
from,
DateTime.ParseExact(request.GetParameter(Constants.QUERY_STRING_TO), Constants.FORMAT_DATETIME, CultureInfo.InvariantCulture),
request.Query
);
}
else
{
messages = monitor.GetMessages(from, request.Query);
}
}
else
{
messages = monitor.GetMessages(request.Query);
}
using (StreamWriter writer = new StreamWriter(response.ContentStream))
{
string json = JsonConvert.SerializeObject(messages);
writer.Write(json);
}
}
/// <summary>
/// Instantiates the service described by the <paramref name="serviceRequest"/>.
/// </summary>
/// <param name="serviceRequest">The <see cref="IServiceRequest"/> that describes the service that needs to be instantiated.</param>
/// <returns>A valid object reference if the service can be found; otherwise, it will return <c>null</c>.</returns>
public virtual object GetService(IServiceRequest serviceRequest)
{
// Allow users to intercept the instantiation process
if (_preProcessor != null)
_preProcessor.Preprocess(serviceRequest);
var factoryRequest = new FactoryRequest
{
ServiceType = serviceRequest.ServiceType,
ServiceName = serviceRequest.ServiceName,
Arguments = serviceRequest.ActualArguments,
Container = _container
};
var instance = _creator.CreateFrom(factoryRequest, serviceRequest.ActualFactory);
// Postprocess the results
var result = new ServiceRequestResult
{
ServiceName = serviceRequest.ServiceName,
ActualResult = instance,
Container = _container,
OriginalResult = instance,
ServiceType = serviceRequest.ServiceType,
AdditionalArguments = serviceRequest.ActualArguments
};
if (_postProcessor != null)
_postProcessor.PostProcess(result);
return result.ActualResult ?? result.OriginalResult;
}
/// <summary>
/// A method that passes every request result made
/// to the list of preprocessors.
/// </summary>
/// <param name="request">The parameter that describes the context of the service request.</param>
public void Preprocess(IServiceRequest request)
{
foreach (var preprocessor in _preProcessors)
{
preprocessor.Preprocess(request);
}
}
public Task<IServiceResponse<int>> InsertMyObject(IServiceRequest<MyObject> obj)
{
obj.MustNotBeNull("obj");
return Task.Factory.StartNew(() =>
{
using (var repo = new ExampleRepo())
{
var toInsert = Mapper.Map<MyEntity>(obj.Argument);
try
{
repo.MyEntities.Insert(toInsert);
}
catch (Exception ex)
{
//yes - catching all exceptions is not good - but this is just demonstrating how you might use the exception to
//generate a failed response that automatically has the exception on it.
//IN SOME CASES, your service layer operations will bubble their exceptions out, of course - it all depends
//on how you want to handle it.
return ex.AsFailedResponse<int>();
}
return toInsert.Id.AsSuccessfulResponse();
}
});
}
public override bool IsValidName(IServiceRequest req, string actionName, IOperationDescriptor operationDesc)
{
if (string.IsNullOrEmpty(this.Name))
return false;
return req.Arguments.ContainsKey(this.Name);
}
public System.Threading.Tasks.Task<IServiceResponse<PagedResult<MyObject>>> QueryMyObjects(IServiceRequest<PagedQuery> query)
{
//no caching here
//although - what we could do is check whether any of the objects coming back are in the cache and, if they are,
//then we replace them for when we do individual gets ONLY
return _inner.QueryMyObjects(query);
}
public async System.Threading.Tasks.Task<IServiceResponse<MyObject>> GetMyObject(IServiceRequest<int> id)
{
// so we use the same validation mechanism that's used over in the Direct service implementation in
// ../WebAPIDemos.ServiceLayer.Direct/MyObjectService.cs
id.MustNotBeNull("id");
//note - I'm using await here to handle the implicit casting of ApiServiceResponse<T> to IServiceResponse<T>
return await _requestManager.Get<ApiServiceResponse<MyObject>>(string.Format("api/MyObjects/{0}", id.Argument.ToString()), id);
}
protected void WriteContent(IServiceRequest request, IServiceResponse response, IResourceRepository resourceRepository)
{
response.ContentType = "text/html";
using (StreamWriter targetWriter = new StreamWriter(response.ContentStream))
{
InternalWriteContent(targetWriter, request, response, resourceRepository);
}
}
private static void WriteSearchResultHeader(StreamWriter writer, IServiceRequest request, IResourceRepository resourceRepository, string searchResultText)
{
string header = resourceRepository.GetResourceAsString("searchresultheader.htm");
Hashtable values = new Hashtable();
values.Add("queryparam", Constants.QUERY_STRING_QUERY);
values.Add("query", request.Query);
values.Add("searchresulttext", searchResultText);
writer.WriteLine(TemplateParser.Parse(header, values));
}
public ServiceProxy(string cloudId, string accessKey, string secretKey, string apiHost)
{
_cloudId = cloudId;
_apiHost = apiHost;
_secretKey = secretKey;
_accessKey = accessKey;
_utility = new ServiceProxyUtility();
_serviceRequest = new ServiceRequest();
}
public AuthorizationInfo GetAuthorizationInfo(IServiceRequest requestContext)
{
object cached;
if (requestContext.Items.TryGetValue("AuthorizationInfo", out cached))
{
return (AuthorizationInfo)cached;
}
return GetAuthorization(requestContext);
}
private void ValidateUser(IServiceRequest request,
IAuthenticationAttributes authAttribtues)
{
// This code is executed before the service
var auth = AuthorizationContext.GetAuthorizationInfo(request);
if (!IsExemptFromAuthenticationToken(auth, authAttribtues))
{
var valid = IsValidConnectKey(auth.Token);
if (!valid)
{
ValidateSecurityToken(request, auth.Token);
}
}
var user = string.IsNullOrWhiteSpace(auth.UserId)
? null
: UserManager.GetUserById(auth.UserId);
if (user == null & !string.IsNullOrWhiteSpace(auth.UserId))
{
throw new SecurityException("User with Id " + auth.UserId + " not found");
}
if (user != null)
{
ValidateUserAccess(user, request, authAttribtues, auth);
}
var info = GetTokenInfo(request);
if (!IsExemptFromRoles(auth, authAttribtues, info))
{
var roles = authAttribtues.GetRoles().ToList();
ValidateRoles(roles, user);
}
if (!string.IsNullOrWhiteSpace(auth.DeviceId) &&
!string.IsNullOrWhiteSpace(auth.Client) &&
!string.IsNullOrWhiteSpace(auth.Device))
{
SessionManager.LogSessionActivity(auth.Client,
auth.Version,
auth.DeviceId,
auth.Device,
request.RemoteIp,
user);
}
}
public void Handle(IServiceRequest request, IServiceResponse response, IResourceRepository resourceRepository)
{
try
{
ProcessRequest(request, response, resourceRepository);
response.StatusCode = Constants.HTTP_200_OK;
response.StatusDescription = "OK";
}
catch (Exception)
{
response.StatusCode = Constants.HTTP_500_SERVER_ERROR;
response.StatusDescription = "Error, review logs";
}
}
public Task<SessionInfo> GetSession(IServiceRequest requestContext)
{
var authorization = _authContext.GetAuthorizationInfo(requestContext);
//if (!string.IsNullOrWhiteSpace(authorization.Token))
//{
// var auth = GetTokenInfo(requestContext);
// if (auth != null)
// {
// return _sessionManager.GetSessionByAuthenticationToken(auth, authorization.DeviceId, requestContext.RemoteIp, authorization.Version);
// }
//}
var user = string.IsNullOrWhiteSpace(authorization.UserId) ? null : _userManager.GetUserById(authorization.UserId);
return _sessionManager.LogSessionActivity(authorization.Client, authorization.Version, authorization.DeviceId, authorization.Device, requestContext.RemoteIp, user);
}
public IServiceResponse Get(IServiceRequest request, IRequestSettings restSettings)
{
if (Auth != null)
client.Authenticator = Auth;
var restRequest = new RestRequest(request.Uri, Method.GET);
var response = client.Execute(restRequest);
return new ServiceResponse
{
Data = response.Content,
StatusCode = response.StatusCode,
ErrorException = response.ErrorException,
ErrorMessage = response.ErrorMessage
};
}
public override void ProcessRequest(IServiceRequest request, IServiceResponse response, IResourceRepository resourceRepository)
{
string[] values = store.Distinct(
request.GetParameter(Constants.QUERY_STRING_FIELD),
DateTime.ParseExact(request.GetParameter(Constants.QUERY_STRING_FROM), Constants.FORMAT_DATETIME, CultureInfo.InvariantCulture),
DateTime.ParseExact(request.GetParameter(Constants.QUERY_STRING_TO), Constants.FORMAT_DATETIME, CultureInfo.InvariantCulture),
request.Query
);
response.ContentType = Constants.CONTENT_TYPE_JSON;
using (StreamWriter writer = new StreamWriter(response.ContentStream))
{
string json = JsonConvert.SerializeObject(values);
writer.Write(json);
}
}
public override void ProcessRequest(IServiceRequest request, IServiceResponse response, IResourceRepository resourceRepository)
{
CountResult[] result = store.Count(
DateTime.ParseExact(request.GetParameter(Constants.QUERY_STRING_FROM), Constants.FORMAT_DATETIME, CultureInfo.InvariantCulture),
DateTime.ParseExact(request.GetParameter(Constants.QUERY_STRING_TO), Constants.FORMAT_DATETIME, CultureInfo.InvariantCulture),
int.Parse(request.GetParameter(Constants.QUERY_STRING_TIMESLICES)),
request.GetParameter(Constants.QUERY_STRING_GROUPBY),
request.Query
);
response.ContentType = Constants.CONTENT_TYPE_JSON;
using (StreamWriter writer = new StreamWriter(response.ContentStream))
{
writer.Write((string) JsonConvert.SerializeObject(result));
}
}
//note - for testability - a better implementation of this service would accept an IServiceCache abstraction
//(name is actually irrelevant - it'd be a proprietary type for this solution),
//and then one implementation of that would operate over the HostingEnvironment.Cache; making it
//possible to isolate this class in a unit test with a mocked IServiceCache implementation.
public async System.Threading.Tasks.Task<IServiceResponse<MyObject>> GetMyObject(IServiceRequest<int> id)
{
id.MustNotBeNull("id");
string cacheKey = MyObjectCacheKey(id.Argument);
//do caching
MyObject cached = (MyObject)HostingEnvironment.Cache[cacheKey];
if (cached != null)
return cached.AsSuccessfulResponse();
//try and retrieve the object from the inner service. The logic here is if we get a successful response, then
//we will cache it. Otherwise we will simply return the response. So, crucially, failed lookups are never cached in
//this implementation - which, in practise, might not be desirable.
var response = await _inner.GetMyObject(id);
if (response.Success)
HostingEnvironment.Cache.Insert(cacheKey, response.Result, null, DateTime.UtcNow.AddMinutes(5), System.Web.Caching.Cache.NoSlidingExpiration);
return response;
}
/// <summary>
/// Begins an asynchronous operation to send a request over the secure channel.
/// </summary>
/// <param name="request">The request to send.</param>
/// <param name="callback">The callback to call when the operation completes.</param>
/// <param name="callbackData">The callback data to return with the callback.</param>
/// <returns>
/// The result which must be passed to the EndSendRequest method.
/// </returns>
/// <exception cref="ServiceResultException">Thrown if any communication error occurs.</exception>
/// <seealso cref="SendRequest"/>
public IAsyncResult BeginSendRequest(IServiceRequest request, AsyncCallback callback, object callbackData)
{
TcpClientChannel channel = m_channel;
if (channel == null)
{
lock (m_lock)
{
if (m_channel == null)
{
OpenOnDemand();
}
channel = m_channel;
}
}
return(channel.BeginSendRequest(request, m_operationTimeout, callback, callbackData));
}
/// <summary>
/// Dispatches an incoming binary encoded request.
/// </summary>
/// <param name="request">Request.</param>
/// <returns>Invoke service response message.</returns>
public virtual InvokeServiceResponseMessage InvokeService(InvokeServiceMessage request)
{
IServiceRequest decodedRequest = null;
IServiceResponse response = null;
// create context for request and reply.
ServiceMessageContext context = MessageContext;
try
{
// check for null.
if (request == null || request.InvokeServiceRequest == null)
{
throw new ServiceResultException(StatusCodes.BadDecodingError, Utils.Format("Null message cannot be processed."));
}
// decoding incoming message.
decodedRequest = BinaryDecoder.DecodeMessage(request.InvokeServiceRequest, null, context) as IServiceRequest;
// invoke service.
response = ProcessRequest(decodedRequest);
// encode response.
InvokeServiceResponseMessage outgoing = new InvokeServiceResponseMessage();
outgoing.InvokeServiceResponse = BinaryEncoder.EncodeMessage(response, context);
return(outgoing);
}
catch (Exception e)
{
// create fault.
ServiceFault fault = CreateFault(decodedRequest, e);
// encode fault response.
if (context == null)
{
context = new ServiceMessageContext();
}
InvokeServiceResponseMessage outgoing = new InvokeServiceResponseMessage();
outgoing.InvokeServiceResponse = BinaryEncoder.EncodeMessage(fault, context);
return(outgoing);
}
}
/// <summary>
/// Handles requests arriving from a channel.
/// </summary>
private void OnRequestReceived(TcpListenerChannel channel, uint requestId, IServiceRequest request)
{
try
{
if (m_callback != null)
{
IAsyncResult result = m_callback.BeginProcessRequest(
channel.GlobalChannelId,
channel.EndpointDescription,
request,
OnProcessRequestComplete,
new object[] { channel, requestId, request });
}
}
catch (Exception e)
{
Utils.LogError(e, "TCPLISTENER - Unexpected error processing request.");
}
}
/// <summary>
/// Begins an asynchronous operation to send a request over the secure channel.
/// </summary>
/// <param name="request">The request to send.</param>
/// <param name="callback">The callback to call when the operation completes.</param>
/// <param name="callbackData">The callback data to return with the callback.</param>
/// <returns>
/// The result which must be passed to the EndSendRequest method.
/// </returns>
/// <exception cref="ServiceResultException">Thrown if any communication error occurs.</exception>
/// <seealso cref="SendRequest"/>
public IAsyncResult BeginSendRequest(IServiceRequest request, AsyncCallback callback, object callbackData)
{
UaSCUaBinaryClientChannel channel = m_channel;
if (channel == null)
{
lock (m_lock)
{
if (m_channel == null)
{
CreateChannel();
}
channel = m_channel;
}
}
return(channel.BeginSendRequest(request, m_operationTimeout, callback, callbackData));
}
/// <summary>
/// 监听异常
/// </summary>
/// <param name="req"></param>
/// <param name="resp"></param>
/// <param name="operationDesc"></param>
public override void OnExceptionFired(IServiceRequest req, IServiceResponse resp, IOperationDescriptor operationDesc)
{
IRedirectToErrorResult errorNav = null;
if (operationDesc != null)
{
if (operationDesc.Extensions.ContainsKey(ControllerListener.ErrorNavigation))
errorNav = operationDesc.Extensions[ControllerListener.ErrorNavigation] as IRedirectToErrorResult;
else if (operationDesc.ServiceDescriptor.Extensions.ContainsKey(ControllerListener.ErrorNavigation))
errorNav = operationDesc.ServiceDescriptor.Extensions[ControllerListener.ErrorNavigation] as IRedirectToErrorResult;
}
//执行失败后， 设置mvc的 controller serviceDispatcherName 和 ActionName
if (errorNav != null)
{
req.Context[ControllerListener.NavigationResult] = errorNav;
if (errorNav.IsSaveModelState)
resp.Result = req.Arguments.FirstOrDefault();//TODO:
}
}
/// <inheritdoc/>
public async Task <IServiceResponse> SendRequestAsync(IServiceRequest request, CancellationToken ct)
{
try
{
ByteArrayContent content = new ByteArrayContent(BinaryEncoder.EncodeMessage(request, m_quotas.MessageContext));
content.Headers.ContentType = m_mediaTypeHeaderValue;
var result = await m_client.PostAsync(m_url, content, ct).ConfigureAwait(false);
result.EnsureSuccessStatusCode();
Stream responseContent = await result.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(BinaryDecoder.DecodeMessage(responseContent, null, m_quotas.MessageContext) as IServiceResponse);
}
catch (Exception ex)
{
Utils.Trace("Exception sending HTTPS request: " + ex.Message);
throw;
}
}
public IServiceResponse Get(IServiceRequest request)
{
if (Auth != null)
{
client.Authenticator = Auth;
}
var restRequest = new RestRequest(request.Uri, Method.GET);
var response = client.Execute(restRequest);
return(new ServiceResponse
{
Data = response.Content,
StatusCode = response.StatusCode,
ErrorException = response.ErrorException,
ErrorMessage = response.ErrorMessage
});
}
public bool Check()
{
bool didAnything = false;
foreach (IHttpRequestModule iHttpReq in m_modules)
{
IServiceRequest httpInfo = null;
if (iHttpReq != null)
{
httpInfo = iHttpReq.GetNextCompletedRequest();
}
if (httpInfo == null)
{
continue;
}
while (httpInfo != null)
{
HttpRequestClass info = (HttpRequestClass)httpInfo;
//m_log.Debug("[AsyncLSL]:" + httpInfo.response_body + httpInfo.status);
// Deliver data to prim's remote_data handler
iHttpReq.RemoveCompletedRequest(info);
object[] resobj = new object[]
{
new LSL_Types.LSLString(info.ReqID.ToString()),
new LSL_Types.LSLInteger(info.Status),
new LSL_Types.list(info.Metadata),
new LSL_Types.LSLString(info.ResponseBody)
};
m_ScriptEngine.AddToObjectQueue(info.PrimID, "http_response", new DetectParams[0], -1, resobj);
httpInfo = iHttpReq.GetNextCompletedRequest();
}
didAnything = true;
}
return(didAnything);
}
/// <summary>
/// Called when a request completes.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
/// <param name="serviceName">The name of the service.</param>
protected virtual void RequestCompleted(IServiceRequest request, IServiceResponse response, string serviceName)
{
uint requestHandle = 0;
StatusCode statusCode = StatusCodes.Good;
if (request != null)
{
requestHandle = request.RequestHeader.RequestHandle;
}
else if (response != null)
{
requestHandle = response.ResponseHeader.RequestHandle;
statusCode = response.ResponseHeader.ServiceResult;
}
if (response == null)
{
statusCode = StatusCodes.Bad;
}
int pendingRequestCount = Interlocked.Decrement(ref m_pendingRequestCount);
if (statusCode != StatusCodes.Good)
{
Utils.Trace(
(int)Utils.TraceMasks.Service,
"{0} Completed. RequestHandle={1}, PendingRequestCount={3}, StatusCode={2}",
serviceName,
requestHandle,
statusCode,
pendingRequestCount);
}
else
{
Utils.Trace(
(int)Utils.TraceMasks.Service,
"{0} Completed. RequestHandle={1}, PendingRequestCount={2}",
serviceName,
requestHandle,
pendingRequestCount);
}
}
/// <summary>
/// Begins an asynchronous operation to send a request over the secure channel.
/// </summary>
public IAsyncResult BeginSendRequest(IServiceRequest request, AsyncCallback callback, object callbackData)
{
#if !SILVERLIGHT
if (!m_servicePointInitialized)
{
ServicePoint sp = System.Net.ServicePointManager.FindServicePoint(m_url);
sp.ConnectionLimit = 1000;
m_servicePointInitialized = true;
}
#endif
HttpWebRequest webRequest = (HttpWebRequest)HttpWebRequest.Create(m_url.ToString());
webRequest.Method = "POST";
if (m_settings.Configuration.UseBinaryEncoding)
{
webRequest.ContentType = "application/octet-stream";
}
else
{
StringBuilder contentType = new StringBuilder();
contentType.Append("application/soap+xml; charset=\"utf-8\"; action=\"");
contentType.Append(Namespaces.OpcUaWsdl);
contentType.Append("/");
string typeName = request.GetType().Name;
int index = typeName.LastIndexOf("Request");
contentType.Append(typeName.Substring(0, index));
;
contentType.Append("\"");
webRequest.ContentType = contentType.ToString();
#if !SILVERLIGHT
webRequest.Headers.Add("OPCUA-SecurityPolicy", this.m_settings.Description.SecurityPolicyUri);
#endif
}
AsyncResult result = new AsyncResult(callback, callbackData, m_operationTimeout, request, webRequest);
webRequest.BeginGetRequestStream(OnGetRequestStreamComplete, result);
return(result);
}
/// <summary>
/// 分发服务调用
/// </summary>
/// <param name="req">请求</param>
/// <returns>返回响应信息</returns>
public IServiceResponse Dispatch(IServiceRequest req)
{
Guard.NotNull(req, "req");
try
{
ListenManager.OnDispatching(req);
return(OnExecute(req));
}
finally
{
try
{
ListenManager.OnDispatched(req);
}
catch (Exception ex)
{
ExceptionManager.Handle(ex);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="req"></param>
/// <param name="resp"></param>
/// <param name="operationDesc"></param>
public override void OnExceptionFired(IServiceRequest req, IServiceResponse resp, IOperationDescriptor operationDesc)
{
var current = MonitorContext.Current;
var monitorData = current.Data;
if (current.OperationStopwatch.IsRunning)
{
current.OperationStopwatch.Stop();
}
else
{
foreach (var key in req.Arguments.Keys)
{
monitorData.Args[key] = req.Arguments[key];
}
}
current.Data.HasError = true;
current.Data.ErrorMessage = resp.Exception.Message;
current.Data.StackTrace = resp.Exception.StackTrace;
}
/// <summary>
/// Creates a fault message.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="exception">The exception.</param>
/// <returns>A fault message.</returns>
protected static Exception CreateSoapFault(IServiceRequest request, Exception exception)
{
ServiceFault fault = CreateFault(request, exception);
// get the error from the header.
ServiceResult error = fault.ResponseHeader.ServiceResult;
if (error == null)
{
error = ServiceResult.Create(StatusCodes.BadUnexpectedError, "An unknown error occurred.");
}
// construct the fault code and fault reason.
string codeName = StatusCodes.GetBrowseName(error.Code);
FaultCode code = null;
FaultReason reason = null;
if (!LocalizedText.IsNullOrEmpty(error.LocalizedText))
{
reason = new FaultReason(new FaultReasonText(Utils.Format("{0}", error.LocalizedText),
CultureInfo.InvariantCulture));
}
else
{
reason = new FaultReason(new FaultReasonText(codeName, CultureInfo.InvariantCulture));
}
if (!String.IsNullOrEmpty(error.SymbolicId))
{
FaultCode subcode = new FaultCode(error.SymbolicId, error.NamespaceUri);
code = new FaultCode(codeName, Namespaces.OpcUa, subcode);
}
else
{
code = new FaultCode(codeName, Namespaces.OpcUa);
}
// throw the fault.
return(new FaultException <ServiceFault>(fault, reason, code));
}
public Task<IServiceResponse<MyObject>> GetMyObject(IServiceRequest<int> id)
{
id.MustNotBeNull("id");
MyObject foo = null;
//return Task.FromResult(foo.AsSuccessfulResponse());
return Task.Factory.StartNew(() =>
{
using (var repo = new ExampleRepo())
{
var found = Mapper.Map<MyObject>(repo.MyEntities.Fetch(id.Argument));
if (found != null)
return found.AsSuccessfulResponse();
else //could be nicer - ideally want a 'AsResponse' method that will auto-select success/fail based on not-null/null
return found.AsFailedResponse();
}
});
}
bool ValidateParamters(IOperationDescriptor operationDesc, IServiceRequest req, ServiceResponse resp)
{
if (!req.ValidateRequest ||
req.Arguments == null ||
req.Arguments.Count == 0)
{
return(true);
}
foreach (var key in req.Arguments.Keys)
{
var errorState = Validator.Validate(req.Arguments[key]);
if (errorState.Count > 0)
{
resp.ErrorState.AddRange(errorState);
return(false);
}
}
return(true);
}
/// <summary>
/// Dispatches an incoming binary encoded request.
/// </summary>
/// <param name="incoming">Incoming request.</param>
public virtual IServiceResponse ProcessRequest(IServiceRequest incoming)
{
try {
SetRequestContext(RequestEncoding.Binary);
ServiceDefinition service = null;
// find service.
if (!SupportedServices.TryGetValue(incoming.TypeId, out service))
{
throw new ServiceResultException(StatusCodes.BadServiceUnsupported,
Utils.Format("'{0}' is an unrecognized service identifier.", incoming.TypeId));
}
// invoke service.
return(service.Invoke(incoming));
} catch (Exception e) {
// create fault.
return(CreateFault(incoming, e));
}
}
protected override void InternalWriteContent(StreamWriter writer, IServiceRequest request, IServiceResponse response, IResourceRepository resourceRepository)
{
resourceRepository.WriteResource("header.htm", writer);
bool activeSearch = (request.Query != null);
try
{
EAEPMessages messages = new EAEPMessages();
string searchResultText = string.Empty;
if (activeSearch)
{
messages = monitor.GetMessages(request.Query);
searchResultText = string.Format("{0} message(s) found", messages.Count);
}
WriteSearchResultHeader(writer, request, resourceRepository, searchResultText);
int maxItems = 100;
if (maxItems > messages.Count) { maxItems = messages.Count; }
string messageTemplate = resourceRepository.GetResourceAsString("eaepmsg.htm");
for (int i = 0; i < maxItems; i++)
{
WriteResultItem(writer, messageTemplate, messages[i]);
}
}
catch (Exception ex)
{
writer.WriteLine(ReplaceCRLFwithHTMLLineBreaks(ex.ToString()));
}
resourceRepository.WriteResource("searchresultfooter.htm", writer);
resourceRepository.WriteResource("footer.htm", writer);
}
/// <summary>
/// Do really cool powershell things
/// </summary>
/// <param name="script"></param>
/// <param name="request"></param>
private void ExecuteScriptForRequest(Script script, IServiceRequest request)
{
Runspace runspace = RunspaceFactory.CreateRunspace();
runspace.Open();
// create a pipeline and feed it the script
Pipeline pipeline = runspace.CreatePipeline();
try
{
pipeline.Commands.AddScript(@"C:\Scripts\" + script.FileName);
}
catch (Exception exception)
{
Displaymessage($"Error: {exception.Message}", MessageType.Failure);
}
// add parameters
runspace.SessionStateProxy.SetVariable("RequestedFor", request.RequestedForGuids);
runspace.SessionStateProxy.SetVariable("Requestor", request.RequestedByGuid);
foreach (var userInput in request.ServiceRequestUserInputs) //just add everything
{
runspace.SessionStateProxy.SetVariable(userInput.Name, userInput.Value);
}
try
{
Collection <PSObject> results = pipeline.Invoke();
Displaymessage("Script results: ", MessageType.Info);
foreach (var psObject in results)
{
Displaymessage(psObject.ToString(), MessageType.ScriptResult);
}
}
catch (Exception exception)
{
Displaymessage($"Error in executing script: {exception.Message}", MessageType.Failure);
}
Console.WriteLine($"Completed execution of {request.Name}");
}
/// <summary>
/// Handles requests arriving from a channel.
/// </summary>
private void OnRequestReceived(TcpServerChannel channel, uint requestId, IServiceRequest request)
{
// HONEYPOT - obtain the remote IP address and port if possible
TcpMessageSocket tcpSocket = channel.Socket as TcpMessageSocket;
IPAddress remoteIP = null;
int remotePort = 0;
if (tcpSocket != null)
{
EndPoint remoteEndpoint = tcpSocket.getRemoteEndpoint();
if (remoteEndpoint != null)
{
IPEndPoint ipEndpoint = remoteEndpoint as IPEndPoint;
if (ipEndpoint != null)
{
remoteIP = ipEndpoint.Address;
remotePort = ipEndpoint.Port;
}
}
}
try
{
if (m_callback != null)
{
IAsyncResult result = m_callback.BeginProcessRequest(
channel.GlobalChannelId,
channel.EndpointDescription,
request,
OnProcessRequestComplete,
new object[] { channel, requestId, request },
remoteIP, // HONEYPOT
remotePort); // HONEYPOT
}
}
catch (Exception e)
{
Utils.Trace(e, "TCPLISTENER - Unexpected error processing request.");
}
}
public IServiceResponse Execute(IServiceRequest request)
{
IServiceResponse response;
var requestObject = request as TRequest;
try
{
ValidateRequest(requestObject);
DoServiceExecute(requestObject);
response = GenerateResponse(requestObject);
}
catch (Exception e)
{
_log.ErrorFormat("Service exception on request (id: {0}) for service: {1}", request.RequestId, request.ServiceName);
_log.DebugFormat("Exception data: {0}{1}", Environment.NewLine, e.Message);
// TODO: I could call a factory to generate an error response
response = BuildErrorResponse(request);
}
return(response);
}
public async System.Threading.Tasks.Task<IServiceResponse<PagedResult<MyObject>>> QueryMyObjects(IServiceRequest<PagedQuery> query)
{
query.MustNotBeNull("query");
//this method of query strings from object content can be refactored. However, it will have to be a more complex solution
//that is completely generic and handles nested objects in the same way that the server libraries expect to see.
//for now, this merely demonstrates the core principle.
Dictionary<string, string> queryKeyValues = new Dictionary<string, string>();
//some system that relies on a similar mechanism to Model Binding should be used to convert to strings. That uses
//the TypeDescriptor.GetConverter mechanism, so we couuld do the same.
queryKeyValues["Page"] = Convert.ToString(query.Argument.Page);
queryKeyValues["PageSize"] = Convert.ToString(query.Argument.PageSize);
string queryString = null;
using (var tempContent = new FormUrlEncodedContent(queryKeyValues))
{
//why use this? It handles the url encoding - and doesn't require System.Web (another popular
//solution uses HttpUtility.ParseQueryString - but client code has no business referencing System.Web).
queryString = await tempContent.ReadAsStringAsync();
}
return await _requestManager.Get<ApiServiceResponse<PagedResult<MyObject>>>(string.Concat("api/MyObjects?", queryString), query);
}
public IAsyncResult BeginSendRequest(IServiceRequest request, AsyncCallback callback, object callbackData)
{
HttpResponseMessage response = null;
try
{
ByteArrayContent content = new ByteArrayContent(BinaryEncoder.EncodeMessage(request, m_quotas.MessageContext));
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
AsyncResult result = new AsyncResult(callback, callbackData, m_operationTimeout, request, null);
m_client.Timeout = TimeSpan.FromMilliseconds(m_operationTimeout);
Task.Run(async() =>
{
try
{
response = await m_client.PostAsync(m_url, content);
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
Utils.Trace("Exception sending HTTPS request: " + ex.Message);
result.Exception = ex;
response = null;
}
result.Response = response;
result.OperationCompleted();
});
return(result);
}
catch (Exception ex)
{
Utils.Trace("Exception sending HTTPS request: " + ex.Message);
AsyncResult result = new AsyncResult(callback, callbackData, m_operationTimeout, request, response);
result.Exception = ex;
result.OperationCompleted();
return(result);
}
}
/// <inheritdoc/>
public IServiceResponse Execute(IServiceRequest request)
{
HttpWebRequest webReq = (HttpWebRequest)WebRequest.Create(BuildUri(request));
webReq.Method = request.Method;
webReq.UserAgent = MistyService.Version;
webReq.Accept = MistyService.GetContentType(request.Format);
if (_timeout != 0)
webReq.Timeout = _timeout;
NameValueCollection headers = request.Headers;
if (headers != null)
{
foreach (String key in headers.Keys)
{
webReq.Headers[key] = headers[key];
}
}
if (request.Body != null &&
("POST".Equals(request.Method, StringComparison.OrdinalIgnoreCase)
|| "PUT".Equals(request.Method, StringComparison.OrdinalIgnoreCase)))
{
using (Stream stream = webReq.GetRequestStream())
using (StreamWriter writer = new StreamWriter(stream, Encoding.UTF8))
{
writer.Write(request.Body);
}
}
try
{
return new HttpResponse(request.Resource, (HttpWebResponse)webReq.GetResponse());
}
catch (WebException e)
{
return new HttpResponse(request.Resource, (HttpWebResponse)e.Response);
}
}
/// <inheritdoc/>
public IAsyncResult BeginSendRequest(IServiceRequest request, AsyncCallback callback, object callbackData)
{
HttpResponseMessage response = null;
try
{
ByteArrayContent content = new ByteArrayContent(BinaryEncoder.EncodeMessage(request, m_quotas.MessageContext));
content.Headers.ContentType = m_mediaTypeHeaderValue;
var result = new HttpsAsyncResult(callback, callbackData, m_operationTimeout, request, null);
Task.Run(async() => {
try
{
var ct = new CancellationTokenSource(m_operationTimeout).Token;
response = await m_client.PostAsync(m_url, content, ct);
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
Utils.Trace("Exception sending HTTPS request: " + ex.Message);
result.Exception = ex;
response = null;
}
result.Response = response;
result.OperationCompleted();
});
return(result);
}
catch (Exception ex)
{
Utils.Trace("Exception sending HTTPS request: " + ex.Message);
HttpsAsyncResult result = new HttpsAsyncResult(callback, callbackData, m_operationTimeout, request, response);
result.Exception = ex;
result.OperationCompleted();
return(result);
}
}
public IServiceResponse Post(IServiceRequest request)
{
if (Auth != null)
client.Authenticator = Auth;
var restRequest = new RestRequest(request.Uri, Method.POST);
if (!string.IsNullOrWhiteSpace(request.Body))
{
restRequest.AddParameter("text/json", request.Body, ParameterType.RequestBody);
restRequest.RequestFormat = DataFormat.Json;
}
var response = client.Execute(restRequest);
return new ServiceResponse
{
Data = response.Content,
StatusCode = response.StatusCode,
ErrorException = response.ErrorException,
ErrorMessage = response.ErrorMessage
};
}
IServiceRequest PopulateModelBinding(IOperationDescriptor operationDesc, IServiceRequest req, IServiceResponse resp)
{
if (req.Arguments == null)
{
return(req);
}
//备份原始请求参数
req.Context["RawArguments"] = req.Arguments;
var data = operationDesc.GetParameterValues(req.Arguments);
var tmpReq = ServiceRequest.Create(req.ServiceName, req.OperationName, data);
tmpReq.ValidateRequest = req.ValidateRequest;
if (tmpReq.Arguments.ContainsKey("AutoCloseServiceContext"))
{
tmpReq.Arguments.Remove("AutoCloseServiceContext");
}
tmpReq.Context = req.Context;
return(tmpReq);
}
/// <summary>
/// Begins processing an incoming request.
/// </summary>
/// <param name="handler">The method which sends the request.</param>
/// <param name="request">The request.</param>
/// <returns>The result object that is used to call the EndSendRequest method.</returns>
public IAsyncResult BeginSendRequest(
ChannelSendRequestEventHandler handler,
IServiceRequest request)
{
m_handler = handler;
m_request = request;
try
{
// queue request.
m_channel.ScheduleOutgoingRequest(this);
}
catch (Exception e)
{
m_error = e;
m_response = null;
// operation completed.
OperationCompleted();
}
return(this);
}
/// <summary>
/// Returns the appropriate code for a Request provided one exists.
/// Otherwise return null
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private string GetCodeFromRequest(IServiceRequest request)
{
using (var context = new ServiceFulfillmentEngineContext())
{
IEnumerable <Script> highPriorityScripts = null;
IEnumerable <Script> lowPriorityScripts = null;
try
{
//get scripts
highPriorityScripts = from s in context.Scripts where s.Priority == Priority.High select s;
lowPriorityScripts = from s in context.Scripts where s.Priority == Priority.Low select s;
}
catch (Exception) { /* database empty or other db problem */ }
string code = null;
//try high priority codes available first
if (highPriorityScripts != null)
{
code = (from r in request.ServiceRequestOptions
where
r.Code ==
(from s in highPriorityScripts where s.ApplicableCode == r.Code select s.ApplicableCode).FirstOrDefault()
select r.Code).FirstOrDefault();
}
//if not try for a lower priority codes
if (code == null && lowPriorityScripts != null)
{
code = (from r in request.ServiceRequestOptions
where
r.Code == (from s in lowPriorityScripts where s.ApplicableCode == r.Code select s.ApplicableCode).FirstOrDefault()
select r.Code).FirstOrDefault();
}
return(code);
}
}
private IEnumerator _Process(IServiceRequest request)
{
if (request != null && request.data is ResultVO)
{
this._isRequesting = true;
this._timeOutTimer.Start();
ResultVO requestVO = request.data as ResultVO;
if (requestVO.result is WWWForm)
{
this._www = new WWW(this.URL, requestVO.result as WWWForm);
}
else
{
this._www = new WWW(this.URL);
}
yield return(this._www);
string resultCode = String.IsNullOrEmpty(this._www.error) ? ErrorCode.NONE : ErrorCode.PARAMETER_ERROR;
string resultData = resultCode == ErrorCode.NONE ? this._www.text : this._www.error;
if (this._www != null && !string.IsNullOrEmpty(this._www.error))
{
Tracer.Echo("HTTPConnection : _Process : error : " + this._www.error);
}
this.Result(new ResultVO(requestVO.id, requestVO.service, resultCode, resultData, requestVO.uniqueID));
yield return(true);
}
else
{
Tracer.Echo("HTTPConnection : _Process : unknown data!");
yield return(false);
}
}
/// <summary>
/// Instantiates the service described by the <paramref name="serviceRequest"/>.
/// </summary>
/// <param name="serviceRequest">The <see cref="IServiceRequest"/> that describes the service that needs to be instantiated.</param>
/// <returns>A valid object reference if the service can be found; otherwise, it will return <c>null</c>.</returns>
public virtual object GetService(IServiceRequest serviceRequest)
{
// Allow users to intercept the instantiation process
if (_preProcessor != null)
{
_preProcessor.Preprocess(serviceRequest);
}
var factoryRequest = new FactoryRequest
{
ServiceType = serviceRequest.ServiceType,
ServiceName = serviceRequest.ServiceName,
Arguments = serviceRequest.ActualArguments,
Container = _container
};
var instance = _creator.CreateFrom(factoryRequest, serviceRequest.ActualFactory);
// Postprocess the results
var result = new ServiceRequestResult
{
ServiceName = serviceRequest.ServiceName,
ActualResult = instance,
Container = _container,
OriginalResult = instance,
ServiceType = serviceRequest.ServiceType,
AdditionalArguments = serviceRequest.ActualArguments
};
if (_postProcessor != null)
{
_postProcessor.PostProcess(result);
}
return(result.ActualResult ?? result.OriginalResult);
}
// ***START***
#region _NAME_ Service
#if (!OPCUA_EXCLUDE__NAME_)
/// <summary>
/// Invokes the _NAME_ service.
/// </summary>
public IServiceResponse _NAME_(IServiceRequest incoming)
{
_NAME_Response response = null;
try
{
OnRequestReceived(incoming);
_NAME_Request request = (_NAME_Request)incoming;
// DeclareResponseParameters
response = new _NAME_Response();
InvokeService();
// SetResponseParameters
}
finally
{
OnResponseSent(response);
}
return(response);
}
/// <summary>
/// Builds a RestRequest and executes it for the Prometheus API
/// </summary>
/// <param name="method">Type of call to make</param>
/// <param name="serviceRequest">Request for body of call</param>
/// <param name="requestId">ID to add to URI of the call</param>
/// <returns>Result of the RestRequest made</returns>
private IRestResponse Request(Method method, IServiceRequest serviceRequest, int requestId = 0)
{
var url = $"{_apiString}/Request";
if (requestId != 0)
{
url += $"/{requestId}";
}
var client = new RestClient(url);
var request = new RestRequest(method);
request.AddHeader("Username", _username);
request.AddHeader("Password", _password);
if (serviceRequest != null)
{
request.RequestFormat = DataFormat.Json;
var serializedRequest = JsonConvert.SerializeObject(serviceRequest);
request.AddBody(serializedRequest);
}
return(client.Execute(request));
}
public static IRequestHandler GetHandler(IServiceRequest request, IEAEPMonitorStore monitorStore)
{
switch (request.Extension.ToLower())
{
case ".json":
switch (request.ResourceName.ToLower())
{
case "count.json":
return new CountService(monitorStore);
case "distinct.json":
return new DistinctService(monitorStore);
default:
return new SearchService(monitorStore);
}
default:
switch (request.ResourceName.ToLower())
{
case "event":
return new EventService(monitorStore);
default:
return new SearchPage(monitorStore);
}
}
}
/// <summary>
/// Handles requests arriving from a channel.
/// </summary>
public async void SendAsync(HttpContext context)
{
IAsyncResult result = null;
try
{
if (m_callback == null)
{
context.Response.ContentLength = 0;
context.Response.ContentType = "text/plain";
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
await context.Response.WriteAsync(string.Empty);
return;
}
byte[] buffer = new byte[(int)context.Request.ContentLength];
lock (m_lock)
{
Task <int> task = context.Request.Body.ReadAsync(buffer, 0, (int)context.Request.ContentLength);
task.Wait();
}
IServiceRequest input = (IServiceRequest)BinaryDecoder.DecodeMessage(buffer, null, m_quotas.MessageContext);
// extract the JWT token from the HTTP headers.
if (input.RequestHeader == null)
{
input.RequestHeader = new RequestHeader();
}
if (NodeId.IsNull(input.RequestHeader.AuthenticationToken) && input.TypeId != DataTypeIds.CreateSessionRequest)
{
if (context.Request.Headers.Keys.Contains("Authorization"))
{
foreach (string value in context.Request.Headers["Authorization"])
{
if (value.StartsWith("Bearer"))
{
input.RequestHeader.AuthenticationToken = new NodeId(value.Substring("Bearer ".Length).Trim());
}
}
}
}
EndpointDescription endpoint = null;
foreach (var ep in m_descriptions)
{
if (ep.EndpointUrl.StartsWith(Utils.UriSchemeHttps))
{
endpoint = ep;
break;
}
}
result = m_callback.BeginProcessRequest(
m_listenerId,
endpoint,
input as IServiceRequest,
null,
null);
IServiceResponse output = m_callback.EndProcessRequest(result);
byte[] response = BinaryEncoder.EncodeMessage(output, m_quotas.MessageContext);
context.Response.ContentLength = response.Length;
context.Response.ContentType = context.Request.ContentType;
context.Response.StatusCode = (int)HttpStatusCode.OK;
await context.Response.Body.WriteAsync(response, 0, response.Length);
}
catch (Exception e)
{
Utils.Trace(e, "HTTPSLISTENER - Unexpected error processing request.");
context.Response.ContentLength = e.Message.Length;
context.Response.ContentType = "text/plain";
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
await context.Response.WriteAsync(e.Message);
}
}
public void RemoveCompletedRequest(IServiceRequest reqid)
{
HttpRequestClass req = (HttpRequestClass) reqid;
lock (HttpListLock)
{
List<HttpRequestClass> tmpReqs;
if (m_pendingRequests.TryGetValue(req.ItemID, out tmpReqs))
{
for (int i = 0; i < tmpReqs.Count; i++)
{
if (tmpReqs[i].ReqID == req.ReqID)
{
tmpReqs[i].Stop();
tmpReqs.RemoveAt(i);
}
}
if (tmpReqs.Count == 1)
m_pendingRequests.Remove(req.ItemID);
else
m_pendingRequests[req.ItemID] = tmpReqs;
}
}
}
public bool Check()
{
bool needToContinue = false;
foreach (IHttpRequestModule iHttpReq in m_modules)
{
IServiceRequest httpInfo = null;
if (iHttpReq != null)
{
httpInfo = iHttpReq.GetNextCompletedRequest();
if (!needToContinue)
{
needToContinue = iHttpReq.GetRequestCount() > 0;
}
}
if (httpInfo == null)
{
continue;
}
while (httpInfo != null)
{
IHttpRequestClass info = (IHttpRequestClass)httpInfo;
//MainConsole.Instance.Debug("[AsyncLSL]:" + httpInfo.response_body + httpInfo.status);
// Deliver data to prim's remote_data handler
iHttpReq.RemoveCompletedRequest(info);
object[] resobj =
{
new LSL_Types.LSLString(info.ReqID.ToString()),
new LSL_Types.LSLInteger(info.Status),
new LSL_Types.list(info.Metadata),
new LSL_Types.LSLString(info.ResponseBody)
};
m_ScriptEngine.AddToObjectQueue(info.PrimID, "http_response", new DetectParams[0], resobj);
if (info.Status == 499 && //Too many for this prim
info.VerbroseThrottle)
{
ISceneChildEntity part = m_ScriptEngine.Scene.GetSceneObjectPart(info.PrimID);
if (part != null)
{
IChatModule chatModule = m_ScriptEngine.Scene.RequestModuleInterface <IChatModule>();
if (chatModule != null)
{
chatModule.SimChat(
part.Name + "(" + part.AbsolutePosition +
") http_response error: Too many outgoing requests.", ChatTypeEnum.DebugChannel,
2147483647, part.AbsolutePosition, part.Name, part.UUID, false, m_ScriptEngine.Scene);
}
}
}
httpInfo = iHttpReq.GetNextCompletedRequest();
}
}
return(needToContinue);
}
/// <summary>
/// Begins processing a request received via a binary encoded channel.
/// </summary>
/// <param name="channeId">A unique identifier for the secure channel which is the source of the request.</param>
/// <param name="endpointDescription">The description of the endpoint which the secure channel is using.</param>
/// <param name="request">The incoming request.</param>
/// <param name="callback">The callback.</param>
/// <param name="callbackData">The callback data.</param>
/// <returns>
/// The result which must be passed to the EndProcessRequest method.
/// </returns>
/// <seealso cref="EndProcessRequest"/>
/// <seealso cref="ITransportListener"/>
public IAsyncResult BeginProcessRequest(
string channeId,
EndpointDescription endpointDescription,
IServiceRequest request,
AsyncCallback callback,
object callbackData)
{
if (channeId == null) throw new ArgumentNullException("channeId");
if (request == null) throw new ArgumentNullException("request");
// create operation.
ProcessRequestAsyncResult result = new ProcessRequestAsyncResult(this, callback, callbackData, 0);
SecureChannelContext context = new SecureChannelContext(
channeId,
endpointDescription,
RequestEncoding.Binary);
// begin invoke service.
return result.BeginProcessRequest(context, request);
}
/// <summary>
/// Creates an audit log entry for the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>log entry</returns>
protected virtual string CreateAuditLogEntry(IServiceRequest request)
{
return(request.RequestHeader.AuditEntryId);
}
/// <summary>
///
/// </summary>
/// <param name="req"></param>
/// <param name="operationDesc"></param>
/// <returns></returns>
protected virtual IServiceResponse OnExecute(IServiceRequest req, IOperationDescriptor operationDesc)
{
var resp = new ServiceResponse();
//得到领域服务元数据
var serviceDesc = operationDesc.ServiceDescriptor;
var svrResolvedContext = new ServiceResolvedContext(serviceDesc, req, resp);
ServiceContext.Current = new ServiceContext {
Request = req, Response = resp
};
try
{
ListenManager.OnServiceDescriptorFound(svrResolvedContext);
if (svrResolvedContext.Cancelled)
{
return(resp);
}
svrResolvedContext.OperationDescriptor = operationDesc;
ListenManager.OnOperationDescriptorFound(svrResolvedContext);
if (svrResolvedContext.Cancelled)
{
return(resp);
}
}
catch (Exception ex)
{
resp.AddException(ex);
return(resp);
}
object service = null;
try
{
service = ServiceLocator(serviceDesc.Id);
}
catch (Exception ex)
{
resp.AddException(new ServiceDispatcherException(ServiceDispatcherExceptionCode.CreateServiceException, ex)
{
ServiceName = req.ServiceName,
OperationName = req.OperationName
});
return(resp);
}
svrResolvedContext.Service = service;
ListenManager.OnServiceResolved(svrResolvedContext);
if (svrResolvedContext.Cancelled)
{
return(resp);
}
try
{
req = PopulateModelBinding(operationDesc, req, resp);
}
catch (Exception ex)
{
resp.AddException(new ServiceDispatcherException(ServiceDispatcherExceptionCode.ParameterBindException, ex)
{
ServiceName = req.ServiceName,
OperationName = req.OperationName
});
return(resp);
}
try
{
if (!ValidateParamters(operationDesc, req, resp))
{
resp.AddException(new ServiceDispatcherException(ServiceDispatcherExceptionCode.ModelValidationException)
{
ServiceName = req.ServiceName,
OperationName = req.OperationName
});
return(resp);
}
}
catch (Exception ex)
{
resp.AddException(new ServiceDispatcherException(ServiceDispatcherExceptionCode.ModelValidationException, ex)
{
ServiceName = req.ServiceName,
OperationName = req.OperationName
});
return(resp);
}
//创建操作上下文对象
var ctx = new OperationExecutedContext(req, operationDesc)
{
Response = resp
};
try
{
//执行前置过滤器
OnBeforeAction(service, ctx);
//如果过滤器进行了必要的拦截则返回
if ((ctx as IOperationExecutingContext).Cancelled)
{
return(resp);
}
//调用领域服务方法
resp.Result = operationDesc.Invoke(service, ctx.Arguments.Values.ToArray());
ctx.Service = service;
//执行后置过滤器
OnAfterAction(ctx);
resp.Success = true;
}
catch (Exception ex)
{
resp.AddException(ex);
}
return(resp);
}
