Session

🌞 낚시대를 여러개를 두자

• Listener 클래스의 Init

    class Listener
    {
        Socket _listenerSocket;
        Action<Socket> _onAcceptHandler;
        public void Init(IPEndPoint endPoint, Action<Socket> onAcceptHandler)
        { 
            //문지기
            _listenerSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            _onAcceptHandler += onAcceptHandler;

            //문지기 교육
            _listenerSocket.Bind(endPoint);

            //영업시작
            //backlog : 최대 대기수
            _listenerSocket.Listen(10);

            for(int i = 0; i<10;i++)
            {
                SocketAsyncEventArgs args = new SocketAsyncEventArgs();
                args.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
                RegisterAccept(args);
            }
        }

SocketAsyncEventArgs를 여러개 만들어 주고, RegisterAccept를 여러번 실행한다.

---

🌞 비동기는 어떻게 일어났는가?

• 현재 프로그램은 Main에서 빈 while문을 무한정 도는 작업을 하고 있다. 그런데 어떻게 Connect가 발생 했을 때, OnAcceptCompleted를 실행 할 수 있는 것인가?

작업자 스레드의 생성이 해답이다.

OnAcceptCompleted에 Break Point를 두고, 디버그를 실행 할 경우 위 사진과 같이 '주 스레드' 이외에 새로운 '작업자 스레드' 가 발생하는 것을 볼 수 있다. 이렇듯 AcceptAsync 메소드에 따라 SocketAsyncEventArgs의 콜백 함수는 새로운 스레드에서 실행 된다는 것을 알 수 있다.

🌼 위 상황의 문제점

• '주 스레드' 와 '작업자 스레드' 는 함께 실행되고 있기 때문에 만약에 동시다발적으로 같은 데이터에 접근하는 경우 Race Condition 문제가 발생한다.

OnAcceptCompleted 부분은 red Zone 즉 멀티스레드를 염두하고 코딩을 해야하는 부분으로 생각을 한 상태에서 코드를 작성해야 할 것이다.

---

🌞 Server의 Receive를 비동기로

using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;

namespace ServerCore
{
    class Session
    {   
        Socket _socket;
        public void Init(Socket socket)
        {
            _socket = socket;

            SocketAsyncEventArgs recvArgs = new SocketAsyncEventArgs();
            recvArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnRecvCompleted);
            recvArgs.SetBuffer(new byte[1024],0,1024);
            
            RegisterRecv(recvArgs);

        }

        void RegisterRecv(SocketAsyncEventArgs args)
        {
            bool pending = _socket.ReceiveAsync(args);
            if (pending == false)
                OnRecvCompleted(null, args);

        }

        void OnRecvCompleted(object obj, SocketAsyncEventArgs args)
        {
            if(args.BytesTransferred != 0 && args.SocketError==SocketError.Success)
            {
                try
                {
                    string recvData = Encoding.UTF8.GetString(args.Buffer, args.Offset, args.BytesTransferred);
                    Console.WriteLine($"[From Client] {recvData}");

                    RegisterRecv(args);
                }
                catch(Exception e)
                {
                    Console.WriteLine($"OnRecvCompleted Failed {e}");
                }
            }
            else
            {
                //TODO Disconect
            }
        }
    }
}

앞선 수업에서 했던 Accept를 하는 부분과 비슷했다.
SocketAsyncEventArgs 선언, Completed 추가, RegisterAsync를 실행해주는 Init

ReceiveAsync처리를 해주는 RegisterRecv

Completed에 추가 될 OnRecvCompleted

다른 점이라고 하면, Args에 Data를 받아 줄 Buffer를 추가한 점이다.

그리고 OnRecvCompleted 부분에서 args.BytesTransferred > 0 보다 큰 경우에만 조건문을 통과하게 했는데 그 이유는 Disconnect와 같은 것을 Receive를 하면 0 byte를 받을 수 있기 때문에 이는 통과 시켜주지 않기 위해서 넣는다.

---

🌞 임시 Disconnect와 Send

        public void Send(byte[] sendBuff)
        {
            _socket.Send(sendBuff);
        }

        public void Disconnect()
        {
            _socket.Shutdown(SocketShutdown.Both);
            _socket.Close();
        }

🌼 Disconnect의 문제점

• 멀티쓰레드 환경이기 때문에 현재 Disconnect 부분이 두번 이상 호출이 될 수 있는 상황이다. Disconnect 된 상태에서 다시 한 번 Disconnect를 하면 에러가 발생하기 때문에 이 부분을 한번만 하게끔 수정해주어야 한다.

        public void Disconnect()
        {
            if (Interlocked.Exchange(ref _disconnected, 1) == 1)
                return;


            _socket.Shutdown(SocketShutdown.Both);
            _socket.Close();
        }

---

🌞 Send를 비동기식으로

