Merge lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug into lp:u1db-qt

[Kevin Wright]

This branch merges the latest trunk with the code for synchronization of databases.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:113
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/1/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/1/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/1/rebuild

review: Needs Fixing (continuous-integration)

[Cris Dywan (kalikiana)]

The code deals with id's being wrapped in {} in places. That's based on behavior of the core code; I think we need a newid() function and solve this in one place.

There's a few instances of the pattern "if (!query.exec()) qDebug" which should probably be using setError.

resetModel can be used in more places currently still doing its equivalent calls.

getValidTargets() and synchronizeTargets() hard-code HTML formatting - that's not good if we plan to see errors in console or XML and will make those cases harder to deal with. The messages should be predictable without using markup - if needed, it's still an option to use regex.
m_errors.append("<b><font color=\"red\">Database "+index_number+"</font></b>: F

FIXMEs that ought to be sorted out:
##KW## The two lists below are currently not used for anything
##KW## maybe this can be removed as it is replaced by revision_number

Unused code:
//targetDb->updateSyncLog(true, QString uid, QString generation, QString transaction_id);
//double target_replica_generation = replyMap["target_replica_generation"].toDouble();

This should probably say the real app name + " (U1Db-Qt)"
request.setRawHeader("User-Agent", "My app name v0.1");
request.setRawHeader("X-Custom-User-Agent", "My app name v0.1");

For good measure processDataFromRemoteServer might want to qDebug if an unexpected i.key() is seen?

This should not be writable, it's only set internally
Q_PROPERTY(QList<QString> errors READ getErrors WRITE setErrors NOTIFY errorsChanged)

"where u1db has been downloaded/branched"
This is very ambiguous and doesn't say where to obtain it. It should say
"where the u1db Python reference implemented has been downloaded from lp:u1db"

review: Needs Fixing

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

114. By Kevin Wright on 2013-08-08

Removed an unecessary function call and code comment from src/database.cpp.

115. By Kevin Wright on 2013-08-08

Removed an unecessary code from src/synchronizer.cpp, and updated putDoc in src/database.cpp to return QString instead of int.

116. By Kevin Wright on 2013-08-08

Updated code comments in src/synchronizer.cpp to be more descriptive with respect to the instructions for how to use the plugin with the python implementation (the server part to be specific).

117. By Kevin Wright on 2013-08-08

Added 'U1Db-Qt v1.0' to the raw header information sent to the server.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:116
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/2/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/2/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/2/rebuild

review: Needs Fixing (continuous-integration)

[Kevin Wright (kevin-wright-1)]

Den 08/08/2013 16:24, skrev Christian Dywan:
> Review: Needs Fixing
>
> The code deals with id's being wrapped in {} in places. That's based on behavior of the core code; I think we need a newid() function and solve this in one place.

Agreed. Will add.

> There's a few instances of the pattern "if (!query.exec()) qDebug" which should probably be using setError.

Agreed. Will modify.
>
> resetModel can be used in more places currently still doing its equivalent calls.
Not sure what this comment means.
> getValidTargets() and synchronizeTargets() hard-code HTML formatting - that's not good if we plan to see errors in console or XML and will make those cases harder to deal with. The messages should be predictable without using markup - if needed, it's still an option to use regex.
> m_errors.append("<b><font color=\"red\">Database "+index_number+"</font></b>: F

The type of errors here are for the benefit of app devs and app users at
the UI level, not console etc. The messages are for use in a QML
application as output from a sync transation to notify re: errors,
warnings and things that went according to plan.

An alternative approach, with broader and more flexible possibilities,
is to have the error information available in a model (QVariantMap) that
includes useful meta data and values (e.g. type of message, message
text, other?). In that way it can be available to app developers as well
as easily adapted for other purposes (e.g. log files, console output).

>
> FIXMEs that ought to be sorted out:
> ##KW## The two lists below are currently not used for anything
> ##KW## maybe this can be removed as it is replaced by revision_number

Both removed.

>
> Unused code:
> //targetDb->updateSyncLog(true, QString uid, QString generation, QString transaction_id);
Could not find this one. Perhaps it was deleted in another modification.
> //double target_replica_generation = replyMap["target_replica_generation"].toDouble();

This variable is probably needed in upcoming modifications, so it is
there but commented out so it does not produce an annoying warning at
compile time.

>
> This should probably say the real app name + " (U1Db-Qt)"
> request.setRawHeader("User-Agent", "My app name v0.1");
> request.setRawHeader("X-Custom-User-Agent", "My app name v0.1");

Changed to 'U1Db-Qt v1.0' on both lines. Those two lines may not even be
necessary, as the server may ignore them, but are kept there and posted
anyway for good measure.

>
> For good measure processDataFromRemoteServer might want to qDebug if an unexpected i.key() is seen?

Not sure it would be needed. If an unexpected key showed up it would be
ignored (as it should be).

>
> This should not be writable, it's only set internally
> Q_PROPERTY(QList<QString> errors READ getErrors WRITE setErrors NOTIFY errorsChanged)

Agreed. Will modify accordingly.

> "where u1db has been downloaded/branched"
> This is very ambiguous and doesn't say where to obtain it. It should say
> "where the u1db Python reference implemented has been downloaded from lp:u1db"
Changed.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:117
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/3/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/3/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/3/rebuild

review: Needs Fixing (continuous-integration)

[Cris Dywan (kalikiana)]

> > getValidTargets() and synchronizeTargets() hard-code HTML formatting -
> that's not good if we plan to see errors in console or XML and will make those
> cases harder to deal with. The messages should be predictable without using
> markup - if needed, it's still an option to use regex.
> > m_errors.append("<b><font color=\"red\">Database
> "+index_number+"</font></b>: F
>
> The type of errors here are for the benefit of app devs and app users at
> the UI level, not console etc. The messages are for use in a QML
> application as output from a sync transation to notify re: errors,
> warnings and things that went according to plan.
>
> An alternative approach, with broader and more flexible possibilities,
> is to have the error information available in a model (QVariantMap) that
> includes useful meta data and values (e.g. type of message, message
> text, other?). In that way it can be available to app developers as well
> as easily adapted for other purposes (e.g. log files, console output).

Okay, I better see the reasoning now. And I think you're mixing two concepts into here, UI error messages and error handling API for letting developers distinguish errors. The user must not see verbatim key names. And the app developer needs a way to distinguish a failing sync from a bug in his code.

I had a thought in that direction in respect to Database::setError originally. SQL errors aren't interesting to anyone but U1Db-Qt developers - they need to be simple and pastable. The same is often true for U1Db-Qt errors. Errors about invalid id's or json are indeed relevant for developers - but only in the console. There's no need to "handle" them, wrong use of the API is to be fixed. One kind of error that we should have API for is: no space left. I apparently never filed a bug for that.

Now for sync, I'd still want the same console output for obvious mistakes like invalid URLs and wrong key names. That is what I was having in mind when I suggested to not have HTML. It's a one-time see the mistake and fix it and not for UI. And it is useful to always log if a connection failed in any way. For the developer's benefit we should have "signal syncFailed". That should suffice to prompt the user appropriately - the developer knows their target audience, what language to use etc.

> > For good measure processDataFromRemoteServer might want to qDebug if an
> unexpected i.key() is seen?
>
> Not sure it would be needed. If an unexpected key showed up it would be
> ignored (as it should be).

I should clarify: if an unexpected key turns up that's a bug in the code. Q_ASSERT is better I guess.

review: Needs Fixing

[Kevin Wright (kevin-wright-1)]

Den 08/08/2013 17:32, skrev Christian Dywan:
> Review: Needs Fixing
>
>
>>> For good measure processDataFromRemoteServer might want to qDebug if an
>> unexpected i.key() is seen?
>>
>> Not sure it would be needed. If an unexpected key showed up it would be
>> ignored (as it should be).
> I should clarify: if an unexpected key turns up that's a bug in the code. Q_ASSERT is better I guess.

In fact there are other key and value pairs that the server does return
that are not yet being used by the Synchronizer class.

Of course it is harmless to notify that there is more information than
expected (or in this case information that is expected but not being
used), and discounting the possibility that at some point in time there
might be a benefit to doing so would not be wise.

For the record though, in this particular case, if there were an
unexpected key (and associated value) that turns up it is because it was
information delivered directly from the server.

Kevin

[Kevin Wright (kevin-wright-1)]

Den 08/08/2013 17:32, skrev Christian Dywan:
> Review: Needs Fixing
>
>>> getValidTargets() and synchronizeTargets() hard-code HTML formatting -
>> that's not good if we plan to see errors in console or XML and will make those
>> cases harder to deal with. The messages should be predictable without using
>> markup - if needed, it's still an option to use regex.
>>> m_errors.append("<b><font color=\"red\">Database
>> "+index_number+"</font></b>: F
>>
>> The type of errors here are for the benefit of app devs and app users at
>> the UI level, not console etc. The messages are for use in a QML
>> application as output from a sync transation to notify re: errors,
>> warnings and things that went according to plan.
>>
>> An alternative approach, with broader and more flexible possibilities,
>> is to have the error information available in a model (QVariantMap) that
>> includes useful meta data and values (e.g. type of message, message
>> text, other?). In that way it can be available to app developers as well
>> as easily adapted for other purposes (e.g. log files, console output).
> Okay, I better see the reasoning now. And I think you're mixing two concepts into here, UI error messages and error handling API for letting developers distinguish errors. The user must not see verbatim key names. And the app developer needs a way to distinguish a failing sync from a bug in his code.

The messages can and should be modified. But the app developer does not
need to necessarily use the log/error/warning output from sync in its
raw form either. It should be up to the developer to determine how they
want to work with the data.

>
> I had a thought in that direction in respect to Database::setError originally. SQL errors aren't interesting to anyone but U1Db-Qt developers - they need to be simple and pastable. The same is often true for U1Db-Qt errors. Errors about invalid id's or json are indeed relevant for developers - but only in the console. There's no need to "handle" them, wrong use of the API is to be fixed. One kind of error that we should have API for is: no space left. I apparently never filed a bug for that.
>
> Now for sync, I'd still want the same console output for obvious mistakes like invalid URLs and wrong key names. That is what I was having in mind when I suggested to not have HTML. It's a one-time see the mistake and fix it and not for UI. And it is useful to always log if a connection failed in any way. For the developer's benefit we should have "signal syncFailed". That should suffice to prompt the user appropriately - the developer knows their target audience, what language to use etc.

Assuming too much about what the app developer wants, the endless
possible types of errors that might be encountered (e.g. faulty app
logic, user input variations, API problems), or who their audience is,
along rigid lines (and then use that logic for designing the API), may
be asking for trouble. What one developer to the next might want (or
need) could be different enough that "signal syncFailed" isn't enough.
This is why I suggested having a much more flexible and less
discriminating approach of making the data vailable using QVarientMap,...

[Cris Dywan (kalikiana)]

> Assuming too much about what the app developer wants, the endless
> possible types of errors that might be encountered (e.g. faulty app
> logic, user input variations, API problems), or who their audience is,
> along rigid lines (and then use that logic for designing the API), may
> be asking for trouble. What one developer to the next might want (or
> need) could be different enough that "signal syncFailed" isn't enough.
> This is why I suggested having a much more flexible and less
> discriminating approach of making the data vailable using QVarientMap,
> with meta data included so u1db dev and app dev can use the information
> in ways they choose, for the ultimate benefit of the end user.
>
> The existing approach is indeed immature in that respect, but the
> suggestion of using a model (QVarientMap) moves beyond current
> limitations and is flexible enough for a broad set of use cases, some of
> which we cannot anticipate on our own, but without creating huge overhead.
>
> It is intended to provide a rich mechanism for developers to create
> robust applications for users that do more than simply give feedback
> that only says "fail". Additionally it can hopefully provide useful
> information for u1db-qt devs as well (who also might happen to build
> apps with the plugin...including examples).

syncFailed was an example only. And I stress free-form strings are not a basis for proper error handling API.

At this point I'd prefer to only use simple qDebug() calls and leave proper error API for a separate task. I created bugs for this: bug 1210448 and bug 1210450.

review: Needs Fixing

[Cris Dywan (kalikiana)]

These are the doc errors I'm currently seeing with the latest changes. They need to be resolve before the branch can be merged:

./src/database.cpp:427: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/database.cpp:428: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/database.cpp:429: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/synchronizer.cpp:33: warning: Cannot find Synchronizer specified with \class in any header file
./src/synchronizer.cpp:156: warning: Cannot find Synchronizer::source specified with \property in any header file
./src/synchronizer.cpp:173: warning: Cannot find Synchronizer::targets specified with \property in any header file
./src/synchronizer.cpp:189: warning: Cannot find Synchronizer::synchronize specified with \property in any header file
./src/synchronizer.cpp:202: warning: Cannot find Synchronizer::errors specified with \property in any header file
./src/synchronizer.cpp:214: warning: Cannot find Synchronizer::errors specified with \property in any header file
./src/synchronizer.cpp:358: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/synchronizer.cpp:359: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/synchronizer.cpp:360: warning: Unknown command '\return'
./src/synchronizer.cpp:783: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/synchronizer.cpp:817: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/synchronizer.cpp:818: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/synchronizer.cpp:889: warning: Unknown command '\param'
 [Maybe you meant '\part'?]
./src/database.cpp:398: warning: Undocumented parameter doc_id in Database::getCurrentDocRevisionNumber()
./src/database.cpp:255: warning: No documentation for 'Database::getDocumentContents()'
./src/database.cpp:324: warning: Undocumented parameter doc_id in Database::getNextDocRevisionNumber()
./src/database.cpp:818: warning: No documentation for 'Database::getSyncLogInfo()'
./src/database.cpp:792: warning: No documentation for 'Database::listTransactionsSince()'
./src/database.cpp:619: warning: No documentation for 'Database::resetModel()'
./src/database.cpp:463: warning: No documentation for 'Database::updateDocRevisionNumber()'
./src/database.cpp:425: warning: Undocumented parameter transaction_id in Database::updateSyncLog()
./src/database.cpp:425: warning: Undocumented parameter generation in Database::updateSyncLog()
./src/database.cpp:425: warning: Undocumented parameter insert in Database::updateSyncLog()
./src/database.cpp:425: warning: Undocumented parameter uid in Database::updateSyncLog()
./src/query.cpp:161: warning: No documentation for 'Query::resetModel()'

[Kevin Wright (kevin-wright-1)]

[snip]
>
> The existing approach is indeed immature in that respect, but the
> suggestion of using a model (QVarientMap) moves beyond current
> limitations and is flexible enough for a broad set of use cases, some of
> which we cannot anticipate on our own, but without creating huge overhead.
>
> It is intended to provide a rich mechanism for developers to create
> robust applications for users that do more than simply give feedback
> that only says "fail". Additionally it can hopefully provide useful
> information for u1db-qt devs as well (who also might happen to build
> apps with the plugin...including examples).
> syncFailed was an example only. And I stress free-form strings are not a basis for proper error handling API.
>
> At this point I'd prefer to only use simple qDebug() calls and leave proper error API for a separate task. I created bugs for this: bug 1210448 and bug 1210450.

I modified things already.

I renamed it sync_output instead of errors (since not everything was an
error), and changed it so that a QVariantMap is returned (rather than
QString) with various meta data, depending on the sync output. There is
a descriptive message for each sync_output record, but it comes along
with hard data, such as what property is related to the message, any
particulars about the database (e.g. name, its index within the targets
definition). Additionally the messages themselves have been modified,
with some former details that were included in the description pushed to
the various meta-data instead. A set of error IDs could be created as well.

The information can be used at the application level, or used by methods
within the plugin itself (e.g. console output, log file).

I'll push those changes since they over write the original error
handling that needed removal/modification.

Kevin

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

118. By Kevin Wright on 2013-08-09

Modified 'errors'. Changed to 'sync_output' (since not everything was an error); changed from QString to QVariantMap that includes more meta-data; and created more generic output descriptions (i.e. removed most hard data and placed into meta-data instead). This approach is still primarily intented as a mechanism for application developers to troubleshoot (or simply keep themselves/users informed of background activity), but can be utilized within the plugin itself as well (e.g. log files, console output). It does not presently include error codes (where appropriate) but should, and additionally it needs to be documented so people can take advantage of it and use it properly. The example u1db-qt-example-6.qml uses it as of this commit, but is only applying the output message and not any of the meta-data.

[Cris Dywan (kalikiana)]

> The information can be used at the application level, or used by methods
> within the plugin itself (e.g. console output, log file).
>
> I'll push those changes since they over write the original error
> handling that needed removal/modification.

Nice stuff actually. Much cleaner than I expected! It should lend itself extremely nicely for test cases as well. I wouldn't have expected this in this MR but I'm not going to complain now ;-)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:118
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/4/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/4/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/4/rebuild

review: Needs Fixing (continuous-integration)

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

119. By Kevin Wright on 2013-08-09

Modified several source files to fix warnings from qdoc.

[Kevin Wright (kevin-wright-1)]

Den 09/08/2013 11:20, skrev Christian Dywan:
> These are the doc errors I'm currently seeing with the latest changes. They need to be resolve before the branch can be merged:
>
> ./src/database.cpp:427: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/database.cpp:428: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/database.cpp:429: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/synchronizer.cpp:33: warning: Cannot find Synchronizer specified with \class in any header file
> ./src/synchronizer.cpp:156: warning: Cannot find Synchronizer::source specified with \property in any header file
> ./src/synchronizer.cpp:173: warning: Cannot find Synchronizer::targets specified with \property in any header file
> ./src/synchronizer.cpp:189: warning: Cannot find Synchronizer::synchronize specified with \property in any header file
> ./src/synchronizer.cpp:202: warning: Cannot find Synchronizer::errors specified with \property in any header file
> ./src/synchronizer.cpp:214: warning: Cannot find Synchronizer::errors specified with \property in any header file
> ./src/synchronizer.cpp:358: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/synchronizer.cpp:359: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/synchronizer.cpp:360: warning: Unknown command '\return'
> ./src/synchronizer.cpp:783: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/synchronizer.cpp:817: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/synchronizer.cpp:818: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/synchronizer.cpp:889: warning: Unknown command '\param'
> [Maybe you meant '\part'?]
> ./src/database.cpp:398: warning: Undocumented parameter doc_id in Database::getCurrentDocRevisionNumber()
> ./src/database.cpp:255: warning: No documentation for 'Database::getDocumentContents()'
> ./src/database.cpp:324: warning: Undocumented parameter doc_id in Database::getNextDocRevisionNumber()
> ./src/database.cpp:818: warning: No documentation for 'Database::getSyncLogInfo()'
> ./src/database.cpp:792: warning: No documentation for 'Database::listTransactionsSince()'
> ./src/database.cpp:619: warning: No documentation for 'Database::resetModel()'
> ./src/database.cpp:463: warning: No documentation for 'Database::updateDocRevisionNumber()'
> ./src/database.cpp:425: warning: Undocumented parameter transaction_id in Database::updateSyncLog()
> ./src/database.cpp:425: warning: Undocumented parameter generation in Database::updateSyncLog()
> ./src/database.cpp:425: warning: Undocumented parameter insert in Database::updateSyncLog()
> ./src/database.cpp:425: warning: Undocumented parameter uid in Database::updateSyncLog()
> ./src/query.cpp:161: warning: No documentation for 'Query::resetModel()'

Hopefully all fixed now. Could not find anything specific to resolve the
warnings about \property, but maybe this is resolved by the change to
fix the warning about \class.

Also \param is used elsewhere in source files, but perhaps was not used
properly in these instances. The references have been remov...

[Kevin Wright (kevin-wright-1)]

Den 08/08/2013 16:24, skrev Christian Dywan:
> Review: Needs Fixing
>
> The code deals with id's being wrapped in {} in places. That's based on behavior of the core code; I think we need a newid() function and solve this in one place.
>
Have not done anything about this. I'm not sure it needs attending to
ahead of higher priority items.
> There's a few instances of the pattern "if (!query.exec()) qDebug" which should probably be using setError.

Have not added any new qDebug messages yet.
>
> resetModel can be used in more places currently still doing its equivalent calls.
Still unsure about this comment -- maybe it was mentioned in another thread.

>
> getValidTargets() and synchronizeTargets() hard-code HTML formatting - that's not good if we plan to see errors in console or XML and will make those cases harder to deal with. The messages should be predictable without using markup - if needed, it's still an option to use regex.
> m_errors.append("<b><font color=\"red\">Database "+index_number+"</font></b>: F

Discussed in another thread. Has been changed completely. No more markup
is included in output messages.

>
> FIXMEs that ought to be sorted out:
> ##KW## The two lists below are currently not used for anything
> ##KW## maybe this can be removed as it is replaced by revision_number
Already removed.
>
> Unused code:
> //targetDb->updateSyncLog(true, QString uid, QString generation, QString transaction_id);
Already removed?
> //double target_replica_generation = replyMap["target_replica_generation"].toDouble();
Already commented on this -- variable might be used in further
modifications. Commented out to avoid seeing warning during builds.

> This should probably say the real app name + " (U1Db-Qt)"
> request.setRawHeader("User-Agent", "My app name v0.1");
> request.setRawHeader("X-Custom-User-Agent", "My app name v0.1");
Already fixed.
>
> For good measure processDataFromRemoteServer might want to qDebug if an unexpected i.key() is seen?

Have not touched this -- will add an else clause.

>
> This should not be writable, it's only set internally
> Q_PROPERTY(QList<QString> errors READ getErrors WRITE setErrors NOTIFY errorsChanged)

Modified to sync_output, QList<QVariant> and read only (commit message
has more details).

>
> "where u1db has been downloaded/branched"
> This is very ambiguous and doesn't say where to obtain it. It should say
> "where the u1db Python reference implemented has been downloaded from lp:u1db"
Already fixed.

Kevin

[Kevin Wright (kevin-wright-1)]

Den 09/08/2013 12:50, skrev Christian Dywan:
>> The information can be used at the application level, or used by methods
>> within the plugin itself (e.g. console output, log file).
>>
>> I'll push those changes since they over write the original error
>> handling that needed removal/modification.
> Nice stuff actually. Much cleaner than I expected! It should lend itself extremely nicely for test cases as well. I wouldn't have expected this in this MR but I'm not going to complain now ;-)

It was actually quite easy to implement. Took less than 30 minutes to
put together.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:119
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/5/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/5/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/5/rebuild

review: Needs Fixing (continuous-integration)

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

120. By Kevin Wright on 2013-08-09

Modified database.cpp so that all query.exec() statements have either qDebug output of the error message, or are covered by setError. Eventually error handling should be more consistant, and perhaps utilize the same mechanism as sync_output in the Synchronizer class. Some functions in Database are used side by side with other functions in Synchronizer, so perhaps this is a wise idea where applicable.

[Kevin Wright (kevin-wright-1)]

>> There's a few instances of the pattern "if (!query.exec()) qDebug"
>> which should probably be using setError.
>
> Have not added any new qDebug messages yet.

Whoops. Misread this one. Added qDebug statements where there was
nothing. Will fix to use setError.

Kevin

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:120
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/6/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/6/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/6/rebuild

review: Needs Fixing (continuous-integration)

[Kevin Wright (kevin-wright-1)]

Den 09/08/2013 13:48, skrev Kevin Wright:
>>> There's a few instances of the pattern "if (!query.exec()) qDebug"
>>> which should probably be using setError.
>> Have not added any new qDebug messages yet.
> Whoops. Misread this one. Added qDebug statements where there was
> nothing. Will fix to use setError.
>
> Kevin
>

Hopefully all done now.

Kevin

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

121. By Kevin Wright on 2013-08-09

Modified database.cpp so that all query.exec() statements are covered by setError. Unfortunately setSerror cannot be the return value in some places, because the method is void or something other than a string.

122. By Kevin Wright on 2013-08-09

Modified database.cpp to fix a small bug re: setError.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:122
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/7/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/7/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/7/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/7/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/7/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/7/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/7/rebuild

review: Needs Fixing (continuous-integration)

[Cris Dywan (kalikiana)]

> Den 09/08/2013 11:20, skrev Christian Dywan:
> > These are the doc errors I'm currently seeing with the latest changes. They
> need to be resolve before the branch can be merged:
> Hopefully all fixed now. Could not find anything specific to resolve the
> warnings about \property, but maybe this is resolved by the change to
> fix the warning about \class.
>
> Also \param is used elsewhere in source files, but perhaps was not used
> properly in these instances. The references have been removed in the
> latest commit, but perhaps this needs to be looked at again.

There's still 17 qdoc warnings. See https://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/7/console I locally see the same.

review: Needs Fixing

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

123. By Kevin Wright on 2013-08-10

Changed qdoc markup class to qmlclass in synchronizer.cpp.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:123
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/8/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/8/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/8/rebuild

review: Needs Fixing (continuous-integration)

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

124. By Kevin Wright on 2013-08-12

Fixed qdoc warnings.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:124
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/9/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/9/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/9/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/9/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/9/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/9/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/9/rebuild

review: Needs Fixing (continuous-integration)

[Cris Dywan (kalikiana)]

I get a unit test failure with the latest update:

  <testcase result="fail" name="U1dbDatabase::test_1_databasePopulated">
    <failure message="Compared values are not the same
   Actual (): false
   Expected (): true" result="fail"/>
  </testcase>

Running "qmltestrunner -import ./_build/modules -input ./tests" gives me the line number:

tests/tst_database.qml(75)

review: Needs Fixing

[Kevin Wright (kevin-wright-1)]

Den 12/08/2013 11:26, skrev Christian Dywan:
> Review: Needs Fixing
>
> I get a unit test failure with the latest update:
>
> <testcase result="fail" name="U1dbDatabase::test_1_databasePopulated">
> <failure message="Compared values are not the same
> Actual (): false
> Expected (): true" result="fail"/>
> </testcase>
>
> Running "qmltestrunner -import ./_build/modules -input ./tests" gives me the line number:
>
> tests/tst_database.qml(75)

The test message seems ambiguous.

Compared values of what?

Kevin

[Cris Dywan (kalikiana)]

There's also Jenkins brokenness with precise:
  Err http://ppa.launchpad.net precise/main i386 Packages
  404 Not Found

Not at all related to u1db-qt - I'm investigating what we can do there.

[Cris Dywan (kalikiana)]

> Den 12/08/2013 11:26, skrev Christian Dywan:
> > Review: Needs Fixing
> >
> > I get a unit test failure with the latest update:
> >
> > <testcase result="fail" name="U1dbDatabase::test_1_databasePopulated">
> > <failure message="Compared values are not the same
> > Actual (): false
> > Expected (): true" result="fail"/>
> > </testcase>
> >
> > Running "qmltestrunner -import ./_build/modules -input ./tests" gives me the
> line number:
> >
> > tests/tst_database.qml(75)
>
> The test message seems ambiguous.
>
> Compared values of what?

Tell me about it, hte default messages of qmltestrunner suck :-(
But the line is:

compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]}) > -1, true)

