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