/// <summary> /// Starts the network connection. /// </summary> protected virtual void Initialize() { try { Debug.Log("Initializing NetworkManager"); SaveLoad.SavePath = Application.persistentDataPath; SaveLoad.Extention = ".sprc"; SaveLoad.EncryptData = false; ensureFileDirectories.Invoke(); if (udpMaster == null || !udpMaster.IsInitialized) { udpMaster = new AppliedUDPMaster <NetworkMessage>(); udpMaster.Initialize("1.1.1.1", PortOut, PortIn); udpMaster.AddListener(this); } networkLogger = new NetworkLogger <NetworkMessage>() { LogFileName = "NetworkLogs.sprc" }; networkLogger.Initialize(udpMaster); } catch (Exception ex) { Debug.LogError(ex.Message); } }
public void NetworkLogger_Error() { var mockAuditEntry = new Mock <IAuditEntry>(); var logTemplate = GlobalConstants.WarewolfLogsTemplate; var mockSerializer = new Mock <ISerializer>(); mockSerializer.Setup(o => o.Serialize(It.IsAny <AuditCommand>())).Verifiable(); var dev2WorkflowSettings = new Mock <Dev2.Common.Interfaces.IDev2WorkflowSettings>(); dev2WorkflowSettings.Setup(o => o.ExecutionLogLevel).Returns(LogLevel.ERROR.ToString); var mockWebSocketPool = new Mock <IWebSocketPool>(); var mockWebSocketWrapper = new Mock <IWebSocketWrapper>(); mockWebSocketWrapper.Setup(o => o.SendMessage(It.IsAny <byte[]>())).Verifiable(); mockWebSocketPool.Setup(o => o.Acquire(Config.Auditing.Endpoint)).Returns(mockWebSocketWrapper.Object).Verifiable(); mockWebSocketPool.Setup(o => o.Release(It.IsAny <IWebSocketWrapper>())).Verifiable(); var networkLogger = new NetworkLogger(mockSerializer.Object, mockWebSocketPool.Object, dev2WorkflowSettings.Object); networkLogger.Error(logTemplate, mockAuditEntry.Object); mockSerializer.Verify(o => o.Serialize(It.IsAny <AuditCommand>()), Times.Once); mockWebSocketWrapper.Verify(o => o.SendMessage(It.IsAny <byte[]>()), Times.Once); mockWebSocketWrapper.Verify(o => o.IsOpen(), Times.Once); mockWebSocketWrapper.Verify(o => o.Connect(), Times.Once); mockWebSocketPool.Verify(o => o.Acquire(Config.Auditing.Endpoint), Times.Once); mockWebSocketPool.Verify(o => o.Release(It.IsAny <IWebSocketWrapper>()), Times.Once); }
/* * +-------------------------+ * | Connection | * +-------------------------+ */ public virtual int Connect(string address, int port) { if (this.threadLoop == false) { CreateThread(); } int node = -1; bool ret = false; try { T transport = new T(); transport.SetServerPort(this.port); ret = transport.Connect(address, port); if (ret) { node = JoinSession(transport); } } catch (Exception e) { NetworkLogger.Log(e.ToString()); } if (this.networkStateHandler != null) { NetworkState state = new NetworkState(); state.type = NetEventType.Connect; state.result = (ret)? NetEventResult.Success : NetEventResult.Failure; this.networkStateHandler(node, state); } return(node); }
/// <summary> /// Updates the nework logger for the selected domain /// </summary> /// <param name="address"></param> private void UpdateNetLogger(string address) { // cjm-sep17 -- generate a Network Ping Logger try { if (_mainWnd.NetLogger == null) { _mainWnd.NetLogger = new NetworkLogger(address); } else { // adjust the ping logger _mainWnd.NetLogger.Reset(); _mainWnd.NetLogger.DomainName = address; } _mainWnd.NetLogger.PingProviderNowAsync(); // _mainWnd.NetLogger.PollProviderAsync(PollTime); remove the polling for now. It's causing crashes and the feature doesn't seem very importantF } catch (Exception ex) { // handles case where we cannot connect to the network NetworkLogger.HandleError(ACENetworkError.Unreachable, address, ex.ToString()); return; } }
/* * +-------------------------+ * | Connection | * +-------------------------+ */ public bool Connect(string address, int port) { if (socket != null) { return(false); } try { socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.NoDelay = true; socket.Connect(address, port); isConnected = true; } catch (Exception e) { NetworkLogger.Log(e.ToString()); socket = null; isConnected = false; } sendQueue.Clear(); recvQueue.Clear(); if (networkStateHandler != null) { NetworkState state = new NetworkState(); state.type = NetEventType.Connect; state.result = isConnected == true ? NetEventResult.Success : NetEventResult.Failure; networkStateHandler(this, state); } return(isConnected); }
protected override void OnConnect(Event e) { Peer peer = e.Peer; uint id = peer.ID + 1; // Increase by 1 so ID of 0 remains free for host if (peer.IsSet) { NetworkLogger.Log($"Client [{id}] connected", LogCategory.Connections); var client = new FlareClientShell(peer) { Id = id }; ClientManager?.AddClient(client); // Send the client its ID manually PayloadHandler.AddCallback <ClientAssigned>(PushClientConnected); SendMessage(new IdAssignment { id = id }, 0, peers: client.Peer); } else { NetworkLogger.Log("Unset peer connected. How?", LogCategory.Connections, LogLevel.Error); } }
/// <summary> /// Remove a callback from listening for payloads of a given type. /// </summary> /// <typeparam name="T">The payload type being listened for</typeparam> /// <param name="callback">The delegate to remove</param> public void RemoveCallback <T>(FlarePayloadCallback <T> callback) where T : INetworkPayload { if (isInvoking) { registrationQueue.Enqueue(() => Remove(callback)); } else { Remove(callback); } void Remove <P>(FlarePayloadCallback <P> c) where P : INetworkPayload { var tag = NetworkTagAttribute.GetTag(typeof(P)); // Remove the callback from the dictionary if (tag != null) { if (payloadCallbacks.TryGetValue(tag.Value, out var value)) { value.Remove(c); } else { NetworkLogger.Log($"Payload type [{typeof(P).Name}] has no callbacks to remove!", LogCategory.PayloadCallbacks, LogLevel.Warning); } } else { NetworkLogger.Log("Cannot remove callbacks for types with no NetworkTag!", LogCategory.PayloadCallbacks, LogLevel.Warning); } } }
/// <summary> /// Add a callback to listen for payloads of a given type. /// </summary> /// <typeparam name="T">The payload type to listen for</typeparam> /// <param name="callback">The delegate to call</param> public void AddCallback <T>(FlarePayloadCallback <T> callback) where T : INetworkPayload { if (isInvoking) { registrationQueue.Enqueue(() => Add(callback)); } else { Add(callback); } void Add <P>(FlarePayloadCallback <P> c) where P : INetworkPayload { var type = typeof(P); var tag = NetworkTagAttribute.GetTag(type); if (tag != null) { // Add the callback to the dictionary if (!payloadCallbacks.TryGetValue(tag.Value, out var value)) { // Create callback entry if it doesn't exist value = new Callback(type); payloadCallbacks.Add(tag.Value, value); } value.Add(c); } else { NetworkLogger.Log("Cannot add callbacks for types with no NetworkTag!", LogCategory.PayloadCallbacks, LogLevel.Message); } } }
/// <summary> /// Remove all registered callbacks for a given payload type. /// </summary> /// <typeparam name="T">The type to remove callbacks for</typeparam> public void ClearCallbacks <T>() where T : INetworkPayload { if (isInvoking) { registrationQueue.Enqueue(() => Clear <T>()); } else { Clear <T>(); } void Clear <P>() where P : INetworkPayload { var tag = NetworkTagAttribute.GetTag(typeof(P)); if (tag != null) { if (payloadCallbacks.ContainsKey(tag.Value)) { payloadCallbacks.Remove(tag.Value); NetworkLogger.Log($"Cleared callbacks for payload type [{typeof(P).Name}]", LogCategory.PayloadCallbacks); } else { NetworkLogger.Log($"Payload type [{typeof(P).Name}] has no callbacks to clear!", LogCategory.PayloadCallbacks, LogLevel.Warning); } } else { NetworkLogger.Log("Cannot clear callbacks for types with no NetworkTag!", LogCategory.PayloadCallbacks, LogLevel.Warning); } } }
internal void Add <T>(FlarePayloadCallback <T> callback) where T : INetworkPayload { int key = callback.GetHashCode(); if (!Values.ContainsKey(key)) { // This cast needs benchmarking Values.Add(key, x => { if (x is T p) { callback(p); } }); if (Type.IsVisible) { NetworkLogger.Log($"Added delegate [{callback.Method.Name}] for payload type [{Name}]", LogCategory.PayloadCallbacks); } } else { NetworkLogger.Log($"Delegate [{callback.Method.Name}] is already added to listen for payload type [{Name}]", LogCategory.PayloadCallbacks, LogLevel.Warning); } }
public void NetworkLogger_Error() { var mockAuditEntry = new Mock <IAuditEntry>(); var logTemplate = GlobalConstants.WarewolfLogsTemplate; var mockSerializer = new Mock <ISerializer>(); mockSerializer.Setup(o => o.Serialize(It.IsAny <AuditCommand>())).Verifiable(); var mockWebSocketPool = new Mock <IWebSocketPool>(); var mockWebSocketWrapper = new Mock <IWebSocketWrapper>(); mockWebSocketWrapper.Setup(o => o.SendMessage(It.IsAny <byte[]>())).Verifiable(); mockWebSocketPool.Setup(o => o.Acquire(Config.Auditing.Endpoint)).Returns(mockWebSocketWrapper.Object).Verifiable(); mockWebSocketPool.Setup(o => o.Release(It.IsAny <IWebSocketWrapper>())).Verifiable(); var networkLogger = new NetworkLogger(mockSerializer.Object, mockWebSocketPool.Object); networkLogger.Error(logTemplate, mockAuditEntry.Object); mockSerializer.Verify(o => o.Serialize(It.IsAny <AuditCommand>()), Times.Once); mockWebSocketWrapper.Verify(o => o.SendMessage(It.IsAny <byte[]>()), Times.Once); mockWebSocketWrapper.Verify(o => o.IsOpen(), Times.Once); mockWebSocketWrapper.Verify(o => o.Connect(), Times.Once); mockWebSocketPool.Verify(o => o.Acquire(Config.Auditing.Endpoint), Times.Once); mockWebSocketPool.Verify(o => o.Release(It.IsAny <IWebSocketWrapper>()), Times.Once); }
protected virtual void OnTimeout(Event e) { NetworkLogger.Log(NetworkLogEvent.ClientTimeout); PayloadHandler.PushPayload(new ClientDisconnected { ClientId = Id }); }
public byte[] GetPacketData() { int size = ReadPacketSize(); if (size <= 0) { return(null); } byte[] data = new byte[size]; try { memoryStream.Position = sizeof(int); memoryStream.Read(data, 0, size); byte[] stream = memoryStream.ToArray(); int restSize = stream.Length - size - sizeof(int); byte[] restStream = new byte[restSize]; Buffer.BlockCopy(stream, size + sizeof(int), restStream, 0, restSize); memoryStream = new MemoryStream(restStream); offset = restSize; } catch (Exception e) { NetworkLogger.Log(e.ToString()); return(null); } return(data); }
public override void AcceptClient() { if ((this.listener != null) && this.listener.Poll(0, SelectMode.SelectRead)) { Socket socket = this.listener.Accept(); int node = -1; try { TransportTCP transport = new TransportTCP(); transport.Initialize(socket); transport.transportName = "serverSocket"; node = JoinSession(transport); } catch (Exception e) { NetworkLogger.Log(e.ToString()); return; } if (node >= 0 && this.networkStateHandler != null) { NetworkState state = new NetworkState(); state.type = NetEventType.Connect; state.result = NetEventResult.Success; this.networkStateHandler(node, state); } } }
internal void Invoke(INetworkPayload value) { NetworkLogger.Log($"Invoking payload type [{Name}]", LogCategory.PayloadProcessing); foreach (var v in Values.Values) { v.Invoke(value); } }
/* * +-------------------------+ * | Constructor | * +-------------------------+ */ public Session() { try { this.transports = new Dictionary <int, T>(); this.mtu = DEFAULT_MTU_SIZE; } catch (Exception e) { NetworkLogger.Log(e.ToString()); } }
/// <summary> /// Remove a client from the client manager by ID. /// </summary> /// <param name="id">The ID of the client to remove</param> internal void RemoveClient(uint id) { if (TryGetClient(id, out var client)) { connectedClients.Remove(id); } else { NetworkLogger.Log($"Unable to remove nonexistent peer with ID [{id}] from ClientManager!", LogCategory.Connections, LogLevel.Error); } }
private void PushClientConnected(ClientAssigned p) { NetworkLogger.Log("Client connection finalized", LogCategory.Connections); PayloadHandler.RemoveCallback <ClientAssigned>(PushClientConnected); if (ClientManager.TryGetClient(p.id, out var client)) { PayloadHandler.PushPayload(new ClientConnected { Client = client }); } }
private void AssignID(IdAssignment p) { // Don't listen for the ID anymore RemoveCallback <IdAssignment>(AssignID); Id = p.id; NetworkLogger.Log($"Client initialized with ID [{Id}]", LogCategory.Connections); SendMessage(new ClientAssigned { id = Id }); }
private void Awake() { if (instance == null) { instance = this; text = GetComponent <TMPro.TMP_Text>(); } else { Destroy(this); } }
public override bool CreateListener(int port, int connectionMax) { try { listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); listener.Bind(new IPEndPoint(IPAddress.Any, port)); } catch (Exception e) { NetworkLogger.Log(e.ToString()); return(false); } return(true); }
public override void OnConnectedToMaster() { NetworkLogger.Log("Connected to Master"); Debug.Log("PUN Basics Tutorial/Launcher: OnConnectedToMaster() was called by PUN"); if (connectToRandomRoom) { PhotonNetwork.JoinRandomRoom(); } else { PhotonNetwork.JoinRoom(roomID); } }
private void StartServer(ushort port) { // Create the address and host Address = new Address { Port = port }; Host.Create(Address, Config.MaxConnections, Config.ChannelCount); ClientManager = new FlareClientManager(Config.MaxConnections); StartUpdateThread(); NetworkLogger.Log(NetworkLogEvent.ServerStart); }
public bool SetDeserializedData(byte[] data) { Clear(); try { buffer.Write(data, 0, data.Length); } catch (Exception e) { NetworkLogger.Log(e.ToString()); return(false); } return(true); }
/* * +-------------------------+ * | Thread | * +-------------------------+ */ protected bool CreateThread() { try { this.thread = new Thread(new ThreadStart(ThreadDispatch)); this.threadLoop = true; this.thread.Start(); } catch (Exception e) { NetworkLogger.Log(e.ToString()); return(false); } return(true); }
protected bool WriteRawBuffer(byte[] data, int size) { try { buffer.Position = offset; buffer.Write(data, 0, size); offset += size; } catch (Exception e) { NetworkLogger.Log(e.ToString()); return(false); } return(true); }
public static void LogToRealLogServer() { var ready = false; var connection = new OnlineServiceConnection(new MockSettings(), () => {}); connection.ServerErrorHappened += error => { throw new ServerErrorReceived(error); }; connection.ContentReady += () => ready = true; using (var logClient = new NetworkLogger(connection)) { for (int timeoutMs = 1000; timeoutMs > 0 && !ready; timeoutMs -= 10) Thread.Sleep(10); logClient.Write(Logger.MessageType.Info, "Hello TestWorld from " + Environment.MachineName); } }
/// <summary> /// Add a client to the client manager. /// </summary> /// <param name="client"></param> internal void AddClient(FlareClientShell client) { uint id = client.Id; // Add client to the connect clients dictionary if (!connectedClients.ContainsKey(id)) { connectedClients.Add(id, client); } else { NetworkLogger.Log($"Unable to add already existing peer with ID [{id}] to ClientManager!", LogCategory.Connections, LogLevel.Error); } }
private NetworkLogger CreateNetLogger(string baseName, string hostname, int port) { lock (this.loggersLock) { if (this.GetNamedNetworkLogger(baseName) != null) { throw new InvalidOperationException("logger named " + baseName + " already exists"); } var logger = new NetworkLogger(hostname, port); this.networkLoggers[baseName] = logger; return(logger); } }
public bool AddBuffer(byte[] data, int size) { try { memoryStream.Position = offset; memoryStream.Write(data, 0, size); offset += size; } catch (Exception e) { NetworkLogger.Log(e.ToString()); memoryStream.Flush(); offset = 0; return(false); } return(true); }
public void StartLogServer() { server = new LocalhostLogServer(new TcpServer()); server.Start(); var ready = false; var connection = new OnlineServiceConnection(); connection.DataReceived += o => ready = true; connection.Connect("localhost", LocalhostLogServer.Port); connection.Send(new LoginRequest("", "DeltaEngine.Logging.Tests")); logger = new NetworkLogger(connection); for (int timeoutMs = 1000; timeoutMs > 0 && !ready; timeoutMs -= 10) Thread.Sleep(10); Assert.IsTrue(ready); }
public MainWindow() { this.Closing += new System.ComponentModel.CancelEventHandler(MainWindow_Closing); InitializeComponent(); _networkLogs = new NetworkLogger(this.Dispatcher); _networkLogs.SessionStart += new NetworkLoggerSessionUpdatedHandler(network_NetworkSessionStart); _networkLogs.SessionEnd += new NetworkLoggerSessionUpdatedHandler(network_NetworkSessionEnd); _networkLogs.Initialize(); _pluginLogs = new PluginLogger(this.Dispatcher); _pluginLogs.ActiveLogChanged += new PluginLoggerActiveLogChangedHandler(_pluginLogs_ActiveLogChanged); _pluginLogs.Initialize(); }