So that translates to "Expected -1 but got something else from putDoc()"

[Kevin Wright (kevin-wright-1)]

Den 12/08/2013 11:35, skrev Christian Dywan:
>> Den 12/08/2013 11:26, skrev Christian Dywan:
>>> Review: Needs Fixing
>>>
>>> I get a unit test failure with the latest update:
>>>
>>> <testcase result="fail" name="U1dbDatabase::test_1_databasePopulated">
>>> <failure message="Compared values are not the same
>>> Actual (): false
>>> Expected (): true" result="fail"/>
>>> </testcase>
>>>
>>> Running "qmltestrunner -import ./_build/modules -input ./tests" gives me the
>> line number:
>>> tests/tst_database.qml(75)
>> The test message seems ambiguous.
>>
>> Compared values of what?
> Tell me about it, hte default messages of qmltestrunner suck :-(
> But the line is:
>
> compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]}) > -1, true)
>
> So that translates to "Expected -1 but got something else from putDoc()"
Yep, found it. putDoc returns a QString, but the test expects bool.

Not sure how to modify the test properly because the return value is
based on the UID of the database, which will be different with each new
database created -- in addition the function that retrieves the database
UID is private, so unless that is made public the only thing that could
be tested for is whether the return string is empty or not. Well, if the
return string contains ":1" that could also be tested for -- not quite a
good test but perhaps better than nothing.

Kevin

[Cris Dywan (kalikiana)]

> > compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]}) > -1,
> true)
> >
> > So that translates to "Expected -1 but got something else from putDoc()"
> Yep, found it. putDoc returns a QString, but the test expects bool.
>
> Not sure how to modify the test properly because the return value is
> based on the UID of the database, which will be different with each new
> database created -- in addition the function that retrieves the database
> UID is private, so unless that is made public the only thing that could
> be tested for is whether the return string is empty or not. Well, if the
> return string contains ":1" that could also be tested for -- not quite a
> good test but perhaps better than nothing.

It sounds sensible to check the empty string - the test only checks if it succeeds or not at the moment. I would leave it to a separate task to extend it to see if that id is valid, works, etc.

[Kevin Wright (kevin-wright-1)]

