/// <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);
}
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 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));
}
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);
}