Send의 비동기식은 기존 앞에서 했던 방식과는 조금 차이가 있다.
왜냐하면, 앞서 했던 Accept와 Receive의 경우 Client에서 신호가 오는 것을 받는 것이라면, Send는 반대로 Server에서 신호를 보내는 것이기 때문이다.

using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace ServerCore
{
    class Session
    {
        Socket _socket;
        int _disconnected = 0;
        SocketAsyncEventArgs _sendArgs = new SocketAsyncEventArgs();
        Queue<byte[]> sendQueue = new Queue<byte[]>();
        bool _pending = false;
        object _lock = new object();
        public void Start(Socket socket)
        {
            _socket = socket;

            SocketAsyncEventArgs recvArgs = new SocketAsyncEventArgs();
            recvArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnRecvCompleted);
            recvArgs.SetBuffer(new byte[1024], 0, 1024);

            _sendArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnSendCompleted);

            RegisterRecv(recvArgs);

        }

        #region 네트워크통신

        public void Send(byte[] sendBuff)
        {
            lock(_lock)
            {
                sendQueue.Enqueue(sendBuff);
                if (_pending == false)
                    RegisterSend();
            }

        }

        void OnSendCompleted(object obj, SocketAsyncEventArgs args)
        {
            lock (_lock)
            {
                if (args.BytesTransferred > 0 && args.SocketError == SocketError.Success)
                {
                    try
                    {
                        _pending = false;
                        if (sendQueue.Count > 0)
                            RegisterSend();
                        else
                            _pending = false;
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine($"OnSendCompleted Failed {e}");
                    }
                }
                else
                {
                    Disconnect();
                }
            }
        }

        void RegisterSend()
        {
            _pending = true;
            byte[] buff = sendQueue.Dequeue();
            _sendArgs.SetBuffer(buff, 0, buff.Length);

            bool pending = _socket.SendAsync(_sendArgs);
            if (pending == false)
                OnSendCompleted(null, _sendArgs);
        }

        public void Disconnect()
        {
            if (Interlocked.Exchange(ref _disconnected, 1) == 1)
                return;


            _socket.Shutdown(SocketShutdown.Both);
            _socket.Close();
        }

        void RegisterRecv(SocketAsyncEventArgs args)
        {
            bool pending = _socket.ReceiveAsync(args);
            if (pending == false)
                OnRecvCompleted(null, args);

        }

        void OnRecvCompleted(object obj, SocketAsyncEventArgs args)
        {
            if(args.BytesTransferred != 0 && args.SocketError==SocketError.Success)
            {
                try
                {
                    string recvData = Encoding.UTF8.GetString(args.Buffer, args.Offset, args.BytesTransferred);
                    Console.WriteLine($"[From Client] {recvData}");

                    RegisterRecv(args);
                }
                catch(Exception e)
                {
                    Console.WriteLine($"OnRecvCompleted Failed {e}");
                }
            }
            else
            {
                Disconnect();
            }
        }
    }
    #endregion
}

Send를 비동기식으로 작성하기 위해서 기존에 Accept와 Async의 방식을 사용하게 되면, SocketAsyncEventArgs를 재사용 할 수 없고 Send를 호출 받을 때마다 새로운 메모리를 할당하게 된다. 그렇기 때문에 먼저 SocketAsyncEventArgs를 인스턴스 변수로 선언을 하고 이를 초기화하는 부분을 Start 메소드에 넣어주었다.

그리고 Async 함수의 경우 스레드를 다루는 부분이기 때문에 유저단에서 명령을 할 뿐 아니라 OS단에서도 명령을 하게 된다. 그렇기 때문에 리소스 또한 많이 먹게 되는데, 기존에 Accept 와 Receive의 경우 갯수를 늘려봐야 몇개 되지 않았지만, Send의 경우 만약에 유저가 천명, 만명이 되어서 그 모든 사람들이 SendAsync를 하게 된다면 서버에 부하가 엄청나게 들어온다. 그렇기 때문에 이를 조절하기 위해서 실제로 실행되는 SendAsync는 하나임을 유지하면서 다른 스레드에서 Send가 들어오면 Send에 아규먼트 값인 sendBuff를 sendQueue에 저장하여 나중에 새로운 SendAsync에서 처리해주게끔 만들어주었다.

하지만 위의 방법은 실제로 문제를 해결했다고 보기는 어렵다. 어차피 결국엔 SendAsync를 Send가 들어온 만큼 수행해야 하기 때문이다. 이 문제를 해결하는 법은 아래에서 알아보도록 하겠습니다.

---

🌞 Send를 좀 더 Compact하게

---

🌼 SocketAsyncEventArgs.BufferList

