/// <summary> /// Try to register a message interpreter on a given port /// </summary> /// <param name="address">Ip address to listen on</param> /// <param name="port">Port to use</param> /// <param name="protocol">Interpreter of the protocol</param> /// <returns>True if registration was successful, otherwise false</returns> public static bool Register(IPAddress address, int port, IMessageInterpreter protocol) { lock (Registrations) { IEnumerable <PortMap> addressRelevant; if (IsAny(address)) { // If this is a registration for all IPAddresses, we need to compare against all entries addressRelevant = Registrations; } else { // Find all registrations on the same or all addresses addressRelevant = Registrations.Where(r => IsAny(r.Address) | r.Address.Equals(address)); } // Within relevant addresses find an entry with the same port var match = addressRelevant.FirstOrDefault(m => m.Port == port); if (match != null && !match.Interpreter.Equals(protocol)) { return(false); // Conflict } // Create a registration Registrations.Add(new PortMap(address, port, protocol)); return(true); } }
public void CaseSetup() { _interpreter = new TestDelimiterInterpreter(); _context = (DelimitedMessageContext)_interpreter.CreateContext(); // Extended properties _context.StartFound = false; }
public WebSocketClient(IMessageInterpreter interpreter, string url) { _interpreter = interpreter; _webSocket = new WebSocket(url); _webSocket.Log.Level = SlackConnector.LoggingLevel == ConsoleLoggingLevel.FatalErrors ? LogLevel.Fatal : LogLevel.Trace; _webSocket.OnMessage += WebSocketOnMessage; _webSocket.OnClose += (sender, args) => OnClose?.Invoke(sender, args); }
/// <summary> /// Initialize TcpTransmission /// </summary> /// <param name="client">The client.</param> /// <param name="interpreter">The interpreter.</param> /// <param name="logger">Logger used to write exceptions to log</param> public TcpTransmission(TcpClient client, IMessageInterpreter interpreter, IModuleLogger logger) { _interpreter = interpreter; _client = client; _stream = client.GetStream(); _logger = logger; // Assign callbacks to make sure the delegate does get collected by the GC ReadCallback = ReadComplete; SendCallback = SendComplete; }
public ChatBusiness(IMessageInterpreter messageInterpreter, IChatRepository chatRepository, IKnowledgeRepository knowledgeRepository) { messageInterpreter.ShouldNotBeNull(); chatRepository.ShouldNotBeNull(); knowledgeRepository.ShouldNotBeNull(); _messageInterpreter = messageInterpreter; _chatRepository = chatRepository; _knowledgeRepository = knowledgeRepository; }
public MasterDataBusiness(IDepartmentRepository departmentRepository, IKnowledgeRepository knowledgeRepository, IMessageInterpreter messageInterpreter) { departmentRepository.ShouldNotBeNull(); knowledgeRepository.ShouldNotBeNull(); messageInterpreter.ShouldNotBeNull(); _departmentRepository = departmentRepository; _knowledgeRepository = knowledgeRepository; _messageInterpreter = messageInterpreter; }
/// <summary> /// Try to register a message interpreter on a given port /// </summary> /// <param name="port">Port to use</param> /// <param name="protocol">Interpreter of the protocol</param> /// <returns>True if registration was successful, otherwise false</returns> public static bool Register(int port, IMessageInterpreter protocol) { lock (Map) { if (Map.ContainsKey(port) && !Map[port].Equals(protocol)) { return(false); } Map[port] = protocol; return(true); } }
public ChatController(IChatRepository chatRepository, ILogger <ChatController> logger, IChatBusiness chatBusiness, IMessageInterpreter messageInterpreter) { chatRepository.ShouldNotBeNull(); logger.ShouldNotBeNull(); chatBusiness.ShouldNotBeNull(); messageInterpreter.ShouldNotBeNull(); _chatRepository = chatRepository; _logger = logger; _chatBusiness = chatBusiness; _messageInterpreter = messageInterpreter; _messageInterpreter = messageInterpreter; }
public WebSocketClient(IMessageInterpreter interpreter, string url, ProxySettings proxySettings) { _interpreter = interpreter; _webSocket = new WebSocket(url); _webSocket.OnMessage += WebSocketOnMessage; _webSocket.OnClose += (sender, args) => OnClose?.Invoke(sender, args); _webSocket.Log.Level = SlackConnector.LoggingLevel == ConsoleLoggingLevel.FatalErrors ? LogLevel.Fatal : LogLevel.Trace; if (proxySettings != null) { _webSocket.SetProxy(proxySettings.Url, proxySettings.Username, proxySettings.Password); } }
public WebSocketClient(IMessageInterpreter interpreter, string url, ProxySettings proxySettings) { _interpreter = interpreter; _webSocket = new WebSocket(url); _webSocket.OnMessage += WebSocketOnMessage; _webSocket.OnClose += (sender, args) => OnClose?.Invoke(sender, args); _webSocket.Log.Level = GetLoggingLevel(); _webSocket.EmitOnPing = true; if (proxySettings != null) { _webSocket.SetProxy(proxySettings.Url, proxySettings.Username, proxySettings.Password); } }
public void ParseHtmlMessageAndUseHtmlInterpreter() { // Arrange _interpreter = HtmlInterpreter.Instance; _context = (DelimitedMessageContext)_interpreter.CreateContext(); var text = Encoding.UTF8.GetBytes(Input); // Act BinaryMessage published = null; Array.Copy(text, 0, _context.ReadBuffer, _context.CurrentIndex, text.Length); _interpreter.ProcessReadBytes(_context, text.Length, m => published = m); // Assert Assert.NotNull(published); Assert.AreEqual(published.Payload, Encoding.UTF8.GetBytes(Output)); }
/// public void Register(TcpListenerConnection listener) { lock (_listeners) { // Steal objects from the first listener if (_protocolInterpreter == null) { _protocolInterpreter = listener.Validator.Interpreter; } if (_logger == null) { _logger = listener.Logger.GetChild(string.Empty, typeof(TcpPortListener)); } _listeners.Add(listener); StartListening(); } }
public void ParsePartialDelimiterMessage(bool useStartDelimiter) { if (!useStartDelimiter) { _interpreter = new EndDelimiterOnlyInterpreter(); } var text = Encoding.Unicode.GetBytes("Wie passend, du kämpfst"); // Arrange var message = new List <byte>(); message.AddRange(TestDelimiterInterpreter.TestStartDelimiter); message.AddRange(text); var readMessage = message.ToArray(); // Act Array.Copy(readMessage, 0, _context.ReadBuffer, 0, readMessage.Length); _interpreter.ProcessReadBytes(_context, readMessage.Length, m => { }); // Assert Assert.IsTrue(_context.StartFound); Assert.AreEqual(readMessage.Length, _context.CurrentIndex); }
private static bool ShouldInterpret( INetworkMediator mediator, IMessageInterpreter interpreter) { return((mediator.IsClient && interpreter.ValidOnClient) || (mediator.IsServer && interpreter.ValidOnServer)); }
public WebSocketClientLite(IMessageInterpreter interpreter) { _interpreter = interpreter; }
public bool Equals(IMessageInterpreter other) { return(ProtocolId == (other as DummyProtocol)?.ProtocolId); }
public PortMap(IPAddress address, int port, IMessageInterpreter interpreter) { Address = address; Port = port; Interpreter = interpreter; }
public WebSocketClient(IMessageInterpreter interpreter, string url) { _webSocket = new WebSocketSharp.WebSocket(url); _webSocket.OnMessage += (sender, args) => OnMessage?.Invoke(sender, interpreter.InterpretMessage(args?.Data ?? "")); _webSocket.OnClose += (sender, args) => OnClose?.Invoke(sender, args); }
/// <inheritdoc /> public bool Equals(IMessageInterpreter messageInterpreter) { return(Equals((object)messageInterpreter)); }