[C++] Service

오늘도 최대한 메모해 보자.

 

1. Service란?

여기서 서비스란 흩어져 있는 여러 기능들을 한 곳에 모아둬, 보다 편하게 사용할 수 있게 한 집합이다.

언제 리스너/송신/수신 오브젝트를 일일이 만들고 설정한단 말인가?

이전에 했던 일련의 작업들이 서비스에 포함된 상태로 동작할 것이다.

 

라이브 서비스에선 모든 기능을 하나의 서버에 두는 것이 아니라,
목적에 맞게 서버를 분산해 운용한다.
서버끼리 붙어야 할 일도 생길 수 있기 때문에 이에 대응해야 한다.
세션이 서버일 수도 있고 클라이언트일 수도 있기 때문에,
Service라는 클래스를 두어 정책을 구분해 운용하기로 한 것이다.

 

 

1. 문제 해결 부터

본격적으로 Service에 대한 구현에 들어가기 전에 이전 과정의 문제에 대한 수정이 필요하다.

 

우린 CP에 핸들을 등록하는 것을 아래와 같이 구현했었다.

// IocpCore.cpp

bool IocpCore::Register(IocpObject* iocpObject)
{
	return ::CreateIoCompletionPort(iocpObject->GetHandle(), _iocpHandle, reinterpret_cast<ULONG_PTR>(iocpObject), 0);
}

키값으로 IocpObject의 포인터를 넘겨줬는데,

만약 저 오브젝트가 사라져 버려서 메모리 오염이 생겨버린다면?

이 부분은 키값과 OVERLAPPED 구조체가 모두 살아있어야 한다는 보장이 필요하다.

 

// IocpCore.cpp

bool IocpCore::Dispatch(uint32 timeoutMs)
{
	DWORD numOfBytes = 0;
	IocpObject* iocpObject = nullptr;
	IocpEvent* iocpEvent = nullptr;

	if (::GetQueuedCompletionStatus(_iocpHandle, OUT &numOfBytes, OUT reinterpret_cast<PULONG_PTR>(&iocpObject), OUT reinterpret_cast<LPOVERLAPPED*>(&iocpEvent), timeoutMs))
	{
		iocpObject->Dispatch(iocpEvent, numOfBytes);
	}
	else
	{
    	// ...
    }    
}

IocpEvent는 큰 문제가 없을 수가 있지만 키값이 쓸 수 없게 되면 진짜 큰 문제가 된다.

 

그럼 일이 다 끝나기 전에 메모리 오염이 발생하는 것을 막기 위해 레퍼런스 카운팅을 하는 방법을 떠올릴 수 있다.

하지만 여기엔 문제가 있다.

 

• 만약 외부에서 다른 스마트 포인터로 카운팅에 들어가 이중으로 카운팅 된다면?
  - 이로 인해 RefCounting은 사용할 수 없게 되었다.
• shared_ptr을 사용하면 프로그래머가 직접적으로 카운팅을 조작할 수 없음

따라서 Event에 IocpObject를 물려주는 방법을 사용할 것이다.

이러면 키를 0으로 밀고 Event만으로 관리할 수 있다.

 

IocpEvent 클래스에 아래와 같이 레퍼런스 변수를 추가한다.

 

class IocpEvent : public OVERLAPPED
{
public:
	IocpEvent(EventType type);

	void			Init();

public:
	EventType		eventType;
	IocpObjectRef		owner; // 이벤트의 주인을 기억
};

원래  shared_ptr을 사용해서 선언해야 하지만 역시 그 긴걸 일일 타이핑 하기엔 번거롭다.

따라서 아래와 같이 미리 선언을 해 두고 활용하기로 한다.

 

EventType도 원래 GetType()으로 가져왔지만 public으로 열어두고 eventType을 직접 꺼내쓸 수 있도록 했다.

 

// shared_ptr
// 번거로운 타이핑 피하기 위함
using IocpCoreRef		= std::shared_ptr<class IocpCore>;
using IocpObjectRef		= std::shared_ptr<class IocpObject>;
using SessionRef		= std::shared_ptr<class Session>;
using ListenerRef		= std::shared_ptr<class Listener>;
using ServerServiceRef		= std::shared_ptr<class ServerService>

미리 ServerSerivceRef까지 만들어 둔다.

