bool revive_if_needed(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
// Revive.
session.create_sync_session();
session.advance_state(lock, waiting_for_access_token);
return true;
}
bool access_token_expired(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
session.advance_state(lock, waiting_for_access_token);
std::shared_ptr<SyncSession> session_ptr = session.shared_from_this();
lock.unlock();
session.m_config.bind_session_handler(session_ptr->m_realm_path, session_ptr->m_config, session_ptr);
return false;
}
void bind_with_admin_token(std::unique_lock<std::mutex>& lock, SyncSession& session,
const std::string& admin_token,
const std::string& server_url) const override
{
session.create_sync_session();
session.advance_state(lock, waiting_for_access_token);
session.m_state->refresh_access_token(lock, session, admin_token, server_url);
}
void close(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
switch (session.m_config.stop_policy) {
case SyncSessionStopPolicy::Immediately:
session.advance_state(lock, inactive);
break;
case SyncSessionStopPolicy::LiveIndefinitely:
// Don't do anything; session lives forever.
break;
case SyncSessionStopPolicy::AfterChangesUploaded:
// Wait for all pending changes to upload.
session.advance_state(lock, dying);
break;
}
}
void handle_reconnect(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
// Ask the binding to retry getting the token for this session.
std::shared_ptr<SyncSession> session_ptr = session.shared_from_this();
lock.unlock();
session.m_config.bind_session_handler(session_ptr->m_realm_path, session_ptr->m_config, session_ptr);
}
void refresh_access_token(std::unique_lock<std::mutex>& lock, SyncSession& session,
std::string access_token,
const util::Optional<std::string>& server_url) const override
{
// Since the sync session was previously unbound, it's safe to do this from the
// calling thread.
if (!session.m_server_url) {
session.m_server_url = server_url;
}
if (session.m_session_has_been_bound) {
session.m_session->refresh(std::move(access_token));
} else {
session.m_session->bind(*session.m_server_url, std::move(access_token));
session.m_session_has_been_bound = true;
}
if (session.m_deferred_commit_notification) {
session.m_session->nonsync_transact_notify(*session.m_deferred_commit_notification);
session.m_deferred_commit_notification = util::none;
}
session.advance_state(lock, active);
if (session.m_deferred_close) {
session.m_deferred_close = false;
session.m_state->close(lock, session);
}
}
void enter_state(std::unique_lock<std::mutex>&, SyncSession& session) const override
{
size_t current_death_count = ++session.m_death_count;
session.m_session->async_wait_for_upload_completion([session=&session, current_death_count](std::error_code) {
std::unique_lock<std::mutex> lock(session->m_state_mutex);
if (session->m_state == &State::dying && session->m_death_count == current_death_count) {
session->advance_state(lock, inactive);
}
});
}
void enter_state(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
// Inform any queued-up completion handlers that they were cancelled.
for (auto& package : session.m_completion_wait_packages) {
package.callback(util::error::operation_aborted);
}
session.m_completion_wait_packages.clear();
session.m_session = nullptr;
session.unregister(lock);
}
void enter_state(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
// If we have no session, we cannot possibly upload anything.
if (!session.m_session) {
session.advance_state(lock, inactive);
return;
}
size_t current_death_count = ++session.m_death_count;
std::weak_ptr<SyncSession> weak_session = session.shared_from_this();
session.m_session->async_wait_for_upload_completion([weak_session, current_death_count](std::error_code) {
if (auto session = weak_session.lock()) {
std::unique_lock<std::mutex> lock(session->m_state_mutex);
if (session->m_state == &State::dying && session->m_death_count == current_death_count) {
session->advance_state(lock, inactive);
}
}
});
}
bool_t SyncAcceptor::OnRead(EventResult *evr)
{
bool_t ret = FALSE;
SyncSession *sess = 0;
ret = MakeEventHandler(sess);
if(!ret) { ECILA_TRACE(); return FALSE; }
ret = AcceptEventHandler(sess);
if(!ret) { ECILA_TRACE(); goto _ERROR; }
ret = ActivateEventHandler(sess);
if(!ret) { ECILA_TRACE(); goto _ERROR; }
return TRUE;
_ERROR:
sess->OnClose(0);
return FALSE;
}
bool handle_error(std::unique_lock<std::mutex>& lock, SyncSession& session, const SyncError& error) const override
{
if (error.is_fatal) {
session.advance_state(lock, inactive);
}
// If the error isn't fatal, don't change state, but don't
// allow it to be reported either.
// FIXME: What if the token expires while a session is dying?
// Should we allow the token to be refreshed so that changes
// can finish being uploaded?
return true;
}
void refresh_access_token(std::unique_lock<std::mutex>& lock, SyncSession& session,
std::string access_token,
const util::Optional<std::string>& server_url) const override
{
session.create_sync_session();
// Since the sync session was previously unbound, it's safe to do this from the
// calling thread.
if (!session.m_server_url) {
session.m_server_url = server_url;
}
if (session.m_session_has_been_bound) {
session.m_session->refresh(std::move(access_token));
session.m_session->cancel_reconnect_delay();
} else {
session.m_session->bind(*session.m_server_url, std::move(access_token));
session.m_session_has_been_bound = true;
}
if (session.m_server_override)
session.m_session->override_server(session.m_server_override->address, session.m_server_override->port);
// Register all the pending wait-for-completion blocks.
for (auto& package : session.m_completion_wait_packages) {
(*session.m_session.*package.waiter)(std::move(package.callback));
}
session.m_completion_wait_packages.clear();
// Handle any deferred commit notification.
if (session.m_deferred_commit_notification) {
session.m_session->nonsync_transact_notify(*session.m_deferred_commit_notification);
session.m_deferred_commit_notification = util::none;
}
session.advance_state(lock, active);
if (session.m_deferred_close) {
session.m_state->close(lock, session);
}
}
void close(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
switch (session.m_config.stop_policy) {
case SyncSessionStopPolicy::Immediately:
// Immediately kill the session.
session.advance_state(lock, inactive);
break;
case SyncSessionStopPolicy::LiveIndefinitely:
case SyncSessionStopPolicy::AfterChangesUploaded:
// Defer handling closing the session until after the login response succeeds.
session.m_deferred_close = true;
break;
}
}
void enter_state(std::unique_lock<std::mutex>&, SyncSession& session) const override
{
++session.m_pending_upload_threads;
std::thread([session=&session] {
std::unique_lock<std::mutex> lock(session->m_state_mutex);
if (session->m_pending_upload_threads != 1) {
--session->m_pending_upload_threads;
return;
}
if (session->m_state != &State::dying) {
// The session was revived. Don't kill it.
--session->m_pending_upload_threads;
return;
}
session->m_session->wait_for_upload_complete_or_client_stopped();
--session->m_pending_upload_threads;
session->advance_state(lock, inactive);
}).detach();
}
static void handle_progress_update(SyncSession& session, uint64_t downloaded, uint64_t downloadable,
uint64_t uploaded, uint64_t uploadable, bool is_fresh=true) {
session.handle_progress_update(downloaded, downloadable, uploaded, uploadable, is_fresh);
}
void close_if_connecting(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
// Ignore the sync configuration's stop policy as we're not yet connected.
session.advance_state(lock, inactive);
}
static void handle_error(SyncSession& session, SyncError error)
{
session.handle_error(std::move(error));
}
static void nonsync_transact_notify(SyncSession& session, VersionID::version_type version)
{
session.nonsync_transact_notify(version);
}
static void set_error_handler(SyncSession& session, std::function<SyncSessionErrorHandler> callback)
{
session.set_error_handler(std::move(callback));
}
void log_out(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
session.advance_state(lock, inactive);
}
bool revive_if_needed(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
// Revive.
session.advance_state(lock, active);
return false;
}
inline bool sessions_are_inactive(const SyncSession& session)
{
return session.state() == SyncSession::PublicState::Inactive;
}
void enter_state(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
session.m_session = nullptr;
session.m_server_url = util::none;
session.unregister(lock);
}
inline bool sessions_are_connected(const SyncSession& session) {
return session.connection_state() == SyncSession::ConnectionState::Connected;
}
static void set_sync_transact_callback(SyncSession& session,
std::function<SyncSessionTransactCallback> callback)
{
session.set_sync_transact_callback(std::move(callback));
}
void access_token_expired(std::unique_lock<std::mutex>& lock, SyncSession& session) const override
{
session.advance_state(lock, waiting_for_access_token);
}