Den 12/08/2013 11:55, skrev Christian Dywan:
>>> compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]}) > -1,
>> true)
>>> So that translates to "Expected -1 but got something else from putDoc()"
>> Yep, found it. putDoc returns a QString, but the test expects bool.
>>
>> Not sure how to modify the test properly because the return value is
>> based on the UID of the database, which will be different with each new
>> database created -- in addition the function that retrieves the database
>> UID is private, so unless that is made public the only thing that could
>> be tested for is whether the return string is empty or not. Well, if the
>> return string contains ":1" that could also be tested for -- not quite a
>> good test but perhaps better than nothing.
> It sounds sensible to check the empty string - the test only checks if it succeeds or not at the moment. I would leave it to a separate task to extend it to see if that id is valid, works, etc.
I misunderstood slightly what the original test was looking for...it was
checking for an int actually, and whether it was > -1. In any case I
have changed it to check the return string and whether != empty string.

The qmltestrunner program seems to hang sometimes. It is difficult to
know if it is running or not. Is that normal?

Kevin

[Kevin Wright (kevin-wright-1)]

Den 12/08/2013 12:02, skrev <email address hidden>:
> Den 12/08/2013 11:55, skrev Christian Dywan:
>>>> compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]}) >
>>>> -1,
>>> true)
>>>> So that translates to "Expected -1 but got something else from
>>>> putDoc()"
>>> Yep, found it. putDoc returns a QString, but the test expects bool.
>>>
>>> Not sure how to modify the test properly because the return value is
>>> based on the UID of the database, which will be different with each new
>>> database created -- in addition the function that retrieves the
>>> database
>>> UID is private, so unless that is made public the only thing that could
>>> be tested for is whether the return string is empty or not. Well, if
>>> the
>>> return string contains ":1" that could also be tested for -- not
>>> quite a
>>> good test but perhaps better than nothing.
>> It sounds sensible to check the empty string - the test only checks
>> if it succeeds or not at the moment. I would leave it to a separate
>> task to extend it to see if that id is valid, works, etc.
> I misunderstood slightly what the original test was looking for...it
> was checking for an int actually, and whether it was > -1. In any case
> I have changed it to check the return string and whether != empty string.
>
> The qmltestrunner program seems to hang sometimes. It is difficult to
> know if it is running or not. Is that normal?
>
> Kevin
>
>
Checking for an empty string does not appear to be working no matter
which way I try. Will keep at it.

However, it also appears that there is a check for the file name of the
database. The test is only the name of the file itself, but the value
recieved appears to be the absolute path.

Kevin

[Kevin Wright (kevin-wright-1)]

Den 12/08/2013 12:22, skrev <email address hidden>:
> Den 12/08/2013 12:02, skrev <email address hidden>:
>> Den 12/08/2013 11:55, skrev Christian Dywan:
>>>>> compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]})
>>>>> > -1,
>>>> true)
>>>>> So that translates to "Expected -1 but got something else from
>>>>> putDoc()"
>>>> Yep, found it. putDoc returns a QString, but the test expects bool.
>>>>
>>>> Not sure how to modify the test properly because the return value is
>>>> based on the UID of the database, which will be different with each
>>>> new
>>>> database created -- in addition the function that retrieves the
>>>> database
>>>> UID is private, so unless that is made public the only thing that
>>>> could
>>>> be tested for is whether the return string is empty or not. Well,
>>>> if the
>>>> return string contains ":1" that could also be tested for -- not
>>>> quite a
>>>> good test but perhaps better than nothing.
>>> It sounds sensible to check the empty string - the test only checks
>>> if it succeeds or not at the moment. I would leave it to a separate
>>> task to extend it to see if that id is valid, works, etc.
>> I misunderstood slightly what the original test was looking for...it
>> was checking for an int actually, and whether it was > -1. In any
>> case I have changed it to check the return string and whether !=
>> empty string.
>>
>> The qmltestrunner program seems to hang sometimes. It is difficult to
>> know if it is running or not. Is that normal?
>>
>> Kevin
>>
>>
> Checking for an empty string does not appear to be working no matter
> which way I try. Will keep at it.
>
> However, it also appears that there is a check for the file name of
> the database. The test is only the name of the file itself, but the
> value recieved appears to be the absolute path.

Scratch this last one. Seems to be a misunderstanding.

>
> Kevin

[Cris Dywan (kalikiana)]

> There's also Jenkins brokenness with precise:
> Err http://ppa.launchpad.net precise/main i386 Packages
> 404 Not Found
>
> Not at all related to u1db-qt - I'm investigating what we can do there.

FYI A work-around for the issue is in place (real fix will take longer). The next automated build should run fine.

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

125. By Kevin Wright on 2013-08-12

Modified tests. In one instance a query property was missing from a Query element (in tst_query.qml), and in another occurance the test needed to be updated to reflect a different return value (in test_database.qml).

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:125
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/10/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/10/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/10/rebuild

review: Needs Fixing (continuous-integration)

[lp:~kevin-wright-1/u1db-qt/synchronizer-merged-with-trunk-8-aug]

126. By Kevin Wright on 2013-08-12

Fixed one test to remove a warning.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:126
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/11/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/11/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/11/rebuild

review: Needs Fixing (continuous-integration)

[Cris Dywan (kalikiana)]

ERROR: No artifacts found that match the file pattern "**/*test*.xml". Configuration error?
ERROR: '**/*test*.xml' doesn't match anything: '**' exists but not '**/*test*.xml'

I'm seeing to get this sorted. As far as I'm concerned, the build, tests and docs pass and this is down to Jenkins.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:126
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/12/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/12/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/12/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/12/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/12/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/12/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:126
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/13/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/13/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/13

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/13/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:126
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/14/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/14/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/16
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/14

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/14/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:126
http://jenkins.qa.ubuntu.com/job/u1db-qt-ci/15/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-precise-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-quantal-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-raring-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-amd64-ci/17
    SUCCESS: http://jenkins.qa.ubuntu.com/job/u1db-qt-saucy-armhf-ci/15

Click here to trigger a rebuild:
http://s-jenkins:8080/job/u1db-qt-ci/15/rebuild

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-07-31 12:22:38 +0000
+++ CMakeLists.txt	2013-08-12 16:20:45 +0000
@@ -8,11 +8,12 @@
 include(FindPkgConfig)
 include(GNUInstallDirs)
 find_package(Qt5Core REQUIRED)
+find_package(Qt5Network REQUIRED)
 find_package(Qt5Sql REQUIRED)
 add_definitions(-DWITHQT5=1)
 
 set(U1DB_QT_LIBNAME u1db-qt5)
-set(QT_PKGCONFIG_DEPENDENCIES "Qt5Core Qt5Quick Qt5Sql")
+set(QT_PKGCONFIG_DEPENDENCIES "Qt5Core Qt5Network Qt5Quick Qt5Sql")
 set(QT_U1DB_PKGCONFIG_FILE lib${U1DB_QT_LIBNAME}.pc)
 
 # Build flags
@@ -42,4 +43,3 @@
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${QT_U1DB_PKGCONFIG_FILE}
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
     )
-

=== modified file 'documentation/u1db.qdocconf'
--- documentation/u1db.qdocconf	2013-05-13 12:24:31 +0000
+++ documentation/u1db.qdocconf	2013-08-12 16:20:45 +0000
@@ -9,6 +9,7 @@
           ../src/document.h \
           ../src/index.h \
           ../src/query.h \
+          ../src/synchronizer.h \
           ../src/global.h
 Cpp.ignoretokens = Q_DECL_EXPORT \
                    Q_PROPERTY \
@@ -25,7 +26,8 @@
 ../examples/u1db-qt-example-2b \
 ../examples/u1db-qt-example-3 \
 ../examples/u1db-qt-example-4 \
-../examples/u1db-qt-example-5
+../examples/u1db-qt-example-5 \
+../examples/u1db-qt-example-6
 
 imagedirs = images 
 

=== added directory 'examples/u1db-qt-example-6'
=== added file 'examples/u1db-qt-example-6/u1db-qt-example-6.qdoc'
--- examples/u1db-qt-example-6/u1db-qt-example-6.qdoc	1970-01-01 00:00:00 +0000
+++ examples/u1db-qt-example-6/u1db-qt-example-6.qdoc	2013-08-12 16:20:45 +0000
@@ -0,0 +1,387 @@
+/*!
+
+\page  u1db-qt-tutorial-6.html
+
+\title U1Db-Qt Synchronizing Tutorial
+
+This tutorial is designed to demonstrate a variety of essential U1Db-Qt functionality and usage, including:
+
+\list 1
+    \li Synchronizing two databases
+    \li Utilizing the U1db-Qt Index element
+    \li Various approaches to define U1db-Qt Document elements when using the Index element
+    \li Partnering the U1db-Qt Index element and a QML ListView element 
+\endlist
+
+\section1 Storing Data
+
+\section2 The Database Element
+
+\section3 Creating a Database
+
+A Database is very simple to create. It only needs an id and a path where the file will be created. A Database is a model, which can be used by elements, such as the ListView further in this example.
+
+\code
+U1db.Database {
+    id: aDatabase
+    path: "aDatabase4"
+}
+\endcode
+
+\section1 The Document Element
+
+\section2 Declaring Documents (at Runtime)
+
+A Document can be instantiated at runtime, or generated dynamically. The examples below demonstrate the former.
+
+A very basic Document could include its unique 'id' and 'docId' properties. While it is not mandatory to define these properties, in some cases they can be convenient references. More advanced applications would likely find these very useful, and in some cases may be an absolute necessity to achieve the objectives of the program.
+
+This example of a very simple Document will not initially do anything, until more properties are added and defined:
+
+\code
+U1db.Document {
+    id: aDocument1
+    docId: 'helloworld1'
+}
+\endcode
+
+A basic but still practical Document definition contains several essential properties. In addition to 'id' and 'docId' (discussed above), the 'database', 'create', and 'defaults' properties are also very important, and are introduced below.
+
+The 'database' property ensures that the Document is attached to an already defined (or possibly soon to be defined one) identified by its id (in this case 'aDatabase'). For example:
+
+\code
+U1db.Document {
+    id: aDocument1
+    database: aDatabase
+    docId: 'helloworld1'
+}
+\endcode
+
+Should the Database not already contain a Document with the same docId ('hellowworld1' in this example) when a 'create' property is present and set to true it will be generated. For example:
+
+\code
+U1db.Document {
+    id: aDocument1
+    database: aDatabase
+    docId: 'helloworld1'
+    create: true
+}
+\endcode
+
+However, the Document still requires some data to be useful, which is what the 'defaults' property provides. The value of 'defaults' is a map of data that will be stored in the database (again when the create property is et to true). It contain key:value pairs, where the value can be a string, number, or nested object (e.g. additional fields, lists). For example:
+
+\code
+U1db.Document {
+    id: aDocument1
+    database: aDatabase
+    docId: 'helloworld1'
+    create: true
+    defaults:{"hello": { "world": { "message":"Hello World", "id": 1 } } }
+}
+\endcode
+
+As mentioned above, lists can also be nested in Document data. Lists provide a convenient method for producing multiple instances of the same key (AKA 'field' or 'sub-field'). The example code below shows valid use of the 'message' and 'id' sub-fields multiple times within the same object.
+
+\code
+U1db.Document {
+    id: aDocument2
+    database: aDatabase
+    docId: 'helloworld2'
+    create: true
+    defaults:{"hello": { "world": [
+                            { "message":"Hello World", "id": 2 },
+                            { "message":"Hello World", "id": 2.5 }
+                        ] } }
+}
+\endcode
+
+When the default Javascript Object Notation itself is formatted with appropriate line breaks and indentation, it becomes easier to visualize an embedded list, containing sub-fields 'message' and 'id' (and their respective values):
+
+\code
+{"hello":
+    { "world":
+        [
+            { "message":"Hello World", "id": 2 },
+            { "message":"Hello World", "id": 2.5 }
+        ]
+    }
+}
+\endcode
+
+In dot notation these sub-fields are represented by 'hello.world.message' and 'hello.world.id' respectively. Later in this tutorial these will be utilized within the 'expression' property of U1Db-Qt's Index element, in close collaboration with a QML ListView's delegates.
+
+
+Normally when a docId already exists in a database, and when the set flag is set to true, the value in 'defaults' will be ignored (and the existing data in the database will remain untouched). Sometimes a developer needs to easily overwrite the data in an existing document. The 'contents' property can be used for just that purpose. When 'contents' is defined, its value will replace existing data in the database, for the document identified by the docId. In addition, 'contents' can be used to add new documents, in the same way as the 'create: true' + 'defaults' combination does; in other words, if the document defined by 'docId' does not exist it will be created.
+
+\code
+U1db.Document {
+    id: aDocument3
+    database: aDatabase
+    docId: 'helloworld3'
+    contents:{"hello": { "world": [
+                            { "message":"Hello World", "id": 3 },
+                            { "message":"Hello World", "id": 3.33 },
+                            { "message":"Hello World", "id": 3.66 }
+                        ] } }
+}
+\endcode
+
+If 'defaults' exists, 'create' is set to 'true' (or 'false' for that matter) and 'contents' is also defined, it is the latter that takes precidence. In other words, 'create' and 'defaults' will be ignored. The following example demonstrates this scenario:
+
+\code
+U1db.Document {
+    id: aDocument3
+    database: aDatabase
+    docId: 'helloworld3'
+    create: true
+    default:{"hello": { "world": [{ "message":"Hello World", "id": 3 }] } }
+    contents:{"hello": { "world": [
+                                    { "message":"Hello World", "id": 3 },
+                                    { "message":"Hello World", "id": 3.33 },
+                                    { "message":"Hello World", "id": 3.66 }
+                        ] } }
+}
+\endcode
+
+This snippet simply represents the absence of the 'create' property, which is synonymous with 'create: false'. The Document can still be recognized within the application, but until applicable properties (such as those outlined above) are added and/or modified then nothing will be added or modified in the database, and this instance may have very little practical value.
+
+\code
+U1db.Document {
+    id: aDocument4
+    database: aDatabase
+    docId: 'helloworld4'
+    defaults:{"hello": { "world": { "message":"Hello World", "id": 4 } } }
+}
+\endcode
+
+\section3 Samples of Stored Documents
+
+The data stored in the database after defining the above Document elements (and then running the application, will consist of the following:
+
+\table
+\header
+    \li docId
+    \li content
+\row
+
+    \li 'helloworld1'
+    \li
+\code
+{
+    "hello": {
+        "world": {
+            "id": 1,
+            "message": "Hello World"
+        }
+    }
+}
+
+\endcode
+
+
+\row
+
+    \li 'helloworld2'
+    \li
+\code
+{
+    "hello": {
+        "world": [
+            {
+                "id": 2,
+                "message": "Hello World"
+            },
+            {
+                "id": 2.5,
+                "message": "Hello World"
+            }
+        ]
+    }
+}
+\endcode
+
+\row
+
+    \li 'helloworld3'
+    \li
+\code
+{
+    "hello": {
+        "world": [
+            {
+                "id": 3,
+                "message": "Hello World"
+            },
+            {
+                "id": 3.33,
+                "message": "Hello World"
+            },
+            {
+                "id": 3.66,
+                "message": "Hello World"
+            }
+        ]
+    }
+}
+\endcode
+
+
+\endtable
+
+\section1 Retrieving Data
+
+To retrieve the Documents that were declared earlier requires two additional elements: Index and Query.
+
+\section2 The Index Element
+
+\section3 Creating and Index Element
+
+The Index element requires both a unique 'id' and a pointer to a 'database' in order to begin becoming useful, as demonstrated here:
+
+\code
+U1db.Index{
+    database: aDatabase
+    id: by_helloworld
+}
+\endcode
+
+In the future, the Index element will support on disk storage of appropriate results / data. At the present time only in memory indexing is done, but once the storing capability is implemented, defining and identifying it is as simple as using the 'name' property (which will be stored in the database along with the relvent data that goes with it). The snippet below shows the use of the 'name' property:
+
+\code
+U1db.Index{
+    database: aDatabase
+    id: by_helloworld
+    //name: "by-helloworld"
+}
+\endcode
+
+The Index element describes, using dot notation, the fields and sub-fields where the developer expects to find information. That information is defined in a list, and added as the value for the 'expression' property. The list can contain one or more entries, as exemplified here (the property is commented out due to its current status):
+
+\code
+U1db.Index{
+    database: aDatabase
+    id: by_helloworld
+    //name: "by-helloworld"
+    expression: ["hello.world.id","hello.world.message"]
+}
+\endcode
+
+\section2 The QueryElement
+
+\section3 Creating a Query Element
+
+The Query element has two responsibilities: a bridge from Database+Index to other parts of the application, as well as further filtering of data in the database (in addition to what Index provides).
+
+In order to fulfil its duties as a bridge to an Index (and Database), the 'index' property must point to an Index element, identified by its 'id'. For example:
+
+\code
+U1db.Query{
+    id: aQuery
+    index: by_helloworld
+}
+\endcode
+
+While Index helps to filter data based on 'where' it is located (e.g. field.sub-field), Query helps determine the additional set of criteria for 'what' is being searched for. The intent of the 'query' property is to provide the mechanism for defnining the search criteria, but at the time of writing that functionality is not yet available. However, once the implementation is in place, using it is only requires defining the property's value (e.g. "Hello World"). Wild card searches using '*' are supported, which is the default query (i.e. if 'query' is not set it is assumed to be '*'). For example (the property is commented out due to its current status):
+
+\code
+U1db.Query{
+    id: aQuery
+    index: by_helloworld
+    //query: "*"
+}
+\endcode
+
+When the 'query' property becomes available, only wildcard search definitions for "starts with" will be suppoprted. Thus the following would be supported:
+
+\code
+U1db.Query{
+    id: aQuery
+    index: by_helloworld
+    //query: "Hello*"
+}
+\endcode
+
+
+But this would not:
+
+\code
+U1db.Query{
+    id: aQuery
+    index: by_helloworld
+    //query: "*World"
+}
+\endcode
+
+Note: again, the 'query' property is commented out in the above two snippets due to its current status
+
+\section1 Using Data
+
+\section2 Data and the Application UI
+
+\section3 Using Data With Models and Views
+
+This simple snippet represents how to attach a ListModel to a ListView. In this instance the model 'aQuery' is representative of the Query + Index combination defined earlier:
+
+\code
+ListView {
+    width: units.gu(45)
+    height: units.gu(80)
+    model: aQuery
+}
+\endcode
+
+\section4 Data and Delegates
+
+How a model and ListView + delegates work together is a common QML concept, and not specific to U1Db-Qt. However, the asynchronous nature of this relationship is important to understand. When using QML ListView, delegates will be created based on particular properties such as the size of the application window, ListView, and delegate itself (amongst other factors). Each delegate can then represent a Document retrieved from the Database based on the record's index. This example demonstrates some of the property definitions that contribute to determining the number of delegates a ListView will contain:
+
+\code
+ListView {
+    width: units.gu(45)
+    height: units.gu(80)
+    model: aQuery
+
+    delegate: Text {
+        x: 66; y: 77
+    }
+
+}
+\endcode
+
+
+When the number of Documents is less than or equal to the number of delegates then there is a one to one mapping of index to delegate (e.g. the first delegate will represent the Document with an index = 0; the second, index = 1; and so on).
+
+When there are more Documents than delegates the ListView will request a new index depending on the situation (e.g. a user scrolls up or down). For example, if a ListView has 10 delegates, but 32 Documents to handle, when a user initially scrolls the first delegate will change from representing the Document with index = 0 to the Document that might have index = 8; the second, from index = 1 to index = 9; ...; the 10th delegate from index = 9 to index = 17. A second scrolling gesture the first index may change to 15, and the final index 24. And so on. Scrolling in the opposite direction will have a similar effect, but the Document index numbers for each delegate will obviously start to decline (towards their original values).
+
+The following snippet, which modifies the above delegate definition, could demonstrate this effect if there were enough Documents to do so (i.e. some number greater than the number of delegates):
+
+\code
+ListView {
+    width: units.gu(45)
+    height: units.gu(80)
+    model: aQuery
+
+    delegate: Text {
+        x: 66; y: 77
+        text: index
+    }
+
+}
+\endcode
+
+The object called 'contents' contains one or more properties. This example demonstrates the retrieval of data based on the U1db.Index defined earlier (id: by-helloworld). In this instance the Index contained two expressions simultaniously, "hello.world.id" and "hello.world.message"
+
+\code
+ListView {
+    width: units.gu(45)
+    height: units.gu(80)
+    model: aQuery
+
+    delegate: Text {
+        x: 66; y: 77
+        text: "(" + index + ") '" + contents.message + " " + contents.id + "'"
+    }
+
+}
+\endcode
+
+*/

