GncXmlBackend Class Reference

Inheritance diagram for GncXmlBackend:

Public Member Functions
	GncXmlBackend (const GncXmlBackend &)=delete
GncXmlBackend	operator= (const GncXmlBackend &)=delete
	GncXmlBackend (const GncXmlBackend &&)=delete
GncXmlBackend	operator= (const GncXmlBackend &&)=delete
void	session_begin (QofSession *session, const char *new_uri, SessionOpenMode mode) override
	Open the file or connect to the server.
void	session_end () override
void	load (QofBook *book, QofBackendLoadType loadType) override
	Load the minimal set of application data needed for the application to be operable at initial startup.
void	export_coa (QofBook *) override
	Extract the chart of accounts from the current database and create a new database with it.
void	sync (QofBook *book) override
	Synchronizes the engine contents to the backend.
void	safe_sync (QofBook *book) override
	Perform a sync in a way that prevents data loss on a DBI backend.
void	commit (QofInstance *instance) override
	Commits the changes from the engine to the backend data storage.
const char *	get_filename ()
QofBook *	get_book ()
Public Member Functions inherited from QofBackend
	QofBackend (const QofBackend &)=delete
	QofBackend (const QofBackend &&)=delete
virtual void	begin (QofInstance *)
	Called when the engine is about to make a change to a data structure.
virtual void	rollback (QofInstance *)
	Revert changes in the engine and unlock the backend.
void	set_error (QofBackendError err)
	Set the error value only if there isn't already an error already.
QofBackendError	get_error ()
	Retrieve the currently-stored error and clear it.
bool	check_error ()
	Report if there is an error.
void	set_message (std::string &&)
	Set a descriptive message that can be displayed to the user when there's an error.
const std::string &&	get_message ()
	Retrieve and clear the stored error message.
void	set_percentage (QofBePercentageFunc pctfn)
	Store and retrieve a backend-specific function for determining the progress in completing a long operation, for use with a progress meter.
QofBePercentageFunc	get_percentage ()
const std::string &	get_uri ()
	Retrieve the backend's storage URI.

Additional Inherited Members
Static Public Member Functions inherited from QofBackend
static bool	register_backend (const char *, const char *)
	Class methods for dynamically loading the several backends and for freeing them at shutdown.
static void	release_backends ()
Protected Attributes inherited from QofBackend
QofBePercentageFunc	m_percentage
std::string	m_fullpath
	Each backend resolves a fully-qualified file path.

Detailed Description

Definition at line 26 of file gnc-xml-backend.hpp.

Constructor & Destructor Documentation

~GncXmlBackend()

GncXmlBackend::~GncXmlBackend

(

)

Definition at line 51 of file gnc-xml-backend.cpp.

{
    session_end();
};

Member Function Documentation

commit()

void GncXmlBackend::commit ( QofInstance *  instance )

overridevirtual

Commits the changes from the engine to the backend data storage.

Reimplemented from QofBackend.

Definition at line 327 of file gnc-xml-backend.cpp.

{
    if (qof_instance_is_dirty(instance))
        qof_instance_mark_clean(instance);
}

export_coa()

void GncXmlBackend::export_coa ( QofBook *  )

overridevirtual

Extract the chart of accounts from the current database and create a new database with it.

Implemented only in the XML backend at present.

Reimplemented from QofBackend.

Definition at line 344 of file gnc-xml-backend.cpp.

{
    auto out = g_fopen(m_fullpath.c_str(), "w");
    if (out == NULL)
    {
        set_error(ERR_FILEIO_WRITE_ERROR);
        set_message(strerror(errno));
        return;
    }
    gnc_book_write_accounts_to_xml_filehandle_v2(this, book, out);
    fclose(out);
}

get_book()

QofBook * GncXmlBackend::get_book ( )

inline

Definition at line 45 of file gnc-xml-backend.hpp.

{ return m_book; }

get_filename()

const char * GncXmlBackend::get_filename ( )

inline

Definition at line 44 of file gnc-xml-backend.hpp.

