void GameHandler::on_link_lost(SEGSEvent *ev)
{
GameLink * lnk = (GameLink *)ev->src();
GameSession &session = m_session_store.session_from_event(ev);
if(session.is_connected_to_map_server_id==0)
{
if(session.m_direction==GameSession::EXITING_TO_MAP)
{
SessionStore::MTGuard guard(m_session_store.reap_lock());
m_session_store.mark_session_for_reaping(&session,lnk->session_token());
m_session_store.session_link_lost(lnk->session_token());
}
else
{
EventProcessor * tgt = HandlerLocator::getAuth_Handler();
tgt->putq(new ClientDisconnectedMessage({lnk->session_token()}));
m_session_store.session_link_lost(lnk->session_token());
m_session_store.remove_by_token(lnk->session_token(), session.auth_id());
}
}
else
m_session_store.session_link_lost(lnk->session_token());
// Post disconnect event to link, will close it's processing loop
lnk->putq(new DisconnectEvent(lnk->session_token()));
}
void GameHandler::on_disconnect(DisconnectRequest *ev)
{
GameLink * lnk = (GameLink *)ev->src();
GameSession &session = m_session_store.session_from_event(ev);
if(session.is_connected_to_map_server_id==0)
{
if(session.m_direction==GameSession::EXITING_TO_MAP)
{
SessionStore::MTGuard guard(m_session_store.reap_lock());
m_session_store.mark_session_for_reaping(&session,lnk->session_token());
m_session_store.session_link_lost(lnk->session_token());
}
else
{
EventProcessor * tgt = HandlerLocator::getAuth_Handler();
tgt->putq(new ClientDisconnectedMessage({lnk->session_token()}));
m_session_store.session_link_lost(lnk->session_token());
m_session_store.remove_by_token(lnk->session_token(), session.auth_id());
}
}
else
m_session_store.session_link_lost(lnk->session_token());
lnk->putq(new DisconnectResponse);
// Post disconnect event to link, will close it's processing loop, after it sends the response
lnk->putq(new DisconnectEvent(lnk->session_token())); // this should work, event if different threads try to do it in parallel
}
void GameHandler::reap_stale_links()
{
SessionStore::MTGuard guard(m_session_store.reap_lock());
EventProcessor * tgt = HandlerLocator::getAuth_Handler();
m_session_store.reap_stale_links("GameInstance", link_is_stale_if_disconnected_for,
[tgt](uint64_t tok) {
tgt->putq(new ClientDisconnectedMessage({tok}));
});
}
void COgreKeyboard::init ( RenderWindow *theWindow )
{
if (eventProcessor)
kill();
eventProcessor = new EventProcessor();
eventProcessor->initialise(theWindow);
eventProcessor->addKeyListener(this);
eventProcessor->startProcessingEvents();
}
///
/// \brief This handler is called when we get the account information for a
/// \param ev
///
void GameHandler::on_account_data(GameAccountResponse *ev)
{
GameSession &session(m_session_store.session_from_event(ev));
// we've got db answer, session is ok again
m_session_store.locked_unmark_session_for_reaping(&session);
session.m_game_account = ev->m_data;
// Inform auth server about succesful client connection
EventProcessor *tgt = HandlerLocator::getAuth_Handler();
tgt->putq(new ClientConnectedMessage({ev->session_token(),m_server->getId(),0 }));
m_session_store.add_to_active_sessions(&session);
CharacterSlots *slots_event=new CharacterSlots;
slots_event->set_account_data(&session.m_game_account);
session.link()->putq(slots_event);
}
/*!
* @brief Add a user
* @param[in] username
* @param[in] password
* @param[in] access_level
* @return Returns a string, if successful "OK" otherwise an error
*/
QString AdminRPC::addUser(const QString &username, const QString &password, int access_level)
{
QString result;
uint64_t fake_session_token = s_last_token++;
int token = static_cast<int>(fake_session_token);
// Create and insert a record of this request into m_completion_state
m_completion_state.insert(token, "");
qCDebug(logRPC) << "addUser call in progress";
EventProcessor *tgt = HandlerLocator::getAuthDB_Handler();
tgt->putq(new CreateAccountMessage({username, password, access_level}, fake_session_token, this));
QTimer response_timer;
QTimer timeout;
timeout.setSingleShot(true);
QEventLoop loop;
loop.connect(&timeout, SIGNAL(timeout()), SLOT(quit()));
loop.connect(this, SIGNAL(responseRecieved()), SLOT(quit()));
loop.connect(&response_timer, &QTimer::timeout, [=] () {
if (!m_completion_state[token].isEmpty())
{
emit responseRecieved(); // Response recieved we can break out of event loop
return;
}
else
return;
});
response_timer.start(500); // Checks completion status every 500ms
timeout.start(5000); // Timeout of 5 seconds in case something goes wrong.
loop.exec();
if (!m_completion_state[token].isEmpty())
{
result = m_completion_state[token];
response_timer.stop();
m_completion_state.remove(token); // Tidy up
}
else
{
result = "Something went wrong";
response_timer.stop();
m_completion_state.remove(token);
}
return result;
}
void LoadBBY::loadEvents(API::Progress &prog, const char *progMsg,
ANSTO::Tar::File &tarFile,
EventProcessor &eventProcessor) {
prog.doReport(progMsg);
// select bin file
int64_t fileSize = 0;
const std::vector<std::string> &files = tarFile.files();
for (const auto &file : files)
if (file.rfind(".bin") == file.length() - 4) {
tarFile.select(file.c_str());
fileSize = tarFile.selected_size();
break;
}
// for progress notifications
ANSTO::ProgressTracker progTracker(prog, progMsg, fileSize,
Progress_LoadBinFile);
uint64_t x = 0; // 9 bits [0-239] tube number
uint64_t y = 0; // 8 bits [0-255] position along tube
// uint v = 0; // 0 bits [ ]
// uint w = 0; // 0 bits [ ] energy
uint64_t dt = 0;
double tof = 0.0;
if ((fileSize == 0) || !tarFile.skip(128))
return;
int state = 0;
uint64_t c;
while ((c = static_cast<unsigned int>(tarFile.read_byte())) !=
static_cast<unsigned int>(-1)) {
bool event_ended = false;
switch (state) {
case 0:
x = (c & 0xFF) >> 0; // set bit 1-8
break;
case 1:
x |= (c & 0x01) << 8; // set bit 9
y = (c & 0xFE) >> 1; // set bit 1-7
break;
case 2:
event_ended = (c & 0xC0) != 0xC0;
if (!event_ended)
c &= 0x3F;
y |= (c & 0x01) << 7; // set bit 8
dt = (c & 0xFE) >> 1; // set bit 1-5(7)
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
event_ended = (c & 0xC0) != 0xC0;
if (!event_ended)
c &= 0x3F;
dt |= (c & 0xFF) << (5 + 6 * (state - 3)); // set bit 6...
break;
}
state++;
if (event_ended || (state == 8)) {
state = 0;
if ((x == 0) && (y == 0) && (dt == 0xFFFFFFFF)) {
tof = 0.0;
eventProcessor.newFrame();
} else if ((x >= HISTO_BINS_X) || (y >= HISTO_BINS_Y)) {
// ignore
} else {
// conversion from 100 nanoseconds to 1 microsecond
tof += static_cast<int>(dt) * 0.1;
eventProcessor.addEvent(x, y, tof);
}
progTracker.update(tarFile.selected_position());
}
}
}