=== added file 'examples/u1db-qt-example-6/u1db-qt-example-6.qml'
--- examples/u1db-qt-example-6/u1db-qt-example-6.qml	1970-01-01 00:00:00 +0000
+++ examples/u1db-qt-example-6/u1db-qt-example-6.qml	2013-08-12 16:20:45 +0000
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * Authors:
+ *  Kevin Wright <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import U1db 1.0 as U1db
+import Ubuntu.Components 0.1
+
+
+Item {
+
+        width: units.gu(45)
+        height: units.gu(80)
+
+        U1db.Database {
+            id: aDatabase
+            path: "aDatabase6"
+        }
+
+       U1db.Document {
+            id: aDocument1
+            database: aDatabase
+            docId: 'helloworld'
+            create: true
+            contents:{"hello": { "world": [ { "message": "Hello World" } ] } }
+
+        }
+
+       U1db.Index{
+           database: aDatabase
+           id: by_helloworld
+           expression: ["hello.world.message"]
+       }
+
+       U1db.Query{
+           id: aQuery
+           index: by_helloworld
+           query: [{"message":"Hel*"}]
+       }
+
+       U1db.Synchronizer{
+           id: aSynchronizer
+           source: aDatabase
+           targets: [{remote:true},
+               {remote:true,
+                   ip:"127.0.0.1",
+                   port: 7777,
+                   name:"example1.u1db",
+                   resolve_to_source:true},
+               {remote:"OK"}]
+           synchronize: false
+       }
+
+    MainView {
+
+        id: u1dbView
+        width: units.gu(45)
+        height: units.gu(80)
+        anchors.top: parent.top;
+
+        Tabs {
+            id: tabs
+            anchors.fill: parent
+
+            Tab {
+                objectName: "Tab1"
+
+                title: i18n.tr("Hello U1Db!")
+
+                page: Page {
+                    id: helloPage
+
+                    Rectangle {
+                         width: units.gu(45)
+                         height: units.gu(40)
+                         anchors.top: parent.top;
+                         border.width: 1
+
+                         Text {
+                             id: sourceLabel
+                             anchors.top: parent.top;
+                             font.bold: true
+                             text: "aDatabase6 Contents"
+                         }
+
+                        ListView {
+                            id: sourceListView
+                            width: units.gu(45)
+                            height: units.gu(35)
+                            anchors.top: sourceLabel.bottom;
+                            model: aQuery
+
+                            delegate: Text {
+                                wrapMode: Text.WordWrap
+                                x: 6; y: 77
+                                text: {
+                                    text: "(" + index + ") '" + contents.message + "'"
+                                }
+                            }
+                        }
+
+
+                    }
+
+                   Rectangle {
+                       id: lowerRectangle
+                       width: units.gu(45)
+                       height: units.gu(35)
+                       anchors.bottom: parent.bottom;
+                       border.width: 1
+
+                       Text {
+                           id: errorsLabel
+                           anchors.top: parent.top;
+                           font.bold: true
+                           text: "Log:"
+                       }
+
+                       ListView {
+
+                           parent: lowerRectangle
+                           width: units.gu(45)
+                           height: units.gu(30)
+                           anchors.top: errorsLabel.bottom;
+                           model: aSynchronizer
+                           delegate:Text {
+                                width: units.gu(40)
+                                anchors.left: parent.left
+                                anchors.right: parent.right
+                                wrapMode: Text.WordWrap
+                                text: {
+                                    text: sync_output
+                                }
+                            }
+                        }
+
+                       Button{
+                           parent: lowerRectangle
+                           anchors.bottom: parent.bottom;
+                           text: "Sync"
+                           onClicked: aSynchronizer.synchronize = true
+                           anchors.left: parent.left
+                           anchors.right: parent.right
+
+                       }
+
+                   }
+                }
+
+            }
+
+        }
+
+    }
+
+}
+
+

=== modified file 'modules/U1db/CMakeLists.txt'
--- modules/U1db/CMakeLists.txt	2013-05-01 22:49:50 +0000
+++ modules/U1db/CMakeLists.txt	2013-08-12 16:20:45 +0000
@@ -1,4 +1,5 @@
 find_package(Qt5Quick REQUIRED)
+find_package(Qt5Network REQUIRED)
 
 get_target_property(QMAKE_EXECUTABLE Qt5::qmake LOCATION)
 # See http://doc-snapshot.qt-project.org/5.0/qtcore/qlibraryinfo.html#LibraryLocation-enum
@@ -13,6 +14,7 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${Qt5Sql_INCLUDE_DIRS}
+    ${Qt5Network_INCLUDE_DIRS}
     )
 
 add_library(U1DBPlugin SHARED ${U1DBPlugin_SRCS})
@@ -21,6 +23,7 @@
 target_link_libraries(U1DBPlugin
   ${U1DB_QT_LIBNAME}
   ${Qt5Quick_LIBRARIES}
+  ${Qt5Network_LIBRARIES}
   )
 
 include_directories(
@@ -28,6 +31,7 @@
     ${U1DB_INCLUDE_DIRS}
     ${CMAKE_CURRENT_BINARY_DIR}
     ${Qt5Quick_INCLUDE_DIRS}
+    ${Qt5Network_INCLUDE_DIRS}
     )
 
 # copy qmldir file into build directory for shadow builds

=== modified file 'modules/U1db/plugin.cpp'
--- modules/U1db/plugin.cpp	2013-02-15 11:43:45 +0000
+++ modules/U1db/plugin.cpp	2013-08-12 16:20:45 +0000
@@ -21,6 +21,7 @@
 #include "document.h"
 #include "index.h"
 #include "query.h"
+#include "synchronizer.h"
 #include "plugin.h"
 #include <qqml.h>
 
@@ -32,5 +33,6 @@
     qmlRegisterType<Document>(uri, 1, 0, "Document");
     qmlRegisterType<Index>(uri, 1, 0, "Index");
     qmlRegisterType<Query>(uri, 1, 0, "Query");
+    qmlRegisterType<Synchronizer>(uri, 1, 0, "Synchronizer");
 }
 

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2013-07-31 12:22:38 +0000
+++ src/CMakeLists.txt	2013-08-12 16:20:45 +0000
@@ -6,6 +6,7 @@
     document.cpp
     index.cpp
     query.cpp
+    synchronizer.cpp
     )
 
 # Generated files
@@ -14,6 +15,7 @@
     moc_document.cpp
     moc_index.cpp
     moc_query.cpp
+    moc_synchronizer.cpp
     )
 set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${U1DB_QT_GENERATED}")
 
@@ -27,6 +29,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     ${Qt5Core_INCLUDE_DIRS}
+    ${Qt5Network_INCLUDE_DIRS}
     ${Qt5Sql_INCLUDE_DIRS}
     ${U1DB_INCLUDE_DIRS}
     )
@@ -35,6 +38,7 @@
 target_link_libraries(${U1DB_QT_LIBNAME}
     ${Qt5Core_LIBRARIES}
     ${Qt5Sql_LIBRARIES}
+    ${Qt5Network_LIBRARIES}
     ${U1DB_LDFLAGS}
     )
 
@@ -50,7 +54,7 @@
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     )
 