{ return m_fullpath.c_str(); }

load()

void GncXmlBackend::load ( QofBook *  , QofBackendLoadType    )

overridevirtual

Load the minimal set of application data needed for the application to be operable at initial startup.

It is assumed that the application will perform a 'run_query()' to obtain any additional data that it needs. For file-based backends, it is acceptable for the backend to return all data at load time; for SQL-based backends, it is acceptable for the backend to return no data.

Thus, for example, the old GnuCash postgres backend returned the account tree, all currencies, and the pricedb, as these were needed at startup. It did not have to return any transactions whatsoever, as these were obtained at a later stage when a user opened a register, resulting in a query being sent to the backend. The current DBI backend on the other hand loads the entire database into memory.

(Its OK to send over entities at this point, but one should be careful of the network load; also, its possible that whatever is sent is not what the user wanted anyway, which is why its better to wait for the query).

Implements QofBackend.

Definition at line 229 of file gnc-xml-backend.cpp.

{
 
    QofBackendError error;
 
    if (loadType != LOAD_TYPE_INITIAL_LOAD) return;
 
    error = ERR_BACKEND_NO_ERR;
    if (m_book)
        g_object_unref(m_book);
    m_book = QOF_BOOK(g_object_ref(book));
 
    int rc;
    switch (determine_file_type (m_fullpath))
    {
    case GNC_BOOK_XML2_FILE:
        rc = qof_session_load_from_xml_file_v2 (this, book,
                                                     GNC_BOOK_XML2_FILE);
        if (rc == FALSE)
        {
            PWARN ("Syntax error in Xml File %s", m_fullpath.c_str());
            error = ERR_FILEIO_PARSE_ERROR;
        }
        break;
 
    case GNC_BOOK_XML2_FILE_NO_ENCODING:
        error = ERR_FILEIO_NO_ENCODING;
        PWARN ("No character encoding in Xml File %s", m_fullpath.c_str());
        break;
    case GNC_BOOK_XML1_FILE:
        rc = qof_session_load_from_xml_file (book, m_fullpath.c_str());
        if (rc == FALSE)
        {
            PWARN ("Syntax error in Xml File %s", m_fullpath.c_str());
            error = ERR_FILEIO_PARSE_ERROR;
        }
        break;
    case GNC_BOOK_POST_XML2_0_0_FILE:
        error = ERR_BACKEND_TOO_NEW;
        PWARN ("Version of Xml file %s is newer than what we can read",
               m_fullpath.c_str());
        break;
    default:
        /* If file type wasn't known, check errno again to give the
        user some more useful feedback for some particular error
        conditions. */
        switch (errno)
        {
        case EACCES: /* No read permission */
            PWARN ("No read permission to file");
            error = ERR_FILEIO_FILE_EACCES;
            break;
        case EISDIR: /* File is a directory - but on this error we don't arrive here */
            PWARN ("Filename is a directory");
            error = ERR_FILEIO_FILE_NOT_FOUND;
            break;
        default:
            PWARN ("File not any known type");
            error = ERR_FILEIO_UNKNOWN_FILE_TYPE;
            break;
        }
        break;
    }
 
    if (error != ERR_BACKEND_NO_ERR)
    {
        set_error(error);
    }
 
    /* We just got done loading, it can't possibly be dirty !! */
    qof_book_mark_session_saved (book);
}

safe_sync()

void GncXmlBackend::safe_sync ( QofBook *  )

inlineoverridevirtual

Perform a sync in a way that prevents data loss on a DBI backend.

Implements QofBackend.

Definition at line 42 of file gnc-xml-backend.hpp.

{ sync(book); } // XML sync is inherently safe.

session_begin()

void GncXmlBackend::session_begin ( QofSession *  session, const char *  new_uri, SessionOpenMode  mode  )

overridevirtual

Open the file or connect to the server.

Parameters

session	The QofSession that will control the backend.
new_uri	The location of the data store that the backend will use.
mode	The session open mode. See qof_session_begin().

Implements QofBackend.