여기선 각 클래스에 대해 할 수가 없으니 전방선언한다.

 

다시 IocpEvent.h로 돌아와서 AcceptEvent 클래스에 세션 포인터 변수를 추가한다.

// IocpEvent.h
public:
	SessionRef	session = nullptr;

 

 

 

이제 기존 코드들을 수정해 나간다.

// IocpCore.cpp

bool IocpCore::Register(IocpObjectRef iocpObject)
{
	return ::CreateIoCompletionPort(iocpObject->GetHandle(), _iocpHandle, /*key*/0, 0);
}

더 이상 키값이 필요 없기 때문에 키값을 0으로 밀어준 상태에서 걸어준다.

 

 

// IocpCore.cpp

bool IocpCore::Dispatch(uint32 timeoutMs)
{
	DWORD numOfBytes = 0;
	ULONG_PTR key = 0;
	IocpEvent* iocpEvent = nullptr;
    
	if (::GetQueuedCompletionStatus(_iocpHandle, OUT & numOfBytes, OUT & key, OUT reinterpret_cast<LPOVERLAPPED*>(&iocpEvent), timeoutMs))
	{
		IocpObjectRef iocpObject = iocpEvent->owner; // 여기서 IocpObject를 넘겨주고
		iocpObject->Dispatch(iocpEvent, numOfBytes); // 그걸로 Dispatch
	}
	else
	{
		int32 errCode = ::WSAGetLastError();
		switch (errCode)
		{
		case WAIT_TIMEOUT:
			return false;
		default:
			// TODO : 로그 찍기
			IocpObjectRef iocpObject = iocpEvent->owner;
			iocpObject->Dispatch(iocpEvent, numOfBytes);
			break;
			return true;
		}

	}
}

기존의 IocpObject를 선언하는 것은 지우고, Key도 0으로 밀어준다.

IocpObjectRef를 선언해 이벤트에서 오브젝트를 받아 둔다.

넘겨받은 오브젝트로 Dispatch를 호출하게 한다.

아래쪽에도 위와 동일하게 작성하여 Dispatch 할 수 있도록 한다.

 

수정사항이 생겼으니 빌드하며 문제점을 잡아나간다.

아래와 같이 코드들을 수정해 나간다.

// 이 코드가
Session* session = xnew<Session>();

// 이렇게 변하는 식
SessionRef session = MakeShared<Session>();

사실 세션을 MakeShared로 생성하는 것은 구조 상 문제가 있지만,

일단 임시로 이렇게 둔다.

 

그리고 AcceptEx()를 호출하는 데 있어서, 이 이벤트는 acceptEvent라 볼 수 있는데,

아직 acceptEvent()에 이벤트의 주인이라 할 수 있는 IocpObject를 연결해 주지 않았다.

StartAccept()로 돌아가서 acceptEvent()를 만드는 부분을 수정하자.

 

// Listener.cpp

const int32 acceptCount = 1;
for (int32 i = 0; i < acceptCount; i++)
{
	AcceptEvent* acceptEvent = xnew<AcceptEvent>();
    	acceptEvent->owner = shared_from_this(); // 추가!
	_acceptEvents.push_back(acceptEvent);
	RegisterAccept(acceptEvent);
}

여기서 왜 shared_ptr<IocpObject>(this) 의 형태로 넘겨주지 않았냐 라는 의문이 생길 수도 있다.

이렇게 해 버리면 카운트가 1인 새로운 포인터가 생기는 것이기 때문에 치명적인 문제가 생길 수 있다.

기존의 포인터를 쓰게 하지 못해서 결국 오브젝트가 소멸해 버리는 결과가 생길 수 있다.

이 문제를 해결하기 위해 shared_from_this()를 사용했다.

 

이걸 사용하기 위해선 먼저 Listener 클래스의 부모인 IocpObject클래스의 헤더로 가서 어떤 클래스를 상속받아야 한다.

 

// IocpCore.h

class IocpObject : public enable_shared_from_this<IocpObject>
{
public:
	virtual HANDLE GetHandle() abstract;
	virtual void Dispatch(class IocpEvent* iocpEvent, int32 numOfBytes = 0) abstract;
};

enable_shared_from_this라는 클래스를 상속받는다.