-install(FILES global.h database.h document.h index.h query.h
+install(FILES global.h database.h document.h index.h query.h synchronizer.h
     DESTINATION ${INCLUDE_INSTALL_DIR}
     )
 

=== modified file 'src/database.cpp'
--- src/database.cpp	2013-04-29 23:54:19 +0000
+++ src/database.cpp	2013-08-12 16:20:45 +0000
@@ -106,7 +106,8 @@
     /* A unique ID is used for the connection name to ensure that we aren't
        re-using or replacing other opend databases. */
     if (!m_db.isValid())
-        m_db = QSqlDatabase::addDatabase("QSQLITE", QUuid::createUuid().toString());
+        m_db = QSqlDatabase::addDatabase("QSQLITE",QUuid::createUuid().toString());
+
     if (!m_db.isValid())
         return setError("QSqlDatabase error");
     m_db.setDatabaseName(path);
@@ -251,6 +252,42 @@
 }
 
 /*!
+ * \internal
+ * \brief Database::getDocumentContents
+ *
+ * Returns the string representation of a document that has
+ * been selected from the database using a document id.
+ *
+ */
+
+QString
+Database::getDocumentContents(const QString& docId)
+{
+    if (!initializeIfNeeded())
+        return QString();
+
+    QSqlQuery query(m_db.exec());
+    query.prepare("SELECT document.doc_rev, document.content, "
+        "count(conflicts.doc_rev) AS conflicts FROM document LEFT OUTER JOIN "
+        "conflicts ON conflicts.doc_id = document.doc_id WHERE "
+        "document.doc_id = :docId GROUP BY document.doc_id, "
+        "document.doc_rev, document.content");
+    query.bindValue(":docId", docId);
+    if (query.exec())
+    {
+        if (query.next())
+        {
+            if (query.value("conflicts").toInt() > 0)
+                setError(QString("Conflicts in %1").arg(docId));
+            return query.value("content").toString();
+        }
+        return setError(QString("Failed to get document %1: No document").arg(docId)) ? QString() : QString();
+    }
+    return setError(QString("Failed to get document %1: %2\n%3").arg(docId).arg(query.lastError().text()).arg(query.lastQuery())) ? QString() : QString();
+}
+
+
+/*!
     Returns the contents of a document by \a docId in a form that QML recognizes
     as a Variant object, it's identical to Document::getContents() with the
     same \a docId.
@@ -284,6 +321,9 @@
     return setError(QString("Failed to get document %1: %2\n%3").arg(docId).arg(query.lastError().text()).arg(query.lastQuery())) ? QVariant() : QVariant();
 }
 
+/*!
+    The increaseVectorClockRev(int oldRev) function is deprecated.
+ */
 static int
 increaseVectorClockRev(int oldRev)
 {
@@ -291,54 +331,304 @@
 }
 
 /*!
+ * \internal
+  This function creates a new revision number.
+
+  It returns a string for use in the document table's 'doc_rev' field.
+ */
+
+QString Database::getNextDocRevisionNumber(QString doc_id)
+{
+
+    QString revision_number = getReplicaUid()+":1";
+
+    QString current_revision_number = getCurrentDocRevisionNumber(doc_id);
+
+    /*!
+        Some revisions contain information from previous
+conflicts/syncs. Revisions are delimited by '|'.
+
+     */
+
+    QStringList current_revision_list = current_revision_number.split("|");
+
+    Q_FOREACH (QString current_revision, current_revision_list) {
+
+        /*!
+            Each revision contains two pieces of information,
+the uid of the database that made the revsion, and a counter
+for the revsion. This information is delimited by ':'.
+
+         */
+
+        QStringList current_revision_number_list = current_revision.split(":");
+
+        if(current_revision_number_list[0]==getReplicaUid()) {
+
+            /*!
+                If the current revision uid  is the same as this Database's uid the counter portion is increased by one.
+
+             */
+
+            int revision_generation_number = current_revision_number_list[1].toInt()+1;
+
+            revision_number = getReplicaUid()+":"+QString::number(revision_generation_number);
+
+        }
+        else {
+
+            /*!
+                If the current revision uid  is not the same as this Database's uid then the revision represents a change that originated in another database.
+
+             */
+            //revision_number+="|"+current_revision;
+
+            /* Not sure if the above is necessary,
+             *and did not appear to be working as intended either.
+             *
+             * Commented out, but maybe OK to delete.
+             */
+        }
+
+    }
+
+    /*!
+        The Database UID has curly brackets, but they are not required for the revision number and need to be removed.
+
+     */
+
+    revision_number = revision_number.replace("{","");
+
+    revision_number = revision_number.replace("}","");
+
+    return revision_number;
+
+}
+
+/*!
+ * \internal
+    The getCurrentDocRevisionNumber(QString doc_id) function
+returns the current string value from the document table's
+doc_rev field.
+
+ */
+
+
+QString Database::getCurrentDocRevisionNumber(QString doc_id){
+    if (!initializeIfNeeded())
+        return QString();
+
+    QSqlQuery query(m_db.exec());
+
+    query.prepare("SELECT doc_rev from document WHERE doc_id = :docId");
+    query.bindValue(":docId", doc_id);
+
+    if (query.exec())
+    {
+        while (query.next())
+        {
+            return query.value("doc_rev").toString();
+        }
+
+    }
+    else{
+        return setError(query.lastError().text()) ? QString() : QString();
+    }
+    return QString();
+}
+
+/*!
+ * \internal
+ * \brief Database::updateSyncLog
+ *
+ * This method is used at the end of a synchronization session,
+ * to update the database with the latest information known about the peer
+ * database that was synced against.
+ */
+void Database::updateSyncLog(bool insert, QString uid, QString generation, QString transaction_id)
+{
+
+    if (!initializeIfNeeded())
+        return;
+
+    QSqlQuery query(m_db.exec());
+
+    if(insert==true){
+        query.prepare("INSERT INTO sync_log(known_generation,known_transation_id,known_transation_id) VALUES(:knownGeneration, :knownTransactionId, :replicaUid)");
+
+    }
+    else{
+        query.prepare("UPDATE sync_log SET known_generation = :knownGeneration, known_transation_id = :knownTransactionId WHERE replica_uid = :replicaUid");
+    }
+
+
+    query.bindValue(":replicaUid", uid);
+    query.bindValue(":knownGeneration", generation);
+    query.bindValue(":knownTransactionId", transaction_id);
+    if (!query.exec())
+    {
+        setError(query.lastError().text());
+
+    }
+
+}
+
+/*!
+ * \internal
+ * \brief Database::updateDocRevisionNumber
+ *
+ * Whenever a document as added or modified it needs a new revision number.
+ *
+ * The revision number contains information about revisions made at the source,
+ * but also revisions to the document by target databases (and then synced with the source).
+ *
+ */
+
+void Database::updateDocRevisionNumber(QString doc_id,QString revision){
+    if (!initializeIfNeeded())
+        return;
+
+    QSqlQuery query(m_db.exec());
+
+    query.prepare("UPDATE document SET doc_rev = :revisionId WHERE doc_id = :docId");
+    query.bindValue(":docId", doc_id);
+    query.bindValue(":revisionId", revision);
+    if (!query.exec())
+    {
+        setError(query.lastError().text());
+
+    }
+
+}
+
+/*!
+    The getCurrentGenerationNumber() function searches for the
+current generation number from the  sqlite_sequence table.
+The return value can then be used during a synchronization session,
+amongst other things.
+
+ */
+
+int Database::getCurrentGenerationNumber(){
+
+    int sequence_number = -1;
+
+    QSqlQuery query(m_db.exec());
+
+    query.prepare("SELECT seq FROM sqlite_sequence WHERE name = 'transaction_log'");
+
+    if (query.exec())
+    {
+        while (query.next())
+        {
+            sequence_number = (query.value("seq").toInt());
+
+        }
+
+    }
+    else{
+        setError(query.lastError().text());
+    }
+
+    return sequence_number;
+
+}
+
+/*!
+    The generateNewTransactionId() function generates a random
+transaction id string, for use when creating new transations.
+
+ */
+
+QString Database::generateNewTransactionId(){
+
+    QString uid = "T-"+QUuid::createUuid().toString();
+    uid = uid.replace("}","");
+    uid = uid.replace("{","");
+    return uid;
+
+}
+
+/*!
+    Each time a document in the Database is created or updated a
+new transaction is performed, and information about it inserted into the
+transation_log table using the createNewTransaction(QString doc_id)
+function.
+
+ */
+
+int Database::createNewTransaction(QString doc_id){
+
+    QString transaction_id = generateNewTransactionId();
+
+    QSqlQuery query(m_db.exec());
+
+    QString queryString = "INSERT INTO transaction_log(doc_id, transaction_id) VALUES('"+doc_id+"', '"+transaction_id+"')";
+
+    if (!query.exec(queryString)){
+        return -1;
+    }
+    else{
+        return 0;
+    }
+
+    return -1;
+}
+
+/*!
     Updates the existing \a contents of the document identified by \a docId if
     there's no error.
     If no \a docId is given or \a docId is an empty string the \a contents will be
     stored under an autogenerated name.
     Returns the new revision of the document, or -1 on failure.
  */
-int
+QString
 Database::putDoc(QVariant contents, const QString& docId)
 {
     if (!initializeIfNeeded())
-        return -1;
+        return "";
 
     QString newOrEmptyDocId(docId);
     QVariant oldDoc = newOrEmptyDocId.isEmpty() ? QVariant() : getDocUnchecked(newOrEmptyDocId);
-    /* FIXME: Conflicts */
-
-    int newRev = increaseVectorClockRev(7/*contents.rev*/);
+
+    QString revision_number = getNextDocRevisionNumber(newOrEmptyDocId);
+
     QSqlQuery query(m_db.exec());
     if (oldDoc.isValid())
     {
         query.prepare("UPDATE document SET doc_rev=:docRev, content=:docJson WHERE doc_id = :docId");
         query.bindValue(":docId", newOrEmptyDocId);
-        query.bindValue(":docRev", newRev);
+        query.bindValue(":docRev", revision_number);
         // Parse Variant from QML as JsonDocument, fallback to string
         QString json(QJsonDocument::fromVariant(contents).toJson());
         query.bindValue(":docJson", json.isEmpty() ? contents : json);
         if (!query.exec())
-            return setError(QString("Failed to put/ update document %1: %2\n%3").arg(newOrEmptyDocId).arg(query.lastError().text()).arg(query.lastQuery())) ? -1 : -1;
+            return setError(QString("Failed to put/ update document %1: %2\n%3").arg(newOrEmptyDocId).arg(query.lastError().text()).arg(query.lastQuery())) ? "" : "";
         query.prepare("DELETE FROM document_fields WHERE doc_id = :docId");
         query.bindValue(":docId", newOrEmptyDocId);
         if (!query.exec())
-            return setError(QString("Failed to delete document field %1: %2\n%3").arg(newOrEmptyDocId).arg(query.lastError().text()).arg(query.lastQuery())) ? -1 : -1;
+            return setError(QString("Failed to delete document field %1: %2\n%3").arg(newOrEmptyDocId).arg(query.lastError().text()).arg(query.lastQuery())) ? "" : "";
+
+        createNewTransaction(newOrEmptyDocId);
+
     }
     else
     {
         if (newOrEmptyDocId.isEmpty())
             newOrEmptyDocId = QString("D-%1").arg(QUuid::createUuid().toString().mid(1).replace("}",""));
         if (!QRegExp("^[a-zA-Z0-9.%_-]+$").exactMatch(newOrEmptyDocId))
-            return setError(QString("Invalid docID %1").arg(newOrEmptyDocId)) ? -1 : -1;
+            return setError(QString("Invalid docID %1").arg(newOrEmptyDocId)) ? "" : "";
 
         query.prepare("INSERT INTO document (doc_id, doc_rev, content) VALUES (:docId, :docRev, :docJson)");
         query.bindValue(":docId", newOrEmptyDocId);
-        query.bindValue(":docRev", newRev);
+        query.bindValue(":docRev", revision_number);
         // Parse Variant from QML as JsonDocument, fallback to string
         QJsonDocument json(QJsonDocument::fromVariant(contents));
         query.bindValue(":docJson", json.isEmpty() ? contents : json.toJson());
         if (!query.exec())
-            return setError(QString("Failed to put document %1: %2\n%3").arg(docId).arg(query.lastError().text()).arg(query.lastQuery())) ? -1 : -1;
+            return setError(QString("Failed to put document %1: %2\n%3").arg(docId).arg(query.lastError().text()).arg(query.lastQuery())) ? "" : "";
+
+        createNewTransaction(newOrEmptyDocId);
     }
 
     beginResetModel();
@@ -350,8 +640,22 @@
 
     Q_EMIT docChanged(newOrEmptyDocId, contents);
 
-    return newRev;
-}
+    return revision_number;
+}
+
+/*!
+ * \brief Database::resetModel
+ *
+ * Resets the Database model.
+ */
+
+void Database::resetModel(){
+
+    beginResetModel();
+    endResetModel();
+
+}
+
 
 /*!
     Returns a list of all stored documents by their docId.
@@ -376,6 +680,7 @@
         }
         return list;
     }
+
     return setError(QString("Failed to list documents: %1\n%2").arg(query.lastError().text()).arg(query.lastQuery())) ? list : list;
 }
 
@@ -400,6 +705,12 @@
     Q_EMIT pathChanged(path);
 }
 
+/*!
+ * \brief Database::getPath
+ *
+ * Simply returns the path of the database.
+ *
+ */
 QString
 Database::getPath()
 {
@@ -516,6 +827,76 @@
     return list;
 }
 
+/* Handy functions for synchronization. */
+
+/*!
+ * \internal
+ * \brief Database::listTransactionsSince
+ *
+ * This lists transactions for the database since a particular generation number.
+ *
+ */
+
+QList<QString> Database::listTransactionsSince(int generation){
+
+    QList<QString> list;
+
+    if (!initializeIfNeeded())
+        return list;
+
+    QSqlQuery query(m_db.exec());
+
+    QString queryStmt = "SELECT generation, doc_id, transaction_id FROM transaction_log where generation > "+QString::number(generation);
+
+    if (query.exec(queryStmt))
+    {
+        while (query.next())
+        {
+            list.append(query.value("generation").toString()+"|"+query.value("doc_id").toString()+"|"+query.value("transaction_id").toString());
+        }
+
+        return list;
+
+    }
+
+    return list;
+
+}
+
+/*!
+ * \internal
+ * \brief Database::getSyncLogInfo
+ *
+ * Provides the information about previous synchronizations between the database and another (if any).
+ *
+ */
+
+QMap<QString,QVariant> Database::getSyncLogInfo(QMap<QString,QVariant> lastSyncInformation, QString uid, QString prefix){
+
+    if (!initializeIfNeeded())
+        return lastSyncInformation;
+
+    QString queryStmt = "SELECT known_transaction_id, known_generation FROM sync_log WHERE replica_uid = '"+uid +"'";
+
+    QSqlQuery query(m_db.exec());
+
+    if (query.exec(queryStmt))
+    {
+        while (query.next())
+        {
+            lastSyncInformation.insert(prefix + "_replica_generation", query.value(1).toInt());
+            lastSyncInformation.insert(prefix + "_replica_transaction_id",query.value(0).toString());
+            return lastSyncInformation;
+        }
+
+    }
+    else{
+        setError(query.lastError().text());
+    }
+
+    return lastSyncInformation;
+}
+
 QT_END_NAMESPACE_U1DB
 
 #include "moc_database.cpp"

=== modified file 'src/database.h'
--- src/database.h	2013-04-23 15:17:24 +0000
+++ src/database.h	2013-08-12 16:20:45 +0000
@@ -36,21 +36,33 @@
 public:
     Database(QObject* parent = 0);
 
+
     // QAbstractListModel
     QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
     QHash<int, QByteArray>roleNames() const;
     int rowCount(const QModelIndex & parent = QModelIndex()) const;
+    void resetModel();
 
     QString getPath();
     void setPath(const QString& path);
     Q_INVOKABLE QVariant getDoc(const QString& docId);
+    QString getDocumentContents(const QString& docId);
     QVariant getDocUnchecked(const QString& docId) const;
