/// <summary>
/// Invokes the appropriate service handler (registered using a ServiceAttribute)
/// </summary>
public void InvokeServiceHandler(Message request, Message response, HttpSessionState session, HttpResponse httpresponse)
{
if (request.Type.Equals(this.Request))
{
try
{
Message temp_response = response;
Object[] parameters = new Object[] { request, temp_response };
Object declaringTypeInstance = Activator.CreateInstance(this.MethodInfo.DeclaringType);
this.MethodInfo.Invoke(declaringTypeInstance, parameters);
temp_response = (Message)parameters[1];
temp_response.Type = this.Response;
temp_response.Scope = request.Scope;
temp_response.Version = request.Version;
temp_response.RequestDetails = request.RequestDetails;
Logger.Instance.Debug("Invoked service for request: " + request.Type);
Dispatcher.Instance.EnqueueOutgoingMessage(temp_response, session.SessionID);
}
catch (Exception e)
{
String err = "";
err+="Exception while invoking service handler - " + this.MethodInfo.Name + " in " + this.MethodInfo.DeclaringType.Name + "\n";
err += "Request Message - " + request.Type + "\n";
err += "Response Message - " + response.Type + "\n";
err += "Message - " + e.Message + "\n";
err += "Stacktrace - " + e.StackTrace + "\n";
Logger.Instance.Error(err);
}
}
}
public void TestMessageHandler(Message request, ref Message response)
{
response.Data.Add("success", true);
String message;
try
{
message = ((JsonString)request.Data["message"]).Value;
}
catch
{
message = "";
}
response.Data.Add("message", "I received from you " + message);
}
/// <summary>
/// Invokes the appropriate handler for a given request
/// </summary>
/// <param name="request">The ServiceRequest object corresponding to the incoming request</param>
/// <param name="response">The ServiceResponse object corresponding to the outgoing response</param>
public void HandleRequest(Message request, Message response, HttpSessionState session, HttpResponse httpresponse)
{
try
{
Logger.Instance.Debug("Invoking services for request: " + request.Type);
List<Service> handlers = RequestToServiceMap[request.Type];
foreach (Service handler in handlers)
{
handler.InvokeServiceHandler(request, response, session, httpresponse);
}
}
catch (KeyNotFoundException)
{
//There's no Service to handle the incoming request -- Log it to the console
Logger.Instance.Debug("No service registered to handle request: " + request.Type);
}
}
/// <summary>
/// Parses incoming messages and returns a list to be dispatched
/// </summary>
/// <param name="iter">The iterator with the message element list (xml)</param>
/// <param name="context">The HttpContext of the request</param>
/// <param name="broker">The ServiceBroker handling the request</param>
/// <param name="details">The RequestDetails from the request</param>
/// <returns></returns>
public List<Message> ParseIncomingMessages(HttpContext context, ServiceBroker broker, RequestDetails details, String content_type)
{
List<Message> messages = new List<Message>();
switch (content_type)
{
case ServiceBroker.APPLICATION_JSON:
JsonArray messageArray = (JsonArray)details.JSON["messages"];
foreach (JsonObject jsonMessage in messageArray)
{
Message m = new Message(jsonMessage, context.Session, broker, details);
m.Direction = MessageDirection.INCOMING;
messages.Add(m);
}
break;
case ServiceBroker.XML_JSON:
XPathNodeIterator iter = details.XMLIterator;
while (iter.MoveNext())
{
Message m = new Message(iter.Current, context.Session, broker, details);
m.Direction = MessageDirection.INCOMING;
messages.Add(m);
}
break;
}
Logger.Instance.Debug("Parsed " + messages.Count + " incoming message(s)");
return messages;
}