static void
qof_session_load_backend(QofSession * session, const char * access_method)
{
GSList *p;
QofBackendProvider *prov;
char *msg;
gboolean prov_type;
gboolean (*type_check) (const char*);
ENTER (" list=%d, initted=%s", g_slist_length(provider_list),
qof_providers_initialized ? "true" : "false");
prov_type = FALSE;
if (!qof_providers_initialized)
{
qof_providers_initialized = TRUE;
}
p = provider_list;
while (p != NULL)
{
prov = static_cast<QofBackendProvider*>(p->data);
/* Does this provider handle the desired access method? */
if (0 == g_ascii_strcasecmp (access_method, prov->access_method))
{
/* More than one backend could provide this
access method, check file type compatibility. */
type_check = (gboolean (*)(const char*)) prov->check_data_type;
if (type_check)
{
prov_type = (type_check)(session->book_id);
if (!prov_type)
{
PINFO(" %s not usable", prov->provider_name);
p = p->next;
continue;
}
}
PINFO (" selected %s", prov->provider_name);
if (NULL == prov->backend_new)
{
p = p->next;
continue;
}
/* Use the providers creation callback */
session->backend = (*(prov->backend_new))();
session->backend->provider = prov;
/* Tell the book about the backend that they'll be using. */
qof_book_set_backend (session->book, session->backend);
LEAVE (" ");
return;
}
p = p->next;
}
msg = g_strdup_printf("failed to load '%s' using access_method", access_method);
qof_session_push_error (session, ERR_BACKEND_NO_HANDLER, msg);
g_free(msg);
LEAVE (" ");
}
void
qof_session_save (QofSession *session,
QofPercentageFunc percentage_func)
{
QofBackend *be;
if (!session) return;
if (!g_atomic_int_dec_and_test(&session->lock))
goto leave;
ENTER ("sess=%p book_id=%s",
session, session->book_id ? session->book_id : "(null)");
/* If there is a backend, and the backend is reachable
* (i.e. we can communicate with it), then synchronize with
* the backend. If we cannot contact the backend (e.g.
* because we've gone offline, the network has crashed, etc.)
* then give the user the option to save to the local disk.
*
* hack alert -- FIXME -- XXX the code below no longer
* does what the words above say. This needs fixing.
*/
be = session->backend;
if (be)
{
/* if invoked as SaveAs(), then backend not yet set */
qof_book_set_backend (session->book, be);
be->percentage = percentage_func;
if (be->sync)
{
(be->sync)(be, session->book);
if (save_error_handler(be, session))
goto leave;
}
/* If we got to here, then the backend saved everything
* just fine, and we are done. So return. */
/* Return the book_id to previous value. */
qof_session_clear_error (session);
LEAVE("Success");
goto leave;
}
else
{
if (ERR_BACKEND_NO_ERR != qof_session_get_error(session))
{
/* push_error strdups, stack const is fine. */
const char *msg = "failed to load backend";
qof_session_push_error(session, ERR_BACKEND_NO_HANDLER, msg);
}
}
LEAVE("error -- No backend!");
leave:
g_atomic_int_inc(&session->lock);
return;
}
static gboolean
save_error_handler(QofBackend *be, QofSession *session)
{
QofBackendError err;
err = qof_backend_get_error(be);
if (ERR_BACKEND_NO_ERR != err)
{
qof_session_push_error (session, err, NULL);
return TRUE;
}
return FALSE;
}
void
qof_session_ensure_all_data_loaded (QofSession *session)
{
QofBackend* backend;
if (session == NULL) return;
backend = qof_session_get_backend(session);
if (backend == NULL) return;
if (backend->load == NULL) return;
backend->load(backend, qof_session_get_book(session), LOAD_TYPE_LOAD_ALL);
qof_session_push_error (session, qof_backend_get_error(backend), NULL);
}
void
qof_session_safe_save(QofSession *session, QofPercentageFunc percentage_func)
{
QofBackend *be = session->backend;
gint err;
char *msg = NULL;
g_return_if_fail( be != NULL );
g_return_if_fail( be->safe_sync != NULL );
be->percentage = percentage_func;
(be->safe_sync)( be, qof_session_get_book( session ));
err = qof_backend_get_error(session->backend);
msg = qof_backend_get_message(session->backend);
if (err != ERR_BACKEND_NO_ERR)
{
g_free(session->book_id);
session->book_id = NULL;
qof_session_push_error (session, err, msg);
}
}
void
qof_session_load (QofSession *session,
QofPercentageFunc percentage_func)
{
QofBook *newbook, *oldbook;
QofBackend *be;
QofBackendError err;
if (!session) return;
if (!session->book_id) return;
ENTER ("sess=%p book_id=%s", session, session->book_id
? session->book_id : "(null)");
/* At this point, we should are supposed to have a valid book
* id and a lock on the file. */
oldbook = session->book;
/* XXX why are we creating a book here? I think the books
* need to be handled by the backend ... especially since
* the backend may need to load multiple books ... XXX. FIXME.
*/
newbook = qof_book_new();
session->book = newbook;
PINFO ("new book=%p", newbook);
qof_session_clear_error (session);
/* This code should be sufficient to initialize *any* backend,
* whether http, postgres, or anything else that might come along.
* Basically, the idea is that by now, a backend has already been
* created & set up. At this point, we only need to get the
* top-level account group out of the backend, and that is a
* generic, backend-independent operation.
*/
be = session->backend;
qof_book_set_backend(newbook, be);
/* Starting the session should result in a bunch of accounts
* and currencies being downloaded, but probably no transactions;
* The GUI will need to do a query for that.
*/
if (be)
{
be->percentage = percentage_func;
if (be->load)
{
be->load (be, newbook, LOAD_TYPE_INITIAL_LOAD);
qof_session_push_error (session, qof_backend_get_error(be), NULL);
}
}
/* XXX if the load fails, then we try to restore the old set of books;
* however, we don't undo the session id (the URL). Thus if the
* user attempts to save after a failed load, they weill be trying to
* save to some bogus URL. This is wrong. XXX FIXME.
*/
err = qof_session_get_error(session);
if ((err != ERR_BACKEND_NO_ERR) &&
(err != ERR_FILEIO_FILE_TOO_OLD) &&
(err != ERR_FILEIO_NO_ENCODING) &&
(err != ERR_FILEIO_FILE_UPGRADE) &&
(err != ERR_SQL_DB_TOO_OLD) &&
(err != ERR_SQL_DB_TOO_NEW))
{
/* Something broke, put back the old stuff */
qof_book_set_backend (newbook, NULL);
qof_book_destroy (newbook);
session->book = oldbook;
LEAVE("error from backend %d", qof_session_get_error(session));
return;
}
qof_book_set_backend (oldbook, NULL);
qof_book_destroy (oldbook);
LEAVE ("sess = %p, book_id=%s", session, session->book_id
? session->book_id : "(null)");
}
void
qof_session_begin (QofSession *session, const char * book_id,
gboolean ignore_lock, gboolean create, gboolean force)
{
gchar *scheme = NULL, *filename = NULL;
if (!session) return;
ENTER (" sess=%p ignore_lock=%d, book-id=%s",
session, ignore_lock,
book_id ? book_id : "(null)");
/* Clear the error condition of previous errors */
qof_session_clear_error (session);
/* Check to see if this session is already open */
if (session->book_id)
{
if (ERR_BACKEND_NO_ERR != qof_session_get_error(session))
qof_session_push_error (session, ERR_BACKEND_LOCKED, NULL);
LEAVE("push error book is already open ");
return;
}
/* seriously invalid */
if (!book_id)
{
if (ERR_BACKEND_NO_ERR != qof_session_get_error(session))
qof_session_push_error (session, ERR_BACKEND_BAD_URL, NULL);
LEAVE("push error missing book_id");
return;
}
scheme = g_uri_parse_scheme (book_id);
if (g_strcmp0 (scheme, "file") == 0)
filename = g_filename_from_uri (book_id, NULL, NULL);
else if (!scheme)
filename = g_strdup (book_id);
if (filename && g_file_test (filename, G_FILE_TEST_IS_DIR))
{
if (ERR_BACKEND_NO_ERR == qof_session_get_error(session))
qof_session_push_error (session, ERR_BACKEND_BAD_URL, NULL);
g_free (filename);
g_free (scheme);
LEAVE("Can't open a directory");
return;
}
/* destroy the old backend */
qof_session_destroy_backend(session);
/* Store the session URL */
session->book_id = g_strdup (book_id);
if (filename)
qof_session_load_backend(session, "file");
else /* access method found, load appropriate backend */
qof_session_load_backend(session, scheme);
g_free (filename);
g_free (scheme);
/* No backend was found. That's bad. */
if (NULL == session->backend)
{
g_free(session->book_id);
session->book_id = NULL;
if (ERR_BACKEND_NO_ERR == qof_session_get_error(session))
qof_session_push_error (session, ERR_BACKEND_BAD_URL, NULL);
LEAVE (" BAD: no backend: sess=%p book-id=%s",
session, book_id ? book_id : "(null)");
return;
}
/* If there's a begin method, call that. */
if (session->backend->session_begin)
{
char *msg;
QofBackendError err;
(session->backend->session_begin)(session->backend, session,
session->book_id, ignore_lock,
create, force);
PINFO("Done running session_begin on backend");
err = qof_backend_get_error(session->backend);
msg = qof_backend_get_message(session->backend);
if (err != ERR_BACKEND_NO_ERR)
{
g_free(session->book_id);
session->book_id = NULL;
qof_session_push_error (session, err, msg);
LEAVE(" backend error %d %s", err, msg ? msg : "(null)");
return;
}
if (msg != NULL)
{
PWARN("%s", msg);
g_free(msg);
}
}
LEAVE (" sess=%p book-id=%s",
session, book_id ? book_id : "(null)");
}
void
qof_session_save (QofSession *session,
QofPercentageFunc percentage_func)
{
GList *node;
QofBackend *be;
gboolean partial, change_backend;
QofBackendProvider *prov;
GSList *p;
QofBook *book, *abook;
int err;
gint num;
char *msg = NULL;
char *book_id;
if (!session) return;
if (!g_atomic_int_dec_and_test(&session->lock))
goto leave;
ENTER ("sess=%p book_id=%s",
session, session->book_id ? session->book_id : "(null)");
/* Partial book handling. */
book = qof_session_get_book(session);
partial = (gboolean)GPOINTER_TO_INT(qof_book_get_data(book, PARTIAL_QOFBOOK));
change_backend = FALSE;
msg = g_strdup_printf(" ");
book_id = g_strdup(session->book_id);
if (partial == TRUE)
{
if (session->backend && session->backend->provider)
{
prov = session->backend->provider;
if (TRUE == prov->partial_book_supported)
{
/* if current backend supports partial, leave alone. */
change_backend = FALSE;
}
else
{
change_backend = TRUE;
}
}
/* If provider is undefined, assume partial not supported. */
else
{
change_backend = TRUE;
}
}
if (change_backend == TRUE)
{
qof_session_destroy_backend(session);
if (!qof_providers_initialized)
{
qof_providers_initialized = TRUE;
}
p = provider_list;
while (p != NULL)
{
prov = p->data;
if (TRUE == prov->partial_book_supported)
{
/** \todo check the access_method too, not in scope here, yet. */
/* if((TRUE == prov->partial_book_supported) &&
(0 == g_ascii_strcasecmp (access_method, prov->access_method)))
{*/
if (NULL == prov->backend_new) continue;
/* Use the providers creation callback */
session->backend = (*(prov->backend_new))();
session->backend->provider = prov;
if (session->backend->session_begin)
{
/* Call begin - backend has been changed,
so make sure a file can be written,
use ignore_lock and force create */
g_free(session->book_id);
session->book_id = NULL;
(session->backend->session_begin)(session->backend, session,
book_id, TRUE, TRUE, TRUE);
PINFO("Done running session_begin on changed backend");
err = qof_backend_get_error(session->backend);
msg = qof_backend_get_message(session->backend);
if (err != ERR_BACKEND_NO_ERR)
{
g_free(session->book_id);
session->book_id = NULL;
qof_session_push_error (session, err, msg);
LEAVE("changed backend error %d", err);
goto leave;
}
if (msg != NULL)
{
PWARN("%s", msg);
g_free(msg);
msg = NULL;
}
}
/* Tell the books about the backend that they'll be using. */
for (node = session->books; node; node = node->next)
{
book = node->data;
qof_book_set_backend (book, session->backend);
}
p = NULL;
}
if (p)
{
p = p->next;
}
}
if (!session->backend)
{
if (ERR_BACKEND_NO_ERR != qof_session_get_error(session))
{
msg = g_strdup_printf("failed to load backend");
qof_session_push_error(session, ERR_BACKEND_NO_HANDLER, msg);
}
goto leave;
}
}
/* If there is a backend, and the backend is reachable
* (i.e. we can communicate with it), then synchronize with
* the backend. If we cannot contact the backend (e.g.
* because we've gone offline, the network has crashed, etc.)
* then give the user the option to save to the local disk.
*
* hack alert -- FIXME -- XXX the code below no longer
* does what the words above say. This needs fixing.
*/
be = session->backend;
if (be)
{
for (node = session->books; node; node = node->next)
{
abook = node->data;
/* if invoked as SaveAs(), then backend not yet set */
qof_book_set_backend (abook, be);
be->percentage = percentage_func;
if (be->sync)
{
(be->sync)(be, abook);
if (save_error_handler(be, session))
goto leave;
}
}
/* If we got to here, then the backend saved everything
* just fine, and we are done. So return. */
/* Return the book_id to previous value. */
qof_session_clear_error (session);
LEAVE("Success");
goto leave;
}
else
{
if (ERR_BACKEND_NO_ERR != qof_session_get_error(session))
{
msg = g_strdup_printf("failed to load backend");
qof_session_push_error(session, ERR_BACKEND_NO_HANDLER, msg);
}
}
LEAVE("error -- No backend!");
leave:
if (msg != NULL) g_free(msg);
g_atomic_int_inc(&session->lock);
return;
}
void
qof_session_begin (QofSession *session, const char * book_id,
gboolean ignore_lock, gboolean create, gboolean force)
{
gchar **splituri;
if (!session) return;
ENTER (" sess=%p ignore_lock=%d, book-id=%s",
session, ignore_lock,
book_id ? book_id : "(null)");
/* Clear the error condition of previous errors */
qof_session_clear_error (session);
/* Check to see if this session is already open */
if (session->book_id)
{
if (ERR_BACKEND_NO_ERR != qof_session_get_error(session))
qof_session_push_error (session, ERR_BACKEND_LOCKED, NULL);
LEAVE("push error book is already open ");
return;
}
/* seriously invalid */
if (!book_id)
{
if (ERR_BACKEND_NO_ERR != qof_session_get_error(session))
qof_session_push_error (session, ERR_BACKEND_BAD_URL, NULL);
LEAVE("push error missing book_id");
return;
}
/* destroy the old backend */
qof_session_destroy_backend(session);
/* Store the session URL */
session->book_id = g_strdup (book_id);
/* Look for something of the form of "file://", "http://" or
* "postgres://". Everything before the colon is the access
* method. Load the first backend found for that access method.
*/
splituri = g_strsplit ( book_id, "://", 2 );
if ( splituri[1] == NULL ) /* no access method in the uri, use generic "file" backend */
qof_session_load_backend(session, "file");
else /* access method found, load appropriate backend */
qof_session_load_backend(session, splituri[0]);
g_strfreev ( splituri );
/* No backend was found. That's bad. */
if (NULL == session->backend)
{
g_free(session->book_id);
session->book_id = NULL;
if (ERR_BACKEND_NO_ERR == qof_session_get_error(session))
qof_session_push_error (session, ERR_BACKEND_BAD_URL, NULL);
LEAVE (" BAD: no backend: sess=%p book-id=%s",
session, book_id ? book_id : "(null)");
return;
}
/* If there's a begin method, call that. */
if (session->backend->session_begin)
{
char *msg;
int err;
(session->backend->session_begin)(session->backend, session,
session->book_id, ignore_lock,
create, force);
PINFO("Done running session_begin on backend");
err = qof_backend_get_error(session->backend);
msg = qof_backend_get_message(session->backend);
if (err != ERR_BACKEND_NO_ERR)
{
g_free(session->book_id);
session->book_id = NULL;
qof_session_push_error (session, err, msg);
LEAVE(" backend error %d %s", err, msg ? msg : "(null)");
return;
}
if (msg != NULL)
{
PWARN("%s", msg);
g_free(msg);
}
}
LEAVE (" sess=%p book-id=%s",
session, book_id ? book_id : "(null)");
}
static void
qof_session_load_backend(QofSession * session, const char * access_method)
{
GSList *p;
GList *node;
QofBackendProvider *prov;
QofBook *book;
char *msg;
gint num;
gboolean prov_type;
gboolean (*type_check) (const char*);
gchar *libdir_from_env = NULL;
ENTER (" list=%d, initted=%s", g_slist_length(provider_list),
qof_providers_initialized ? "true" : "false");
prov_type = FALSE;
if (!qof_providers_initialized)
{
libdir_from_env = g_strdup(g_getenv("QOF_LIB_DIR"));
for (num = 0; backend_list[num].filename != NULL; num++)
{
if (libdir_from_env)
{
if (!(qof_load_backend_library(libdir_from_env,
backend_list[num].filename)
|| qof_load_backend_library(backend_list[num].libdir,
backend_list[num].filename)))
{
PWARN (" failed to load %s from %s or %s",
backend_list[num].filename, libdir_from_env,
backend_list[num].libdir);
}
}
else
{
if (!qof_load_backend_library(backend_list[num].libdir,
backend_list[num].filename))
{
PWARN (" failed to load %s from %s",
backend_list[num].filename, backend_list[num].libdir);
}
}
}
g_free(libdir_from_env);
qof_providers_initialized = TRUE;
}
p = provider_list;
while (p != NULL)
{
prov = p->data;
/* Does this provider handle the desired access method? */
if (0 == g_ascii_strcasecmp (access_method, prov->access_method))
{
/* More than one backend could provide this
access method, check file type compatibility. */
type_check = (gboolean (*)(const char*)) prov->check_data_type;
if (type_check)
{
prov_type = (type_check)(session->book_id);
if (!prov_type)
{
PINFO(" %s not usable", prov->provider_name);
p = p->next;
continue;
}
}
PINFO (" selected %s", prov->provider_name);
if (NULL == prov->backend_new)
{
p = p->next;
continue;
}
/* Use the providers creation callback */
session->backend = (*(prov->backend_new))();
session->backend->provider = prov;
/* Tell the books about the backend that they'll be using. */
for (node = session->books; node; node = node->next)
{
book = node->data;
qof_book_set_backend (book, session->backend);
}
LEAVE (" ");
return;
}
p = p->next;
}
msg = g_strdup_printf("failed to load '%s' using access_method", access_method);
qof_session_push_error (session, ERR_BACKEND_NO_HANDLER, msg);
LEAVE (" ");
}