/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
using (var game = new Pong())
{
game.Run();
}
}
public void Start(int count, Pong pong)
{
_initialCount = _pingCount = count;
_watch = Stopwatch.StartNew();
pong.Ping(this);
}
public void Setup()
{
_ping = new PingActor();
_ping2 = new PingActor();
_ping3 = new PingActor();
_ping4 = new PingActor();
_pong = new PongActor();
}
static void Main(string[] args)
{
using (Pong game = new Pong())
{
#if !DEBUG
game.IsFullScreen = true;
#endif
game.Run();
}
}
private void Consume(Pong pong)
{
_pingCount--;
if (_pingCount == 0)
{
_watch.Stop();
Trace.WriteLine("Ping -> Pong " + _pingCount + " On Thread: " + Thread.CurrentThread.ManagedThreadId);
long perSecond = ((long) _initialCount*2000)/(_watch.ElapsedMilliseconds == 0 ? 1 : _watch.ElapsedMilliseconds);
Trace.WriteLine("Elapsed Time = " + _watch.ElapsedMilliseconds + "ms, Messages Per Second = " + perSecond);
return;
}
if (_pingCount%50000 == 0)
{
Trace.WriteLine("Ping -> Pong " + _pingCount + " On Thread: " + Thread.CurrentThread.ManagedThreadId);
}
pong.Ping(this);
}
private void Consume(Pong pong)
{
_pingCount--;
if (_pingCount == 0)
{
_watch.Stop();
Trace.WriteLine("Ping -> Pong " + _pingCount + " On Thread: " + Thread.CurrentThread.ManagedThreadId);
long perSecond = ((long)_initialCount * 2000) / (_watch.ElapsedMilliseconds == 0 ? 1 : _watch.ElapsedMilliseconds);
Trace.WriteLine("Elapsed Time = " + _watch.ElapsedMilliseconds + "ms, Messages Per Second = " + perSecond);
return;
}
if (_pingCount % 50000 == 0)
{
Trace.WriteLine("Ping -> Pong " + _pingCount + " On Thread: " + Thread.CurrentThread.ManagedThreadId);
}
pong.Ping(this);
}
public void DetermineApproprateSerialization()
{
var a = new Bye();
var b = new Ping();
var c = new Pong();
var d = new DummyMessage();
var e = new DummyProtoMessage();
var at = _sh.DetermineApproprateSerialization(a);
var bt = _sh.DetermineApproprateSerialization(b);
var ct = _sh.DetermineApproprateSerialization(c);
var dt = _sh.DetermineApproprateSerialization(d);
var et = _sh.DetermineApproprateSerialization(e);
Assert.AreEqual(SerializationType.Manual, at);
Assert.AreEqual(SerializationType.Manual, bt);
Assert.AreEqual(SerializationType.Manual, ct);
Assert.AreEqual(SerializationType.Binary, dt);
Assert.AreEqual(SerializationType.Protobuf, et);
}
void OnPing(byte[] buf, int size, IPEndPoint remoteEP)
{
int offset = 1;
var connectionId = BinaryUtil.ReadInt(buf, ref offset);
if (!m_PeerManager.TryGetValue(connectionId, out var peer))
{
return;
}
if (!Ping.TryUnpack(buf, size, peer.Encryptor, out var packet))
{
return;
}
peer.Update(remoteEP, packet.SendSequence, packet.ReceiveSequence);
offset = new Pong(GetSendId(connectionId), peer).Pack(m_SendBuffer, peer.Encryptor);
m_Socket.Send(m_SendBuffer, 0, offset, peer.EndPoint);
Log.Trace("OnPing {0}", connectionId);
}
public void PongSimple3()
{
PlayerData p1 = new PlayerData("toto");
PlayerData p2 = new PlayerData("toto2");
p1.AddHand(new Tile(Tile.Family.Bamboo, 1));
p1.AddHand(new Tile(Tile.Family.Bamboo, 1));
p1.AddHand(new Tile(Tile.Family.Bamboo, 1));
p2.AddRejected(new Tile(Tile.Family.Bamboo, 1));
IRule rule = new Pong();
List <PlayerData> lpd = new List <PlayerData>();
lpd.Add(p1);
lpd.Add(p2);
List <Mahjong.Plugin.IReferee.m_rulepossibility> possi = rule.Execute(lpd, p1);
Assert.AreEqual(possi.Count, 1);
}
public static bool TryUnpack(byte[] buf, int size, Encryptor encryptor, out Pong packet)
{
int offset = 0;
if (sizeof(byte) + sizeof(int) + sizeof(short) + sizeof(short) > size || buf[offset++] != (byte)Type)
{
packet = default;
return(false);
}
if (!encryptor.TryDecrypt(buf, 5, ref size))
{
packet = default;
return(false);
}
var id = BinaryUtil.ReadInt(buf, ref offset);
var sendSeq = BinaryUtil.ReadShort(buf, ref offset);
var recvSeq = BinaryUtil.ReadShort(buf, ref offset);
packet = new Pong(id, sendSeq, recvSeq);
return(true);
}
public static int Main(string[] args)
{
QCoreApplication app = new QCoreApplication(args);
if (!QDBusConnection.SessionBus().IsConnected()) {
Console.Write("Cannot connect to the D-BUS session bus.\n" +
"To start it, run:\n" +
"\teval `dbus-launch --auto-syntax`\n");
return 1;
}
if (!QDBusConnection.SessionBus().RegisterService(SERVICE_NAME)) {
Console.WriteLine(QDBusConnection.SessionBus().LastError().Message());
return 1;
}
Pong pong = new Pong();
Connect(app, SIGNAL("aboutToQuit()"), pong, SLOT("Terminator()"));
QDBusConnection.SessionBus().RegisterObject("/", pong, (int) QDBusConnection.RegisterOption.ExportAllSlots);
return QCoreApplication.Exec();
}
private void ReceiveHead(IAsyncResult ar)
{
int count = (int)ar.AsyncState;
count += socket.EndReceive(ar);
//如果头数据长度不够，继续读
if (count < headlen)
{
socket.BeginReceive(head, count, headlen - count, SocketFlags.None, new AsyncCallback(ReceiveHead), count);
}
else
{
//处理一下高低字节位问题
byte[] realBytesLen = new byte[headlen];
for (int i = 0; i < headlen; i++)
{
realBytesLen[i] = head[headlen - 1 - i];
}
int length = ByteUtil.byteArray2Int(realBytesLen, 0);
byte[] data = new byte[length];//声明接受数组
count = 0;
while (count < length)
{
int tempLength = socket.Receive(data, count, length - count, SocketFlags.None);
count += tempLength;
}
socket.BeginReceive(head, 0, headlen, SocketFlags.None, new AsyncCallback(ReceiveHead), 0);
MarsMessage msg = ProtobufTool.DeSerialize <MarsMessage>(data);
//心跳消息直接在本类处理
if (msg.messageType == 1)
{
Pong pong = ProtobufTool.DeSerialize <Pong>(msg.data);
Pong(pong);
}
else
{
MessageDispatcher.Receive(msg);
}
}
}
/// <summary>
/// Drone response handler.
///
/// <para>Will listen to the udp packages send from the drone to the receiver and looks up what command it is and react
/// to it</para>
/// </summary>
private void runResponseHandler()
{
new Thread(() =>
{
// Answer with a Pong
try
{
using (var udpClient = new UdpClient(devicePort))
{
LOGGER.Info(String.Format("Listing for response on port %s", devicePort));
while (listenToResponse)
{
byte[] packet = udpClient.Receive(ref SumoRemote);;
//LOGGER.trace("Receiving packet {}", convertAndCutPacket(packet, false));
commonEventListeners.Where(e => e.test(packet)).ToList().ForEach(e => e.consume(packet));
// Answer with a Pong
if (packet[0] == 4 || packet[0] == 2)
{
sendCommand(Pong.pong(packet[2]));
continue;
}
eventListeners.Where(e => e.test(packet)).ToList().ForEach(e => e.consume(packet));
}
}
}
catch (IOException)
{
LOGGER.Warn("Error occurred while receiving packets from the drone.");
}
}).Start();
}
public static void Test()
{
var system = new ActorSystem();
var pingPong = new CountdownEvent(PingPongCount);
var bruce = new Bruce(pingPong);
var lee = new Lee(pingPong);
system.Add(bruce, ctx => { ctx.Actor.Bus = ctx.Bus; });
system.Add(lee, ctx => { ctx.Actor.Bus = ctx.Bus; });
var c = system.Start();
var p = new Pong();
c.Publish(ref p);
var ended = pingPong.Wait(TimeSpan.FromSeconds(10));
c.Stop();
Assert.True(ended, "Bruce/Lee didn't ping/pong");
}
public async Task ReceiveAsync(IContext context)
{
switch (context.Message)
{
case Started _:
Logger.LogDebug("{Context}", context.Self);
break;
case ClusterInit init:
_identity = init.Identity;
_initKind = init.Kind;
break;
case Ping ping:
var pong = new Pong {
Message = ping.Message, Kind = _initKind ?? "", Identity = _identity ?? ""
};
Logger.LogDebug("Received Ping, replying Pong: {@Pong}", pong);
context.Respond(pong);
break;
case SlowPing ping:
await Task.Delay(ping.DelayMs);
var slowPong = new Pong {
Message = ping.Message, Kind = _initKind ?? "", Identity = _identity ?? ""
};
Logger.LogDebug("Received SlowPing, replying Pong after {Delay} ms: {@Pong}", ping.DelayMs, slowPong);
context.Respond(slowPong);
break;
case WhereAreYou hi:
Logger.LogDebug("Responding to location request");
context.Respond(new HereIAm {
Address = context.Self !.Address, RequestId = hi.RequestId
});
break;
private void ProcessMessage(IServer server, ISession session, object message)
{
if (message is Ping)
{
Pong poing = new Pong();
poing.NodeID = ID;
poing.Properties = GetResourceStatistics();
server.Send(poing, session);
}
else if (message is BroadSubscriber)
{
BroadSubscriber bs = (BroadSubscriber)message;
RegisterRemoteSubscribers(bs.NodeID, bs.Name);
Loger.Process(LogType.DEBUG, "registered remote subscriber [{0}]", bs.Name);
}
else if (message is GetSubscribers)
{
GetSubscribersResponse response = new GetSubscribersResponse();
response.NodeID = ID;
response.Subscribers = mLocalSubscriberCenter.GetAll();
server.Send(response, session);
}
else if (message is BroadRemoveSubscriber)
{
BroadRemoveSubscriber remove = (BroadRemoveSubscriber)message;
UnRegisterRemoteSubscribers(remove.Name);
}
else if (message is Message)
{
((Message)message).Track("node receive message");
Publish((Message)message);
((Message)message).EndTrack("node receive message completed!", this);
}
else
{
}
}
public void HandleKey(ConsoleKeyInfo?cki2)
{
ConsoleKeyInfo cki = (ConsoleKeyInfo)cki2;
if (cki.Key == ConsoleKey.D1)
{
Hide();
Snake snake = new Snake(this);
return;
}
else if (cki.Key == ConsoleKey.D2)
{
Hide();
Tetris tetris = new Tetris();
return;
}
else if (cki.Key == ConsoleKey.D3)
{
Hide();
Pong pong = new Pong(true);
return;
}
else if (cki.Key == ConsoleKey.D4)
{
Hide();
Pong pong = new Pong(false);
return;
}
else if (cki.Key == ConsoleKey.D5)
{
}
else if (cki.Key == ConsoleKey.Q)
{
Environment.Exit(0);
}
getKey();
}
public static void test(string apiKey)
{
Console.WriteLine("Testing basic connectivity...");
Pong pong = ES.testPing(apiKey);
Console.WriteLine("Message from server: " + pong.message);
FileStream file = getTestPdfFile();
Console.WriteLine("Testing file transfer...");
Byte[] bytes = new byte[file.Length];
file.Read(bytes, 0, bytes.Length);
Byte[] rbytes = ES.testEchoFile(apiKey, bytes);
bool resultOk = true;
if (bytes.Length == rbytes.Length)
{
int i = bytes.Length;
while (--i >= 0)
{
if (bytes[i] != rbytes[i])
{
resultOk = false;
break;
}
}
}
if (resultOk)
{
Console.WriteLine("Woohoo! Everything seems to work.");
}
else
{
Console.WriteLine("ERROR: Some kind of problem with file transfer, it seems.");
}
}
public static PlayState CreateLocalMultiPlayerGame(Game game)
{
Pong gameRef = (Pong)game;
return(new PlayState(game, new HumanPlayer(gameRef.Settings.player1Up, gameRef.Settings.player1Down), new HumanPlayer(gameRef.Settings.player2Up, gameRef.Settings.player2Down)));
}
public static PlayState CreateSinglePlayerGame(Game game)
{
Pong gameRef = (Pong)game;
return(new PlayState(game, new HumanPlayer(gameRef.Settings.player1Up, gameRef.Settings.player1Down), new AIPlayer()));
}
public static int Main(string[] args)
{
QCoreApplication app = new QCoreApplication(args);
QObject obj = new QObject();
Pong pong = new Pong(obj);
pong.Connect(app, SIGNAL("aboutToQuit()"), SIGNAL("aboutToQuit()"));
pong.value = "initial value";
QDBusConnection.SessionBus().RegisterObject("/", obj);
if (!QDBusConnection.SessionBus().RegisterService(SERVICE_NAME)) {
Console.Error.WriteLine(QDBusConnection.SessionBus().LastError().Message());
return(1);
}
return QCoreApplication.Exec();
}
private void InvokePong(Pong packet)
{
packetListener.OnPong(packet);
}
private void HandlePong(Pong pong)
{
Ponged.Complete(pong);
}
public void SetPong(Pong pong, MyClientMessage message) => message.Pong = pong;
static void Main()
{
Pong game = new Pong();
game.Run();
}
private void readIncomingCommunication(string msg)
{
mutex.WaitOne();
var data = (JObject)JsonConvert.DeserializeObject(msg);
Console.WriteLine(data["type"]);
string type = data["type"].Value <string>();
MemoryStream stream = GenerateStreamFromString(msg);
stream.Position = 0;
// TODO : faire vérification si communication est bien formée
// vérifier type message
if (type.Contains(ECommunicationType.HELLO))
{
Hello receivedHello = new Hello();
List <Peer> listeNoeudsVoisins;
if (type == ECommunicationType.HELLO_A)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Hello_A));
receivedHello = (Hello_A)ser.ReadObject(stream);
listeNoeudsVoisins = receivedHello.pairs;
// si hello qui quelqu'un m'a envoyé, vérifier qu'il n'a pas été déjà reçu à moins de 10 sec
// si non, répondre le hello reçu avec la liste noeuds
//List<Peer> liste = helloSenders.Where(p => (p.Key.addr == receivedHello.addr_source)).Select(p => p.Key).ToList();
if (chatUDPController.isANewReceivedHello(receivedHello, type) /*liste.Count == 0*/)
{
//List<Peer> listeNoeudsVoisins = receivedHello.pairs;
/*if (receivedHello.GetType() == typeof(Hello_A))
* {*/
Hello_R hello_r = new Hello_R(myAddress, myPort, chatUDPController.MyNodes);
Peer peer_dest = new Peer(receivedHello.addr_source, receivedHello.port_source);
//chatUDPController.helloSenders.Add(peer_dest, DateTime.Now);
chatUDPController.receivedHelloAList.Add(peer_dest, DateTime.Now);
chatUDPController.sendHello(hello_r, peer_dest);
// A TRAITER : Sauf si un noeuds fait un HELLO avec une liste de paire vide (isolé) auquel cas on le rajoute automatiquement
// si source contient que moi dans sa liste de noeuds, l'ajouter à ma liste de noeuds (même que ça dépasse 4)
// si aucun noeud voisin ou 1 seul et moi même
chatUDPController.addPeerToCurrentNeighbors(peer_dest, listeNoeudsVoisins.Count == 0 || (listeNoeudsVoisins.Count == 1 && listeNoeudsVoisins[0].addr.Equals(myAddress) && listeNoeudsVoisins[0].port == myPort));
/*if ((listeNoeudsVoisins.Count == 0
|| (listeNoeudsVoisins.Count == 1 && listeNoeudsVoisins[0].addr == myAddress)) /*listeNoeudsVoisins.Where(p => (p.addr == adresse)).ToList().Count > 0)*
|| && !chatUDPController.myNodes.Contains(peer_dest))
|| {
|| chatUDPController.myNodes.Add(peer_dest);
|| }*/
//}
// récuperer sa liste de noeuds et ajouter à la sienne
//fillNeighbours(listeNoeudsVoisins, type);
listeNoeudsVoisins.ForEach(p => chatUDPController.addPeerToCurrentNeighbors(p, false));
}
}
else if (type == ECommunicationType.HELLO_R)
{
if (chatUDPController.isANewReceivedHello(receivedHello, type))
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Hello_R));
receivedHello = (Hello_R)ser.ReadObject(stream);
listeNoeudsVoisins = receivedHello.pairs;
Peer peer_dest = new Peer(receivedHello.addr_source, receivedHello.port_source);
chatUDPController.receivedHelloRList.Add(peer_dest, DateTime.Now);
//chatUDPController.addPeerToCurrentNeighbors(peer_dest, listeNoeudsVoisins.Count == 0 || (listeNoeudsVoisins.Count == 1 && listeNoeudsVoisins[0].addr == myAddress));
// récuperer sa liste de noeuds et ajouter à la sienne
//fillNeighbours(listeNoeudsVoisins, type);
listeNoeudsVoisins.ForEach(p => chatUDPController.addPeerToCurrentNeighbors(p, false));
}
}
}
else if (type == ECommunicationType.MESSAGE)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Message));
Message message = (Message)ser.ReadObject(stream);
// vérifier si message pas encore reçu
if (chatUDPController.isANewReceivedMessage(message) /*sentAndReceivedMessages.Where(m => m == message.hash).ToList().Count == 0*/)
{
treatReceivedMessage(message);
}
}
else if (type == ECommunicationType.PING)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Ping));
Ping ping = (Ping)ser.ReadObject(stream);
chatUDPController.sendPong(ping.addr_source, ping.port_source);
}
else if (type == ECommunicationType.PONG)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Pong));
Pong pong = (Pong)ser.ReadObject(stream);
//chatUDPController.receivedPongs.Add(pong);
if (chatUDPController.SentPings.ContainsKey(pong.addr_source + pong.port_source))
{
chatUDPController.SentPings[pong.addr_source + pong.port_source] = true;
}
// TODO : ajouter réponse pong à ping correspondant
/*if (chatUDPController.dictPingPong.ContainsKey(pong.addr_source + pong.port_source))
* {
* chatUDPController.dictPingPong.Remove(pong.addr_source + pong.port_source);
* }*/
// chatUDPController.
}
else if (type == ECommunicationType.GOODBYE)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Goodbye));
Goodbye goodbye = (Goodbye)ser.ReadObject(stream);
// vérifier si goodbye pas encore reçu
if (chatUDPController.isANewReceivedGoodbye(goodbye) /*sentAndReceivedMessages.Where(m => m == message.hash).ToList().Count == 0*/)
{
chatUDPController.sentAndReceivedGoodbyes.Add(goodbye.nickname);
chatUDPController.sendReceivedGoodbye(goodbye);
}
}
else
{
Console.WriteLine("Default case");
}
mutex.ReleaseMutex();
}
void Receive_Ping(G2ReceivedPacket packet)
{
Core.ServiceBandwidth[Core.DhtServiceID].InPerSec += packet.Root.Data.Length;
Ping ping = Ping.Decode(packet);
bool lanIP = Utilities.IsLocalIP(packet.Source.IP);
bool validSource = (!lanIP || LanMode && lanIP);
// set local IP
SetLocalIP(ping.RemoteIP, packet);
// check loop back
if (ping.Source != null && Local.Equals(ping.Source))
{
if (packet.ReceivedTcp)
packet.Tcp.CleanClose("Loopback connection");
return;
}
// dont send back pong if received tunneled and no longer need to use lookup proxies
// remote would only send tunneled ping if UseGlobalProxies published info on network
// let our lookup address expire from remote's routing table
if (packet.Tunneled && !UseLookupProxies)
return;
// setup pong reply
Pong pong = new Pong();
if (ping.Source != null)
pong.Source = GetLocalSource();
if (ping.RemoteIP != null)
pong.RemoteIP = packet.Source.IP;
if (!IsLookup && Core.Context.SignedUpdate != null && Core.Context.SignedUpdate.Loaded)
pong.Version = Core.Context.SignedUpdate.SequentialVersion;
int sentBytes = 0;
// received tcp
if (packet.ReceivedTcp)
{
if (ping.Source == null)
{
packet.Tcp.SendPacket(pong);
return;
}
if (validSource)
{
if (ping.Source.Firewall == FirewallType.Open)
Routing.Add(new DhtContact(ping.Source, packet.Source.IP));
// received incoming tcp means we are not firewalled
if (!packet.Tcp.Outbound)
{
// done here to prevent setting open for loopback tcp connection
Core.SetFirewallType(FirewallType.Open);
pong.Source.Firewall = FirewallType.Open;
}
}
// check if already connected
if (packet.Tcp.Proxy == ProxyType.Unset && TcpControl.GetProxy(ping.Source) != null)
{
packet.Tcp.CleanClose("Dupelicate Connection");
return;
}
packet.Tcp.UserID = ping.Source.UserID;
packet.Tcp.ClientID = ping.Source.ClientID;
packet.Tcp.TcpPort = ping.Source.TcpPort;
packet.Tcp.UdpPort = ping.Source.UdpPort;
// if inbound connection, to our open host, and haven't checked fw yet
if (!packet.Tcp.Outbound &&
ping.Source.Firewall != FirewallType.Open &&
!packet.Tcp.CheckedFirewall)
{
TcpControl.MakeOutbound(packet.Source, ping.Source.TcpPort, "check firewall");
packet.Tcp.CheckedFirewall = true;
}
pong.Direct = true;
sentBytes = packet.Tcp.SendPacket(pong);
// dont send close if proxies maxxed yet, because their id might be closer than current proxies
}
// ping received udp or tunneled
else
{
if (validSource)
{
// received udp traffic, we must be behind a NAT at least
if (Core.Firewall == FirewallType.Blocked && !packet.Tunneled)
Core.SetFirewallType(FirewallType.NAT);
Routing.TryAdd(packet, ping.Source);
}
// if received over lan, the port isn't set
if (packet.Source.UdpPort == 0)
packet.Source.UdpPort = ping.Source.UdpPort;
// send pong
sentBytes = SendPacket(packet.Source, pong);
}
Core.ServiceBandwidth[Core.DhtServiceID].OutPerSec += sentBytes;
}
private void HandleInternal(Pong msg)
{
Console.WriteLine("Received a pong");
}
/// <summary>
/// Receive web socket result
/// </summary>
/// <param name="buffer">The buffer to copy data into</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The web socket result details</returns>
public override async Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> buffer, CancellationToken cancellationToken)
{
try
{
// we may receive control frames so reading needs to happen in an infinite loop
while (true)
{
// allow this operation to be cancelled from iniside OR outside this instance
using (CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_internalReadCts.Token, cancellationToken))
{
WebSocketFrame frame = null;
try
{
frame = await WebSocketFrameReader.ReadAsync(_stream, buffer, linkedCts.Token);
Events.Log.ReceivedFrame(_guid, frame.OpCode, frame.IsFinBitSet, frame.Count);
}
catch (SocketException)
{
// do nothing, the socket has been disconnected
}
catch (InternalBufferOverflowException ex)
{
await CloseOutputAutoTimeoutAsync(WebSocketCloseStatus.MessageTooBig, "Frame too large to fit in buffer. Use message fragmentation", ex);
throw;
}
catch (ArgumentOutOfRangeException ex)
{
await CloseOutputAutoTimeoutAsync(WebSocketCloseStatus.ProtocolError, "Payload length out of range", ex);
throw;
}
catch (EndOfStreamException ex)
{
await CloseOutputAutoTimeoutAsync(WebSocketCloseStatus.InvalidPayloadData, "Unexpected end of stream encountered", ex);
throw;
}
catch (OperationCanceledException ex)
{
await CloseOutputAutoTimeoutAsync(WebSocketCloseStatus.EndpointUnavailable, "Operation cancelled", ex);
throw;
}
catch (Exception ex)
{
await CloseOutputAutoTimeoutAsync(WebSocketCloseStatus.InternalServerError, "Error reading WebSocket frame", ex);
throw;
}
switch (frame.OpCode)
{
case WebSocketOpCode.ConnectionClose:
return(await RespondToCloseFrame(frame, buffer, linkedCts.Token));
case WebSocketOpCode.Ping:
ArraySegment <byte> pingPayload = new ArraySegment <byte>(buffer.Array, buffer.Offset, frame.Count);
await SendPongAsync(pingPayload, linkedCts.Token);
break;
case WebSocketOpCode.Pong:
ArraySegment <byte> pongBuffer = new ArraySegment <byte>(buffer.Array, frame.Count, buffer.Offset);
Pong?.Invoke(this, new PongEventArgs(pongBuffer));
break;
case WebSocketOpCode.TextFrame:
if (!frame.IsFinBitSet)
{
// continuation frames will follow, record the message type Text
_continuationFrameMessageType = WebSocketMessageType.Text;
}
return(new WebSocketReceiveResult(frame.Count, WebSocketMessageType.Text, frame.IsFinBitSet));
case WebSocketOpCode.BinaryFrame:
if (!frame.IsFinBitSet)
{
// continuation frames will follow, record the message type Binary
_continuationFrameMessageType = WebSocketMessageType.Binary;
}
return(new WebSocketReceiveResult(frame.Count, WebSocketMessageType.Binary, frame.IsFinBitSet));
case WebSocketOpCode.ContinuationFrame:
return(new WebSocketReceiveResult(frame.Count, _continuationFrameMessageType, frame.IsFinBitSet));
default:
Exception ex = new NotSupportedException($"Unknown WebSocket opcode {frame.OpCode}");
await CloseOutputAutoTimeoutAsync(WebSocketCloseStatus.ProtocolError, ex.Message, ex);
throw ex;
}
}
}
}
catch (Exception catchAll)
{
// Most exceptions will be caught closer to their source to send an appropriate close message (and set the WebSocketState)
// However, if an unhandled exception is encountered and a close message not sent then send one here
if (_state == WebSocketState.Open)
{
await CloseOutputAutoTimeoutAsync(WebSocketCloseStatus.InternalServerError, "Unexpected error reading from WebSocket", catchAll);
}
throw;
}
}
public void Pong(Pong pong)
{
_queue.Enqueue(() => Consume(pong));
}
private void Initialize(string uri, string subProtocol, List <KeyValuePair <string, string> > cookies, List <KeyValuePair <string, string> > customHeaderItems, string userAgent, string origin, WebSocketVersion version, EndPoint httpConnectProxy, int receiveBufferSize)
{
if (version == WebSocketVersion.None)
{
NotSpecifiedVersion = true;
version = WebSocketVersion.Rfc6455;
}
Version = version;
ProtocolProcessor = GetProtocolProcessor(version);
Cookies = cookies;
Origin = origin;
if (!string.IsNullOrEmpty(userAgent))
{
if (customHeaderItems == null)
{
customHeaderItems = new List <KeyValuePair <string, string> >();
}
customHeaderItems.Add(new KeyValuePair <string, string>("User-Agent", userAgent));
}
if (customHeaderItems != null && customHeaderItems.Count > 0)
{
CustomHeaderItems = customHeaderItems;
}
Handshake handshake = new Handshake();
m_CommandDict.Add(handshake.Name, handshake);
Text text = new Text();
m_CommandDict.Add(text.Name, text);
Binary binary = new Binary();
m_CommandDict.Add(binary.Name, binary);
Close close = new Close();
m_CommandDict.Add(close.Name, close);
Ping ping = new Ping();
m_CommandDict.Add(ping.Name, ping);
Pong pong = new Pong();
m_CommandDict.Add(pong.Name, pong);
BadRequest badRequest = new BadRequest();
m_CommandDict.Add(badRequest.Name, badRequest);
m_StateCode = -1;
SubProtocol = subProtocol;
Items = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
m_HttpConnectProxy = httpConnectProxy;
TcpClientSession tcpClientSession;
if (uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase))
{
tcpClientSession = CreateClient(uri);
}
else
{
if (!uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("Invalid uri", "uri");
}
tcpClientSession = CreateSecureClient(uri);
}
tcpClientSession.ReceiveBufferSize = ((receiveBufferSize > 0) ? receiveBufferSize : 4096);
tcpClientSession.Connected += client_Connected;
tcpClientSession.Closed += client_Closed;
tcpClientSession.Error += client_Error;
tcpClientSession.DataReceived += client_DataReceived;
Client = tcpClientSession;
EnableAutoSendPing = true;
}
public void Pong(Pong pong)
{
_fiber.Add(() => Consume(pong));
}
public void Pong(Pong pong)
{
_fiber.Add(() => Consume(pong));
}
public BaseGameState(Game game) : base(game)
{
GameRef = (Pong)game;
}
/// <summary>
/// Called when a Pong frame is received
/// </summary>
/// <param name="e"></param>
protected virtual void OnPong(PongEventArgs e)
{
Pong?.Invoke(this, e);
}
static void Main()
{
Pong pong = new Pong();
Game g = new Game();
}
static void Main()
{
using (var game = new Pong())
game.Run();
}
private async Task ProcessMessageAsync <T>(
Blockchain <T> blockchain,
Message message,
CancellationToken cancellationToken)
where T : IAction
{
switch (message)
{
case Ping ping:
{
_logger.Debug($"Ping received.");
var reply = new Pong
{
Identity = ping.Identity,
};
await ReplyAsync(reply, cancellationToken);
break;
}
case Messages.PeerSetDelta peerSetDelta:
{
_deltas.Enqueue(peerSetDelta.Delta);
break;
}
case GetBlockHashes getBlockHashes:
{
IEnumerable <HashDigest <SHA256> > hashes =
blockchain.FindNextHashes(
getBlockHashes.Locator,
getBlockHashes.Stop,
500);
var reply = new BlockHashes(hashes)
{
Identity = getBlockHashes.Identity,
};
await ReplyAsync(reply, cancellationToken);
break;
}
case GetBlocks getBlocks:
{
await TransferBlocks(
blockchain, getBlocks, cancellationToken);
break;
}
case GetTxs getTxs:
{
await TransferTxs(
blockchain, getTxs, cancellationToken);
break;
}
case TxIds txIds:
{
await ProcessTxIds(
txIds, blockchain, cancellationToken);
break;
}
default:
Trace.Fail($"Can't handle message. [{message}]");
break;
}
}
public void isPing_NumDivBy5_Pong()
{
Pong testPingPong = new Pong();
Assert.AreEqual("Ping", testPingPong.GetPong(3));
}
public void Run()
{
Stopwatch timer = Stopwatch.StartNew();
const int actorCount = 20;
const int pingCount = 4000;
var actors = new ActorInstance[actorCount + 1];
var complete = new Future<int>();
var latch = new CountdownLatch(actorCount * pingCount, complete.Complete);
for (int i = actorCount; i >= 0; i--)
{
actors[i] = AnonymousActor.New(inbox =>
{
var pong = new Pong();
var server = actors[(i + 1)];
inbox.Loop(loop =>
{
loop.Receive<Request<Ping>>(request =>
{
request.Respond(pong);
loop.Continue();
});
});
if (i < actorCount)
{
var ping = new Ping();
int count = 0;
Action loop = null;
loop = () =>
{
server.Request(ping, inbox)
.Receive<Response<Pong>>(response =>
{
latch.CountDown();
count++;
if (count < pingCount)
loop();
});
};
loop();
}
});
}
bool completed = complete.WaitUntilCompleted(5.Minutes());
timer.Stop();
for (int i = 0; i < actorCount; i++)
{
actors[i].Exit();
actors[i] = null;
}
if (!completed)
{
Console.WriteLine("Process did not complete");
return;
}
Console.WriteLine("Processed {0} messages in with {1} actors in {2}ms", pingCount, actorCount, timer.ElapsedMilliseconds);
Console.WriteLine("That's {0} messages per second!", ((long)pingCount * actorCount * 2 * 1000) / timer.ElapsedMilliseconds);
}
private void ProcessMessageHandler(object target, Message message)
{
switch (message)
{
case Ping ping:
{
_logger.Debug($"Received a {nameof(Ping)} message.");
// This case can be dealt in Transport.
var pong = new Pong()
{
Identity = ping.Identity,
};
Transport.ReplyMessage(pong);
break;
}
case GetChainStatus getChainStatus:
{
_logger.Debug($"Received a {nameof(GetChainStatus)} message.");
// This is based on the assumption that genesis block always exists.
var chainStatus = new ChainStatus(
BlockChain.Genesis.Hash,
BlockChain.Tip.Index,
BlockChain.Tip.TotalDifficulty)
{
Identity = getChainStatus.Identity,
};
Transport.ReplyMessage(chainStatus);
break;
}
case FindNeighbors _:
_logger.Debug($"Received a {nameof(FindNeighbors)} message.");
break;
case GetBlockHashes getBlockHashes:
{
BlockChain.FindNextHashes(
getBlockHashes.Locator,
getBlockHashes.Stop,
FindNextHashesChunkSize
).Deconstruct(
out long?offset,
out IReadOnlyList <HashDigest <SHA256> > hashes
);
var reply = new BlockHashes(offset, hashes)
{
Identity = getBlockHashes.Identity,
};
Transport.ReplyMessage(reply);
break;
}
case GetRecentStates getRecentStates:
TransferRecentStates(getRecentStates);
break;
case GetBlocks getBlocks:
TransferBlocks(getBlocks);
break;
case GetTxs getTxs:
TransferTxs(getTxs);
break;
case TxIds txIds:
ProcessTxIds(txIds);
break;
case BlockHashes _:
_logger.Error($"{nameof(BlockHashes)} messages are only for IBD.");
break;
case BlockHeaderMessage blockHeader:
Task.Run(
async() => await ProcessBlockHeader(blockHeader, _cancellationToken),
_cancellationToken
);
break;
case GetBlockStates getBlockStates:
TransferBlockStates(getBlockStates);
break;
default:
throw new InvalidMessageException(
$"Failed to handle message: {message}",
message
);
}
}
static void Main()
{
Pong game = new Pong();
game.Run();
}
public override void Draw(float dt)
{
base.Draw(dt);
var g = Game.Inst.Graphics;
var fadeVal = Math.Min(0.5f * m_Time * m_Time, 1.0f);
Pong.PsChromaticAberration.SetConstants(0.85f * fadeVal);
Pong.PsBlend.SetConstants(fadeVal * fadeVal);
Pong.PsNoise.SetConstants(Pong.Rnd(1, 999));
g.BeginFrame();
if (m_Time < 3.0f)
{
g.RenderTarget = Pong.RenderTargets[0];
g.PixelShader = g.DefaultPixelShader;
g.PixelShader.SetTextures(Pong.TexSplash);
g.DrawTriMesh(Pong.TmUnitQuad, Matrix4x4.Identity());
g.ApplyPostFX(Pong.RenderTargets[0], Pong.PsChromaticAberration);
}
else
{
Pong.PsBlend.SetConstants(0.86f);
}
g.ApplyPostFX(Pong.RenderTargets[0], Pong.PsBlend);
g.ApplyPostFX(Pong.RenderTargets[0], Pong.PsSoft);
g.ApplyPostFX(g.ScreenRenderTarget, Pong.PsNoise);
g.EndFrame();
m_Time += dt;
if (m_Time > 3.5f)
{
Game.Inst.LeaveScene();
Game.Inst.EnterScene(new PlayingScene());
}
}
