sco/pokerth
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactored server states - removed all thread local storage objects to ensure that they do not cause resource leaks.

Browse Source
This commit is contained in:
lotodore
2007-11-21 23:34:25 +00:00
parent a7f0a23f22
commit e28220a8ad
4 changed files with 84 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/net/common/servergamestate.cpp
+35 -75
View File
@@ -220,33 +220,26 @@ AbstractServerGameStateReceiving::Process(ServerGameThread &server)
//-----------------------------------------------------------------------------
AbstractServerGameStateTimer::AbstractServerGameStateTimer()
: m_timer(boost::posix_time::time_duration(0, 0, 0), boost::timers::portable::microsec_timer::manual_start)
{
}
AbstractServerGameStateTimer::~AbstractServerGameStateTimer()
{
}
void
AbstractServerGameStateTimer::Init()
AbstractServerGameStateTimer::Init(ServerGameThread & server)
{
m_timer.reset();
m_timer.start();
// Reset timer.
server.GetStateTimer().reset();
server.GetStateTimer().start();
}
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateInit> ServerGameStateInit::Ptr;
ServerGameStateInit ServerGameStateInit::m_state;
ServerGameStateInit &
ServerGameStateInit::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateInit);
return *Ptr;
return m_state;
}
ServerGameStateInit::ServerGameStateInit()
@@ -388,15 +381,12 @@ AbstractServerGameStateRunning::HandleNewSession(ServerGameThread &server, Sessi
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateWaitAck> ServerGameStateWaitAck::Ptr;
ServerGameStateWaitAck ServerGameStateWaitAck::m_state;
ServerGameStateWaitAck &
ServerGameStateWaitAck::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateWaitAck);
return *Ptr;
return m_state;
}
ServerGameStateWaitAck::ServerGameStateWaitAck()
@@ -412,7 +402,7 @@ ServerGameStateWaitAck::Process(ServerGameThread &server)
{
int retVal;
if (GetTimer().elapsed().total_seconds() >= SERVER_START_GAME_TIMEOUT_SEC)
if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_START_GAME_TIMEOUT_SEC)
{
// On timeout: start anyway.
server.SetState(SERVER_START_GAME_STATE::Instance());
@@ -447,15 +437,12 @@ ServerGameStateWaitAck::InternalProcess(ServerGameThread &server, SessionWrapper
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateStartGame> ServerGameStateStartGame::Ptr;
ServerGameStateStartGame ServerGameStateStartGame::m_state;
ServerGameStateStartGame &
ServerGameStateStartGame::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateStartGame);
return *Ptr;
return m_state;
}
ServerGameStateStartGame::ServerGameStateStartGame()
@@ -500,15 +487,12 @@ ServerGameStateStartGame::Process(ServerGameThread &server)
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateStartHand> ServerGameStateStartHand::Ptr;
ServerGameStateStartHand ServerGameStateStartHand::m_state;
ServerGameStateStartHand &
ServerGameStateStartHand::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateStartHand);
return *Ptr;
return m_state;
}
ServerGameStateStartHand::ServerGameStateStartHand()
@@ -614,15 +598,12 @@ ServerGameStateStartHand::Process(ServerGameThread &server)
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateStartRound> ServerGameStateStartRound::Ptr;
ServerGameStateStartRound ServerGameStateStartRound::m_state;
ServerGameStateStartRound &
ServerGameStateStartRound::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateStartRound);
return *Ptr;
return m_state;
}
ServerGameStateStartRound::ServerGameStateStartRound()
@@ -810,15 +791,12 @@ ServerGameStateStartRound::Process(ServerGameThread &server)
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateWaitPlayerAction> ServerGameStateWaitPlayerAction::Ptr;
ServerGameStateWaitPlayerAction ServerGameStateWaitPlayerAction::m_state;
ServerGameStateWaitPlayerAction &
ServerGameStateWaitPlayerAction::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateWaitPlayerAction);
return *Ptr;
return m_state;
}
ServerGameStateWaitPlayerAction::ServerGameStateWaitPlayerAction()
@@ -855,7 +833,7 @@ ServerGameStateWaitPlayerAction::Process(ServerGameThread &server)
#ifdef SERVER_TEST
else if (true)
#else
else if (GetTimer().elapsed().total_seconds() >= server.GetGameData().playerActionTimeoutSec + SERVER_PLAYER_TIMEOUT_ADD_DELAY_SEC)
else if (server.GetStateTimer().elapsed().total_seconds() >= server.GetGameData().playerActionTimeoutSec + SERVER_PLAYER_TIMEOUT_ADD_DELAY_SEC)
#endif
{
// Player did not act fast enough. Act for him.
@@ -979,15 +957,12 @@ ServerGameStateWaitPlayerAction::PerformPlayerAction(ServerGameThread &server, b
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateComputerAction> ServerGameStateComputerAction::Ptr;
ServerGameStateComputerAction ServerGameStateComputerAction::m_state;
ServerGameStateComputerAction &
ServerGameStateComputerAction::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateComputerAction);
return *Ptr;
return m_state;
}
ServerGameStateComputerAction::ServerGameStateComputerAction()
@@ -1003,7 +978,7 @@ ServerGameStateComputerAction::Process(ServerGameThread &server)
{
int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_COMPUTER_ACTION_DELAY_SEC)
if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_COMPUTER_ACTION_DELAY_SEC)
{
boost::shared_ptr<PlayerInterface> tmpPlayer = server.GetGame().getCurrentPlayer();
@@ -1025,15 +1000,12 @@ ServerGameStateComputerAction::InternalProcess(ServerGameThread &/*server*/, Ses
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateDealCardsDelay> ServerGameStateDealCardsDelay::Ptr;
ServerGameStateDealCardsDelay ServerGameStateDealCardsDelay::m_state;
ServerGameStateDealCardsDelay &
ServerGameStateDealCardsDelay::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateDealCardsDelay);
return *Ptr;
return m_state;
}
ServerGameStateDealCardsDelay::ServerGameStateDealCardsDelay()
@@ -1066,7 +1038,7 @@ ServerGameStateDealCardsDelay::Process(ServerGameThread &server)
delay = SERVER_DEAL_RIVER_CARD_DELAY_SEC;
break;
}
if (!delay || GetTimer().elapsed().total_seconds() >= delay)
if (!delay || server.GetStateTimer().elapsed().total_seconds() >= delay)
server.SetState(ServerGameStateStartRound::Instance());
return retVal;
@@ -1080,15 +1052,12 @@ ServerGameStateDealCardsDelay::InternalProcess(ServerGameThread &/*server*/, Ses
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateShowCardsDelay> ServerGameStateShowCardsDelay::Ptr;
ServerGameStateShowCardsDelay ServerGameStateShowCardsDelay::m_state;
ServerGameStateShowCardsDelay &
ServerGameStateShowCardsDelay::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateShowCardsDelay);
return *Ptr;
return m_state;
}
ServerGameStateShowCardsDelay::ServerGameStateShowCardsDelay()
@@ -1104,7 +1073,7 @@ ServerGameStateShowCardsDelay::Process(ServerGameThread &server)
{
int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_SHOW_CARDS_DELAY_SEC)
if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_SHOW_CARDS_DELAY_SEC)
{
Game &curGame = server.GetGame();
SendNewRoundCards(server, curGame, curGame.getCurrentHand()->getCurrentRound());
@@ -1124,15 +1093,12 @@ ServerGameStateShowCardsDelay::InternalProcess(ServerGameThread &/*server*/, Ses
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateNextHandDelay> ServerGameStateNextHandDelay::Ptr;
ServerGameStateNextHandDelay ServerGameStateNextHandDelay::m_state;
ServerGameStateNextHandDelay &
ServerGameStateNextHandDelay::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateNextHandDelay);
return *Ptr;
return m_state;
}
ServerGameStateNextHandDelay::ServerGameStateNextHandDelay()
@@ -1148,7 +1114,7 @@ ServerGameStateNextHandDelay::Process(ServerGameThread &server)
{
int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_HAND_SEC)
if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_HAND_SEC)
server.SetState(ServerGameStateStartHand::Instance());
return retVal;
@@ -1162,15 +1128,12 @@ ServerGameStateNextHandDelay::InternalProcess(ServerGameThread &/*server*/, Sess
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateNextGameDelay> ServerGameStateNextGameDelay::Ptr;
ServerGameStateNextGameDelay ServerGameStateNextGameDelay::m_state;
ServerGameStateNextGameDelay &
ServerGameStateNextGameDelay::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateNextGameDelay);
return *Ptr;
return m_state;
}
ServerGameStateNextGameDelay::ServerGameStateNextGameDelay()
@@ -1186,7 +1149,7 @@ ServerGameStateNextGameDelay::Process(ServerGameThread &server)
{
int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_GAME_SEC)
if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_GAME_SEC)
{
Game &curGame = server.GetGame();
// The game has ended. Notify all clients.
@@ -1226,15 +1189,12 @@ ServerGameStateNextGameDelay::InternalProcess(ServerGameThread &/*server*/, Sess
//-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateFinal> ServerGameStateFinal::Ptr;
ServerGameStateFinal ServerGameStateFinal::m_state;
ServerGameStateFinal &
ServerGameStateFinal::Instance()
{
if (!Ptr.get())
Ptr.reset(new ServerGameStateFinal);
return *Ptr;
return m_state;
}
ServerGameStateFinal::ServerGameStateFinal()
src/net/common/servergamethread.cpp
+15 -2
View File
@@ -56,7 +56,8 @@ private:
ServerGameThread::ServerGameThread(ServerLobbyThread &lobbyThread, u_int32_t id, const string &name, const string &pwd, const GameData &gameData, unsigned adminPlayerId, GuiInterface &gui, ConfigFile *playerConfig)
: m_adminPlayerId(adminPlayerId), m_lobbyThread(lobbyThread), m_gui(gui),
m_gameData(gameData), m_id(id), m_name(name), m_password(pwd), m_playerConfig(playerConfig),
m_curState(NULL), m_gameNum(1)
m_curState(NULL), m_gameNum(1),
m_stateTimer(boost::posix_time::time_duration(0, 0, 0), boost::timers::portable::microsec_timer::manual_start)
{
m_senderCallback.reset(new GameSenderCallback(*this));
m_sender.reset(new SenderThread(GetSenderCallback()));
@@ -499,10 +500,22 @@ ServerGameThread::GetState()
void
ServerGameThread::SetState(ServerGameState &newState)
{
newState.Init();
newState.Init(*this);
m_curState = &newState;
}
const boost::timers::portable::microsec_timer &
ServerGameThread::GetStateTimer() const
{
return m_stateTimer;
}
boost::timers::portable::microsec_timer &
ServerGameThread::GetStateTimer()
{
return m_stateTimer;
}
SenderThread &
ServerGameThread::GetSender()
{
src/net/servergamestate.h
+27 -36
View File
@@ -44,7 +44,7 @@ public:
virtual ~ServerGameState();
// Initialize after switching to this state.
virtual void Init() = 0;
virtual void Init(ServerGameThread &server) = 0;
// Handling of a new session.
virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session) = 0;
@@ -70,24 +70,6 @@ protected:
virtual int InternalProcess(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) = 0;
};
// Abstract State: Timer.
class AbstractServerGameStateTimer : virtual public ServerGameState
{
public:
virtual ~AbstractServerGameStateTimer();
virtual void Init();
const boost::timers::portable::microsec_timer &GetTimer() const {return m_timer;}
protected:
AbstractServerGameStateTimer();
private:
boost::timers::portable::microsec_timer m_timer;
};
// Abstract State: Game is running.
class AbstractServerGameStateRunning : virtual public ServerGameState
{
@@ -102,6 +84,15 @@ protected:
AbstractServerGameStateRunning();
};
// Abstract State: Timer.
class AbstractServerGameStateTimer : virtual public ServerGameState
{
public:
virtual ~AbstractServerGameStateTimer();
virtual void Init(ServerGameThread &server);
};
// State: Initialization.
class ServerGameStateInit : public AbstractServerGameStateReceiving
{
@@ -111,7 +102,7 @@ public:
virtual ~ServerGameStateInit();
virtual void Init() {}
virtual void Init(ServerGameThread & /*server*/) {}
//
virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session);
@@ -126,7 +117,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateInit> Ptr;
static ServerGameStateInit m_state;
};
// Wait for Ack of start event.
@@ -150,7 +141,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateWaitAck> Ptr;
static ServerGameStateWaitAck m_state;
};
// State: Start server game.
@@ -162,7 +153,7 @@ public:
virtual ~ServerGameStateStartGame();
virtual void Init() {}
virtual void Init(ServerGameThread & /*server*/) {}
//
virtual int Process(ServerGameThread &server);
@@ -174,7 +165,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateStartGame> Ptr;
static ServerGameStateStartGame m_state;
};
// State: Start new hand.
@@ -186,7 +177,7 @@ public:
virtual ~ServerGameStateStartHand();
virtual void Init() {}
virtual void Init(ServerGameThread & /*server*/) {}
//
virtual int Process(ServerGameThread &server);
@@ -198,7 +189,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateStartHand> Ptr;
static ServerGameStateStartHand m_state;
};
// State: Start new round.
@@ -210,7 +201,7 @@ public:
virtual ~ServerGameStateStartRound();
virtual void Init() {}
virtual void Init(ServerGameThread & /*server*/) {}
//
virtual int Process(ServerGameThread &server);
@@ -222,7 +213,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateStartRound> Ptr;
static ServerGameStateStartRound m_state;
};
// State: Wait for a player action.
@@ -248,7 +239,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateWaitPlayerAction> Ptr;
static ServerGameStateWaitPlayerAction m_state;
};
// State: Delay and computer action
@@ -272,7 +263,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateComputerAction> Ptr;
static ServerGameStateComputerAction m_state;
};
// State: Delay after dealing cards
@@ -296,7 +287,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateDealCardsDelay> Ptr;
static ServerGameStateDealCardsDelay m_state;
};
// State: Delay after showing cards (all in)
@@ -320,7 +311,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateShowCardsDelay> Ptr;
static ServerGameStateShowCardsDelay m_state;
};
// State: Delay before next hand.
@@ -344,7 +335,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateNextHandDelay> Ptr;
static ServerGameStateNextHandDelay m_state;
};
// State: Delay before next hand.
@@ -368,7 +359,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateNextGameDelay> Ptr;
static ServerGameStateNextGameDelay m_state;
};
// State: Final.
@@ -380,7 +371,7 @@ public:
virtual ~ServerGameStateFinal();
virtual void Init() {}
virtual void Init(ServerGameThread & /*server*/) {}
protected:
@@ -391,7 +382,7 @@ protected:
private:
static boost::thread_specific_ptr<ServerGameStateFinal> Ptr;
static ServerGameStateFinal m_state;
};
#ifdef _MSC_VER
src/net/servergamethread.h
+7
View File
@@ -24,6 +24,7 @@
#include <net/sessionmanager.h>
#include <gui/guiinterface.h>
#include <gamedata.h>
#include <core/boost/timers.hpp>
#include <deque>
@@ -108,6 +109,9 @@ protected:
ServerGameState &GetState();
void SetState(ServerGameState &newState);
const boost::timers::portable::microsec_timer &GetStateTimer() const;
boost::timers::portable::microsec_timer &GetStateTimer();
SenderThread &GetSender();
ReceiverHelper &GetReceiver();
@@ -153,8 +157,11 @@ private:
ServerGameState *m_curState;
unsigned m_gameNum;
boost::timers::portable::microsec_timer m_stateTimer;
friend class AbstractServerGameStateReceiving;
friend class AbstractServerGameStateRunning;
friend class AbstractServerGameStateTimer;
friend class ServerGameStateInit;
friend class ServerGameStateWaitAck;
friend class ServerGameStateStartGame;