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; } } }