이는 내부적으로 weak_ptr을 생성하고 이를 lock을 걸어서 넘겨주는 것으로 동작한다.

이 클래스를 상속받음으로써 이제 모든 IocpObject를 상속받는 클래스들은 shared_ptr의 형태로만 활용할 수 있다.

따라서 쌩 포인터를 만들어 스택에 올리는 것이 아닌 Make Shared를 통해 만들어야 한다는 것을 염두에 두어야 한다.

 

 

2. 클래스 구현

Service 클래스엔 많은 것들이 모일 것이다.

 

// Service.h

#pragma once
#include "NetAddress.h"
#include "IocpCore.h"
#include "Listener.h"
#include <functional>

enum class ServiceType : uint8
{
	Server,
	Client
};

using SessionFactory = function<SessionRef(void)>;

class Service : public enable_shared_from_this<Service>
{
public:
	Service(ServiceType type, NetAddress address, IocpCoreRef core, SessionFactory factory, int32 maxSessionCount = 1);
	virtual ~Service();

	// 자식 클래스는 무조건 Start()를 구현해야 함
	virtual bool			Start() abstract;
	bool				CanStart() { return _sessionFactory != nullptr; }

	virtual void			CloseService();
	void				SetSessionFactory(SessionFactory func) { _sessionFactory = func; }

	SessionRef			CreateSession();
	void				AddSession(SessionRef session);
	void				ReleaseSession(SessionRef session);
	int32				GetCurrentSessionCount() { return _sessionCount; }
	int32				GetMaxSessionCount() { return _maxSessionCount; }

public:
	ServiceType			GetServiceType() { return _type; }
	NetAddress			GetNetAddress() { return _netAddress; }
	// 외부에서 꺼내서 카운트를 늘리기 보단
	// 참조를 넘겨주게 해 부하를 줄일 수 있다
	IocpCoreRef&			GetIocpCore() { return _iocpCore; }

protected:
	USE_LOCK;
	ServiceType			_type;
	NetAddress			_netAddress = {};
	IocpCoreRef			_iocpCore;

	Set<SessionRef>			_sessions;
	int32				_sessionCount = 0;
	int32				_maxSessionCount = 0;
	SessionFactory			_sessionFactory;
};

일단 서비스 타입을 서버와 클라이언트의 2종류로 나눠놨다.

클래스는 만약을 대비해 shared ptr을 넘겨줄 수 있도록 enable_shared_from_this를 상속받는다.

SessionFactory라는 함수를 받는 녀석을 볼 수 있는데, 세션을 만들어 줄 함수를 정의한 것이다.

 

생성자로는 서비스를 정의할 정보들을 받는다.

무슨 타입인지, 클라/서버의 주소는 뭔지, 서비스를 정의할 함수는 뭔지, 동접은 얼마나 받을 것인지 등의 정보를 받는다.

 

이외의 필요한 변수화 함수들을 선언 및 정의해 준다.

 

// Service.cpp

#include "pch.h"
#include "Service.h"
#include "Session.h"
#include "Listener.h"

Service::Service(ServiceType type, NetAddress address, IocpCoreRef core, SessionFactory factory, int32 maxSessionCount)
	: _type(type), _netAddress(address), _iocpCore(core), _sessionFactory(factory), _maxSessionCount(maxSessionCount)
{

}

Service::~Service()
{
}

void Service::CloseService()
{
	// TODO
}

SessionRef Service::CreateSession()
{
	SessionRef session = _sessionFactory();

	if (_iocpCore->Register(session) == false)
		return nullptr;

	return session;
}

// 세션에 ID를 할당해 그걸로 관리할 수는 있지만,
// 일단은 세션의 주소(포인터)를 갖고 있는 식으로 구현
void Service::AddSession(SessionRef session)
{
	WRITE_LOCK;
	_sessionCount++;
	_sessions.insert(session);
}

void Service::ReleaseSession(SessionRef session)
{
	WRITE_LOCK;
	ASSERT_CRASH(_sessions.erase(session) != 0);
	_sessionCount--;
}

생성자는 받은 인자들을 멤버변수에 세팅한다.

소멸자와 CloseService()에서는 일단은 아직 아무 동작도 하지 않을 것이다.

 

CreateSession()은 세션을 만들고(소켓 생성), 그 핸들을 CP에 등록해 주는 역할을 한다.

 

