public void EngageWith(ISocket socket)
{
_socket = socket;
_notIoArgs.AcceptSocket = _socket.UnderlyingSocket;
_receiveArgs.AcceptSocket = _socket.UnderlyingSocket;
_sendArgs.AcceptSocket = _socket.UnderlyingSocket;
}
public Func<byte[], int, int, Action<Action<int>, Action<Exception>>> CreateReadBody(
ISocket socket,
ArraySegment<byte> bodyDataReadWithHeaders)
{
return (buffer, offset, count) =>
{
if (bodyDataReadWithHeaders.Count > 0)
{
int bytesRead;
bytesRead = Math.Min(bodyDataReadWithHeaders.Count, count);
Buffer.BlockCopy(bodyDataReadWithHeaders.Array, bodyDataReadWithHeaders.Offset, buffer, offset, bytesRead);
if (bytesRead < bodyDataReadWithHeaders.Count)
bodyDataReadWithHeaders =
new ArraySegment<byte>(
bodyDataReadWithHeaders.Array,
bodyDataReadWithHeaders.Offset + bytesRead,
bodyDataReadWithHeaders.Count - bytesRead);
else
bodyDataReadWithHeaders = default(ArraySegment<byte>);
return (r, e) => r(bytesRead);
}
else if (socket != null)
{
return socket.Read(buffer, offset, count);
}
else
{
return (r, e) => r(0);
}
};
}
public static void CloseSock(ISocket socket, int timeout = 0)
{
if (socket.GetSocket().ProtocolType == ProtocolType.Tcp) socket.GetSocket().Shutdown(SocketShutdown.Both);
if (timeout == 0) socket.Close();
else socket.Close(timeout);
}
public static Task<IEnumerable<KeyValuePair<string, string>>> GetHeaders(ISocket socket)
{
var headers = new MemoryStream ();
return Util.ReadExactly (socket, 10).ContinueWith (t =>
{
t.PropagateExceptions ();
byte[] lenBuffer = t.Result;
int pos = Array.IndexOf (lenBuffer, (byte)':');
var lenString = Encoding.UTF8.GetString (lenBuffer, 0, pos);
var len = int.Parse (lenString) + 1;
pos++;
var alreadyReadLen = lenBuffer.Length - pos;
headers.Write (lenBuffer, pos, alreadyReadLen);
return Util.ReadDataAsync (socket, headers, len - alreadyReadLen);
}).Unwrap ().ContinueWith (t2 =>
{
t2.PropagateExceptions ();
var rv = new List<KeyValuePair<string, string>> ();
var headerPairs = Encoding.UTF8.GetString (headers.ToArray ()).Split ((char)0);
for (var i = 0; i < headerPairs.Length - 1; i += 2)
rv.Add (new KeyValuePair<string, string> (headerPairs[i], headerPairs[i + 1]));
return Util.TaskFromResult ((IEnumerable<KeyValuePair<string, string>>)rv);
}).Unwrap ();
}
/// <summary>
/// Constructs a new KayakContext with the provided `ISocket`, `IKayakServerRequest`, and
/// `IKayakServerResponse` objects.
/// </summary>
public KayakContext(ISocket socket, IKayakServerRequest request, IKayakServerResponse response)
{
Socket = socket;
Request = request;
Response = response;
Items = new Dictionary<object, object>();
}
protected NodeBase(ICluster owner, IPEndPoint endpoint, IFailurePolicy failurePolicy, ISocket socket)
{
this.owner = owner;
this.endpoint = endpoint;
this.socket = socket;
this.failurePolicy = failurePolicy;
this.name = endpoint.ToString();
failLock = new Object();
writeQueue = new ConcurrentQueue<Data>();
readQueue = new Queue<Data>();
mustReconnect = true;
IsAlive = true;
counterEnqueuePerSec = Metrics.Meter("node write enqueue/sec", endpoint.ToString(), Interval.Seconds);
counterDequeuePerSec = Metrics.Meter("node write dequeue/sec", endpoint.ToString(), Interval.Seconds);
counterOpReadPerSec = Metrics.Meter("node op read/sec", endpoint.ToString(), Interval.Seconds);
counterWriteQueue = Metrics.Counter("write queue length", endpoint.ToString());
counterReadQueue = Metrics.Counter("read queue length", endpoint.ToString());
counterWritePerSec = Metrics.Meter("node write/sec", endpoint.ToString(), Interval.Seconds);
counterErrorPerSec = Metrics.Meter("node in error/sec", endpoint.ToString(), Interval.Seconds);
counterItemCount = Metrics.Counter("commands", endpoint.ToString());
gaugeSendSpeed = Metrics.Gauge("send speed", endpoint.ToString());
}
public static bool SC_LOGIN_RESULT_Handler(ISocket sock, byte[] buffer)
{
SC_LOGIN_RESULT_Packet packet = PacketHelper.ParsePacketStruct<SC_LOGIN_RESULT_Packet>(buffer);
Int16 readLen = PacketHelper.ParseBodyLen(buffer);
if (readLen < PacketHelper.Size(packet))
{
Console.WriteLine("read length is too small({0})", readLen);
return true; // socket close
}
if (packet.Result == 1)
{
Console.WriteLine("Login success");
Program.loginResult = 1;
Program.m_alldone.Set();
}
else if (packet.Result == 0)
{
Console.WriteLine("Login fail");
Program.loginResult = 0;
Program.m_alldone.Set();
}
else
{
Console.WriteLine("unknown result({0})", packet.Result);
return true;
}
return false;
}
public static KayakContext CreateContext(ISocket socket)
{
var request = new KayakServerRequest(socket);
var response = new KayakServerResponse(socket);
return new KayakContext(socket, request, response);
}
public ClacksClient(ISocket socket) {
if(socket == null) {
throw new ArgumentNullException("socket");
}
_socket = socket;
_receiver = new ResponseReceiver(_socket);
}
private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug("Client Connected");
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b)));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(_x509Certificate,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
protected virtual void InitSocket() {
if(_socket != null && !_socket.IsDisposed) {
return;
}
_socket = _pool.GetSocket();
_receiver = new ResponseReceiver(_socket);
}
public SocketSender(IFireflyService service, ISocket socket)
{
_service = service;
_socket = socket;
_state = State.Immediate;
_socketEvent = _service.Memory.AllocSocketEvent();
}
public IEnumerable<object> BeginRequestInternal(ISocket socket)
{
var bufferHeaders = new ContinuationState<LinkedList<ArraySegment<byte>>>(socket.BufferHeaders());
yield return bufferHeaders;
var headerBuffers = bufferHeaders.Result;
Dictionary<string, object> env = new Dictionary<string, object>();
var bodyDataReadWithHeaders = headerBuffers.Last.Value;
headerBuffers.RemoveLast();
var headersString = headerBuffers.GetString();
var reader = new StringReader(headersString);
var requestLine = reader.ReadRequestLine();
var headers = reader.ReadHeaders();
env["Owin.RequestMethod"] = requestLine.Verb;
env["Owin.RequestUri"] = requestLine.RequestUri;
env["Owin.RequestHeaders"] = headers;
env["Owin.BaseUri"] = "";
env["Owin.RemoteEndPoint"] = socket.RemoteEndPoint;
env["Owin.RequestBody"] = CreateReadBody(socket, bodyDataReadWithHeaders);
// TODO provide better values
env["Owin.ServerName"] = "";
env["Owin.ServerPort"] = 0;
env["Owin.UriScheme"] = "http";
yield return env;
}
public RpcClient(ISocket socket)
{
if(socket == null) {
throw new ArgumentNullException("socket");
}
_socket = socket;
}
public StreamProxy(ISocket inStream, ISocket outStream, int bufferSize = 16384)
{
Logger.Debug("Setting up Stream Proxy from " + inStream.GetType() + " to " + outStream.GetType() + "(bufsize=" + bufferSize + ")");
_inStream = inStream;
_outStream = outStream;
_bufferSize = bufferSize;
}
public Connection(IServerTrace trace, AppDelegate app, ISocket socket, Action<ISocket> disconnected)
{
_trace = trace;
_app = app;
_socket = socket;
_disconnected = disconnected;
}
public Receiver(ISocket socket, Action<string> messageAction, Action closeAction)
{
_socket = socket;
_messageAction = messageAction;
_closeAction = closeAction;
_queue = new Queue<byte>();
}
public void EngageWith(ISocket socket)
{
Interlocked.Exchange(ref _flushingInProgress, 0);
Interlocked.Exchange(ref _writingOffset, 0);
Interlocked.Exchange(ref _socketException, null);
_asyncSocket.EngageWith(socket);
}
private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
public NodeType SendReceiveAndVerify(ISocket socket, TimeSpan timeout)
{
var greetingMessageNegotiator = NodeGreetingMessageNegotiatorFactory.CreateFromSocket(socket);
var tcpSocket = socket as TcpSocket;
var sendReceiveTimeout = new Tuple<int, int>(0, 0);
if (tcpSocket != null)
{
sendReceiveTimeout = new Tuple<int, int>(tcpSocket.TcpClient.SendTimeout,
tcpSocket.TcpClient.ReceiveTimeout);
tcpSocket.TcpClient.SendTimeout = timeout.ToMillisOrZero();
tcpSocket.TcpClient.ReceiveTimeout = timeout.ToMillisOrZero();
}
try
{
greetingMessageNegotiator.WriteGreeting(_greetingMessage);
var readGreeting = greetingMessageNegotiator.VerifyRemoteGreeting(_expectedRemoteNodeTypes);
return readGreeting.NodeType;
}
catch (IOException)
{
throw new TimeoutException("Timeout occurred negotiating after connection had been established");
}
finally
{
if (tcpSocket != null)
{
tcpSocket.TcpClient.SendTimeout = sendReceiveTimeout.Item1;
tcpSocket.TcpClient.ReceiveTimeout = sendReceiveTimeout.Item2;
}
}
}
public HttpServerTransactionDelegateWrapper(IHttpServerTransactionDelegate realDelegate,
IConnectionWatcher connectionWatcher,
ISocket socket)
{
_realDelegate = realDelegate;
_connectionWatcher = connectionWatcher;
_socket = socket;
}
/// <summary>
/// Constructs a `KayakServerResponse` that will write to the given `ISocket`.
/// </summary>
public KayakServerResponse(ISocket socket)
{
this.socket = socket;
statusCode = 200;
reasonPhrase = "OK";
httpVersion = "HTTP/1.0";
headers = new Dictionary<string,string>();
}
public IrcClient(IMessageParser parser, IResponseValidator responseValidator, ISocket socket, bool isConnected, bool connecting)
{
this.parser = parser;
this.responseValidator = responseValidator;
this.socket = socket;
IsConnected = isConnected;
this.connecting = connecting;
}
internal override void Bind(ISocket appServer)
{
if (Handshake != null)
{
Handshake.Handler = this;
}
base.Bind(appServer);
}
public void Dispose()
{
if (_socket != null)
{
_socket.Dispose();
_socket = null;
}
}
public UdpSession(ISocket host, IPEndPoint remoteEP)
{
Host = host;
RemoteEndPoint = remoteEP;
var socket = host.Socket;
_Connected = socket.Connected;
}
public Connection(IFireflyService services, AppDelegate app, ISocket socket, Action<ISocket> disconnected)
{
_services = services;
_app = app;
_socket = socket;
_socketSender = new SocketSender(_services, _socket);
_disconnected = disconnected;
}
public ISocketDelegate OnConnection(IServer server, ISocket socket)
{
var txDel = new HttpServerTransactionDelegate(socket.RemoteEndPoint.Address, responseFactory, requestDelegate);
var delWrapper = new HttpServerTransactionDelegateWrapper(txDel, connWatcher, socket);
var socketDelegate = new IosHttpServerSocketDelegate(delWrapper);
socketDelegate.Start(socket);
return socketDelegate;
}
public ISocketDelegate OnConnection(IServer server, ISocket socket)
{
// XXX freelist
var txDel = new HttpServerTransactionDelegate(responseFactory, requestDelegate);
var socketDelegate = new HttpServerSocketDelegate(txDel);
socketDelegate.Start(socket);
return socketDelegate;
}
public bool Provide(ISocket socket) {
if(!_waiting) {
return false;
}
_socket = socket;
_handle.Set();
return true;
}
public void Connect(RedFoxEndpoint endpoint, ISocketConfiguration socketConfiguration)
{
if (socketConfiguration == null)
{
throw new ArgumentNullException("socketConfiguration");
}
if (_socket != null)
{
throw new InvalidOperationException("Subscriber already connected");
}
_cts = new CancellationTokenSource();
_socket = SocketFactory.CreateAndConnectAsync(endpoint, NodeType.ServiceQueueReader, socketConfiguration);
_socket.Disconnected += SocketDisconnected;
NodeGreetingMessageVerifier.SendReceiveAndVerify(_socket, socketConfiguration.ConnectTimeout);
if (!_cts.IsCancellationRequested)
{
_messageReceiveLoop = new MessageReceiveLoop(_messageSerialization, _socket, OnMessageReceived, MessageReceiveLoopOnException);
_messageReceiveLoop.Start();
}
}
public INodeGreetingMessageNegotiator CreateFromSocket(ISocket socket)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
var streamSocket = socket as IStreamSocket;
if (streamSocket != null)
{
return(new NodeGreetingMessageStreamSocketNegotiator(streamSocket));
}
var queueSocket = socket as IQueueSocket;
if (queueSocket != null)
{
return(new NodeGreetingMessageQueueSocketNegotiator(queueSocket));
}
throw new NotSupportedException(String.Format("{0} does not know ISocket of type {1}", GetType().Name, socket.GetType().Name));
}
public IMessageFrameWriter CreateWriterFromSocket(ISocket socket)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
var streamSocket = socket as IStreamSocket;
if (streamSocket != null)
{
return(new MessageFrameStreamWriter(streamSocket));
}
var queueSocket = socket as IQueueSocket;
if (queueSocket != null)
{
return(new MessageFrameQueueWriter(queueSocket));
}
throw new NotSupportedException(String.Format("{0} does not know ISocket of type {1}", GetType().Name, socket.GetType().Name));
}
public void OnConnectionRequestedTest()
{
ipv4Protocol.Listen();
ManualResetEventSlim mevent = new ManualResetEventSlim(false);
mevent.Reset();
bool eventInvoked = false;
ipv4Protocol.OnConnectionRequested += (socket) =>
{
eventInvoked = true;
mevent.Set();
};
UdpProtocol ipvClient = this.CreateIPV4ClientProtocol(clientAddress);
ISocket clientSocket = ipvClient.Connect(serverAddress, PORT);
sockets.Add(clientSocket);
clientSocket.Send(TestData.GetDummyStream().ToArray());
mevent.Wait(1000);
Assert.IsTrue(clientSocket.Connected, "A socket connection was not established.");
Assert.IsTrue(eventInvoked, "On Connection Requested event was not invoked");
}
private void ListenLoop(object unused)
{
while (this._isListening)
{
if (!Netplay.disconnect)
{
try
{
ISocket client = (ISocket) new TcpSocket(this._listener.AcceptTcpClient());
Console.WriteLine(Language.GetTextValue("Net.ClientConnecting", (object)client.GetRemoteAddress()));
this._listenerCallback(client);
}
catch (Exception ex)
{
}
}
else
{
break;
}
}
this._listener.Stop();
}
// Just pass back the response
private void HandleBodyState(ReceiveContext context, ISocket socket, ISocketAsyncEventArgs saea)
{
int rec = Math.Min(saea.Buffer.Length, context.RemainingExpected);
context.Response.Write(saea.Buffer, 0, rec);
context.RemainingExpected -= rec;
if (context.RemainingExpected == 0)
{
context.Response.Position = 0;
OnResponse(context.CorrelationId, context.Response);
CleanReceive(false);
StartReceive();
}
else
{
saea.SetBuffer(0, Math.Min(context.Buffer.Length, context.RemainingExpected));
if (!socket.ReceiveAsync(saea))
{
OnReceiveCompleted(socket, saea);
}
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
public void TestReqRep()
{
int port1 = 55677;
AutoResetEvent eventRaised = new AutoResetEvent(false);
using (var poller = new PollerAdapter())
{
ISocket rep = poller.AddSocket(SocketType.Response, $"tcp://127.0.0.1:{port1}", true, "TestServer");
ISocket req = poller.AddSocket(SocketType.Request, $"tcp://127.0.0.1:{port1}", false, "TestClient");
byte[][] Response = { Encoding.UTF8.GetBytes("Topic A"), Encoding.UTF8.GetBytes("Message Conetxt") };
byte[][] Request = { Encoding.UTF8.GetBytes("Topic A"), Encoding.UTF8.GetBytes("Message Request") };
req.Received += (s, e) =>
{
List <string> receiveData = ReqReceive(e.Item);
for (int i = 0; i < receiveData.Count; i++)
{
Assert.AreEqual(Encoding.UTF8.GetString(Response[i]), receiveData[i]);
}
eventRaised.Set();
};
rep.Received += (s, e) =>
{
List <string> receiveData = ReqReceive(e.Item);
for (int i = 0; i < receiveData.Count; i++)
{
Assert.AreEqual(Encoding.UTF8.GetString(Request[i]), receiveData[i]);
}
rep.SendData(Response);
};
poller.Start();
Thread.Sleep(1000);
req.SendData(Request);
Assert.IsTrue(eventRaised.WaitOne(2000), "No Receive any event");
poller.StopAll();
}
}
public void SetUp()
{
ep = new IPEndPoint(IPAddress.Loopback, Config.Port);
wh = new ManualResetEventSlim();
var schedulerDelegate = new SchedulerDelegate();
scheduler = new DefaultKayakScheduler(schedulerDelegate);
schedulerDelegate.OnStoppedAction = () =>
{
stopListening.Dispose();
stopListening = null;
wh.Set();
};
schedulerDelegate.OnExceptionAction = e =>
{
schedulerError = e;
Debug.WriteLine("Error on scheduler");
e.DebugStackTrace();
scheduler.Stop();
};
scheduler.Post(() =>
{
stopListening = server.Listen(ep);
schedulerStartedAction();
});
var serverDelegate = new ServerDelegate();
server = new DefaultKayakServer(serverDelegate, scheduler);
clientSocketDelegate = new SocketDelegate();
client = new DefaultKayakSocket(clientSocketDelegate, scheduler);
}
private async Task CopyTo(ISocket udpClient, string file, TaskCompletionSource <bool> openTaskCompletionSource, CancellationToken cancellationToken)
{
var bufferSize = 81920;
byte[] buffer = new byte[bufferSize];
int read;
var resolved = false;
using (var source = _socketFactory.CreateNetworkStream(udpClient, false))
{
using (var fileStream = FileSystem.GetFileStream(file, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, FileOpenOptions.None))
{
var currentCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, new CancellationTokenSource(TimeSpan.FromSeconds(30)).Token).Token;
while ((read = await source.ReadAsync(buffer, 0, buffer.Length, currentCancellationToken).ConfigureAwait(false)) != 0)
{
cancellationToken.ThrowIfCancellationRequested();
currentCancellationToken = cancellationToken;
read -= RtpHeaderBytes;
if (read > 0)
{
fileStream.Write(buffer, RtpHeaderBytes, read);
}
if (!resolved)
{
resolved = true;
DateOpened = DateTime.UtcNow;
Resolve(openTaskCompletionSource);
}
}
}
}
}
// Async send loop body
private static void OnSendCompleted(ISocket sender, ISocketAsyncEventArgs saea)
{
var connection = saea.UserToken as Connection;
if (connection == null)
{
// It should not happen but it makes Sonar happy
CleanAsyncArgs(saea);
return;
}
if (saea.SocketError != SocketError.Success)
{
connection.FaultSend(new TransportException(TransportError.WriteError,
new SocketException((int)saea.SocketError)));
return;
}
// Async loop
if (saea.BytesTransferred != saea.Count)
{
connection.LoopSend(saea.Offset + saea.BytesTransferred, saea.Count - saea.BytesTransferred);
}
else
{
int read = connection._sendContext.Data.Read(connection._sendContext.Buffer, 0,
connection._sendContext.Buffer.Length);
if (read != 0)
{
connection.LoopSend(0, read);
}
else
{
connection.CompleteSend();
}
}
}
// Start is called before the first frame update
async void Start()
{
// Access the gameSceneController
gameSceneController = FindObjectOfType <GameSceneController>();
// Create the client
var client = new Client("http", gameHost, gamePort, gameKey);
const string email = "*****@*****.**";
const string password = "******";
var session = await client.AuthenticateEmailAsync(email, password);
Debug.Log(session);
socket = client.NewSocket();
socket.Connected += () => Debug.Log("Socket connected.");
socket.Closed += () => Debug.Log("Socket closed");
socket.ReceivedChannelMessage += async matched =>
{
Debug.LogFormat("Match: {0}", matched);
};
await socket.ConnectAsync(session);
await socket.AddMatchmakerAsync("*", 2, 2);
var channel = await socket.JoinChatAsync(RoomName, ChannelType.Room);
Debug.LogFormat("Join chat channel: {0}", channel);
var content = new Dictionary <string, string> {
{ "hello", "world" }
}.ToJson();
_ = socket.WriteChatMessageAsync(channel, content);
}
public void WhenIacDontSgaByteStreamShouldReturnEmptyAndNotReply()
#endif
{
ISocket socket = A.Fake <ISocket>();
using (INetworkStream networkStream = A.Fake <INetworkStream>())
{
A.CallTo(() => socket.GetStream()).Returns(networkStream);
A.CallTo(() => socket.Connected).Returns(true);
bool isFirst = true;
A.CallTo(() => socket.Available).ReturnsLazily(() =>
{
if (isFirst)
{
isFirst = false;
return(1);
}
return(0);
});
using (TcpByteStream tcpByteStream = new TcpByteStream(socket))
{
A.CallTo(() => networkStream.ReadByte()).ReturnsNextFromSequence(new int[] { (int)Commands.InterpretAsCommand, (int)Commands.Dont, (int)Options.SuppressGoAhead });
tcpByteStream.Connected.Should().BeTrue();
using (ByteStreamHandler sut = new ByteStreamHandler(tcpByteStream, new CancellationTokenSource()))
{
#if ASYNC
string response = await sut.ReadAsync(TimeSpan.FromMilliseconds(10));
#else
string response = sut.Read(TimeSpan.FromMilliseconds(10));
#endif
response.Should().BeEmpty();
A.CallTo(() => networkStream.WriteByte(A <byte> .Ignored)).MustNotHaveHappened();
}
}
}
}
private void CloseSocket(AsyncContinuation continuation)
{
try
{
var sock = _socket;
_socket = null;
if (sock != null)
{
sock.Close();
}
continuation(null);
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
continuation(exception);
}
}
private void SocketOnDataReceived(object sender, SocketReceivedDataEventArgs args)
{
if (_activeRequest == null)
{
return;
}
ISocket socket = (ISocket)sender;
if (_activeRequest.OnResponseReceived(args))
{
_lastResponse = _activeRequest.Response;
_activeRequest = null;
// If this was an async send, we saved a ref to the socket. Clean that up now.
if (_socket != null && _socket == socket)
{
_socket.SocketClosed -= SocketOnSocketClosed;
_socket.DataReceived -= SocketOnDataReceived;
_socket.Dispose();
_socket = null;
}
_requestCompletedEvent.Set();
}
}
private Task StartStreaming(ISocket udpClient, HdHomerunManager hdHomerunManager, IpAddressInfo remoteAddress, IpAddressInfo localAddress, int localPort, TaskCompletionSource <bool> openTaskCompletionSource, CancellationToken cancellationToken)
{
return(Task.Run(async() =>
{
using (udpClient)
{
using (hdHomerunManager)
{
try
{
await CopyTo(udpClient, TempFilePath, openTaskCompletionSource, cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException ex)
{
Logger.Info("HDHR UDP stream cancelled or timed out from {0}", remoteAddress);
openTaskCompletionSource.TrySetException(ex);
}
catch (Exception ex)
{
Logger.ErrorException("Error opening live stream:", ex);
openTaskCompletionSource.TrySetException(ex);
}
try
{
await hdHomerunManager.StopStreaming().ConfigureAwait(false);
}
catch
{
}
}
}
await DeleteTempFile(TempFilePath).ConfigureAwait(false);
}));
}
// Extract size and correlation Id, then start receive body loop.
private void HandleHeaderState(ReceiveContext context, ISocket socket, ISocketAsyncEventArgs saea)
{
int responseSize = BigEndianConverter.ToInt32(saea.Buffer);
int correlationId = BigEndianConverter.ToInt32(saea.Buffer, SizeLength);
// TODO check absurd response size?
int matching;
if (!_correlationIds.TryDequeue(out matching) || matching != correlationId)
{
throw new CorrelationException(matching, correlationId);
}
context.State = ReceiveState.Body;
context.CorrelationId = correlationId;
// responseSize includes 4 bytes of correlation id
context.RemainingExpected = responseSize - CorrelationIdLength;
context.Response = _responsePool.Reserve();
saea.SetBuffer(0, Math.Min(context.Buffer.Length, context.RemainingExpected));
if (!socket.ReceiveAsync(saea))
{
OnReceiveCompleted(socket, saea);
}
}
// Note: This is called from the read thread without sync context
public void ReceiveMessageBuffer(ISocket readingSocket, EndPoint messageSender, BMSByte buffer)
{
IMessageConstructor constructor = MessageBufferInterpreter.ReconstructPacketPage(buffer, messageSender);
if (constructor.MessageReconstructed)
{
try
{
var m = (IMessage)ForgeMessageCodes.Instantiate(constructor.MessageBuffer.GetBasicType <int>());
ProcessMessageSignature(readingSocket, messageSender, constructor.MessageBuffer, m);
if (m.Receipt != null)
{
if (_storedMessages.Exists(m.Receipt))
{
return;
}
_storedMessages.AddMessage(m, messageSender, _networkMediator.PlayerTimeout);
}
m.Deserialize(constructor.MessageBuffer);
var interpreter = m.Interpreter;
if (interpreter != null)
{
_synchronizationContext.Post(InterpretWithinContext, new SocketContainerSynchronizationReadData
{
Interpreter = interpreter,
Sender = messageSender,
Message = m
});
}
}
catch (MessageCodeNotFoundException) { }
MessageBufferInterpreter.Release(constructor);
}
}
public void GetterSetterTest()
{
CameraSocket testCameraSocket = new CameraSocket();
#region socket
Assert.IsNull(testCameraSocket.DataSocket);
WSocket testSocket = new WSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
testCameraSocket.DataSocket = testSocket;
Assert.IsTrue(testCameraSocket.DataSocket != null);
Assert.IsTrue(testCameraSocket.DataSocket.Equals(testSocket));
ISocket testSocketget = testCameraSocket.DataSocket;
Assert.IsTrue(testSocket.Equals(testSocketget));
#endregion
#region config
CameraConfiguration camConfigTest = new CameraConfiguration
{
Id = 233,
CamFileIdentity = "superTest string"
};
Assert.IsNull(testCameraSocket.Config);
testCameraSocket.Config = camConfigTest;
Assert.IsTrue(testCameraSocket.Config.Id == 233);
Assert.IsTrue(testCameraSocket.Config.CamFileIdentity == "superTest string");
#endregion
}
/// <summary>
/// Gets directoryinfo item count and total size
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="brickDirectoryPath">relative path to folder on brick</param>
/// <returns>DirectoryInfo</returns>
/// <exception cref="ArgumentException"/>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="FirmwareException"/>
public static async Task <DirectoryInfo> GetDirectoryInfo(ISocket socket, string brickDirectoryPath)
{
brickDirectoryPath = FileSystem.ToBrickDirectoryPath(brickDirectoryPath);
brickDirectoryPath.IsBrickDirectoryPath();
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, 8, 0))
{
cb.OpCode(OP.opFILENAME);
cb.Raw((byte)FILENAME_SUBCODE.TOTALSIZE);
cb.PARS(brickDirectoryPath);
cb.GlobalIndex(0);
cb.GlobalIndex(4);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
byte[] data = response.PayLoad;
int items = BitConverter.ToInt32(data, 0);
int size = BitConverter.ToInt32(data, 4);
return(new DirectoryInfo(items, size));
}
private bool SelectReceiverAndSend(Message message, ISocket scaleOutBackend, ExternalRouteLookupRequest lookupRequest)
{
var handled = false;
if (message.Distribution == DistributionPattern.Broadcast)
{
handled = SendMessageLocally(internalRoutingTable.FindRoutes(lookupRequest), message);
handled = MessageCameFromLocalActor(message) &&
SendMessageAway(externalRoutingTable.FindRoutes(lookupRequest), message, scaleOutBackend) ||
handled;
}
else
{
var localDestinations = internalRoutingTable.FindRoutes(lookupRequest);
var remoteDestinations = externalRoutingTable.FindRoutes(lookupRequest);
var local = localDestinations.FirstOrDefault()?.As <IDestination>();
var remote = remoteDestinations.FirstOrDefault()?.Node.As <IDestination>();
var destination = (local != null && remote != null)
? roundRobinDestinationList.SelectNextDestination(local, remote)
: (local ?? remote);
if (destination != null)
{
if (MessageCameFromOtherNode(message) || destination.Equals(local))
{
handled = SendMessageLocally(localDestinations, message);
}
if (!handled)
{
handled = SendMessageAway(remoteDestinations, message, scaleOutBackend);
}
}
}
return(handled);
}
public static Tuple <int, EndPoint> ReceiveMessage(ISocket socket, Buffer buffer, SocketCommunicationTypes type = SocketCommunicationTypes.Blocking, MessageThreadCallback callback = null)
{
if (type == SocketCommunicationTypes.Blocking)
{
switch (socket.GetSocket().ProtocolType)
{
case ProtocolType.Tcp:
return(Tuple.Create(socket.GetSocket().Receive(Buffer.GetBufferRef(buffer)), socket.GetSocket().RemoteEndPoint));
case ProtocolType.Udp:
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
return(Tuple.Create(socket.GetSocket().ReceiveFrom(Buffer.GetBufferRef(buffer), ref remoteEndPoint), remoteEndPoint));
default:
throw new ConstraintException("Socket must be of type TCP or UDP.");
}
}
if (callback == null)
{
throw new ArgumentNullException(string.Format("{0}=null; You must provide a valid callback when using the NonBlocking type", "callback"));
}
new Thread(() => MessageReceiveThread(socket, buffer, callback)).Start();
return(Tuple.Create(-1, new IPEndPoint(-1, -1) as EndPoint)); //Return negative 1 as 0 bytes received is valid and we want an invalid value
}
private bool ReceiveResponseFromClient(ISocket client, Buffer recvBuffer)
{
var serverExitFlag = false;
do
{
var(item1, _) = AweSock.ReceiveMessage(client, recvBuffer);
if (item1 > 0)
{
if (!ValidateResponse(recvBuffer))
{
return(false);
}
serverExitFlag = true;
}
else if (item1 == 0)
{
return(false);
}
//Thread.Sleep(1000);
} while (!serverExitFlag);
return(true);
}
private void OnClientConnect(ISocket clientSocket)
{
this.ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(clientSocket, this.scheme);
connection.MessageReceived += new EventHandler <TextMessageHandledEventArgs>(this.ConnectionMessageReceivedEventHandler);
connection.BinaryMessageReceived += new EventHandler <BinaryMessageHandledEventArgs>(this.ConnectionBinaryMessageReceivedEventHandler);
connection.Opened += new EventHandler <ConnectionEventArgs>(this.ConnectionOpenedEventHandler);
connection.Closed += new EventHandler <ConnectionEventArgs>(this.ConnectionClosedEventHandler);
connection.ErrorReceived += new EventHandler <ErrorEventArgs>(this.ConnectionErrorEventHandler);
connection.StandardHttpRequestReceived += new EventHandler <StandardHttpRequestReceivedEventArgs>(this.ConnectionStandardHttpRequestReceivedEventHandler);
if (this.IsSecure)
{
clientSocket.Authenticated += new EventHandler(this.SocketAuthenticatedEventHandler);
clientSocket.Authenticate(this.authenticationX509Certificate);
}
else
{
connection.StartReceiving();
}
}
public static void Shutdown(this ISocket socket)
{
var handle = (uint)socket.Handle;
try
{
socket.Shutdown(SocketShutdown.Both);
}
catch
{
}
try
{
socket.Close();
}
catch
{
}
closesocket(handle);
socket.Dispose();
}
/// <summary>
/// Gets any warnings <see cref="Warning"/>
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <returns></returns>
public static async Task <IEnumerable <Warning> > GetWarnings(ISocket socket)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, 1, 0))
{
GetWarning_BatchCommand(cb, 0);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
byte bitField = response.PayLoad[0];
if (bitField == 0)
{
return new List <Warning> {
Warning.None
}
}
;
Warning warning = (Warning)bitField;
return(warning.GetFlags());
}
private bool ReceiveResponseFromClient(ISocket client, Buffer recvBuffer)
{
bool SERVER_EXIT_FLAG = false;
do
{
var bytesReceived = AweSock.ReceiveMessage(client, recvBuffer);
if (bytesReceived.Item1 > 0)
{
if (!ValidateResponse(recvBuffer))
{
return(false);
}
SERVER_EXIT_FLAG = true;
}
else if (bytesReceived.Item1 == 0)
{
return(false);
}
//Thread.Sleep(1000);
} while (!SERVER_EXIT_FLAG);
return(true);
}
public async Task <int> Login(string email, string password)
{
try
{
_session = await _client.AuthenticateEmailAsync(email, password, null, false);
}
catch (ApiResponseException e)
{
switch (e.Message)
{
case "Invalid email address format.":
return(401);
case "User account not found.":
return(402);
case "Invalid credentials.":
return(403);
default:
return(404);
}
}
_context.ReplaceCurrentPlayerId(_session.UserId);
// create socket
_socket = _client.CreateWebSocket();
await _socket.ConnectAsync(_session);
// set socket event
_socket.OnMatchmakerMatched += OnMatchmakerMatched;
_socket.OnMatchState += OnMatchState;
_socket.OnNotification += OnNotification;
return(400);
}
// GetSockOpt(u32 socket, u32 level, u32 option_name) -> (i32 ret, u32 bsd_errno, u32, buffer<unknown, 0x22, 0>)
public ResultCode GetSockOpt(ServiceCtx context)
{
int socketFd = context.RequestData.ReadInt32();
SocketOptionLevel level = (SocketOptionLevel)context.RequestData.ReadInt32();
BsdSocketOption option = (BsdSocketOption)context.RequestData.ReadInt32();
(ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x22();
WritableRegion optionValue = context.Memory.GetWritableRegion(bufferPosition, (int)bufferSize);
LinuxError errno = LinuxError.EBADF;
ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
errno = socket.GetSocketOption(option, level, optionValue.Memory.Span);
if (errno == LinuxError.SUCCESS)
{
optionValue.Dispose();
}
}
return(WriteBsdResult(context, 0, errno));
}
public NodeType SendReceiveAndVerify(ISocket socket, TimeSpan timeout)
{
var greetingMessageNegotiator = NodeGreetingMessageNegotiatorFactory.CreateFromSocket(socket);
var tcpSocket = socket as TcpSocket;
var sendReceiveTimeout = new Tuple <int, int>(0, 0);
if (tcpSocket != null)
{
sendReceiveTimeout = new Tuple <int, int>(tcpSocket.TcpClient.SendTimeout,
tcpSocket.TcpClient.ReceiveTimeout);
tcpSocket.TcpClient.SendTimeout = timeout.ToMillisOrZero();
tcpSocket.TcpClient.ReceiveTimeout = timeout.ToMillisOrZero();
}
try
{
greetingMessageNegotiator.WriteGreeting(_greetingMessage);
var readGreeting = greetingMessageNegotiator.VerifyRemoteGreeting(_expectedRemoteNodeTypes);
return(readGreeting.NodeType);
}
catch (IOException)
{
throw new TimeoutException("Timeout occurred negotiating after connection had been established");
}
finally
{
if (tcpSocket != null)
{
tcpSocket.TcpClient.SendTimeout = sendReceiveTimeout.Item1;
tcpSocket.TcpClient.ReceiveTimeout = sendReceiveTimeout.Item2;
}
}
}
