/// <summary>
/// Sends the specified slice.
/// </summary>
/// <exception cref="System.ArgumentNullException">slice</exception>
/// <exception cref="System.InvalidOperationException">Socket as not been Assign():ed.</exception>
/// <seealso cref="StreamSocketWriterJob"/>
/// <seealso cref="SliceSocketWriterJob"/>
public void Send(ISocketWriterJob job)
{
if (job == null)
{
throw new ArgumentNullException("job");
}
if (_socket == null || !_socket.Connected)
{
throw new InvalidOperationException("Socket is not connected.");
}
lock (this)
{
if (_currentJob != null)
{
_logger.Debug(_writeArgs.GetHashCode() + ": Enqueueing ");
_writeQueue.Enqueue(job);
return;
}
_logger.Debug(_writeArgs.GetHashCode() + ": sending directly ");
_currentJob = job;
}
_currentJob.Write(_writeArgs);
var isPending = _socket.SendAsync(_writeArgs);
if (!isPending)
{
HandleWriteCompleted(_writeArgs.SocketError, _writeArgs.BytesTransferred);
}
}
/// <summary>
/// Releases a <see cref="SocketAsyncEventArgs"/> instance back into the pool, so that it can be reused.
/// </summary>
/// <param name="socketAsync">A <see cref="SocketAsyncEventArgs"/> to release back into the pool.</param>
public void Release(SocketAsyncEventArgs socketAsync)
{
Log.Debug(m => m("Releasing SocketAsyncEventArgs: {0} [{1}, {2}]", socketAsync.GetHashCode(), _count, _pool.Count));
_pool.Enqueue(socketAsync);
_autoResetEvent.Set();
}
private void AsyncCompleted(object sender, SocketAsyncEventArgs e)
{
EventWaitHandle handle = (EventWaitHandle)e.UserToken;
_log.WriteLine(
"AsyncCompleted: " + e.GetHashCode() + " SocketAsyncEventArgs with manual event " +
handle.GetHashCode() + " error: " + e.SocketError);
handle.Set();
}
private void Connected(object sender, SocketAsyncEventArgs e)
{
EventWaitHandle handle = (EventWaitHandle)e.UserToken;
_output.WriteLine(
"Connected: " + e.GetHashCode() + " SocketAsyncEventArgs with manual event " +
handle.GetHashCode() + " error: " + e.SocketError);
Error = e.SocketError;
handle.Set();
}
public Session(Socket socket, int socketBufferSize, Log logger)
{
sendSaea.AcceptSocket = socket;
sendSaea.Completed += IOCompleted;
sendSaea.SetBuffer(new byte[socketBufferSize], 0, socketBufferSize);
receiveSaea.AcceptSocket = socket;
receiveSaea.Completed += IOCompleted;
receiveSaea.SetBuffer(new byte[socketBufferSize], 0, socketBufferSize);
this.logger = logger;
logger?.Info($"Session.Session: receiveSaea={receiveSaea.GetHashCode()}, sendSaea={sendSaea.GetHashCode()}, socket={receiveSaea.AcceptSocket.GetHashCode()}");
}
private void Connected(object sender, SocketAsyncEventArgs e)
{
EventWaitHandle handle = (EventWaitHandle)e.UserToken;
_output.WriteLine(
"Connected: " + e.GetHashCode() + " SocketAsyncEventArgs with manual event " +
handle.GetHashCode() + " error: " + e.SocketError);
Error = e.SocketError;
if (Error != SocketError.Success)
{
Thread.Sleep(TestSettings.FailingTestTimeout); // Give the other end a chance to call Accept().
_serverSocket.Dispose(); // Cancels the test
}
handle.Set();
}
public void push(SocketAsyncEventArgs item)
{
if (item == null)
{
throw new ArgumentNullException("item이 null입니다.");
}
int hashInputItem = item.GetHashCode();
//해당 풀에서 생성된 객체인지 확인한다.
if (Array.Find <SocketAsyncEventArgs>(m_arrPool,
element => (element.GetHashCode() == hashInputItem)) != null)
{
m_stackServiceableObjectPool.Push(item);
}
else
{
throw new ArgumentException("해당 객체 풀에서 생성된 객체가 아닙니다.");
}
}
private void DualModeConnect_AcceptAsync_Helper(IPAddress listenOn, IPAddress connectTo)
{
using (Socket serverSocket = new Socket(SocketType.Stream, ProtocolType.Tcp))
{
int port = serverSocket.BindToAnonymousPort(listenOn);
serverSocket.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += AsyncCompleted;
ManualResetEvent waitHandle = new ManualResetEvent(false);
args.UserToken = waitHandle;
args.SocketError = SocketError.SocketError;
_log.WriteLine(args.GetHashCode() + " SocketAsyncEventArgs with manual event " + waitHandle.GetHashCode());
if (!serverSocket.AcceptAsync(args))
{
throw new SocketException((int)args.SocketError);
}
SocketClient client = new SocketClient(_log, serverSocket, connectTo, port);
var waitHandles = new WaitHandle[2];
waitHandles[0] = waitHandle;
waitHandles[1] = client.WaitHandle;
int completedHandle = WaitHandle.WaitAny(waitHandles, Configuration.PassingTestTimeout);
if (completedHandle == WaitHandle.WaitTimeout)
{
throw new TimeoutException("Timed out while waiting for either of client and server connections...");
}
if (completedHandle == 1) // Client finished
{
if (client.Error != SocketError.Success)
{
// Client SocketException
throw new SocketException((int)client.Error);
}
if (!waitHandle.WaitOne(5000)) // Now wait for the server.
{
throw new TimeoutException("Timed out while waiting for the server accept...");
}
}
_log.WriteLine(args.SocketError.ToString());
if (args.SocketError != SocketError.Success)
{
throw new SocketException((int)args.SocketError);
}
Socket clientSocket = args.AcceptSocket;
Assert.NotNull(clientSocket);
Assert.True(clientSocket.Connected);
AssertDualModeEnabled(clientSocket, listenOn);
Assert.Equal(AddressFamily.InterNetworkV6, clientSocket.AddressFamily);
if (connectTo == IPAddress.Loopback)
{
Assert.Contains(((IPEndPoint)clientSocket.LocalEndPoint).Address, ValidIPv6Loopbacks);
}
else
{
Assert.Equal(connectTo.MapToIPv6(), ((IPEndPoint)clientSocket.LocalEndPoint).Address);
}
clientSocket.Dispose();
}
}
private void AsyncCompleted(object sender, SocketAsyncEventArgs e)
{
EventWaitHandle handle = (EventWaitHandle)e.UserToken;
_log.WriteLine(
"AsyncCompleted: " + e.GetHashCode() + " SocketAsyncEventArgs with manual event " +
handle.GetHashCode() + " error: " + e.SocketError);
handle.Set();
}
private void Connected(object sender, SocketAsyncEventArgs e)
{
EventWaitHandle handle = (EventWaitHandle)e.UserToken;
_output.WriteLine(
"Connected: " + e.GetHashCode() + " SocketAsyncEventArgs with manual event " +
handle.GetHashCode() + " error: " + e.SocketError);
Error = e.SocketError;
if (Error != SocketError.Success)
{
Task.Delay(Configuration.FailingTestTimeout).Wait(); // Give the other end a chance to call Accept().
_serverSocket.Dispose(); // Cancels the test
}
handle.Set();
}
private void Accepted(object sender, SocketAsyncEventArgs e)
{
EventWaitHandle handle = (EventWaitHandle)e.UserToken;
_output.WriteLine(
"Accepted: " + e.GetHashCode() + " SocketAsyncEventArgs with manual event " +
handle.GetHashCode() + " error: " + e.SocketError);
_acceptedSocket = e.AcceptSocket;
handle.Set();
}
private void DualModeConnect_AcceptAsync_Helper(IPAddress listenOn, IPAddress connectTo)
{
using (Socket serverSocket = new Socket(SocketType.Stream, ProtocolType.Tcp))
{
int port = serverSocket.BindToAnonymousPort(listenOn);
serverSocket.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += AsyncCompleted;
ManualResetEvent waitHandle = new ManualResetEvent(false);
args.UserToken = waitHandle;
args.SocketError = SocketError.SocketError;
_log.WriteLine(args.GetHashCode() + " SocketAsyncEventArgs with manual event " + waitHandle.GetHashCode());
if (!serverSocket.AcceptAsync(args))
{
throw new SocketException((int)args.SocketError);
}
SocketClient client = new SocketClient(_log, serverSocket, connectTo, port);
var waitHandles = new WaitHandle[2];
waitHandles[0] = waitHandle;
waitHandles[1] = client.WaitHandle;
int completedHandle = WaitHandle.WaitAny(waitHandles, 5000);
if (completedHandle == WaitHandle.WaitTimeout)
{
throw new TimeoutException("Timed out while waiting for either of client and server connections...");
}
if (completedHandle == 1) // Client finished
{
if (client.Error != SocketError.Success)
{
// Client SocketException
throw new SocketException((int)client.Error);
}
if (!waitHandle.WaitOne(5000)) // Now wait for the server.
{
throw new TimeoutException("Timed out while waiting for the server accept...");
}
}
_log.WriteLine(args.SocketError.ToString());
if (args.SocketError != SocketError.Success)
{
throw new SocketException((int)args.SocketError);
}
Socket clientSocket = args.AcceptSocket;
Assert.NotNull(clientSocket);
Assert.True(clientSocket.Connected);
Assert.Equal(AddressFamily.InterNetworkV6, clientSocket.AddressFamily);
if (connectTo == IPAddress.Loopback)
{
Assert.Contains(((IPEndPoint)clientSocket.LocalEndPoint).Address, ValidIPv6Loopbacks);
}
else
{
Assert.Equal(connectTo.MapToIPv6(), ((IPEndPoint)clientSocket.LocalEndPoint).Address);
}
clientSocket.Dispose();
}
}
private void DualModeConnect_AcceptAsync_Helper(IPAddress listenOn, IPAddress connectTo)
{
using (Socket serverSocket = new Socket(SocketType.Stream, ProtocolType.Tcp))
{
int port = serverSocket.BindToAnonymousPort(listenOn);
serverSocket.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += AsyncCompleted;
ManualResetEvent waitHandle = new ManualResetEvent(false);
args.UserToken = waitHandle;
_log.WriteLine(args.GetHashCode() + " SocketAsyncEventArgs with manual event " + waitHandle.GetHashCode());
serverSocket.AcceptAsync(args);
SocketClient client = new SocketClient(serverSocket, connectTo, port);
Assert.True(waitHandle.WaitOne(Configuration.PassingTestTimeout), "Timed out while waiting for connection");
if (args.SocketError != SocketError.Success)
{
throw new SocketException((int)args.SocketError);
}
Socket clientSocket = args.AcceptSocket;
Assert.NotNull(clientSocket);
Assert.True(clientSocket.Connected);
Assert.True(clientSocket.DualMode);
Assert.Equal(AddressFamily.InterNetworkV6, clientSocket.AddressFamily);
Assert.Equal(connectTo.MapToIPv6(), ((IPEndPoint)clientSocket.LocalEndPoint).Address);
}
}
private void ConnectCallback(object sender, SocketAsyncEventArgs e)
{
session = new Session(e.ConnectSocket, socketBufferSize, logger);
logger?.Info($"Client.ConnectCallback: session={session.GetHashCode()}, e={e.GetHashCode()}, e.SocketError={e?.SocketError}");
session.ReceiveCallback += ReceiveCallback;
session.Start();
}