Addsession()과 ReleaseSession()은 이름 그대로 세션을 추가하고 풀어주는 역할을 한다.

혹시 모를 메모리 오염 방지를 위해 WRITE LOCK도 걸어준다.

 

2-1. Client Service

아까 서비스 타입을 클라이언트와 서버 2가지로 나눴다.

먼저 클라이언트 클래스부터 만들어 보자.

 

// Service.h

class ClientService : public Service
{
public:
	ClientService(NetAddress targetAddress, IocpCoreRef core, SessionFactory factory, int32 maxSessionCount = 1);
	virtual ~ClientService() {}

	virtual bool	Start() override;
};

지금은 클라이언트 서비스에 대해 생각 할 단계는 아닌 듯 하니 최소한의 구색만 갖췄다.

 

// Service.cpp

ClientService::ClientService(NetAddress targetAddress, IocpCoreRef core, SessionFactory factory, int32 maxSessionCount)
	: Service(ServiceType::Client, targetAddress, core, factory, maxSessionCount)
{
}

bool ClientService::Start()
{
	// TODO
	return true;
}

정의도 심플하다.

대신 클라이언트기 때문에 주소를 받는 부분의 네이밍은 targetAddress가 되었다.

 

 

2-2. Server Service

이제 서버 클래스를 만들자.

 

class ServerService : public Service
{
public:
	ServerService(NetAddress targetAddress, IocpCoreRef core, SessionFactory factory, int32 maxSessionCount = 1);
	virtual ~ServerService() {}

	virtual bool	Start() override;
	virtual void	CloseService() override;

private:
	// 서버 역할을 할 것이기 때문에 Listener가 필요
	ListenerRef		_listener = nullptr;
};

클라이언트 클래스에 비해 몇 가지가 추가되었다.

선언한 함수도 그 내용물을 어느 정도 채울 것이다.

서버 서비스기 때문에 리스너 오브젝트의 레퍼런스도 받는다.

 

ServerService::ServerService(NetAddress address, IocpCoreRef core, SessionFactory factory, int32 maxSessionCount)
	: Service(ServiceType::Server, address, core, factory, maxSessionCount)
{
}

bool ServerService::Start()
{
	if (CanStart() == false)
		return false;

	_listener = MakeShared<Listener>();
	if (_listener == nullptr)
		return false;

	// enable_shared_from_this가 ServerSerivce가 아니라 Service에 걸려있기 때문에
	// 포인터 캐스팅으로 넘겨줘야 함
	ServerServiceRef service = static_pointer_cast<ServerService>(shared_from_this());
	if (_listener->StartAccept(service) == false)
		return false;

	return true;
}

void ServerService::CloseService()
{
	// TODO

	Service::CloseService();
}

생성자는 크게 다를 것이 없다.

클라이언트가 아니라 서버기 때문에 자신의 주소를 받을 것이므로 targetAddress가 아니라 그냥 address가 됐다.

 

CanStart()로 functionFactory가 nullptr이 아닌지 체크하고,

Listener를 만들어 그 레퍼런스를 멤버변수에 넘겨준다.

 

ServerService의 정보를 활용해 리스너가 작동해야 하므로 ServerService 자신의 레퍼런스를 넘겨받아야 하는데,

당연히 여기서도 그냥 쌩 포인터로 넘겨주면 안 된다.

그래서 바로 shared_from_this()로 넘겨주려니 여기서도 문제가 생긴다.

그냥 저렇게 넘겨주면 Service를 넘겨주는 꼴이 된다.

enable_shared_from_this 클래스를 상속받은 것은 ServerService가 아니라 Service이기 때문이다.

따라서 포인터 캐스팅으로 ServerService로 캐스팅한 후 넘겨주어야 한다

그리고 AcceptEx()를 걸어주며 결과를 리턴한다.

 

CloseService()는 부모 클래스에서도 제대로 정의하지 않았으므로 이대로 둔다.

 

3. Listener 클래스 수정

기존의 StartAccept()는 NetAddress를 받아서 동작했지만,

이번에 그런 분산된 기능들을 Service에 다 모았으므로, 이에 맞게 수정해 주어야 한다.

전역으로 선언한 IocpCore 변수도 사용하지 않을 것이기에 제거한다.

 

// Listener.cpp