• 이 메소드는 SetBuffer의 리스트 버전으로 Buffer를 리스트 형식으로 저장을 하여, 한꺼번에 Async를 실행하게 해주기 때문에 위에서 문제였던 Async를 여러번 하는 문제를 해결 할 수 있는 방법이다.
• 주의사항 : SetBuffer와 BufferList는 둘 중 하나만 사용을 해야 한다. 만약에 두 개 모두 값이 존재하는 경우 에러가 발생한다.

---

🌼 Dequeue 부분을 수정하자

void RegisterSend()
       {
           _pending = true;

           List<ArraySegment<byte>> list = new List<ArraySegment<byte>>();

           while(_sendQueue.Count > 0)
           {
               byte[] buff = _sendQueue.Dequeue();
               list.Add(new ArraySegment<byte>(buff, 0, buff.Length));
           }

           _sendArgs.BufferList = list;

           bool pending = _socket.SendAsync(_sendArgs);
           if (pending == false)
               OnSendCompleted(null, _sendArgs);
       }

• 기존에 있던 Dequeue 부분은 sendQueue에서 값들을 하나씩 빼줬다. 이번에는 BufferList를 이용 할 것이기 때문에 이 BufferList에 sendQueue 내부에 있는 모든 값들을 옮길 것이다. 그렇기 때문에 while문을 돌면서 sendQueue의 Count가 0이 될때까지 임의의 buff 리스트를 두어 그쪽에 저장을 할 것이다.

  왜 바로 BufferList에 Add 하지 않고, 임의의 BufferList를 두는가?
  현재 List는 단순히 byte형 Buffer를 받고 있지 않다. 이것은 BufferList 또한 같은데, ArraySegment는 배열 내부의 부분을 담는 구조체이다. 그렇다면 기존에 알던 byte형 List와는 다를 수도 있다는 것이고, 실제로 다르다.
  이 BufferList에 경우 '=' 연산자를 통해서만 값들을 제대로 복사 할 수 있다. 따라서 위와 같이 임의의 BufferList를 두는 작업을 하는 것이다.

using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace ServerCore
{
    class Session
    {
        Socket _socket;
        int _disconnected = 0;
        SocketAsyncEventArgs _sendArgs = new SocketAsyncEventArgs();
        SocketAsyncEventArgs _recvArgs = new SocketAsyncEventArgs();
        List<ArraySegment<byte>> _pendingList = new List<ArraySegment<byte>>();
        Queue<byte[]> _sendQueue = new Queue<byte[]>();
        bool _pending = false;
        object _lock = new object();
        public void Start(Socket socket)
        {
            _socket = socket;

            _recvArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnRecvCompleted);
            _recvArgs.SetBuffer(new byte[1024], 0, 1024);

            _sendArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnSendCompleted);

            RegisterRecv();

        }

        #region 네트워크통신

        public void Send(byte[] sendBuff)
        {
            lock(_lock)
            {
                _sendQueue.Enqueue(sendBuff);
                if (_pendingList.Count == 0)
                    RegisterSend();
            }

        }

        void OnSendCompleted(object obj, SocketAsyncEventArgs args)
        {
            lock (_lock)
            {
                if (args.BytesTransferred > 0 && args.SocketError == SocketError.Success)
                {
                    try
                    {
                        _sendArgs.BufferList = null;
                        _pendingList.Clear();

                        Console.WriteLine($"Transferred bytes : {_sendArgs.BytesTransferred}");

                        if (_sendQueue.Count > 0)
                            RegisterSend();
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine($"OnSendCompleted Failed {e}");
                    }
                }
                else
                {
                    Disconnect();
                }
            }
        }

        void RegisterSend()
        {
            _pendingList.Clear();

            while(_sendQueue.Count > 0)
            {
                byte[] buff = _sendQueue.Dequeue();
                _pendingList.Add(new ArraySegment<byte>(buff, 0, buff.Length));
            }

            _sendArgs.BufferList = _pendingList;

            bool pending = _socket.SendAsync(_sendArgs);
            if (pending == false)
                OnSendCompleted(null, _sendArgs);
        }

        public void Disconnect()
        {
            if (Interlocked.Exchange(ref _disconnected, 1) == 1)
                return;


            _socket.Shutdown(SocketShutdown.Both);
            _socket.Close();
        }

        void RegisterRecv()
        {
            bool pending = _socket.ReceiveAsync(_recvArgs);
            if (pending == false)
                OnRecvCompleted(null, _recvArgs);

        }

        void OnRecvCompleted(object obj, SocketAsyncEventArgs args)
        {
            if(args.BytesTransferred != 0 && args.SocketError==SocketError.Success)
            {
                try
                {
                    string recvData = Encoding.UTF8.GetString(args.Buffer, args.Offset, args.BytesTransferred);
                    Console.WriteLine($"[From Client] {recvData}");

                    RegisterRecv();
                }
                catch(Exception e)
                {
                    Console.WriteLine($"OnRecvCompleted Failed {e}");
                }
            }
            else
            {
                Disconnect();
            }
        }
    }
    #endregion
}

