void Pipe::flushFrames( ObjectManager* om )
{
LB_TS_THREAD( _pipeThread );
ClientPtr client = getClient();
for( FrameHashCIter i = _impl->frames.begin(); i !=_impl->frames.end(); ++i)
{
Frame* frame = i->second;
frame->setFrameData( 0 ); // datas are flushed below
client->unmapObject( frame );
delete frame;
}
_impl->frames.clear();
for( FrameDataHashCIter i = _impl->inputFrameDatas.begin();
i != _impl->inputFrameDatas.end(); ++i )
{
FrameDataPtr data = i->second;
data->deleteGLObjects( om );
}
_impl->inputFrameDatas.clear();
for( FrameDataHashCIter i = _impl->outputFrameDatas.begin();
i != _impl->outputFrameDatas.end(); ++i )
{
FrameDataPtr data = i->second;
data->resetPlugins();
data->deleteGLObjects( om );
client->unmapObject( data.get( ));
getNode()->releaseFrameData( data );
}
_impl->outputFrameDatas.clear();
}
void Node::_flushObjects()
{
ClientPtr client = getClient();
{
lunchbox::ScopedMutex<> mutex( _barriers );
for( BarrierHash::const_iterator i =_barriers->begin();
i != _barriers->end(); ++ i )
{
co::Barrier* barrier = i->second;
client->unmapObject( barrier );
delete barrier;
}
_barriers->clear();
}
lunchbox::ScopedMutex<> mutex( _frameDatas );
LBASSERT( _frameDatas->empty( ));
for( FrameDataHashCIter i = _frameDatas->begin();
i != _frameDatas->end(); ++i )
{
FrameDataPtr frameData = i->second;
client->unmapObject( frameData.get( ));
}
_frameDatas->clear();
}
Config* Server::chooseConfig( const fabric::ConfigParams& p )
{
if( !isConnected( ))
return 0;
ClientPtr client = getClient();
fabric::ConfigParams params( p );
if( params.getWorkDir().empty( ))
params.setWorkDir( Global::getWorkDir( ));
if( params.getRenderClient().empty( ))
params.setRenderClient( Global::getProgramName( ));
if( params.getGPUFilter().empty( ))
params.setGPUFilter( client->getGPUFilter( ));
if( params.getRenderClient().empty( ))
{
LBWARN << "No render client in ConfigParams specified" << std::endl;
return 0;
}
const uint32_t requestID = client->registerRequest();
send( fabric::CMD_SERVER_CHOOSE_CONFIG )
<< requestID << params << eq::Global::getConfigFile();
while( !client->isRequestServed( requestID ))
getClient()->processCommand();
void* ptr = 0;
client->waitRequest( requestID, ptr );
return static_cast<Config*>( ptr );
}
void Config::setupMessagePump( Pipe* pipe )
{
const bool isThreaded = pipe->isThreaded();
const WindowSystem windowSystem = pipe->getWindowSystem();
if( isThreaded && windowSystem.getName() != "AGL" )
return;
// called from pipe threads - but only during init
static co::base::Lock _lock;
co::base::ScopedWrite mutex( _lock );
if( _eventQueue.getMessagePump( )) // Already done
return;
MessagePump* pump = pipe->createMessagePump();
_eventQueue.setMessagePump( pump );
ClientPtr client = getClient();
CommandQueue* queue = EQSAFECAST( CommandQueue*,
client->getMainThreadQueue( ));
EQASSERT( queue );
EQASSERT( !queue->getMessagePump( ));
queue->setMessagePump( pump );
}
MojErr PopBusDispatcher::SyncFolder(MojServiceMessage* msg, MojObject& payload)
{
// cacel shut down if it is in shut down state
CancelShutdown();
MojLogTrace(s_log);
MojLogInfo(s_log, "SyncFolder's payload: %s", AsJsonString(payload).c_str());
try {
// TODO: need to figure out how to get/create activity
ActivityPtr activity; // = GetActivity(payload);
MojObject accountId;
MojErr err = payload.getRequired("accountId", accountId);
ErrorToException(err);
ClientPtr client = GetOrCreateClient(accountId, false);
client->SyncFolder(payload);
err = msg->replySuccess();
ErrorToException(err);
return MojErrNone;
} catch (const std::exception& e) {
MojErrThrowMsg(MojErrInternal, "%s", e.what());
}
return MojErrNone;
}
Config* getConfig( const int argc, char** argv )
{
// 1. initialization of a local client node
ClientPtr client = new Client;
if( client->initLocal( argc, argv ))
{
// 2. connect to server
ServerPtr server = new Server;
if( client->connectServer( server ))
{
// 3. choose configuration
ConfigParams configParams;
Config* config = server->chooseConfig( configParams );
if( config )
return config;
LBERROR << "No matching config on server" << std::endl;
// -2. disconnect server
client->disconnectServer( server );
}
else
LBERROR << "Can't open server" << std::endl;
// -1. exit local client node
client->exitLocal();
}
else
LBERROR << "Can't init local client node" << std::endl;
return 0;
}
MojErr PopBusDispatcher::CredentialsChanged(MojServiceMessage* msg, MojObject& payload)
{
// cancel shut down if it is in shut down state
CancelShutdown();
MojLogTrace(s_log);
MojString json;
MojErr err = payload.toJson(json);
ErrorToException(err);
MojLogInfo(s_log, "PopBusDispatcher::CredentialsChanged: payload=%s", json.data());
MojObject accountId;
err = payload.getRequired("accountId", accountId);
ErrorToException(err);
try {
ClientPtr client = GetOrCreateClient(accountId);
// Calling UpdateAccount will force a folder sync.
client->UpdateAccount(payload, true);
} catch (const std::exception& e) {
MojErrThrowMsg(MojErrInternal, "%s", e.what());
}
return msg->replySuccess();
}
void Pipe::_releaseViews()
{
LB_TS_THREAD( _pipeThread );
for( bool changed = true; changed; )
{
changed = false;
for( ViewHashIter i =_impl->views.begin(); i !=_impl->views.end(); ++i )
{
View* view = i->second;
view->commit();
if( view->getVersion() + 20 > view->getHeadVersion( ))
continue;
// release unused view to avoid memory leaks due to deltas piling up
view->_pipe = 0;
ClientPtr client = getClient();
client->unmapObject( view );
_impl->views.erase( i );
NodeFactory* nodeFactory = Global::getNodeFactory();
nodeFactory->releaseView( view );
changed = true;
break;
}
}
}
MojErr PopBusDispatcher::AccountEnabled(MojServiceMessage* msg, MojObject& payload)
{
// cacel shut down if it is in shut down state
CancelShutdown();
MojLogTrace(s_log);
MojLogInfo(s_log, "AccountEnabled's payload: %s", AsJsonString(payload).c_str());
bool enabled = false;
MojErr err = payload.getRequired("enabled", enabled);
ErrorToException(err);
MojObject accountId;
err = payload.getRequired("accountId", accountId);
ErrorToException(err);
if(enabled) {
ClientPtr client = GetOrCreateClient(accountId, false);
client->EnableAccount(msg, payload);
client->UpdateAccount(payload, false);
}
else {
ClientPtr client = GetOrCreateClient(accountId, false);
client->DisableAccount(msg, payload);
}
return MojErrNone;
}
void Config::deregisterObject( co::Object* object )
{
EQASSERT( object )
EQASSERT( object->isMaster( ));
if( !object->isAttached( )) // not registered
return;
const uint32_t latency = getLatency();
ClientPtr client = getClient();
if( latency == 0 || !_running || !object->isBuffered( )) // OPT
{
client->deregisterObject( object );
return;
}
// Keep a distributed object latency frames.
// Replaces the object with a dummy proxy object using the
// existing master change manager.
ConfigSwapObjectPacket packet;
packet.requestID = getLocalNode()->registerRequest();
packet.object = object;
send( client, packet );
client->waitRequest( packet.requestID );
}
Config* Server::chooseConfig( const ConfigParams& parameters )
{
if( !isConnected( ))
return 0;
const std::string& renderClient = parameters.getRenderClient();
if( renderClient.empty( ))
{
EQWARN << "No render client in ConfigParams specified" << std::endl;
return 0;
}
ServerChooseConfigPacket packet;
ClientPtr client = getClient();
packet.requestID = client->registerRequest();
const std::string& workDir = parameters.getWorkDir();
std::string rendererInfo = workDir + '#' + renderClient;
#ifdef _WIN32 // replace dir delimiters since '\' is often used as escape char
for( size_t i=0; i<rendererInfo.length(); ++i )
if( rendererInfo[i] == '\\' )
rendererInfo[i] = '/';
#endif
send( packet, rendererInfo );
while( !client->isRequestServed( packet.requestID ))
getClient()->processCommand();
void* ptr = 0;
client->waitRequest( packet.requestID, ptr );
return static_cast<Config*>( ptr );
}
PopBusDispatcher::ClientPtr PopBusDispatcher::GetOrCreateClient(MojObject& accountId, bool sync)
{
MojLogTrace(s_log);
ClientPtr client;
ClientMap::iterator it;
it = m_clients.find(accountId);
if (it == m_clients.end()) {
MojLogInfo(s_log, "Creating PopClient");
shared_ptr<DatabaseInterface> databaseInterface(new MojoDatabase(m_dbClient));
client.reset(new PopClient(databaseInterface, this, accountId, &m_service));
m_clients[accountId] = client;
client->CreateSession();
MojLogInfo(s_log, "Setting pop client with account id %s", AsJsonString(accountId).c_str());
} else {
client = it->second;
}
assert(client.get());
MojObject payload;
if (sync) {
client->SyncAccount(payload);
}
return client;
}
MojErr PopBusDispatcher::AccountCreator::CreatePopAccountResponse(MojObject& response, MojErr err)
{
MojLogInfo(m_log, "AccountCreator::CreatePopAccountResponse");
MojLogTrace(m_log);
if (err)
return m_msg->replyError(err);
MojString json;
err = response.toJson(json);
MojLogInfo(m_log, "%s", json.data());
// put the id we have just gotten into the payload we send to smtp account
MojObject resultArray;
err = response.getRequired("results", resultArray);
ErrorToException(err);
MojObject result;
resultArray.at(0, result);
MojObject mailAccountId;
err = result.getRequired("id", mailAccountId);
ErrorToException(err);
err = m_payload.put("mailAccountId", mailAccountId);
ErrorToException(err);
MojObject accountId;
err = m_payload.getRequired("accountId", accountId);
ErrorToException(err);
ClientPtr client = m_dispatcher.GetOrCreateClient(accountId);
client->SendRequest(m_smtpAccountCreatedSlot, "com.palm.smtp", "accountCreated", m_payload);
return MojErrNone;
}
uint32_t Config::finishAllFrames()
{
if( _finishedFrame == _currentFrame )
return _currentFrame;
EQLOG( co::base::LOG_ANY ) << "-- Finish All Frames --" << std::endl;
ConfigFinishAllFramesPacket packet;
send( getServer(), packet );
ClientPtr client = getClient();
const uint32_t timeout = getTimeout();
while( _finishedFrame < _currentFrame )
{
try
{
client->processCommand( timeout );
}
catch( const co::Exception& e )
{
EQWARN << e.what() << std::endl;
break;
}
}
handleEvents();
_updateStatistics( _currentFrame );
_releaseObjects();
EQLOG( co::base::LOG_ANY ) << "-- Finished All Frames --" << std::endl;
return _currentFrame;
}
bool Config::exit()
{
update();
finishAllFrames();
co::LocalNodePtr localNode = getLocalNode();
localNode->disableSendOnRegister();
ConfigExitPacket packet;
packet.requestID = localNode->registerRequest();
send( getServer(), packet );
ClientPtr client = getClient();
while( !localNode->isRequestServed( packet.requestID ))
client->processCommand();
bool ret = false;
localNode->waitRequest( packet.requestID, ret );
while( tryNextEvent( )) /* flush all pending events */ ;
if( _lastEvent )
_lastEvent->release();
_eventQueue.flush();
_lastEvent = 0;
_running = false;
return ret;
}
bool Config::init( const uint128_t& initID )
{
EQASSERT( !_running );
_currentFrame = 0;
_unlockedFrame = 0;
_finishedFrame = 0;
_frameTimes.clear();
co::LocalNodePtr localNode = getLocalNode();
ConfigInitPacket packet;
packet.requestID = localNode->registerRequest();
packet.initID = initID;
send( getServer(), packet );
ClientPtr client = getClient();
while( !localNode->isRequestServed( packet.requestID ))
client->processCommand();
localNode->waitRequest( packet.requestID, _running );
localNode->enableSendOnRegister();
if( _running )
handleEvents();
else
EQWARN << "Config initialization failed: " << getError() << std::endl
<< " Consult client log for further information" << std::endl;
return _running;
}
Config* Server::chooseConfig( const fabric::ConfigParams& p )
{
if( !isConnected( ))
return 0;
ClientPtr client = getClient();
fabric::ConfigParams params( p );
if( params.getName().empty( ))
params.setName( client->getName( ));
if( params.getWorkDir().empty( ))
params.setWorkDir( Global::getWorkDir( ));
if( params.getRenderClient().empty( ))
params.setRenderClient( Global::getProgramName( ));
if( params.getGPUFilter().empty( ))
params.setGPUFilter( client->getGPUFilter( ));
if( params.getRenderClient().empty( ))
LBWARN << "No render client in ConfigParams specified" << std::endl;
lunchbox::Request< void* > request = client->registerRequest< void* >();
send( fabric::CMD_SERVER_CHOOSE_CONFIG )
<< request << params << eq::Global::getConfigFile();
while( !request.isReady( ))
getClient()->processCommand();
return static_cast< Config* >( request.wait( ));
}
MessagePump* Config::getMessagePump()
{
ClientPtr client = getClient();
CommandQueue* queue = EQSAFECAST( CommandQueue*,
client->getMainThreadQueue( ));
if( queue )
return queue->getMessagePump();
return 0;
}
void PopBusDispatcher::Cleanup()
{
for (ClientMap::iterator it = m_clients.begin(); it != m_clients.end(); it++) {
ClientPtr client = (*it).second;
if (client->IsAccountDeleted()) {
m_clients.erase(it);
break;
}
}
}
void Gamefield::onStart(ClientPtr client, PacketPtr packet) {
auto p = std::dynamic_pointer_cast<StartPacket >(packet);
String color = mOptions.player.color[rand()%mOptions.player.color.size()];
printf("Player %s joind the game\n", p->Name.c_str());
PlayerPtr ply = std::make_shared<Player>(shared_from_this(), client, color, p->Name);
mPlayer[client->getId()] = ply;
ply->addBall(createBall(ply));
ply->updateClient();
client->emit(std::make_shared<EmptyPacket<PID_Start> >());
}
void Server::releaseConfig( Config* config )
{
LBASSERT( isConnected( ));
ClientPtr client = getClient();
lunchbox::Request< void > request = client->registerRequest< void >();
send( fabric::CMD_SERVER_RELEASE_CONFIG ) << config->getID() << request;
while( !request.isReady( ))
client->processCommand();
}
void Server::unmap()
{
ClientPtr client = getClient();
const uint32_t requestID = client->registerRequest();
send( fabric::CMD_SERVER_UNMAP ) << requestID;
while( !client->isRequestServed( requestID ))
client->processCommand();
client->waitRequest( requestID );
}
void Server::releaseConfig( Config* config )
{
LBASSERT( isConnected( ));
ClientPtr client = getClient();
const uint32_t requestID = client->registerRequest();
send( fabric::CMD_SERVER_RELEASE_CONFIG ) << config->getID() << requestID;
while( !client->isRequestServed( requestID ))
client->processCommand();
client->waitRequest( requestID );
}
uint32_t Config::finishFrame()
{
ClientPtr client = getClient();
const uint32_t latency = getLatency();
const uint32_t frameToFinish = (_currentFrame >= latency) ?
_currentFrame - latency : 0;
ConfigStatistics stat( Statistic::CONFIG_FINISH_FRAME, this );
stat.event.data.statistic.frameNumber = frameToFinish;
{
ConfigStatistics waitStat( Statistic::CONFIG_WAIT_FINISH_FRAME, this );
waitStat.event.data.statistic.frameNumber = frameToFinish;
// local draw sync
if( _needsLocalSync( ))
while( _unlockedFrame < _currentFrame )
client->processCommand();
// local node finish (frame-latency) sync
const Nodes& nodes = getNodes();
if( !nodes.empty( ))
{
EQASSERT( nodes.size() == 1 );
const Node* node = nodes.front();
while( node->getFinishedFrame() < frameToFinish )
client->processCommand();
}
// global sync
const uint32_t timeout = getTimeout();
co::base::Clock time;
const int64_t pingTimeout = co::Global::getKeepaliveTimeout();
while( !_finishedFrame.timedWaitGE( frameToFinish, pingTimeout ))
{
if( time.getTime64() >= timeout || !getLocalNode()->pingIdleNodes())
{
EQWARN << "Timeout waiting for nodes to finish frame "
<< frameToFinish << std::endl;
break;
}
}
}
handleEvents();
_updateStatistics( frameToFinish );
_releaseObjects();
EQLOG( co::base::LOG_ANY ) << "---- Finished Frame --- " << frameToFinish
<< " (" << _currentFrame << ')' << std::endl;
return frameToFinish;
}
void Pipe::_flushQueues()
{
LB_TS_THREAD( _pipeThread );
ClientPtr client = getClient();
for( QueueHashCIter i = _impl->queues.begin(); i !=_impl->queues.end(); ++i)
{
co::QueueSlave* queue = i->second;
client->unmapObject( queue );
delete queue;
}
_impl->queues.clear();
}
void HubApi::on(ClientManagerListener::ClientRemoved, const ClientPtr& aClient) noexcept {
addAsyncTask([=] {
removeSubModule(aClient->getClientId());
if (!subscriptionActive("hub_removed")) {
return;
}
send("hub_removed", {
{ "id", aClient->getClientId() }
});
});
}
PlayerBehavior::CONTROLL PlayerBehavior::makeControll( ) {
PlayerBehavior::CONTROLL controll;
if ( _controll ) {
// 自分で動かす
DevicePtr device = Device::getTask( );
unsigned char button = device->getButton( );
CameraPtr camera = Camera::getTask( );
PlayerCameraPtr p_camera = std::dynamic_pointer_cast< PlayerCamera >( camera );
Vector move_vec = p_camera->getConvertDeviceVec( );
Character::STATUS status = _parent->getStatus( );
move_vec = move_vec.normalize( ) * status.speed;//プレイヤーの進行ベクトル
controll.move = move_vec;
if ( button & BUTTON_D ) {
controll.action = CONTROLL::DEATHBLOW;
} else if ( button & BUTTON_A ) {
controll.action = CONTROLL::ATTACK;
} else {
controll.action = CONTROLL::NONE;
}
} else {
// ネットから動かす
ClientPtr client = Client::getTask( );
CLIENTDATA data = client->getClientData( );
Vector target;
target.x = data.player[ _player_id ].x;
target.y = data.player[ _player_id ].y;
Vector vec = target - _parent->getPos( );
Character::STATUS status = _parent->getStatus( );
if ( vec.getLength( ) > status.speed * 2 ) {
vec = vec.normalize( ) * status.speed;
controll.move = vec;
}
switch ( data.player[ _player_id ].action ) {
case ACTION_NONE:
controll.action = CONTROLL::NONE;
break;
case ACTION_ATTACK:
controll.action = CONTROLL::ATTACK;
break;
case ACTION_DEATHBLOW:
controll.action = CONTROLL::MUSTDEATHBLOW;
break;
}
}
return controll;
}
void Gamefield::onJoin(ClientPtr client, PacketPtr packet) {
//Set Callbacks
client->on(PID_Leave, std::bind(&Gamefield::onLeave, this, _1, _2));
client->on(PID_Start, std::bind(&Gamefield::onStart, this, _1, _2));
client->on(PID_GetStats, std::bind(&Gamefield::onGetStats, this, _1, _2));
client->setOnDisconnect(std::bind(&Gamefield::onDisconnected, this, _1));
//Send all elements
client->emit(std::make_shared<SetElementsPacket>(mElements));
//Add to update queue
mClients.push_back(client);
if(mUpdaterRunning == false)
startUpdater();
}
json HubApi::serializeClient(const ClientPtr& aClient) noexcept {
json j = {
{ "identity", HubInfo::serializeIdentity(aClient) },
{ "connect_state", HubInfo::serializeConnectState(aClient) },
{ "hub_url", aClient->getHubUrl() },
{ "id", aClient->getClientId() },
{ "favorite_hub", aClient->getFavToken() },
{ "share_profile", aClient->getShareProfile() }
//{ "share_profile", Serializer::serializeShare aClient->getShareProfile() },
};
Serializer::serializeCacheInfo(j, aClient->getCache(), Serializer::serializeUnreadChat);
return j;
}
/**
* Checks to see if POP transport can be shut down or not.
*/
bool PopBusDispatcher::CanShutdown()
{
bool shutdown = true;
ClientMap::iterator it;
for (it = m_clients.begin(); it != m_clients.end(); ++it) {
ClientPtr client = (*it).second;
if (client->IsActive()) {
shutdown = false;
break;
}
}
return shutdown;
}
