public void InvokeReceiveIfNotNull(NetworkData data)
{
if (NetworkEventLoop.Receive != null)
{
NetworkEventLoop.Receive(data, this);
}
}
public static void Receive(NetworkData data, IConnection channel)
{
var command = Encoding.UTF8.GetString(data.Buffer);
//Console.WriteLine("Received: {0}", command);
if (command.ToLowerInvariant() == "gettime")
{
var time = Encoding.UTF8.GetBytes(DateTime.Now.ToLongTimeString());
channel.Send(new NetworkData {
Buffer = time, Length = time.Length, RemoteHost = channel.RemoteHost
});
//Console.WriteLine("Sent time to {0}", channel.Node);
}
else
{
Console.WriteLine("Invalid command: {0}", command);
var invalid = Encoding.UTF8.GetBytes("Unrecognized command");
channel.Send(new NetworkData
{
Buffer = invalid,
Length = invalid.Length,
RemoteHost = channel.RemoteHost
});
}
}
protected virtual void onRealtimeUpdate(float deltaTime)
{
if (m_CurNetworkData != null)
{
m_CurNetworkData.Timeout -= deltaTime;
if (m_CurNetworkData.Timeout <= 0)
{
m_CurNetworkData.Callback("");
m_CurNetworkData = null;
}
}
if (m_CurNetworkData == null && m_NetworkDataList.Count > 0)
{
m_CurNetworkData = m_NetworkDataList[0];
m_NetworkDataList.RemoveAt(0);
if (m_CurCoroutine != null)
{
C_MonoSingleton <C_GameFramework> .GetInstance().StopCoroutine(m_CurCoroutine);
}
//开始请求数据
m_CurCoroutine = C_MonoSingleton <C_GameFramework> .GetInstance().StartCoroutine(GetResponse(m_CurNetworkData));
}
}
protected override void ReceivedData(NetworkData availableData, ReactorResponseChannel responseChannel)
{
if (EventLoop.Receive != null)
{
EventLoop.Receive(availableData, responseChannel);
}
}
bool ICommand.Run(string MessageText, SlackRTM.Events.Message RawMessage, bool IsTargeted, SlackRTM.Slack Instance)
{
/* ****
* Select.
* ****/
var match = Regex.Match(
MessageText,
@"(Select|Pick|With) (?<name>[\w:\.]+)",
RegexOptions.IgnoreCase);
if (IsTargeted && match.Success)
{
Host LastHost;
NetworkData network = Singleton <NetworkData> .Instance;
Instance.SetLastHost(LastHost = network.Find(match.Groups["name"].Value));
if (LastHost == null)
{
Instance.SendMessage(RawMessage.Channel, "I couldn't find it");
return(true);
}
Instance.SendMessage(RawMessage.Channel, string.Format("{0}: {1} [{2}] ({3})", LastHost.FriendlyName, LastHost.Owner, network.Status(LastHost), LastHost.Age.ToString()));
return(true);
}
return(false);
}
private async void SendImageMessage()
{
Console.WriteLine("STATUS: Sending a picture");
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
openFileDialog.Filter = "Image files (*.jpg;*.jpeg)|*.jpg;*.jpeg;";
openFileDialog.RestoreDirectory = true;
openFileDialog.ShowDialog();
string filePath = openFileDialog.FileName;
if (!String.IsNullOrEmpty(filePath))
{
Bitmap bitmap = new Bitmap(filePath);
string fileName = Path.GetFileName(filePath);
string imagePath = await FileService.SaveImage(bitmap, fileName);
string bitmapString = ImageService.BitmapToString(bitmap);
NetworkData networkImage = new NetworkData(User, NetworkDataType.Image, fileName + " " + bitmapString);
ImageChatMessage visibleImage = new ImageChatMessage(networkImage.User.UserName, networkImage.Date,
imagePath);
ImageChatMessage hiddenImage = new ImageChatMessage(networkImage.User.UserName, networkImage.Date,
imagePath, Visibility.Hidden);
Application.Current.Dispatcher.Invoke(() =>
{
AddMessage(visibleImage, hiddenImage);
});
await Connection.SendNetworkData(networkImage);
}
}
private async void AddReceivedMessage(NetworkData networkMessage)
{
if (networkMessage.DataType == NetworkDataType.Message)
{
TextChatMessage visibleMessage = new TextChatMessage(networkMessage.User.UserName, networkMessage.Date,
networkMessage.Data);
TextChatMessage hiddenMessage = new TextChatMessage(networkMessage.User.UserName, networkMessage.Date,
networkMessage.Data, Visibility.Hidden);
Application.Current.Dispatcher.Invoke(() =>
{
AddMessage(visibleMessage, hiddenMessage, true);
});
}
else if (networkMessage.DataType == NetworkDataType.Image)
{
string fileName = networkMessage.Data.Split(new char[] { ' ' }, 2)[0];
string imageData = networkMessage.Data.Split(new char[] { ' ' }, 2)[1];
Console.WriteLine(fileName);
Console.WriteLine(imageData);
Bitmap receivedBitmap = ImageService.StringToBitmap(imageData);
string imagePath = await FileService.SaveImage(receivedBitmap, fileName, false);
ImageChatMessage visibleImage = new ImageChatMessage(networkMessage.User.UserName, networkMessage.Date,
imagePath);
ImageChatMessage hiddenImage = new ImageChatMessage(networkMessage.User.UserName, networkMessage.Date,
imagePath, Visibility.Hidden);
Application.Current.Dispatcher.Invoke(() =>
{
AddMessage(visibleImage, hiddenImage, true);
});
}
}
/// <summary>
/// 方法被实现直接调用，以将数据发送给它
/// </summary>
/// <param name="data">The data to pass directly to the recipient</param>
public virtual void OnReceive(NetworkData data)
{
if (this.ReceiveList != null)
{
this.ReceiveList(data, this); //发出警报
}
}
protected override void OnMessage(NetworkData data, IConnection responseChannel)
{
var protoMessage = _protobufDecoder.Decode(data.Buffer);
var testkitMesage = _msgDecoder.Decode(protoMessage);
_handler.OnMessage(testkitMesage, responseChannel);
}
/// <summary>
/// 数据接收
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void PortDataReceived(object sender, SerialDataReceivedEventArgs e)
{
Thread.Sleep(50);
////禁止接收事件时直接退出
//if (OnReceive==null) return;
if (this.WasDisposed)
{
return;
}
//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环
try
{
this.IsParsing = true; //设置标记，说明已经开始处理数据，一会儿要使用系统UI
int n = ListenerSocket.BytesToRead;
byte[] buf = new byte[n];
this.ListenerSocket.Read(buf, 0, n);
NetworkData networkData = NetworkData.Create(this.Listener, buf, n);
this.ReceivedData(networkData);
}
catch (Exception ex)
{
string enmsg = string.Format("Serial Port {0} Communication Fail\r\n" + ex.ToString(), ListenerSocket.PortName);
}
finally
{
IsParsing = false; //监听完毕， UI可关闭串口
}
}
void OnNetworkDataReceived(object sender, ReceivedNetworkDataEventArgs e)
{
NetworkData data = e.Data;
switch (e.Type)
{
case ENetDataType.ExperimentState:
{
ExperimentState state = (ExperimentState)data;
ExperimentManager.Instance().SetExperimentStatus(state.Status);
break;
}
case ENetDataType.UserState:
ExperimentManager.Instance().ReceivedUserStateUpdate((UserState)data);
break;
case ENetDataType.RandomState:
ExperimentManager.Instance().ReceivedRandomStateUpdate((RandomState)data);
break;
case ENetDataType.ResponseState:
ExperimentManager.Instance().ReceivedResponseStateUpdate((ResponseState)data);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void AddPlayer(NetworkData player)
{
var text = playerTexts[player.NetworkID];
var component = text.GetComponent <Text>();
component.text = player.Username + "[" + player.NetworkID + "]";
}
/// <summary>
/// Abstract method to be filled in by a child class - data received from the
/// network is injected into this method via the <see cref="NetworkData" /> data type.
/// </summary>
/// <param name="availableData">Data available from the network, including a response address</param>
/// <param name="responseChannel">Available channel for handling network response</param>
protected virtual void ReceivedData(NetworkData availableData)
{
//if (EventLoop.Receive != null)
//{
// EventLoop.Receive(availableData, responseChannel);
//}
}
public async Task SerializesToValidNetworkDataV2()
{
var serializer = new YamlSerializer();
var networkData = new NetworkData(new Dictionary <string, object>
{
{ "ethernets", new
{
eth0 = new
{
match = new { macaddress = "00:11:22:33:44:55" },
dhcp4 = true
}
} }
});
await using var resultStream = await serializer.SerializeToYaml(networkData);
using var streamReader = new StreamReader(resultStream);
var act = await streamReader.ReadToEndAsync();
Assert.Equal(@"version: 2
ethernets:
eth0:
match:
macaddress: 00:11:22:33:44:55
dhcp4: true
", act);
}
public override NetworkData GetNetworkData()
{
try{
NetworkInterface intf = NetworkInterface.GetAllNetworkInterfaces().First(x => x.Name.ToLower().Equals(NETWORKINTERFACE_WIFI)) as NetworkInterface;
intf = (intf == null || (intf != null && intf.GetIPProperties().UnicastAddresses.Count == 0) ? NetworkInterface.GetAllNetworkInterfaces().First(x => x.Name.ToLower().Equals(NETWORKINTERFACE_3G)) as NetworkInterface : intf);
if (intf != null && intf.GetIPProperties().UnicastAddresses.Count > 0)
{
NetworkData returnData = new NetworkData();
foreach (var addrInfo in intf.GetIPProperties().UnicastAddresses)
{
switch (addrInfo.Address.AddressFamily)
{
case System.Net.Sockets.AddressFamily.InterNetwork:
//IPv4
returnData.IPv4 = addrInfo.Address.ToString();
break;
case System.Net.Sockets.AddressFamily.InterNetworkV6:
//IPv6
returnData.IPv6 = addrInfo.Address.ToString();
if (returnData.IPv6.Contains("%"))
{
returnData.IPv6 = returnData.IPv6.Split('%')[0];
}
break;
default:
break;
}
}
return(returnData);
}
}catch (Exception ex) { SystemLogger.Log(SystemLogger.Module.PLATFORM, "Error found while retrieving NetworkData", ex); }
return(null);
}
public void Process(NetworkData networkData)
{
if (processors.TryGetValue(networkData.GetType(), out Tuple <object, MethodInfo> info))
{
info.Item2.Invoke(info.Item1, new object[] { networkData });
}
}
public dynamic GetReportData()
{
// Generating employee list
var employees = Enumerable
.Range(0, NumberData.GetNumber(10, 50))
.Select(i =>
{
dynamic newEmployee = new ExpandoObject();
newEmployee.BirthDate = DateTimeData.GetDatetime(new DateTime(1973, 1, 1), new DateTime(1997, 12, 1));
newEmployee.FirstName = NameData.GetFirstName();
newEmployee.LastName = NameData.GetSurname();
newEmployee.Company = NameData.GetCompanyName();
newEmployee.Email = NetworkData.GetEmail();
newEmployee.PhoneNumber = PhoneNumberData.GetInternationalPhoneNumber();
newEmployee.Address = string.Format("{0} {1} {2}\n{3},{4} {5}", PlaceData.GetStreetName(), PlaceData.GetStreetNumber(), PlaceData.GetAddress(), PlaceData.GetCity(), PlaceData.GetState(), PlaceData.GetZipCode());
newEmployee.PersonalQuote = TextData.GetSentences(5);
newEmployee.PorfileFileName = $"{FakeData.NumberData.GetNumber(0,7)}.png";
// NOTE: Even though ExpandoObject is compatible with IDictionary<string,object>,
// The template engine only accepts Dictionary<string,object>
return(new Dictionary <string, object>(newEmployee));
})
.ToList();
dynamic reportData = new ExpandoObject();
reportData.Employees = employees;
return(reportData);
}
protected void InitOutbound(IConnection channel, INode remoteSocketAddress, NetworkData msg)
{
AssociationHandle handle;
Init(channel, remoteSocketAddress, RemoteAddress, msg, out handle);
StatusPromise.SetResult(handle);
}
public void Init(int id)
{
clientId = id;
authorityId = id + 1;
IsTrue(clientId >= 0 && clientId < MaxClients);
IsTrue(authorityId >= 0 && authorityId < MaxAuthority);
if (id == 0)
{
client = null; //initialize as server
server = new NetworkData[MaxClients - 1];
for (int i = 0; i < server.Length; ++i)
{
server[i] = new NetworkData();
InitPriorities(server[i]);
}
}
else
{
client = new NetworkData(); //initialize as client
server = null;
InitPriorities(client);
}
}
void InitPriorities(NetworkData data)
{
for (int i = 0; i < MaxCubes; ++i)
{
data.priorities[i].cubeId = i;
}
}
public void TextChatMessageListener(NetworkData data)
{
TextChatMessage textChatMessage = data as TextChatMessage;
String Msg = textChatMessage.MessageText;
if (Msg.StartsWith("/"))
{
Player player1 = Server.GetPlayer(textChatMessage.Sender);
textChatMessage.Name = player1.Name;
string[] chatCommandArray = Msg.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
string command = chatCommandArray.First();
//Send to COmmand Manager
if (chatCommandArray.Length > 1)
{
CommandManager.HandlePlayerCommand(chatCommandArray.First().Replace("/", ""), chatCommandArray.Skip(1).ToArray(), player1);
}
else
{
CommandManager.HandlePlayerCommand(chatCommandArray.First().Replace("/", ""), new String[] { }, player1);
}
return;
}
Server.TextChatMessageListener(data);
}
public void ResetCubePriority(NetworkData data, int count, int[] cubeIds)
{
for (int i = 0; i < count; ++i)
{
data.priorities[cubeIds[i]].value = 0.0f;
}
}
void UpdateCubePriorities(NetworkData data)
{
IsTrue(snapshot != null);
for (int i = 0; i < MaxCubes; ++i)
{
var cube = cubes[i].GetComponent <NetworkCube>();
if (cube.HasHolder()) //don't send state updates held cubes. they are synchronized differently.
{
data.priorities[i].value = DontSend;
continue;
}
if (IsClient() && cube.authorityId == 0 && !cube.isPendingCommit) //only send white cubes from client -> server if they are pending commit after returning to default authority
{
data.priorities[i].value = DontSend;
continue;
}
var priority = 1.0f; //base priority
if (collisionFrames[i] + CollisionPriority >= simulationFrame)
{
priority = 10.0f; //higher priority for cubes that were recently in a high energy collision
}
if (cube.heldFrame + ThrownObjectPriority >= (long)simulationFrame)
{
priority = 1000000.0f; //*extremely* high priority for cubes that were just thrown by a player
}
data.priorities[i].value += priority;
}
}
public void Shutdown()
{
clientId = 0;
authorityId = 0;
client = null;
server = null;
}
private async Task Queue(NetworkData nd)
{
if (nd == null)
{
return;
}
if (nd is NetworkDataKeepAlive keepAlive)
{
return;
}
using (var messages = await messageQueue.WaitAsync())
{
if (waitMessage.IsWaiting())
{
messages.Value.Enqueue(nd);
waitMessage.Signal();
}
else
{
var onMessageReceived = OnMessageReceived;
if (onMessageReceived != null)
{
_ = onMessageReceived(this, nd, cancel.Token);
}
else
{
messages.Value.Enqueue(nd);
}
}
}
}
protected override void OnMessage(NetworkData data, IConnection responseChannel)
{
if (data.Length > 0)
{
ChannelLocalActor.Notify(responseChannel, new InboundPayload(FromData(data)));
}
}
protected virtual void ReceiveCallback(IAsyncResult ar)
{
var receiveState = (NetworkState)ar.AsyncState;
try
{
var received = receiveState.Socket.EndReceive(ar);
if (!receiveState.Socket.Connected || received == 0)
{
Receiving = false;
Close(new HeliosConnectionException(ExceptionType.Closed));
return;
}
receiveState.Buffer.WriteBytes(receiveState.RawBuffer, 0, received);
List <IByteBuf> decoded;
Decoder.Decode(this, receiveState.Buffer, out decoded);
foreach (var message in decoded)
{
var networkData = NetworkData.Create(receiveState.RemoteHost, message);
InvokeReceiveIfNotNull(networkData);
}
//reuse the buffer
if (receiveState.Buffer.ReadableBytes == 0)
{
receiveState.Buffer.SetIndex(0, 0);
}
else
{
receiveState.Buffer.CompactIfNecessary();
}
//continue receiving in a loop
if (Receiving)
{
receiveState.Socket.BeginReceive(receiveState.RawBuffer, 0, receiveState.RawBuffer.Length,
SocketFlags.None, ReceiveCallback, receiveState);
}
}
catch (SocketException ex) //typically means that the socket is now closed
{
Receiving = false;
Close(new HeliosConnectionException(ExceptionType.Closed, ex));
}
catch (ObjectDisposedException ex) //socket was already disposed
{
Receiving = false;
InvokeDisconnectIfNotNull(RemoteHost,
new HeliosConnectionException(ExceptionType.Closed, ex));
}
catch (Exception ex)
{
InvokeErrorIfNotNull(ex);
}
}
public void Encode(NetworkData data, out List <NetworkData> encoded)
{
var length = data.Length + _lengthAdjustment;
if (_lengthIncludesLenghtFieldLength)
{
length += _lengthFieldLength;
}
encoded = new List <NetworkData>();
if (length < 0)
{
throw new ArgumentException(string.Format("Adjusted frame length ({0}) is less than zero", length));
}
var newData = new byte[0];
using (var memoryStream = new MemoryStream())
{
switch (_lengthFieldLength)
{
case 1:
if (length >= 256)
{
throw new ArgumentException("length of object does not fit into one byte: " + length);
}
memoryStream.Write(BitConverter.GetBytes((byte)length), 0, 1);
break;
case 2:
if (length >= 65536)
{
throw new ArgumentException("length of object does not fit into a short integer: " + length);
}
memoryStream.Write(BitConverter.GetBytes((ushort)length), 0, 2);
break;
case 4:
memoryStream.Write(BitConverter.GetBytes((uint)length), 0, 4);
break;
case 8:
memoryStream.Write(BitConverter.GetBytes((long)length), 0, 8);
break;
default:
throw new Exception("Unknown lenght field length");
}
memoryStream.Write(data.Buffer, 0, data.Length);
newData = memoryStream.GetBuffer();
}
var networkData = NetworkData.Create(data.RemoteHost, newData,
_lengthIncludesLenghtFieldLength ? length : length + _lengthFieldLength);
encoded.Add(networkData);
HeliosTrace.Instance.EncodeSuccess();
}
public virtual ResultOfParsingFrame ParseToFrame(NetworkData data)
{
if (data == null)
{
return(ResultOfParsingFrame.FormatNotMatched);
}
return(ParseToFrame(data.Buffer));
}
public void CreateNetworkData(int probeDataId, NetworkData data)
{
data.ProbeDataId = probeDataId;
data.CreatedOn = DateTime.UtcNow;
_Context.NetworkData.Add(data);
_Context.SaveChanges();
}
public void SerializeNetworkData()
{
NetworkData networkData = GetNetworkTestData();
byte[] serializedData = networkData.ToByte();
var deserializedNetworkData = new NetworkData(serializedData);
// TODO: implement IEquatable<>
AssertThatDataAreEqual(GetNetworkTestData(), deserializedNetworkData);
}
private void AssertThatDataAreEqual(NetworkData expectedData, NetworkData actualData)
{
Assert.AreEqual(expectedData.Command, actualData.Command);
Assert.AreEqual(expectedData.UserId, actualData.UserId);
Assert.AreEqual(expectedData.AppName, actualData.AppName);
Assert.AreEqual(expectedData.Platform, actualData.Platform);
Assert.AreEqual(expectedData.CommandDetails, actualData.CommandDetails);
Assert.AreEqual(expectedData.BinaryData, actualData.BinaryData);
}
public void Send(NetworkData data)
{
HeliosTrace.Instance.TcpClientSendQueued ();
SendInternal(data.Buffer, 0, data.Length, data.RemoteHost);
}
public void InvokeReceiveIfNotNull(NetworkData data)
{
if (NetworkEventLoop.Receive != null)
{
NetworkEventLoop.Receive(data, this);
}
}
