private static Stream Serialize(Message message) { MemoryStream stream = new MemoryStream(); Serializer.Serialize(message, stream); stream.Flush(); return stream; }
internal ClientCommandEventArgs(string localEndPoint, string remoteEndPoint, ServiceType serviceType, Message requestMessage, DateTime requestTime, Message responseMessage, DateTime responseTime) : this(localEndPoint, remoteEndPoint, serviceType, requestMessage, requestTime) { this.responseMessage = responseMessage; this.responseTime = responseTime; hasResponse = true; }
internal ClientCommandEventArgs(string localEndPoint, string remoteEndPoint, ServiceType serviceType, Message requestMessage, DateTime requestTime) { this.localEndPoint = localEndPoint; this.remoteEndPoint = remoteEndPoint; this.serviceType = serviceType; this.requestTime = requestTime; this.requestMessage = requestMessage; }
public void Serialize(Message message, Stream output) { if (output == null) throw new ArgumentNullException("output"); if (!output.CanWrite) throw new ArgumentException("The output stream cannot be written."); BinaryWriter writer = new BinaryWriter(output, Encoding); Serialize(message, writer); }
internal Message ProcessCallback(ServiceType serviceType, Message inputStream) { if (serviceType == ServiceType.Admin) return Processor.Process(inputStream); if (serviceType == ServiceType.Manager) return Manager.Processor.Process(inputStream); if (serviceType == ServiceType.Root) return Root.Processor.Process(inputStream); if (serviceType == ServiceType.Block) return Block.Processor.Process(inputStream); throw new InvalidOperationException(); }
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; } }
protected abstract void Serialize(Message message, BinaryWriter writer);
internal void Response(Message response) { ClientCommandEventArgs args = new ClientCommandEventArgs(LocalEndPoint, remoteEndPoint, currentServiceType, currentRequest, currentRequestTime, response, DateTime.Now); try { service.OnClientResponse(args); //TODO: should we store the entire command? commandCount++; } finally { currentRequest = null; } }
internal void Request(ServiceType serviceType, Message request) { currentRequest = request; currentRequestTime = DateTime.Now; currentServiceType = serviceType; ClientCommandEventArgs args = new ClientCommandEventArgs(LocalEndPoint, remoteEndPoint, currentServiceType, currentRequest, currentRequestTime); service.OnClientRequest(args); }
public Message Process(Message request) { Message response; if (MessageStream.TryProcess(this, request, out response)) return response; response = ((RequestMessage)request).CreateResponse(); // For each message in the message input, try { string command = request.Name; // Report on the services running, if (command.Equals("report")) { lock (service.serverManagerLock) { // TODO: long tm = 0; // Total Memory long fm = 0; // Free Memory long td = 0; // Total Space long fd = 0; // Free Space if (service.Block == null) { response.Arguments.Add("block=no"); } else { response.Arguments.Add(service.Block.BlockCount.ToString()); } response.Arguments.Add("manager=" + (service.Manager == null ? "no" : "yes")); response.Arguments.Add("root=" + (service.Root == null ? "no" : "yes")); response.Arguments.Add(tm - fm); response.Arguments.Add(tm); response.Arguments.Add(td - fd); response.Arguments.Add(td); } } else if (command.Equals("reportStats")) { // Analytics stats; we convert the stats to a long[] array and // send it as a reply. long[] stats = GetStats(); response.Arguments.Add(stats); } else { // Starts a service, if (command.Equals("init")) { string service_type = request.Arguments[0].ToString(); service.StartService(service_type); } // Stops a service, else if (command.Equals("dispose")) { string service_type = request.Arguments[0].ToString(); service.StopService(service_type); } else { throw new Exception("Unknown command: " + command); } // Add reply message, response.Arguments.Add(1L); } } catch (OutOfMemoryException e) { service.Logger.Error(service, "Out Of Memory Error."); // This will end the connection); throw; } catch (Exception e) { service.Logger.Error("Error while processing."); response.Arguments.Add(new MessageError(e)); } return response; }
private static string Serialize(Message messageStream) { MemoryStream outputStream = new MemoryStream(); JsonRpcMessageSerializer messageSerializer = new JsonRpcMessageSerializer(Encoding.UTF8); messageSerializer.Serialize(messageStream, outputStream); outputStream.Position = 0; StreamReader reader = new StreamReader(outputStream); string line; StringBuilder sb = new StringBuilder(); while ((line = reader.ReadLine()) != null) { sb.Append(line); } return sb.ToString(); }
public Message Process(Message request) { Message response; if (MessageStream.TryProcess(this, request, out response)) return response; response = ((RequestMessage) request).CreateResponse(); // The messages in the stream, try { // Check the service isn't in a stop state, service.CheckErrorState(); switch (request.Name) { case "getServerListForBlock": { long blockId = request.Arguments[0].ToInt64(); BlockServerInfo[] servers = service.GetServerListForBlock(blockId); IServiceAddress[] addresses = new IServiceAddress[servers.Length]; int[] status = new int[servers.Length]; response.Arguments.Add(servers.Length); for (int i = 0; i < servers.Length; i++) { addresses[i] = servers[i].Address; status[i] = (int) servers[i].Status; } response.Arguments.Add(addresses); response.Arguments.Add(status); break; } case "allocateNode": { int nodeSize = request.Arguments[0].ToInt32(); DataAddress address = service.AllocateNode(nodeSize); response.Arguments.Add(address); break; } case "registerBlockServer": { IServiceAddress address = (IServiceAddress)request.Arguments[0].Value; service.RegisterBlockServer(address); response.Arguments.Add(1L); break; } case "unregisterBlockServer": { IServiceAddress address = (IServiceAddress)request.Arguments[0].Value; service.UnregisterBlockServer(address); response.Arguments.Add(1L); break; } case "unregisterAllBlockServers": { service.UnregisterAllBlockServers(); response.Arguments.Add(1L); break; } // root servers case "registerRootServer": { IServiceAddress address = (IServiceAddress)request.Arguments[0].Value; service.RegisterRootServer(address); response.Arguments.Add(1L); break; } case "unregisterRootServer": { IServiceAddress address = (IServiceAddress)request.Arguments[0].Value; service.UnregisterRootServer(address); response.Arguments.Add(1L); break; } case "unregisterAllRootServers": { service.UnregisterAllRootServers(); response.Arguments.Add(1L); break; } case "getRootForPath": { string pathName = (string)request.Arguments[0].Value; IServiceAddress address = service.GetRootForPath(pathName); response.Arguments.Add(address); break; } case "addPathRootMapping": { string pathName = request.Arguments[0].ToString(); IServiceAddress address = (IServiceAddress)request.Arguments[1].Value; service.AddPathRootMapping(pathName, address); response.Arguments.Add(1L); break; } case "removePathRootMapping": { string pathName = request.Arguments[0].ToString(); service.RemovePathRootMapping(pathName); response.Arguments.Add(1L); break; } case "getPaths": { string[] pathSet = service.GetPaths(); response.Arguments.Add(pathSet); break; } case "getServerGUIDList": { long blockId = request.Arguments[0].ToInt64(); long[] serverGuids = service.GetServerGuidList(blockId); response.Arguments.Add(serverGuids); break; } case "addBlockServerMapping": { long blockId = request.Arguments[0].ToInt64(); long serverGuid = request.Arguments[1].ToInt64(); service.AddBlockServerMapping(blockId, serverGuid); response.Arguments.Add(1L); break; } case "removeBlockServerMapping": { long blockId = request.Arguments[0].ToInt64(); long serverGuid = request.Arguments[1].ToInt64(); service.RemoveBlockServerMapping(blockId, serverGuid); response.Arguments.Add(1L); break; } case "notifyBlockServerFailure": { IServiceAddress address = (IServiceAddress)request.Arguments[0].Value; service.NotifyBlockServerFailure(address); response.Arguments.Add(1L); break; } case "getBlockMappingCount": { long blockMappingCount = service.GetBlockMappingCount(); response.Arguments.Add(blockMappingCount); break; } case "getBlockMappingRange": { long start = request.Arguments[0].ToInt64(); long end = request.Arguments[1].ToInt64(); long[] mappings = service.GetBlockMappingRange(start, end); response.Arguments.Add(mappings); break; } default: throw new ApplicationException("Unknown message name: " + request.Name); } } catch (OutOfMemoryException e) { service.Logger.Error("Out of Memory", e); service.SetErrorState(e); throw; } catch (Exception e) { service.Logger.Error("Error while processing message", e); response.Arguments.Add(new MessageError(e)); } return response; }
public Message Process(Message messageStream) { return connector.callback(serviceType, messageStream); }
protected override void Serialize(Message message, BinaryWriter writer) { if (message is MessageStream) { MessageStream messageStream = (MessageStream)message; writer.Write(2); int sz = messageStream.MessageCount; writer.Write(sz); foreach (Message child in messageStream) { Serialize(child, writer); } } else { writer.Write(1); string messageName = message.Name; if (String.IsNullOrEmpty(messageName)) { if (message is RequestMessage) throw new ArgumentException("A request message must have a name."); Message request = ((ResponseMessage) message).Request; if (request == null) throw new ArgumentException("An unnamed response must belong to a request context."); messageName = request.Name; } writer.Write(messageName); int sz = message.Arguments.Count; writer.Write(sz); for (int i = 0; i < sz; i++) { MessageArgument argument = message.Arguments[i]; WriteArgument(argument, writer); } writer.Write(8); } }
public static string GetErrorStackTrace(Message message) { MessageError error = GetError(message); return error == null ? null : error.StackTrace; }
public Message Process(Message message) { return DoProcess(message, 0); }
private Message Command(IServiceAddress machine, ServiceType serviceType, Message request) { IMessageProcessor proc = connector.Connect(machine, serviceType); return proc.Process(request); }
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); } }
public Message Process(Message messageStream) { return DoProcess(messageStream, 0); }
protected abstract void Serialize(Message message, TextWriter writer);
public static string GetErrorMessage(Message message) { MessageError error = GetError(message); return error == null ? null : error.Message; }
public Message Process(Message request) { Message response; if (MessageStream.TryProcess(this, request, out response)) return response; // The reply message, response = ((RequestMessage) request).CreateResponse(); try { service.CheckErrorState(); switch (request.Name) { case "publishPath": { string pathName = request.Arguments[0].ToString(); DataAddress rootNode = (DataAddress) request.Arguments[1].Value; service.PublishPath(pathName, rootNode); response.Arguments.Add(1L); break; } case "getSnapshot": { string path = request.Arguments[0].ToString(); DataAddress address = service.GetSnapshot(path); response.Arguments.Add(address); break; } case "getSnapshots": { string path = request.Arguments[0].ToString(); DateTime start = DateTime.FromBinary(request.Arguments[1].ToInt64()); DateTime end = DateTime.FromBinary(request.Arguments[2].ToInt64()); DataAddress[] addresses = service.GetSnapshots(path, start, end); response.Arguments.Add(addresses); break; } case "getCurrentTime": { response.Arguments.Add(DateTime.Now.ToUniversalTime().ToBinary()); break; } case "addPath": { string pathName = request.Arguments[0].ToString(); string pathTypeName = request.Arguments[1].ToString(); DataAddress rootNode = (DataAddress)request.Arguments[2].Value; service.AddPath(pathName, pathTypeName, rootNode); response.Arguments.Add(1L); break; } case "removePath": { string pathName = request.Arguments[0].ToString(); service.RemovePath(pathName); response.Arguments.Add(1L); break; } case "getPathType": { string pathName = request.Arguments[0].ToString(); string pathType = service.GetPathType(pathName); response.Arguments.Add(pathType); break; } case "checkPathType": { string pathType = request.Arguments[0].ToString(); service.CheckPathType(pathType); response.Arguments.Add(1L); break; } case "initPath": { string pathName = request.Arguments[0].ToString(); service.InitPath(pathName); response.Arguments.Add(1L); break; } case "commit": { string pathName = request.Arguments[0].ToString(); DataAddress proposal = (DataAddress)request.Arguments[1].Value; DataAddress rootNode = service.Commit(pathName, proposal); response.Arguments.Add(rootNode); break; } case "bindWithManager": { IServiceAddress manager = (IServiceAddress)request.Arguments[0].Value; service.BindWithManager(manager); response.Arguments.Add(1L); break; } case "unbindWithManager": { IServiceAddress manager = (IServiceAddress)request.Arguments[0].Value; service.UnbindWithManager(manager); response.Arguments.Add(1L); break; } case "pathReport": { string[] pathNames, pathTypes; service.PathReport(out pathNames, out pathTypes); response.Arguments.Add(pathNames); response.Arguments.Add(pathTypes); break; } default: throw new ApplicationException("Unknown message received: " + request.Name); } } catch (OutOfMemoryException e) { service.Logger.Error("Out of memory!"); service.SetErrorState(e); throw e; } catch (Exception e) { service.Logger.Error("Error while processing", e); response.Arguments.Add(new MessageError(e)); } return response; }
public static MessageError GetError(Message message) { if (message is MessageStream) { foreach (Message msg in (MessageStream)message) { MessageError error = GetError(msg); if (error != null) return error; } return null; } return message.Arguments.Count == 1 && message.Arguments[0].Value is MessageError ? (MessageError) message.Arguments[0].Value : null; }
protected virtual void OnClientRequest(ServiceType serviceType, string remoteEndPoint, Message requestMessage) { if (connections == null) return; ClientConnection connection; if (!connections.TryGetValue(remoteEndPoint, out connection)) return; connection.Request(serviceType, requestMessage); }
public Message Process(Message messageStream) { try { lock (connector.proxy_lock) { IMessageSerializer serializer = connector.MessageSerializer; char code = '\0'; if (serviceType == ServiceType.Admin) code = 'a'; else if (serviceType == ServiceType.Block) code = 'b'; else if (serviceType == ServiceType.Manager) code = 'm'; else if (serviceType == ServiceType.Root) code = 'r'; // Write the message. connector.pout.Write(code); TcpServiceAddressHandler handler = new TcpServiceAddressHandler(); byte[] addressBytes = handler.ToBytes(address); connector.pout.Write(handler.GetCode(typeof(TcpServiceAddress))); connector.pout.Write(addressBytes.Length); connector.pout.Write(addressBytes); serializer.Serialize(messageStream, connector.pout.BaseStream); connector.pout.Flush(); ResponseMessage baseResponse = (ResponseMessage) serializer.Deserialize(connector.pin.BaseStream, MessageType.Response); return new ResponseMessage((RequestMessage) messageStream, baseResponse); } } catch (IOException e) { // Probably caused because the proxy closed the connection when a // timeout was reached. throw new Exception("IO Error", e); } }
protected void OnClientResponse(string remoteEndPoint, Message responseMessage) { if (connections == null) return; ClientConnection connection; if (!connections.TryGetValue(remoteEndPoint, out connection)) return; connection.Response(responseMessage); }