bool Listener::StartAccept(ServerServiceRef service)
{
	_service = service;
	if (_service == nullptr)
		return false;

	_socket = SocketUtils::CreateSocket();
	if (_socket == INVALID_SOCKET)
		return false;

	// 전역 선언한 IocpCore를 대체
	// Listener가 IocpObject를 상속받기 때문에 shared_from_this() 사용 가능
	if (_service->GetIocpCore()->Register(shared_from_this()) == false)
		return false;

	if (SocketUtils::SetReuseAddress(_socket, true) == false)
		return false;

	if (SocketUtils::SetLinger(_socket, 0, 0) == false)
		return false;

	// NetAddress도 Service에서 가져옴
	if (SocketUtils::Bind(_socket, _service->GetNetAddress()) == false)
		return false;
        
    	// ...
}

이렇게 필요한 모든 정보들을 Service라는 단일 클래스에서 가져올 수 있게 되었다.

지금은 IocpCore 클래스의 Register()에 변경사항이 없지만, 인자로 shared ptr을 받게 고칠 것이다.

미리 고쳐두었다.

 

RegisterAccept()도 아래와 같이 수정한다.

void Listener::RegisterAccept(AcceptEvent* acceptEvent)
{
	// CP에 걸어주는 것 까지 한방에 처리
	// SessionFactory만 갈아주면서 간편하게 원하는 대로 세션 생성 가능
	SessionRef session = _service->CreateSession(); // Register IOCP

	acceptEvent->Init();
	acceptEvent->session = session;
    
	// ...
}

세션도 서비스에서 세션을 생성해 넘겨줄 수 있다.

세션을 생성하면서 IOCP에 등록까지 이루어진다.

 

이 방법엔 확실한 장점이 있는데,

서비스를 상속받아 원하는 형태로 만들고 SessionFactory만 원하는 형태로 연결해 주면,

나중에 컨텐츠 단에서 어떤 형식으로 세션을 만들어 줄지 지정할 수 있다는 점이다.

컨텐츠 별로 작업해야 하는 번거로움이 어느 정도 해소된다 할 수 있다.

 

IocpCore 클래스의 Register()도 아래와 같이 인자를 고쳐준다.

bool IocpCore::Register(IocpObjectRef iocpObject)
{
	return ::CreateIoCompletionPort(iocpObject->GetHandle(), _iocpHandle, /*key*/0, 0);
}

IocpObject 클래스는 share ptr을 사용하기로 했으므로 전체 프로젝트에서 이걸 통일시켜 주어야 한다.

그냥 섞어 쓴다면 큰 문제가 생길 수 있다.

 

 

4. 서버 작성

이전엔 Listener를 직접 가져와 사용했지만, 이제 더 이상 그런 직접 사용은 하지 않을 것이다.

ServerService를 생성해 이의 Start()를 실행하게끔 하면 이전의 코드를 대체할 수 있다.

 

class GameSession : public Session
{

};

int main()
{
	ServerServiceRef service = MakeShared<ServerService>(
		NetAddress(L"127.0.0.1", 7777),
		MakeShared<IocpCore>(),
		MakeShared<GameSession>, // TODO : SessionManager 등을 활용할 수도 있음
		100);

	ASSERT_CRASH(service->Start());

	for (int32 i = 0; i < 5; i++)
	{
		GThreadManager->Launch([=]()
			{
				while (true)
				{
					service->GetIocpCore()->Dispatch();
				}
			});
	}
    
	// ...
}

기존의 MakeShared는 Variadic Template를 지원하지 않았는데, 아래와 같이 고쳤다.

 

// Memory.h

template<typename Type, typename... Args>
shared_ptr<Type> MakeShared(Args&&... args)
{
	return shared_ptr<Type>{ xnew<Type>(forward<Args>(args)...), xdelete<Type> };
}

// ObjectPool.h

template<typename... Args>
static shared_ptr<Type> MakeShared(Args&&... args)
{
	shared_ptr<Type> ptr = { Pop(forward<Args>(args)...), Push };
	return ptr;
}

 

세션을 만드는 것은 SessionManager 같은 것을 만들어서 거기서 관리하게끔 할 수도 있다.

 

5. 결과

연결이 성공적으로 이루어졌다.

 

참 공부하지 쉽지 않다.