• 이방식으로 Send의 모든 문제를 해결했다고 보기는 어렵다.
  Buffer에 보낼 값들을 모아서 보내긴 했지만,
  아직 이정도로 패킷을 모아 보냈다 하기엔 좀 그렇다.
  그렇기 때문에 엔진 쪽이나, 클라쪽에서 하나의 스레드가 아닌
  여러 스레드가 보내는 데이터를 모으는 엄청 큰 버퍼를 두고
  그 버퍼를 SendAsync하는 방식등을 고려해 볼 수 있을 것이다.

---

🌞 SessionHandler

• Handler를 추가하여, Engine과 컨텐츠를 분리시키자

• Session에서의 행동을 할 callback을 담당하는 부분인 SessionHandler를 만들어보자. 전에 Accept의 경우에도 OnAcceptHandler를 만들어주어서, Accept가 일어나서 완료된 경우에 callback으로 할 일을 실행해주는 것과 같은 것이다.

• Handler를 만들어주는 방법에는 두가지가 있다.
  첫번째는 class를 하나 선언하여 거기에 Handler를 모아서 관리하는 법
  두번쨰는 Session을 상속받는 방법이다.

여기서는 두번째 방법으로 해보겠다.

namespace ServerCore
{
    abstract class Session
    {
        public abstract void OnConnected(EndPoint endPoint);
        public abstract void OnRecv(ArraySegment<byte> buffer);
        public abstract void OnSend(int numOfBytes);
        public abstract void OnDisconnect(EndPoint endPoint);

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace ServerCore
{

    class GameSession : Session
    {
        public override void OnConnected(EndPoint endPoint)
        {
            Console.WriteLine($"OnConnected : {endPoint}");

            byte[] sendBuff = Encoding.UTF8.GetBytes("Welcome to MMORPG Server !");
            Send(sendBuff);

            Thread.Sleep(1000);
            Disconnect();
        }

        public override void OnDisconnect(EndPoint endPoint)
        {
            Console.WriteLine($"OnDisconnected : {endPoint}");
        }

        public override void OnRecv(ArraySegment<byte> buffer)
        {
            string recvData = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count);
            Console.WriteLine($"[From Client] {recvData}");
        }

        public override void OnSend(int numOfBytes)
        {
            Console.WriteLine($"Transferred bytes : {numOfBytes}");
        }
    }
    class Program
    {
        static Listener _listener = new Listener();
        static void Main(string[] args)
        {
            //DNS(Domain Name Service
            string host = Dns.GetHostName();
            IPHostEntry ipHost = Dns.GetHostEntry(host);
            IPAddress ipAddr = ipHost.AddressList[0];
            IPEndPoint endPoint = new IPEndPoint(ipAddr, 7777);

            _listener.Init(endPoint, () => { return new GameSession(); });
                
            while (true)
            {
                ;
            }
        }

    }
}

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace ServerCore
{
    class Listener
    {
        Socket _listenerSocket;
        Func<Session> _sessionFactory;
        public void Init(IPEndPoint endPoint, Func<Session> sessionFactory)
        { 
            //문지기
            _listenerSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            _sessionFactory += sessionFactory;

            //문지기 교육
            _listenerSocket.Bind(endPoint);

            //영업시작
            //backlog : 최대 대기수
            _listenerSocket.Listen(10);

            for(int i = 0; i<10;i++)
            {
                SocketAsyncEventArgs args = new SocketAsyncEventArgs();
                args.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
                RegisterAccept(args);
            }
        }

        void RegisterAccept(SocketAsyncEventArgs args)
        {
            args.AcceptSocket = null;

            bool pending = _listenerSocket.AcceptAsync(args);
            if (pending == false)
                OnAcceptCompleted(null, args);
                   
        }

        void OnAcceptCompleted(object sender, SocketAsyncEventArgs args)
        {
            if (args.SocketError == SocketError.Success)
            {
                Session session = _sessionFactory.Invoke();
                session.Start(args.AcceptSocket);
                session.OnConnected(args.AcceptSocket.RemoteEndPoint);
            }
            else
                Console.WriteLine(args.SocketError.ToString());

            RegisterAccept(args);
        }


        public Socket Accept()
        {
            return _listenerSocket.Accept();
        }
    }
}

여기서 하나 의문인 점이었던 부분은 SessionFactory 부분이었는데, Func 대리자를 통해서 SessionFactory에 GameSession을 대입하는 연산을 하였다. 근데 이 부분에서 Session 클래스에 SessionFactory가 들어갈 수가 있나? 라는 생각을 했는데,
추상클래스의 경우 원래 Session으로 선언해서 사용 할 수가 없지만, 업캐스팅을 통해서는 사용이 가능하다는 것을 알게됐다.