-    Q_INVOKABLE int putDoc(QVariant newDoc, const QString& docID=QString());
+    Q_INVOKABLE QString putDoc(QVariant newDoc, const QString& docID=QString());
     Q_INVOKABLE QList<QString> listDocs();
     Q_INVOKABLE QString lastError();
     Q_INVOKABLE QString putIndex(const QString& index_name, QStringList expressions);
     Q_INVOKABLE QStringList getIndexExpressions(const QString& indexName);
     Q_INVOKABLE QStringList getIndexKeys(const QString& indexName);
+
+    /* Functions handy for Synchronization */
+    QString getNextDocRevisionNumber(QString doc_id);
+    QString getCurrentDocRevisionNumber(QString doc_id);
+    void updateDocRevisionNumber(QString doc_id,QString revision);
+    void updateSyncLog(bool insert, QString uid, QString generation, QString transaction_id);
+    QList<QString> listTransactionsSince(int generation);
+    QMap<QString,QVariant> getSyncLogInfo(QMap<QString,QVariant> lastSyncInformation, QString uid, QString prefix);
+
 Q_SIGNALS:
     void pathChanged(const QString& path);
     void errorChanged(const QString& error);
@@ -63,7 +75,7 @@
      */
     void docLoaded(const QString& docId, QVariant content) const;
 private:
-    Q_DISABLE_COPY(Database)
+    //Q_DISABLE_COPY(Database)
     QString m_path;
     QSqlDatabase m_db;
     QString m_error;
@@ -73,6 +85,11 @@
     bool initializeIfNeeded(const QString& path=":memory:");
     bool setError(const QString& error);
     QString getDocIdByRow(int row) const;
+
+    int createNewTransaction(QString doc_id);
+    QString generateNewTransactionId();
+    int getCurrentGenerationNumber();
+
 };
 
 QT_END_NAMESPACE_U1DB

=== modified file 'src/query.cpp'
--- src/query.cpp	2013-05-01 23:06:01 +0000
+++ src/query.cpp	2013-08-12 16:20:45 +0000
@@ -59,6 +59,7 @@
 QVariant
 Query::data(const QModelIndex & index, int role) const
 {
+
     if (role == 0) // contents
         return m_results.at(index.row());
     if (role == 1) // docId
@@ -150,8 +151,23 @@
 
     }
 
+    resetModel();
+
     Q_EMIT documentsChanged(m_documents);
     Q_EMIT resultsChanged(m_results);