Definition at line 114 of file gnc-xml-backend.cpp.

{
    /* Make sure the directory is there */
    auto path_str = gnc_uri_get_path (new_uri);
    m_fullpath = path_str;
    g_free (path_str);
 
    if (m_fullpath.empty())
    {
        set_error(ERR_FILEIO_FILE_NOT_FOUND);
        set_message("No path specified");
        return;
    }
    if (mode == SESSION_NEW_STORE && save_may_clobber_data())
    {
        set_error(ERR_BACKEND_STORE_EXISTS);
        PWARN ("Might clobber, no force");
        return;
    }
 
    if (!check_path(m_fullpath.c_str(),
                    mode == SESSION_NEW_STORE || mode == SESSION_NEW_OVERWRITE))
        return;
 
    auto dirname = g_path_get_dirname (m_fullpath.c_str());
    m_dirname = dirname;
    g_free (dirname);
 
 
 
    /* ---------------------------------------------------- */
    /* We should now have a fully resolved path name.
     * Let's start logging */
    xaccLogSetBaseName (m_fullpath.c_str());
    PINFO ("logpath=%s", m_fullpath.empty() ? "(null)" : m_fullpath.c_str());
 
    if (mode == SESSION_READ_ONLY)
        return; // Read-only, don't care about locks.
 
    /* Set the lock file */
    m_lockfile = m_fullpath + ".LCK";
    get_file_lock(mode);
}

session_end()

void GncXmlBackend::session_end ( )

overridevirtual

Implements QofBackend.

Definition at line 160 of file gnc-xml-backend.cpp.

{
    if (m_book && qof_book_is_readonly (m_book))
    {
        set_error(ERR_BACKEND_READONLY);
        return;
    }
 
    if (!m_linkfile.empty())
        g_unlink (m_linkfile.c_str());
 
    if (m_lockfd != -1)
    {
        close (m_lockfd);
        m_lockfd = -1;
    }
 
    if (!m_lockfile.empty())
    {
        int rv;
#ifdef G_OS_WIN32
        /* On windows, we need to allow write-access before
           g_unlink() can succeed */
        rv = g_chmod (m_lockfile.c_str(), S_IWRITE | S_IREAD);
#endif
        rv = g_unlink (m_lockfile.c_str());
        if (rv)
        {
            PWARN ("Error on g_unlink(%s): %d: %s", m_lockfile.c_str(),
                   errno, g_strerror (errno) ? g_strerror (errno) : "");
        }
    }
 
    m_dirname.clear();
    m_fullpath.clear();
    m_lockfile.clear();
    m_linkfile.clear();
}

sync()

void GncXmlBackend::sync ( QofBook *  )

overridevirtual

Synchronizes the engine contents to the backend.

This should done by using version numbers (hack alert – the engine does not currently contain version numbers). If the engine contents are newer than what is in the backend, the data is stored to the backend. If the engine contents are older, then the engine contents are updated.

Note that this sync operation is only meant to apply to the current contents of the engine. This routine is not intended to be used to fetch entity data from the backend.

File based backends tend to use sync as if it was called dump. Data is written out into the backend, overwriting the previous data. Database backends should implement a more intelligent solution.

Implements QofBackend.

Definition at line 303 of file gnc-xml-backend.cpp.

{
        /* We make an important assumption here, that we might want to change
     * in the future: when the user says 'save', we really save the one,
     * the only, the current open book, and nothing else. In any case the plans
     * for multiple books have been removed in the meantime and there is just one
     * book, no more.
     */
    if (m_book == nullptr)
        m_book = QOF_BOOK(g_object_ref(book));
    if (book != m_book) return;
 
    if (qof_book_is_readonly (m_book))
    {
        /* Are we read-only? Don't continue in this case. */
        set_error(ERR_BACKEND_READONLY);
        return;
    }
 
    write_to_file (true);
    remove_old_files();
}

---

The documentation for this class was generated from the following files:

• gnc-xml-backend.hpp
• gnc-xml-backend.cpp