static void Main(string[] args)
{
var socket = new SocketReceiver();
socket.Connect(Common.ip, Common.port);
Console.ReadLine();
}
public static void Main(string[] args)
{
SocketReceiver.StartListener();
while (MainWindow.Win.IsOpen)
{
MainWindow.Win.DispatchEvents();
MainWindow.Clear();
if (_state == State.MENU)
{
MenuController.Update();
}
else
{
GameController.Update();
}
if (KeysInfo.Pressed.Contains(Keyboard.Key.Escape))
{
MainWindow.Win.Close();
}
MainWindow.Win.Display();
}
}
public SocketConnection(EndPoint endpoint)
{
_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
_endpoint = endpoint;
_sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
_receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
Features.Set <IConnectionInherentKeepAliveFeature>(this);
}
public TcpConnection(EndPoint endPoint)
{
_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
_endPoint = endPoint;
_sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
_receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
// Add IConnectionInherentKeepAliveFeature to the tcp connection impl since Kestrel doesn't implement
// the IConnectionHeartbeatFeature
Features.Set <IConnectionInherentKeepAliveFeature>(this);
}
public async ValueTask OpenAsync(string host, string database, string userName, string password,
CancellationToken cancellationToken)
{
m_connectorState = ConnectorState.Connecting;
var socketTask = ConnectAsync(host);
var socket = socketTask.IsCompletedSuccessfully
? socketTask.Result
: await socketTask.ConfigureAwait(false);
var sendBufferBytes = m_arrayPool.Rent(512);
var receiveBufferBytes = m_arrayPool.Rent(512);
try
{
var sendBuffer = new Memory <byte>(sendBufferBytes);
var receiveBuffer = new Memory <byte>(sendBufferBytes);
var sender = new SocketSender(socket);
var sendStartupMessageTask =
SendStartupMessage(sender, sendBuffer, database, userName, cancellationToken);
if (!sendStartupMessageTask.IsCompletedSuccessfully)
{
await sendStartupMessageTask.ConfigureAwait(false);
}
var receiver = new SocketReceiver(socket);
var processStartupMessageResponseTask = ProcessStartupMessageResponse(sender, sendBuffer, receiver, receiveBuffer,
userName, password, cancellationToken);
if (!processStartupMessageResponseTask.IsCompletedSuccessfully)
{
await processStartupMessageResponseTask.ConfigureAwait(false);
}
m_connectorState = ConnectorState.ReadyForQuery;
m_connectionInfo = new ConnectionInfo();
m_connectionInfo.Host = host;
m_connectionInfo.Database = database;
m_connectionInfo.UserName = userName;
m_connectionInfo.Password = password;
m_socket = socket;
}
finally
{
m_arrayPool.Return(sendBufferBytes);
m_arrayPool.Return(receiveBufferBytes);
}
}
private async Task <TransportMessage> ReceiveMessageInServer()
{
if (_serverSocket == null)
{
_serverSocket = _listener.EndAcceptSocket(_serverListenResult);
}
var buffer = new byte[65535];
var args = new SocketAsyncEventArgs();
var awaitable = new SocketAwaitable(args);
var receiver = new SocketReceiver(_serverSocket, args, awaitable, buffer);
var protocol = new SimpleProtocolDecoder(new JsonTransportSerializer());
return(await protocol.Decode(receiver) as TransportMessage);
}
public Startup(IHostingEnvironment env)
{
//change to red shiled
SocketReceiver test = new SocketReceiver(new Socket(new SocketInformation()), new IOQueue());
test.WaitForDataAsync();
//////
var builder = new ConfigurationBuilder();
builder.SetBasePath(env.ContentRootPath)
.AddJsonFile("configuration.json", optional: false, reloadOnChange: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
}
/// <summary>
/// Starts Receive Thread
/// </summary>
private void ReceiveThreadStart()
{
lock (m_stateLock)
{
// Initiate Socket Receive Operations
if (m_comandReceiver == null)
{
m_comandReceiver = new SocketReceiver(this, m_commandSocket, "Command");
}
if (m_eventDataReceiver == null)
{
m_eventDataReceiver = new SocketReceiver(this, m_eventDataSocket, "Event");
}
}
}
public async Task T02_Disconnect_ReceiveBytesAsync()
{
var endPoint = new IPEndPoint(IPAddress.IPv6Loopback, 0);
ServerSocket.Bind(endPoint);
ServerSocket.Listen(10);
endPoint = (IPEndPoint)(ServerSocket.LocalEndPoint ?? throw new InvalidOperationException("EndPoint"));
Socket.Connect(endPoint);
var accepted = ServerSocket.Accept();
accepted.Disconnect(false);
var reader = new SocketReceiver(Socket, Logger, "?");
// after the remote socket disconnects, reader.ReceiveByteAsync() returns nothing
var any = await reader.ReceiveAllAsync(default).AnyAsync();
// Start is called before the first frame update
void Start()
{
frameRate = TMConfig.Current.defaultFrameRate;
// Application.targetFrameRate = frameRate;
receiver = new SocketReceiver(TMConfig.Current.port);
receiver.OnBytes += OnBytes;
receiveColor32Array = new Color32[texWidth * texHeight];
receiveColorArray = new Color[texWidth * texHeight];
receiveTex = new Texture2D(texWidth, texHeight, TextureFormat.RGB24, false, true);
receiveTex.filterMode = FilterMode.Point;
receiveMaterial.SetTexture("_MainTex", receiveTex);
harpaModel = GameObject.Find("HarpaModel");
}
private void StartListenerService()
{
try
{
SetStatus("Starting socket server ...");
_sr = new SocketReceiver();
SetStatus("Created socket receiver object ...");
_sr.OnRX += new SocketReceiver.DataRXHandler(OnServerRX);
_sr.OnStatusUpdate += new SocketReceiver.StatusUpdateHandler(OnStatusUpdate);
_sr.OnSocketException += new SocketReceiver.SocketExceptionHandler(OnListenSocketException);
_sr.CreateServer(_ipAddress, _port);
}
catch (Exception ex) //Due to Async op of socket entry will not be here, but just in case
{
SetStatus("Error encountered :" + ex.Message);
//Change button to start again as something as gone wrong
FlipStartStopText();
}
}
private void SendReceive(Socket client)
{
ISocketReceiver <string> _receiver = new SocketReceiver(_client, 1024, 128);
ISocketSender <string> _sender = new SocketSender(_client);
while (true)
{
if (client != null && !client.Connected)
{
break;
}
else if (client != null && client.Connected)
{
_sender.Send("", new ServerSenderAuthenticationLogic());
_receiver.Read(new ServerReceiverAuthenticationLogic());
}
Thread.Sleep(1000);
}
}
protected override void SendReceive()
{
ISocketSender sender = new SocketSender(_client);
ISocketReceiver receiver = new SocketReceiver(_client);
ILogic authen = new BaseSocketLogic(new SocketAuthenLogic(sender, receiver), _client);
ILogic biz = new BaseSocketLogic(new SocketBusinessLogic(sender, receiver), _client);
LogicFlowModel[] logics =
{
//new LogicFlowModel { Logic = authen, Seq = 3 },
new LogicFlowModel {
Logic = biz, Seq = 5
}
};
BaseLogicFlow logicMgr = new SocketLogicFlow(logics);
logicMgr.Execute();
}
internal SocketConnection(Socket socket,
MemoryPool <byte> memoryPool,
PipeScheduler transportScheduler,
ILogger logger,
SocketSenderPool socketSenderPool,
PipeOptions inputOptions,
PipeOptions outputOptions,
bool waitForData = true)
{
Debug.Assert(socket != null);
Debug.Assert(memoryPool != null);
Debug.Assert(logger != null);
_socket = socket;
MemoryPool = memoryPool;
_logger = logger;
_waitForData = waitForData;
_socketSenderPool = socketSenderPool;
LocalEndPoint = _socket.LocalEndPoint;
RemoteEndPoint = _socket.RemoteEndPoint;
ConnectionClosed = _connectionClosedTokenSource.Token;
// On *nix platforms, Sockets already dispatches to the ThreadPool.
// Yes, the IOQueues are still used for the PipeSchedulers. This is intentional.
// https://github.com/aspnet/KestrelHttpServer/issues/2573
var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline;
_receiver = new SocketReceiver(awaiterScheduler);
var pair = DuplexPipe.CreateConnectionPair(inputOptions, outputOptions);
// Set the transport and connection id
Transport = _originalTransport = pair.Transport;
Application = pair.Application;
InitializeFeatures();
}
private async ValueTask <bool> WaitForDisconnect(Socket socket, CancellationToken cancellationToken)
{
var receiveBufferBytes = m_arrayPool.Rent(1);
try
{
var socketReceiver = new SocketReceiver(socket);
var receiveCount = await socketReceiver.ReceiveAsync(receiveBufferBytes, cancellationToken).ConfigureAwait(false);
return(receiveCount <= 0);
}
catch (SocketException socketException) when(socketException.SocketErrorCode == SocketError.ConnectionReset)
{
return(true);
}
catch (SocketException)
{
return(false);
}
finally
{
m_arrayPool.Return(receiveBufferBytes);
}
}
/// <summary>
/// Starts Receive Thread
/// </summary>
private void ReceiveThreadStart()
{
lock (m_stateLock)
{
// Initiate Socket Receive Operations
if (m_comandReceiver == null)
{
m_comandReceiver = new SocketReceiver(this, m_commandSocket, "Command");
}
if (m_eventDataReceiver == null)
{
m_eventDataReceiver = new SocketReceiver(this, m_eventDataSocket, "Event");
}
}
}