+
+}
+
+/*!
+ * \brief Query::resetModel
+ *
+ * Resets the model of the Query
+ *
+ */
+
+void Query::resetModel(){
+    beginResetModel();
+    endResetModel();
 }
 
 /*!

=== modified file 'src/query.h'
--- src/query.h	2013-04-25 13:38:33 +0000
+++ src/query.h	2013-08-12 16:20:45 +0000
@@ -52,6 +52,8 @@
     QStringList getDocuments();
     QList<QVariant> getResults();
 
+    void resetModel();
+
 Q_SIGNALS:
     void indexChanged(Index* index);
     void queryChanged(QVariant query);

=== added file 'src/synchronizer.cpp'
--- src/synchronizer.cpp	1970-01-01 00:00:00 +0000
+++ src/synchronizer.cpp	2013-08-12 16:20:45 +0000
@@ -0,0 +1,1257 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * Authors:
+ *  Kevin Wright <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+#include <QSqlQuery>
+#include <QFile>
+#include <QSqlError>
+#include <QUuid>
+#include <QStringList>
+#include <QJsonDocument>
+
+#include "synchronizer.h"
+#include "private.h"
+
+QT_BEGIN_NAMESPACE_U1DB
+
+/*!
+    \class Synchronizer
+    \inmodule U1Db
+    \ingroup modules
+
+    \brief The Synchronizer class handles synchronizing between two databases.
+
+*/
+
+/*
+
+ Below this line are general methods for this class, such as setting/getting values for various properties.
+
+*/
+
+/*!
+    Create a new Synchronizer element, with an optional \a parent, usually by declaring it as a QML item.
+
+    Synchronizer elements sync two databases together, a 'source' database and a remote or local 'target' database.
+
+    Example use in a QML application:
+
+    U1db.Synchronizer{
+        id: aSynchronizer
+        synchronize: false
+        source: aDatabase
+        targets: [{remote:true,
+        ip:"127.0.0.1",
+        port: 7777,
+        name:"example1.u1db",
+        resolve_to_source:true}]
+
+    }
+
+    Short description of properties:
+
+    id: The element's identification.
+
+    bool synchronize: Is the element actively synching or not. Should be set to false.
+
+    U1DB::Database source: The id of a local database that will be used for synchronization.
+
+    QVariant targets: One or more target databases that will be synched with the local database.
+
+    bool targets.remote: Is the target database a remote or local database.
+
+    QString targets.ip: The ip address of a remote database (if applicable).
+
+    int targets.port: Port number of the remote server.
+
+    QString targets.name: The name of the database.
+
+    bool targets.resolve_to_source: In case of conflict should the sync resolve to the source's data (if true).
+
+    Example use with u1db-serve:
+
+    1. In a terminal cd into a directory where the u1db Python reference implemented has been downloaded from lp:u1db.
+    2. Using Python create a database called 'example1.u1db' using u1db, and a document 'helloworld':
+
+        # python
+
+            >>> import u1db
+            >>> db = u1db.open("example1.u1db",create=True)
+            >>> content = {"hello": { "world": { "message":"Hello World Updated" } } }
+            >>> db.create_doc(content, doc_id="helloworld")
+
+        ctrl+d
+
+    3. From the u1db directory above type './u1db-serve --port=7777' and hit enter.
+    4. Open another terminal tab.
+    5. Change into a directory containing u1db-qt (assuming this class is included in that directory and the installed version on the host computer).
+    6. Change into the directory where u1db-qt-example-6.qml is located.
+    7. Type 'qmlscene u1db-qt-example-6.qml' and hit enter.
+    8. Click the button labelled 'Sync'.
+    9. Check the terminal windows for output from either the client or server.
+
+ */
+
+Synchronizer::Synchronizer(QObject *parent) :
+    QAbstractListModel(parent), m_synchronize(false), m_source(NULL)
+{
+    QObject::connect(this, &Synchronizer::syncChanged, this, &Synchronizer::onSyncChanged);
+}
+
+/*!
+    \internal
+ *Used to implement QAbstractListModel
+ *Implements the variables exposed to the Delegate in a model
+ */
+QVariant
+Synchronizer::data(const QModelIndex & index, int role) const
+{
+    if (role == 0)
+        return m_sync_output.at(index.row());
+    return QVariant();
+}
+
+/*!
+    \internal
+    Used to implement QAbstractListModel
+
+    The number of rows: the number of documents given by the query.
+ */
+int
+Synchronizer::rowCount(const QModelIndex & parent) const
+{
+    return m_sync_output.count();
+}
+
+/*!
+    \internal
+    Used to implement QAbstractListModel
+
+ */
+QHash<int, QByteArray>
+Synchronizer::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles.insert(0, "sync_output");
+    return roles;
+}
+
+
+/*!
+
+
+    Sets the source database.
+
+ */
+void Synchronizer::setSource(Database* source)
+{
+
+    if (m_source == source)
+        return;
+
+    if (m_source)
+        QObject::disconnect(m_source, 0, this, 0);
+
+    m_source = source;
+
+    Q_EMIT sourceChanged(source);
+}
+
+
+/*!
+ * \property Synchronizer::targets
+ *
+ * Sets meta-data for databases to be used during a synchronization session.
+ *
+ * The QVariant is a list that can contain definitions for more than one database
+ * to be used as a target. For example:
+ *
+ * targets: [{remote:true},
+ *  {remote:true,
+ *  ip:"127.0.0.1",
+ *  port: 7777,
+ *  name:"example1.u1db",
+ *  resolve_to_source:true},
+ *  {remote:"OK"}]
+ *
+ * The above example defines three databases. Two of the three definitions in the
+ * example are invalid, the first ({remote:true}) and the third ({remote:"OK"}),
+ * because they are incomplete.
+ *
+ * The second definition is a fully defined and valid definition for a local to
+ * remote synchronization of two databases:
+ *
+ * {remote:true,
+ *  ip:"127.0.0.1",
+ *  port: 7777,
+ *  name:"example1.u1db",
+ *  resolve_to_source:true}
+ *
+ * 'remote' determines whether the database is on disk or located on a server.
+ * 'ip' and 'port' for a server are used only when 'remote' is set to true
+ * 'name' is the name of the local (on disk) or remote database.
+ *  Note: If 'remote' is false this is the relative/absolute file location.
+ * 'resolve_to_source' determines whether to resolve conflicts automatically
+ * in favor of the source (aka local) database's values or the target's.
+ *
+ */
+
+void Synchronizer::setTargets(QVariant targets)
+{
+
+    if (m_targets == targets)
+        return;
+
+    //if (m_targets)
+      //  QObject::disconnect(m_targets, 0, this, 0);
+
+    m_targets = targets;
+    Q_EMIT targetsChanged(targets);
+}
+
+/*!
+ * \property Synchronizer::synchronize
+ */
+
+void Synchronizer::setSync(bool synchronize)
+{
+
+    if (m_synchronize == synchronize)
+        return;
+
+    m_synchronize = synchronize;
+    Q_EMIT syncChanged(synchronize);
+}
+
+
+/*!
+ * \property Synchronizer::resolve_to_source
+ */
+
+void Synchronizer::setResolveToSource(bool resolve_to_source)
+{
+     if (m_resolve_to_source == resolve_to_source)
+        return;
+
+    m_resolve_to_source = resolve_to_source;
+    Q_EMIT resolveToSourceChanged(resolve_to_source);
+}
+
+
+/*!
+ * \fn void Synchronizer::setSyncOutput(QList<QVariant> sync_output)
+ *
+ * Sets the current value for the active session's \a sync_output.
+ *
+ */
+
+void Synchronizer::setSyncOutput(QList<QVariant> sync_output)
+{
+     if (m_sync_output == sync_output)
+        return;
+
+    m_sync_output = sync_output;
+    Q_EMIT syncOutputChanged(sync_output);
+}
+
+/*!
+ * \property Synchronizer::source
+ *
+ *
+ *  Returns a source Database.
+ *
+ */
+Database* Synchronizer::getSource()
+{
+     return m_source;
+}
+
+/*!
+ * \brief Synchronizer::getTargets
+ *
+ *
+ *  Returns meta-data for all target databases.
+ *
+ */
+
+QVariant Synchronizer::getTargets()
+{
+     return m_targets;
+}
+
+/*!
+ * \brief Synchronizer::getSync
+ *
+ *
+ * Returns the current value of synchronize. If true then the synchronize
+ * session is initiated.
+ *
+ * This should probaby always be set to false on application start up.
+ * The application developer should use some trigger to switch it to true
+ * when needed (e.g. button click).
+ *
+ */
+
+bool Synchronizer::getSync()
+{
+     return m_synchronize;
+}
+
+/*!
+ * \brief Synchronizer::getResolveToSource
+ *
+ *
+ * If set to true, any document conflicts created during a sync session
+ * will be resolved in favor of the content from the source database. If false
+ * the content from the target database will replace the document content in
+ * the source database.
+ *
+ */
+
+bool Synchronizer::getResolveToSource(){
+    return m_resolve_to_source;
+}
+
+/*!
+ * \property Synchronizer::sync_output
+ * \brief Synchronizer::getSyncOutput
+ *
+ * Returns the output from a sync session. The list should contain numerous
+ * QVariantMaps, each of which will have various meta-data with informative
+ * information about what happened in the background of the session.
+ *
+ * In some cases the information will be about errors or warnings, and in
+ * other cases simple log messages. Also included would noramlly be associated
+ * properties, elements and other data.
+ *
+ * The information can be used in any number of ways, such as on screen within an app,
+ * testing, console output, logs and more. This is designed to be flexible enough that
+ * the app developer can decide themselves how to best use the data.
+ *
+ */
+
+QList<QVariant> Synchronizer::getSyncOutput(){
+    return m_sync_output;
+}
+
+/*
+
+ Below this line represents the class' more unique functionality.
+ In other words, methods that do more than simply modify/retrieve
+ an element's property values.
+
+*/
+
+
+/*!
+ * \brief Synchronizer::onSyncChanged
+ *
+ * The synchroization process begins here.
+ *
+ */
+
+void Synchronizer::onSyncChanged(bool synchronize){
+
+    Database* source = getSource();
+
+    QList<QVariant> sync_targets;
+
+    /*!
+     * The validator map contains key and value pair definitions,
+     *that are used to confirm that the values provided for each
+     *database target are of the expected type for a particular key.
+     */
+
+    QMap<QString,QString>validator;
+
+    validator.insert("remote","bool");
+    validator.insert("location","QString");
+    validator.insert("resolve_to_source","bool");
+
+
+    /*!
+     * The mandatory map contains the keys that are used to confirm
+     *that a database target definition contains all the mandatory keys
+     *necessary for synchronizing.
+     */
+
+    QList<QString>mandatory;
+
+    mandatory.append("remote");
+    mandatory.append("resolve_to_source");
+
+    if(synchronize == true){
+
+        /*!
+          A list of valid sync target databases is generated by calling the getValidTargets(validator, mandatory) method, and adding the return value to a QList (sync_targets).
+          */
+
+        sync_targets=getValidTargets(validator, mandatory);
+
+        /*!
+         * Once the list of sync targets has been generated the sync activity
+         *can be initiated via the synchronizeTargets function.
+         */
+
+        synchronizeTargets(source, sync_targets);
+
+        /*!
+         * After the synchronization is complete the model is reset so that
+         *log and error messages are available at the application level.
+         *
+         */
+
+        beginResetModel();
+        endResetModel();
+
+        /*!
+          The convenience signals syncOutputChanged and syncCompleted are
+emitted after the model has been reset.
+          */
+
+        Q_EMIT syncOutputChanged(m_sync_output);
+        Q_EMIT syncCompleted();
+
+        /*!
+         * The sync boolean value is reset to its default value (false)
+         *once all sync activity is complete.
+         */
+
+        setSync(false);
+
+    }
+    else{
+
+    }
+}
+
+
+/*!
+ * \internal
+ * \brief Synchronizer::getValidTargets
+ *
+ *
+ * This method confirms that each sync target definition is valid, based
+ * on predefined criteria contained in the validator and mandatory lists.
+ *
+ */
+
+QList<QVariant> Synchronizer::getValidTargets(QMap<QString,QString>validator, QList<QString>mandatory){
+
+    QList<QVariant> sync_targets;
+
+    int index = 0;
+
+    QList<QVariant> targets = getTargets().toList();
+
+    Q_FOREACH (QVariant target_variant, targets)
+    {
+        index++;
+        QString index_number = QString::number(index);
+
+        QMap<QString, QVariant> target = target_variant.toMap();
+
+        bool valid = true;
+        bool complete = true;
+
+        QMapIterator<QString, QVariant> i(target);
+        while (i.hasNext()) {
+
+            i.next();
+
+            if(validator.contains(i.key())&&validator[i.key()]!=i.value().typeName()){
+                valid = false;
+
+                QString message_value = "For property `" + i.key() + "` Expecting type `" + validator[i.key()] + "`, but received type `" + i.value().typeName()+"`";
+                
+                QVariantMap output_map;
+                output_map.insert("concerning_property","targets");
+                output_map.insert("concerning_index",index_number);
+                output_map.insert("message_type","error");
+                output_map.insert("message_value",message_value);
+                m_sync_output.append(output_map);
+                
+                target.insert("sync",false);
+
+                break;
+            }
+
+            if(valid==false){
+                targets.removeOne(target);
+                break;
+            }
+            else{
+                QListIterator<QString> j(mandatory);
+
+                while(j.hasNext()){
+                    QString value = j.next();
+                    if(!target.contains(value)){
+
+                        QString message_value = "Expected property `" + value + "`, but it is not present.";
+
+                        QVariantMap output_map;
+                        output_map.insert("concerning_property","targets");
+                        output_map.insert("concerning_index",index_number);
+                        output_map.insert("message_type","error");
+                        output_map.insert("message_value",message_value);
+                        m_sync_output.append(output_map);
+
+                        target.insert("sync",false);
+                        targets.removeOne(target);
+                        complete = false;
+                        break;
+                    }
+                }
+                if(complete==false){
+                    break;
+                }
+
+            }
+        }
+
+        if(target.contains("sync")&&target["sync"]==false){
+
+            QString message_value = "Not synced due to errors with properties.";
+
+            QVariantMap output_map;
+            output_map.insert("concerning_property","targets");
+            output_map.insert("concerning_index",index_number);
+            output_map.insert("message_type","error");
+            output_map.insert("message_value",message_value);
+            m_sync_output.append(output_map);
+
+        }
+        else
+        {
+            target.insert("sync",true);
+            sync_targets.append(target);
+
+            QString message_value = "Mandatory properties were included and their values are valid.";
+
+            QVariantMap output_map;
+            output_map.insert("concerning_property","targets");
+            output_map.insert("concerning_index",index_number);
+            output_map.insert("message_type","no-errors");
+            output_map.insert("message_value",message_value);
+            m_sync_output.append(output_map);
+
+        }
+
+    }
+
+    return sync_targets;
+
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::synchronizeTargets
+ *
+ * The source database is synchronized with the target databases contained
+ * in the 'targets' list. That list should only contain valid targets, as
+ * determined by Synchronizer::getValidTargets.
+ *
+ */
+
+void Synchronizer::synchronizeTargets(Database *source, QVariant targets){
+
+    if(targets.typeName()== QStringLiteral("QVariantList")){
+
+        QList<QVariant> target_list = targets.toList();
+
+        QListIterator<QVariant> i(target_list);
+
+        int target_index = -1;
+
+        while(i.hasNext()){
+
+            target_index++;
+
+            QVariant target = i.next();
+
+            if(target.typeName()== QStringLiteral("QVariantMap")){
+                QMap<QString,QVariant> target_map = target.toMap();
+
+                if(target_map.contains("remote")&&target_map["remote"]==false){
+                    if(target_map.contains("sync")&&target_map["sync"]==true){
+
+                        QString message_value = "Valid local target.";
+
+                        QVariantMap output_map;
+                        output_map.insert("concerning_property","targets");
+                        output_map.insert("concerning_index",target_index);
+                        output_map.insert("message_type","no-errors");
+                        output_map.insert("message_value",message_value);
+                        m_sync_output.append(output_map);
+
+                        syncLocalToLocal(source, target_map);
+                    }
+                }
+                else if(target_map.contains("remote")&&target_map["remote"]==true){
+                    if(target_map.contains("sync")&&target_map["sync"]==true){
+
+                        //ip
+                        //port
+                        //name
+                        //GET /thedb/sync-from/my_replica_uid
+
+                        QString source_uid = getUidFromLocalDb(source->getPath());
+                        QString get_string = target_map["name"].toString()+"/sync-from/"+source_uid;
+                        QString url_string = "http://"+target_map["ip"].toString();
+                        QString full_get_request = url_string+"/"+get_string;
+                        int port_number = target_map["port"].toInt();
+
+                        QNetworkAccessManager *manager = new QNetworkAccessManager(source);
+
+                        QUrl url(full_get_request);
+                        url.setPort(port_number);
+
+                        QNetworkRequest request(url);
+
+                        connect(manager, &QNetworkAccessManager::finished, this, &Synchronizer::remoteGetSyncInfoFinished);
+
+                        QString message_value = "Valid remote target.";
+
+                        QVariantMap output_map;
+                        output_map.insert("concerning_property","targets");
+                        output_map.insert("concerning_index",target_index);
+                        output_map.insert("message_type","no-errors");
+                        output_map.insert("message_value",message_value);
+                        m_sync_output.append(output_map);
+
+                        manager->get(QNetworkRequest(request));
+
+                    }
+                }
+                else{
+
+                    QString message_value = "Unknown error. Please check properties";
+
+                    QVariantMap output_map;
+                    output_map.insert("concerning_property","targets");
+                    output_map.insert("concerning_index",target_index);
+                    output_map.insert("message_type","error");
+                    output_map.insert("message_value",message_value);
+                    m_sync_output.append(output_map);
+
+                }
+
+            }
+
+        }
+
+    }
+
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::syncLocalToLocal
+ *
+ * This function synchronizes two local databases, a source database and a target database.
+ *
+ */
+
+void Synchronizer::syncLocalToLocal(Database *sourceDb, QMap<QString,QVariant> target)
+{
+
+    QString target_db_name = target["location"].toString();
+
+    Database *targetDb;
+    Index *targetIndex;
+    Query *targetQuery;
+
+    Index *sourceIndex;
+    Query *sourceQuery;
+
+    if(target.contains("id")){
+        targetDb = (Database*)target["id"].value<QObject*>();
+    }
+
+    if(target.contains("target_query")){
+        targetQuery = (Query*)target["target_query"].value<QObject*>();
+        targetIndex = targetQuery->getIndex();
+        targetDb = targetIndex->getDatabase();
+    }
+
+    if(target.contains("source_query")){
+        sourceQuery = (Query*)target["source_query"].value<QObject*>();
+        sourceIndex = sourceQuery->getIndex();
+        sourceDb = sourceIndex->getDatabase();
+    }
+
+    if(sourceDb == NULL || targetDb == NULL){
+
+        QString message_value = "Either source or target does not exist or is not active.";
+
+        QVariantMap output_map;
+        output_map.insert("concerning_property","source|targets");
+        //output_map.insert("concerning_index",index_number); // no access to targets index?
+        output_map.insert("message_type","error");
+        output_map.insert("message_value",message_value);
+        m_sync_output.append(output_map);
+
+        return;
+    }
+
+    QMap<QString,QVariant> lastSyncInformation;
+
+    lastSyncInformation.insert("target_replica_uid",getUidFromLocalDb(target_db_name));
+    lastSyncInformation.insert("target_replica_generation","");
+    lastSyncInformation.insert("target_replica_transaction_id",-1);
+    lastSyncInformation.insert("source_replica_uid",getUidFromLocalDb(sourceDb->getPath()));
+    lastSyncInformation.insert("source_replica_generation","");
+    lastSyncInformation.insert("source_replica_transaction_id",-1);
+
+    lastSyncInformation = getLastSyncInformation(sourceDb, targetDb, false, lastSyncInformation);
+
+    QList<QString> transactionsFromSource;
+    QList<QString> transactionsFromTarget;
+
+    // Check if target and source have ever been synced before
+
+    if(lastSyncInformation["target_replica_uid"].toString() != "" && lastSyncInformation["target_replica_generation"].toString() != "" && lastSyncInformation["target_replica_transaction_id"].toInt() != -1 && lastSyncInformation["source_replica_uid"].toString() != "" && lastSyncInformation["source_replica_generation"].toString() != "" && lastSyncInformation["source_replica_transaction_id"].toInt() != -1)
+    {
+
+        QString message_value = "Source and local database have previously synced.";
+
+        QVariantMap output_map;
+        output_map.insert("concerning_property","source|targets");
+        output_map.insert("concerning_source",sourceDb->getPath());
+        output_map.insert("concerning_target",target_db_name);
+        output_map.insert("message_type","no-errors");
+        output_map.insert("message_value",message_value);
+        m_sync_output.append(output_map);
+
+        //Do some syncing
+
+        transactionsFromSource = sourceDb->listTransactionsSince(lastSyncInformation["source_replica_generation"].toInt());
+
+        transactionsFromTarget = targetDb->listTransactionsSince(lastSyncInformation["target_replica_generation"].toInt());
+
+
+    }
+    else{
+
+        QString message_value = "Source and local database have not previously synced.";
+
+        QVariantMap output_map;
+        output_map.insert("concerning_property","source|targets");
+        output_map.insert("concerning_source",sourceDb->getPath());
+        output_map.insert("concerning_target",target_db_name);
+        output_map.insert("message_type","no-errors");
+        output_map.insert("message_value",message_value);
+        m_sync_output.append(output_map);
+
+        //There is a first time for everything, let's sync!
+
+        transactionsFromSource = sourceDb->listTransactionsSince(0);
+
+        transactionsFromTarget = targetDb->listTransactionsSince(0);
+    }
+
+    /*!
+     * With two distinct lists present, it is now possible to check what
+     * updates should be made, or new documents created in one or the other
+     * database, depending on conditions.
+     *
+     * However, two additional lists containing transactions IDs are required
+     * because the information is contained within delimited strings (see
+     * below for details).
+     *
+    */
+
+    QList<QString> transactionIdsFromSource;
+    QList<QString> transactionIdsFromTarget;
+
+    Q_FOREACH(QString sourceTransaction, transactionsFromSource){
+
+        /*!
+         * Each sourceTransaction is a pipe delimited string containing
+         * generation number, document ID, and transaction ID details
+         * in that order.
+         *
+         * Splitting the string into its component pieces provides a
+         * document ID (the second key in the list).
+         */
+
+        QStringList transactionDetails = sourceTransaction.split("|");
+
+        /*!
+          * It is only necessary to have unique instances of the
+          * document ID.
+          */
+
+        if(!transactionIdsFromSource.contains(transactionDetails[1]))
+            transactionIdsFromSource.append(transactionDetails[1]);
+
+    }
+
+    Q_FOREACH(QString targetTransaction, transactionsFromTarget){
+
+        /*!
+         * Each targetTransaction is a pipe delimited string containing
+         * generation number, document ID, and transaction ID details
+         * in that order.
+         *
+         * Splitting the string into its component pieces provides a
+         * document ID (the second key in the list).
+         */
+
+        QStringList transactionDetails = targetTransaction.split("|");
+
+        /*!
+          * It is only necessary to have unique instances of the
+          * document ID.
+          */
+
+        if(!transactionIdsFromTarget.contains(transactionDetails[1]))
+            transactionIdsFromTarget.append(transactionDetails[1]);
+
+    }   
+
+
+    /* The source replica asks the target replica for the information it has stored about the last time these two replicas were synchronised (if ever).*/
+
+
+    /*
+
+    The application wishing to synchronise sends the following GET request to the server:
+
+    GET /thedb/sync-from/my_replica_uid
+
+    Where thedb is the name of the database to be synchronised, and my_replica_uid is the replica id of the application’s (i.e. the local, or synchronisation source) database
+
+    */
+
+    /*
+
+    The target responds with a JSON document that looks like this:
+
+    {
+        "target_replica_uid": "other_replica_uid",
+        "target_replica_generation": 12,
+        "target_replica_transaction_id": "T-sdkfj92292j",
+        "source_replica_uid": "my_replica_uid",
+        "source_replica_generation": 23,
+        "source_transaction_id": "T-39299sdsfla8"
+    }
+
+    With all the information it has stored for the most recent synchronisation between itself and this particular source replica. In this case it tells us that the synchronisation target believes that when it and the source were last synchronised, the target was at generation 12 and the source at generation 23.
+
+    */
+
+
+    /* The source replica validates that its information regarding the last synchronisation is consistent with the target’s information, and raises an error if not. (This could happen for instance if one of the replicas was lost and restored from backup, or if a user inadvertently tries to synchronise a copied database.) */
+
+
+
+    /* The source replica generates a list of changes since the last change the target replica knows of. */
+
+
+
+    /* The source replica checks what the last change is it knows about on the target replica. */
+
+
+
+    /* If there have been no changes on either replica that the other side has not seen, the synchronisation stops here. */
+
+
+
+    /* The source replica sends the changed documents to the target, along with what the latest change is that it knows about on the target replica. */
+
+
+
+    /* The target processes the changed documents, and records the source replica’s latest change. */
+
+
+
+    /* The target responds with the documents that have changes that the source does not yet know about. */
+
+    /* The source processes the changed documents, and records the target replica’s latest change. */
+
+
+
+    /* If the source has seen no changes unrelated to the synchronisation during this whole process, it now sends the target what its latest change is, so that the next synchronisation does not have to consider changes that were the result of this one.*/
+
+
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::syncDocument
+ *
+ *
+ *  This method is used to synchronize documents from one local database
+ * to another local database.
+ *
+ */
+
+
+QVariant Synchronizer::syncDocument(Database *from, Database *to, QString docId)
+{
+    QVariant document = from->getDoc(docId);
+    to->putDoc(document, docId);
+    QString revision = from->getCurrentDocRevisionNumber(docId);
+    to->updateDocRevisionNumber(docId,revision);
+
+    return document;
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::getLastSyncInformation
+ *
+ *
+ * If the source and target database have ever been synced before the information
+ * from that previous session is returned. This is only used for local to local
+ * databases. The local to remote procedure is handled elsewhere in a different manner.
+ *
+ */
+
+QMap<QString,QVariant> Synchronizer::getLastSyncInformation(Database *sourceDb, Database *targetDb, bool remote, QMap<QString,QVariant> lastSyncInformation){
+
+    if(remote == true){
+
+        QString message_value = "Sync information from remote target not available at this time.";
+
+        QVariantMap output_map;
+        output_map.insert("concerning_property","source|targets");
+        output_map.insert("concerning_source",sourceDb->getPath());
+        output_map.insert("message_type","warning");
+        output_map.insert("message_value",message_value);
+        m_sync_output.append(output_map);
+
+        return lastSyncInformation;
+
+    }
+    else{
+
+        lastSyncInformation["source_replica_uid"].toString();
+
+        lastSyncInformation = targetDb->getSyncLogInfo(lastSyncInformation, lastSyncInformation["source_replica_uid"].toString(),"target");
+
+        lastSyncInformation = sourceDb->getSyncLogInfo(lastSyncInformation, lastSyncInformation["target_replica_uid"].toString(),"source");
+
+    }
+
+    return lastSyncInformation;
+
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::getUidFromLocalDb
+ *
+ *
+ * The unique id of a database is needed in certain situations of a
+ * synchronize session. This method retrieves that id from a local database.
+ *
+ */
+
+QString Synchronizer::getUidFromLocalDb(QString dbFileName)
+{
+
+    QString dbUid;
+
+    QSqlDatabase db;
+
+    db = QSqlDatabase::addDatabase("QSQLITE",QUuid::createUuid().toString());
+
+    QFile db_file(dbFileName);
+
+    if(!db_file.exists())
+    {
+
+        QString message_value = "Database does not exist.";
+
+        QVariantMap output_map;
+        output_map.insert("concerning_property","source|targets");
+        output_map.insert("concerning_database",dbFileName);
+        output_map.insert("message_type","error");
+        output_map.insert("message_value",message_value);
+        m_sync_output.append(output_map);
+
+        return dbUid;
+    }
+    else
+    {
+        db.setDatabaseName(dbFileName);
+        if (!db.open()){
+
+            QString message_value = db.lastError().text();
+
+            QVariantMap output_map;
+            output_map.insert("concerning_property","source|targets");
+            output_map.insert("concerning_database",dbFileName);
+            output_map.insert("message_type","error");
+            output_map.insert("message_value",message_value);
+            m_sync_output.append(output_map);
+
+        }
+        else{
+            QSqlQuery query (db.exec("SELECT value FROM u1db_config WHERE name = 'replica_uid'"));
+
+            if(!query.lastError().isValid() && query.next()){
+                dbUid = query.value(0).toString();
+                db.close();
+
+                dbUid = dbUid.replace("{","");
+
+                dbUid = dbUid.replace("}","");
+
+                return dbUid;
+            }
+            else{
+                qDebug() << query.lastError().text();
+                db.close();
+                return dbUid;
+            }
+        }
+
+    }
+
+    return dbUid;
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::remoteGetSyncInfoFinished
+ *
+ * Once the initial exchange between the client application
+ * and the remote server is complete, this method retrieves
+ * necessary information from the reply that came from the
+ * server, and is required for posting data from the client
+ * in the steps that will follow.
+ *
+ * After the data is saved to a string and the network reply
+ * is closed, the appropriate method for posting
+ * (postDataFromClientToRemoteServer) is then called.
+ *
+ */
+
+void Synchronizer::remoteGetSyncInfoFinished(QNetworkReply* reply)
+{
+
+    QNetworkAccessManager *manager = reply->manager();
+
+    Database *source = qobject_cast<Database *>(manager->parent());
+
+    QUrl postUrl = reply->request().url();
+
+    QByteArray data = reply->readAll();
+
+    QString replyData = QString(data);
+
+    reply->close();
+
+    postDataFromClientToRemoteServer(source, postUrl, replyData);
+}
+
+
+/*!
+ * \internal
+ * \brief Synchronizer::postDataFromClientToRemoteServer
+ *
+ * This method builds a string for posting from the client
+ * application to the remote server, using information previously
+ * gathered from the source and target databases,
+ * and then initiates the post.
+ *
+ */
+
+void Synchronizer::postDataFromClientToRemoteServer(Database *source, QUrl postUrl, QString replyData)
+{
+
+    QVariantMap replyMap;
+
+    QJsonDocument replyJson = QJsonDocument::fromJson(replyData.toUtf8());
+
+    QVariant replyVariant = replyJson.toVariant();
+
+    replyMap = replyVariant.toMap();
+
+    double source_replica_generation = replyMap["source_replica_generation"].toDouble();
+    QString source_replica_uid = replyMap["source_replica_uid"].toString();
+    QString source_replica_transaction_id = replyMap["source_transaction_id"].toString();
+    //double target_replica_generation = replyMap["target_replica_generation"].toDouble();
+    QString target_replica_transaction_id = replyMap["target_replica_transaction_id"].toString();
+    QString target_replica_uid = replyMap["target_replica_uid"].toString();
+
+    QNetworkAccessManager *manager = new QNetworkAccessManager(source);
+
+    connect(manager, &QNetworkAccessManager::finished, this, &Synchronizer::remotePostSyncInfoFinished);
+
+    QByteArray postString;
+
+    postString = "[\r\n";
+    postString.append("{\"last_known_generation\": ");
+    postString.append(QByteArray::number(source_replica_generation));
+    postString.append(", \"last_known_trans_id\": \"");
+    postString.append(source_replica_transaction_id);
+    postString.append("\"}");
+
+    QList<QString> transactions = m_source->listTransactionsSince(source_replica_generation);
+
+    Q_FOREACH(QString transaction,transactions){
+        QStringList transactionData = transaction.split("|");
+
+        QString content = source->getDocumentContents(transactionData[1]);
+        content = content.replace("\r\n","");
+        content = content.replace("\r","");
+        content = content.replace("\n","");
+        content = content.replace("\"","\\\"");
+
+        postString.append(",\r\n{\"content\": \""+content+"\",\"rev\": \""+m_source->getCurrentDocRevisionNumber(transactionData[1])+"\", \"id\": \""+transactionData[1]+"\",\"trans_id\": \""+transactionData[2]+"\",\"gen\": "+transactionData[0]+"}");
+
+    }
+
+    postString.append("\r\n]");
+
+    QByteArray postDataSize = QByteArray::number(postString.size());
+
+    QNetworkRequest request(postUrl);
+    request.setRawHeader("User-Agent", "U1Db-Qt v1.0");
+    request.setRawHeader("X-Custom-User-Agent", "U1Db-Qt v1.0");
+    request.setRawHeader("Content-Type", "application/x-u1db-sync-stream");
+    request.setRawHeader("Content-Length", postDataSize);
+
+    manager->post(QNetworkRequest(request),postString);
+
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::remotePostSyncInfoFinished
+ *
+ * This method is a slot, which is called once the data
+ * from the client application has been posted to the remote
+ * server.
+ *
+ * This is where any new data from the
+ * remote server is gathered, and then the further steps
+ * for processing on the client side are begun.
+ */
+
+void Synchronizer::remotePostSyncInfoFinished(QNetworkReply* reply)
+{
+
+    QNetworkAccessManager *manager = reply->manager();
+
+    Database *source = qobject_cast<Database *>(manager->parent());
+
+    QByteArray data = reply->readAll();
+
+    QString replyData = QString(data);
+
+    reply->close();
+
+    processDataFromRemoteServer(source, replyData);
+
+}
+
+/*!
+ * \internal
+ * \brief Synchronizer::processDataFromRemoteServer
+ *
+ * After the remote target database has replied back, the data it has sent
+ * is processed to determine what action to take on any relevant documents
+ * that may have been included in the data.
+ *
+ */
+
+void Synchronizer::processDataFromRemoteServer(Database *source, QString replyData)
+{
+
+    replyData = replyData.replace("\r\n","");
+
+    QJsonDocument replyJson = QJsonDocument::fromJson(replyData.toUtf8());
+
+    QVariant replyVariant = replyJson.toVariant();
+
+    QVariantList replyList = replyVariant.toList();
+
+    QListIterator<QVariant> i(replyList);
+
+    int index = -1;
+
+    while(i.hasNext()){
+
+        index++;
+
+        QVariant current = i.next();
+
+        QString type_name = QString::fromUtf8(current.typeName());
+
+        if(type_name == "QVariantMap")
+        {
+
+            QVariantMap map = current.toMap();
+
+            if(index == 0)
+            {
+                // Meta data
+            }
+            else
+            {
+                // Document to update
+
+                QString id("");
+                QVariant content("");
+                QString rev("");
+
+                QMapIterator<QString, QVariant> i(map);
+
+                while (i.hasNext()) {
+
+                    i.next();
+
+                    if(i.key()=="content")
+                    {
+                        content = i.value();
+                    }
+                    else if(i.key()=="id")
+                    {
+                        id = i.value().toString();
+                    }
+                    else if(i.key()=="rev")
+                    {
+                        rev = i.value().toString();
+                    }
+
+                }
+
+                if(content!=""&&id!=""&&rev!="")
+                {
+                    source->putDoc(content,id);
+                    source->updateDocRevisionNumber(id,rev);
+                }
+
+            }
+
+        }
+
+    }
+
+}
+
+QT_END_NAMESPACE_U1DB
+
+#include "moc_synchronizer.cpp"
+

=== added file 'src/synchronizer.h'
--- src/synchronizer.h	1970-01-01 00:00:00 +0000
+++ src/synchronizer.h	2013-08-12 16:20:45 +0000
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * Authors:
+ *  Kevin Wright <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef U1DB_SYNCHRONIZER_H
+#define U1DB_SYNCHRONIZER_H
+
+#include <QtCore/QObject>
+#include <QSqlDatabase>
+#include <QVariant>
+#include <QMetaType>
+#include <QtNetwork>
+#include <QNetworkAccessManager>
+
+
+#include "database.h"
+#include "index.h"
+#include "query.h"
+
+QT_BEGIN_NAMESPACE_U1DB
+
+class Q_DECL_EXPORT Synchronizer : public QAbstractListModel {
+    Q_OBJECT
+#ifdef Q_QDOC
+    Q_PROPERTY(Database* source READ getSource WRITE setSource NOTIFY sourceChanged)   
+#else
+    Q_PROPERTY(QT_PREPEND_NAMESPACE_U1DB(Database*) source READ getSource WRITE setSource NOTIFY sourceChanged)  
+#endif
+    Q_PROPERTY(bool synchronize READ getSync WRITE setSync NOTIFY syncChanged)
+    Q_PROPERTY(bool resolve_to_source READ getResolveToSource WRITE setResolveToSource NOTIFY resolveToSourceChanged)
+    Q_PROPERTY(QVariant targets READ getTargets WRITE setTargets NOTIFY targetsChanged)
+    Q_PROPERTY(QList<QVariant> sync_output READ getSyncOutput NOTIFY syncOutputChanged)
+
+public:
+    Synchronizer(QObject* parent = 0);
+
+    // QAbstractListModel
+    QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
+    QHash<int, QByteArray>roleNames() const;
+    int rowCount(const QModelIndex & parent = QModelIndex()) const;
+
+    QList<QVariant> getValidTargets(QMap<QString,QString>validator, QList<QString>mandatory);
+    QMap<QString,QVariant> getLastSyncInformation(Database *sourceDb, Database *targetDb, bool remote, QMap<QString,QVariant> lastSyncInformation);
+
+
+    Database* getSource();
+    QVariant getTargets();
+    bool getSync();
+    bool getResolveToSource();
+    QList<QVariant> getSyncOutput();
+
+    void setSource(Database* source);
+    void setTargets(QVariant targets);
+    void setSync(bool synchronize);
+    void setResolveToSource(bool resolve_to_source);
+    void setSyncOutput(QList<QVariant> sync_output);
+
+    void syncLocalToLocal(Database *sourceDb, QMap<QString,QVariant> target);
+    void synchronizeTargets(Database *source, QVariant targets);
+
+    QVariant syncDocument(Database *from, Database *to, QString docId); 
+    QString getUidFromLocalDb(QString dbFileName);
+
+    void postDataFromClientToRemoteServer(Database *source, QUrl postUrl, QString replyData);
+    void processDataFromRemoteServer(Database *source, QString replyData);
+
+
+Q_SIGNALS:
+
+    /*!
+     * \brief sourceChanged
+     * \param source
+     */
+
+    void sourceChanged(Database* source);
+
+    /*!
+     * \brief targetsChanged
+     * \param targets
+     */
+
+    void targetsChanged(QVariant targets);
+
+    /*!
+     * \brief syncChanged
+     * \param synchronize
+     */
+
+    void syncChanged(bool synchronize);
+
+    /*!
+     * \brief resolveToSourceChanged
+     * \param resolve_to_source
+     */
+
+    void resolveToSourceChanged(bool resolve_to_source);
+
+    /*!
+     * \brief syncOutputChanged
+     * \param sync_output
+     */
+
+    void syncOutputChanged(QList<QVariant> sync_output);
+
+    /*!
+     * \brief syncCompleted
+     */
+
+    void syncCompleted();
+
+private:
+    //Q_DISABLE_COPY(Synchronizer)
+    Database* m_source;
+    bool m_synchronize;
+    bool m_resolve_to_source;
+    QVariant m_targets;
+    QList<QVariant> m_sync_output;
+
+    void onSyncChanged(bool synchronize);
+    void remoteGetSyncInfoFinished(QNetworkReply* reply);
+    void remotePostSyncInfoFinished(QNetworkReply* reply);
+
+};
+
+QT_END_NAMESPACE_U1DB
+
+
+
+#endif // U1DB_SYNCHRONIZER_H
+
+

=== modified file 'tests/tst_database.qml'
--- tests/tst_database.qml	2013-07-16 17:17:53 +0000
+++ tests/tst_database.qml	2013-08-12 16:20:45 +0000
@@ -72,15 +72,15 @@
 
     function test_1_databasePopulated () {
         spyListCompleted.wait()
-        compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]}) > -1, true)
+        compare(myDatabase.putDoc({"animals": ["cat", "dog", "hamster"]}) == '', false)
 
         var myPath = "aDatabaseA"
         myDatabase.path = myPath
         spyPathChanged.wait()
         compare(myDatabase.path, myPath)
-        compare(myDatabase.putDoc({"spam": "eggs"}) > -1, true)
+        compare(myDatabase.putDoc({"spam": "eggs"}) == '', false)
         var json = {"foo": "bar"}
-        compare(myDatabase.putDoc(json, "hijklmn") > -1, true)
+        compare(myDatabase.putDoc(json, "hijklmn") == '', false)
         compare(myDatabase.getDoc("hijklmn"), json)
         compare(myDatabase.getDoc("hijklmn"), json)
     }

=== modified file 'tests/tst_query.qml'
--- tests/tst_query.qml	2013-05-10 16:04:04 +0000
+++ tests/tst_query.qml	2013-08-12 16:20:45 +0000
@@ -117,6 +117,7 @@
     U1db.Query {
         id: wrongQuery
         index: byNamePhone
+        query: [{ 'name': 'Ivanka', 'phone': '*' }]
     }
 
     SignalSpy {