public ResponseMessage(RequestMessage request, ResponseMessage baseResponse)
: this(baseResponse != null ? baseResponse.Name : null, request)
{
if (baseResponse == null)
throw new ArgumentNullException("baseResponse");
foreach(KeyValuePair<string, object> attribute in baseResponse.attributes)
attributes.Add(attribute.Key, attribute.Value);
foreach(MessageArgument argument in baseResponse.arguments)
arguments.Add(argument);
}
protected override Message Deserialize(TextReader reader, MessageType messageType)
{
XmlTextReader xmlReader = new XmlTextReader(reader);
Message message = null;
while (xmlReader.Read()) {
XmlNodeType nodeType = xmlReader.NodeType;
//TODO: should we take the 'encoding' attribute?
if (nodeType == XmlNodeType.XmlDeclaration)
continue;
if (nodeType == XmlNodeType.Comment ||
nodeType == XmlNodeType.Whitespace)
continue;
if (nodeType == XmlNodeType.Element) {
string elementName = xmlReader.LocalName;
if (message == null) {
if (messageType == MessageType.Request)
message = new RequestMessage(elementName);
else
message = new ResponseMessage(elementName);
continue;
}
MessageArgument argument = ReadArgument(xmlReader);
message.Arguments.Add(argument);
} else if (nodeType == XmlNodeType.Attribute) {
if (message == null)
throw new FormatException("Attribute '" + xmlReader.LocalName + "' found at the wrong moment.");
message.Attributes.Add(xmlReader.LocalName, xmlReader.Value);
} else if (nodeType == XmlNodeType.EndElement) {
break;
}
}
if (message == null)
throw new FormatException("Invalid format.");
return message;
}
public void Test2()
{
ResponseMessage response = new ResponseMessage("response");
IServiceAddress[] addresses = new IServiceAddress[1];
int[] status = new int[1];
response.Arguments.Add(1);
addresses[0] = new TcpServiceAddress("127.0.0.1", 3500);
status[0] = (int) ServiceStatus.Up;
response.Arguments.Add(addresses);
response.Arguments.Add(status);
Stream stream = Serialize(response);
Message message = Deserialize(stream, MessageType.Response);
Assert.IsNotNull(message);
Assert.AreEqual(MessageType.Response, message.MessageType);
Assert.AreEqual(3, message.Arguments.Count);
Assert.AreEqual(1, message.Arguments[0].Value);
Assert.IsInstanceOf(typeof(IServiceAddress[]), message.Arguments[1].Value);
}
private Message Deserialize(XmlReader xmlReader, MessageType messageType)
{
Message message = null;
while (xmlReader.Read()) {
XmlNodeType nodeType = xmlReader.NodeType;
if (nodeType == XmlNodeType.DocumentType ||
nodeType == XmlNodeType.Document ||
nodeType == XmlNodeType.Comment ||
nodeType == XmlNodeType.XmlDeclaration)
continue;
if (nodeType == XmlNodeType.Element) {
string elementName = xmlReader.LocalName;
if (message == null) {
if (elementName == "methodCall") {
if (!xmlReader.Read())
throw new FormatException();
if (xmlReader.NodeType != XmlNodeType.Element)
throw new FormatException("Invalid node type found.");
if (xmlReader.LocalName != "methodName")
throw new FormatException("Unexpected element name.");
if (!xmlReader.Read())
throw new FormatException("Method name not found.");
if (xmlReader.NodeType != XmlNodeType.Text)
throw new FormatException("Invalid content in method name element.");
message = new RequestMessage(xmlReader.Value);
} else if (elementName == "methodResponse") {
message = new ResponseMessage();
} else if (elementName == "messageStream") {
message = new MessageStream(messageType);
while (xmlReader.Read()) {
if (xmlReader.NodeType == XmlNodeType.EndElement) {
if (xmlReader.LocalName == "message")
continue;
if (xmlReader.LocalName == "messageStream")
break;
}
((MessageStream)message).AddMessage(Deserialize(xmlReader, messageType));
}
} else {
throw new FormatException("Invalid root element name.");
}
} else if (xmlReader.LocalName == "fault") {
if (messageType != MessageType.Response)
throw new FormatException("Fault element found in a request message.");
object value = ReadValue(xmlReader);
if (!(value is MessageError))
throw new FormatException();
} else if (xmlReader.LocalName == "params") {
ReadParams(message, xmlReader);
} else {
throw new FormatException("Invalid element name.");
}
} else if (nodeType == XmlNodeType.EndElement) {
string elementName = xmlReader.LocalName;
if (elementName == "methodCall" ||
elementName == "methodResponse")
break;
continue;
} else {
throw new FormatException("Invalid node type.");
}
}
if (message == null)
throw new FormatException("Invalid format");
if (message.MessageType != messageType)
throw new FormatException("The returned message is not expected.");
return message;
}
protected override Message Deserialize(BinaryReader reader, MessageType messageType)
{
int type = reader.ReadInt32();
if (type == 2) {
MessageStream stream = new MessageStream(messageType);
int sz = reader.ReadInt32();
for (int i = 0; i < sz; i++) {
stream.AddMessage(Deserialize(reader, messageType));
}
return stream as Message;
}
if (type == 1) {
Message message;
string messageName = reader.ReadString();
if (messageType == MessageType.Request) {
message = new RequestMessage(messageName);
} else {
message = new ResponseMessage(messageName);
}
int sz = reader.ReadInt32();
for (int i = 0; i < sz; i++)
message.Arguments.Add(ReadArgument(reader));
int v = reader.ReadInt32();
if (v != 8)
throw new FormatException();
return message;
}
throw new FormatException("Unable to determine the format of the message.");
}
private Message DoProcess(Message messageStream, int tryCount)
{
try {
HttpWebRequest request = (HttpWebRequest) HttpWebRequest.Create(address.ToUri());
lock (request) {
// Write the message.
request.Headers["Service-Type"] = serviceType.ToString();
if (!String.IsNullOrEmpty(connector.userName) &&
!String.IsNullOrEmpty(connector.password))
request.Credentials = new NetworkCredential(connector.userName, connector.password);
request.Method = "POST";
Stream output = request.GetRequestStream();
connector.MessageSerializer.Serialize(messageStream, output);
output.Flush();
output.Close();
HttpWebResponse response = (HttpWebResponse) request.GetResponse();
if (response.StatusCode != HttpStatusCode.OK)
throw new InvalidOperationException();
Stream input = response.GetResponseStream();
ResponseMessage baseResponse = (ResponseMessage) connector.MessageSerializer.Deserialize(input, MessageType.Response);
return new ResponseMessage((RequestMessage)messageStream, baseResponse);
}
} catch (Exception e) {
if (tryCount == 0 && e is WebException)
// retry ...
return DoProcess(messageStream, tryCount + 1);
MessageError error;
if (e is WebException) {
error = new MessageError(new Exception("Web Error: maybe a timeout in the request.", e));
} else {
// Report this error as a msg_stream fault,
error = new MessageError(new Exception(e.Message, e));
}
Message responseMessage;
if (messageStream is MessageStream) {
responseMessage = MessageStream.NewResponse();
ResponseMessage errorMessage = new ResponseMessage("error");
errorMessage.Arguments.Add(error);
((MessageStream)responseMessage).AddMessage(errorMessage);
} else {
responseMessage = ((RequestMessage) messageStream).CreateResponse("error");
responseMessage.Arguments.Add(error);
}
return responseMessage;
}
}
private Message DoProcess(Message messageStream, int tryCount)
{
TcpConnection c = null;
try {
// Check if there's a connection in the pool already,
c = connector.GetConnection(address);
lock (c) {
// Write the message.
char code = '\0';
if (serviceType == ServiceType.Manager) {
code = 'm';
} else if (serviceType == ServiceType.Root) {
code = 'r';
} else if (serviceType == ServiceType.Block) {
code = 'b';
} else if (serviceType == ServiceType.Admin) {
code = 'a';
}
BinaryWriter writer = new BinaryWriter(c.Stream, Encoding.Unicode);
writer.Write(code);
IMessageSerializer serializer = new BinaryRpcMessageSerializer();
serializer.Serialize(messageStream, c.Stream);
writer.Flush();
Message response = serializer.Deserialize(c.Stream, MessageType.Response);
if (response is MessageStream) {
return response;
} else {
return new ResponseMessage((RequestMessage) messageStream, (ResponseMessage) response);
}
}
} catch (Exception e) {
// If this is a 'connection reset by peer' error, wipe the connection
// from the cache and retry connection,
if (tryCount == 0 &&
(e is SocketException ||
e is EndOfStreamException)) {
connector.InvalidateConnection(address);
// And retry,
return DoProcess(messageStream, tryCount + 1);
}
MessageError error;
if (e is EndOfStreamException) {
error = new MessageError(new Exception("EOF (is net password correct?)", e));
} else {
// Report this error as a msg_stream fault,
error = new MessageError(new Exception(e.Message, e));
}
Message responseMessage;
if (messageStream is MessageStream) {
responseMessage = new MessageStream(MessageType.Response);
ResponseMessage inner = new ResponseMessage();
inner.Arguments.Add(error);
((MessageStream)responseMessage).AddMessage(inner);
} else {
responseMessage = ((RequestMessage) messageStream).CreateResponse();
responseMessage.Arguments.Add(error);
}
return responseMessage;
} finally {
if (c != null)
connector.ReleaseConnection(c);
}
}
internal void OnResponseMessageCreated(ResponseMessage message)
{
if (response != null)
throw new InvalidOperationException("A response for this request was already created.");
response = message;
}
//TODO:
private Message Deserialize(JsonReader reader, MessageType messageType)
{
Message message = null;
while (reader.Read()) {
JsonToken jsonToken = reader.Token;
if (jsonToken == JsonToken.ObjectStart)
continue;
if (jsonToken == JsonToken.ObjectEnd)
return message;
if (jsonToken == JsonToken.PropertyName) {
string propertyName = (string) reader.Value;
if (String.IsNullOrEmpty(propertyName))
throw new FormatException();
if (message == null) {
if (propertyName == "jsonrpc") {
if (!reader.Read())
throw new FormatException();
if (reader.Token != JsonToken.String)
throw new FormatException();
if ((string)reader.Value != "1.0")
throw new FormatException("JSON RPC protocol version not supported.");
} else if (propertyName == "method") {
if (!reader.Read())
throw new FormatException();
if (reader.Token != JsonToken.String)
throw new FormatException("Expected method name.");
message = new RequestMessage((string) reader.Value);
} else if (propertyName == "result") {
if (messageType != MessageType.Response)
throw new FormatException("Unexpected result message.");
message = new ResponseMessage();
} else if (propertyName == "error") {
if (messageType != MessageType.Response)
throw new FormatException("Unexpected error result message.");
message = new ResponseMessage();
message.Arguments.Add(ReadMessageError(reader));
} else if (propertyName == "stream") {
// Addition to support IRPC
message = new MessageStream(messageType);
while (reader.Read()) {
if (reader.Token == JsonToken.ObjectEnd)
break;
((MessageStream)message).AddMessage(Deserialize(reader, messageType));
}
return message;
}
} else if (propertyName == "params") {
if (!reader.Read())
throw new FormatException();
if (reader.Token != JsonToken.ArrayStart)
throw new FormatException();
while (reader.Read()) {
if (reader.Token == JsonToken.ArrayEnd)
break;
message.Arguments.Add(ReadValue(reader));
}
}
}
}
return message;
}
