Merge lp:~kevin-wright-1/u1db-qt/synchronizer-18-juni-i into lp:u1db-qt

[Cris Dywan]

[Cris Dywan (kalikiana)]

syncLocalToLocal should use U1db::Database to re-use the initialization, which would also give it the existing sanity checks

the logic of onSyncChanged is probably best moved into a separate callback. Changing resolve_to_source and targets would trigger it as well. Thus it becomes possible to delay/ thread the real sync and avoid any delay at startup.

Even with keeping in mind it's incomplete //uncommented code and conflicts make reviewing a little hard.

I love the description of the sync via HTTP/ JSON, this would be nice to get into one qdoc-ified comment and make it accessible as documentation.

[lp:~kevin-wright-1/u1db-qt/synchronizer-18-juni-i]

100. By Kevin Wright on 2013-06-27

Migrated listTransactionsSince function from Syncrhonizer class to Database class. Previously this class used the path of a database file rather than an instance of an active Database class' database connection. With the function now hosted by the Database class itself the path of the file and opening of the database connection within the scope of the function is no longer required (i.e. the class' active database connection is used instead).

101. By Kevin Wright on 2013-06-27

Migrated getSyncLogInfoFromLocalDb function from Synchronizer class to Database class, and renamed getSyncLogInfo. Previously this class used the path of a database file rather than an instance of an active Database class' database connection. With the function now hosted by the Database class itself the path of the file and opening of the database connection within the scope of the function is no longer required (i.e. the class' active database connection is used instead). This function is used by the Synchronizer class' getLastSyncInformation function to retrieve data from the source and target databases. The data represents information that one database has about the other the last time they synced (if ever).

102. By Kevin Wright on 2013-06-27

Fixed a regression relating to the active source Database for Synchronizer. In the function syncLocalToLocal is the ability to overide the main source database (the 'source' property) with another database when a query is defined within an individual 'target' definition (with the key 'source_query').

103. By Kevin Wright on 2013-07-04

Added the initial steps for sync with a remote database. There are several steps in the archtitecure for remote sync, whereby the server and client communicate information between each other (e.g. previous sync transations, new data). This commit consists of the first step, where the client initiates the sync transaction and the server responds with known information about previous syncs if any. Also in this commit is the first roughed in code for the second stage of a sync transaction, where the client (aka source) begins sharing information about new data since the previous sync between the two databases (if any previous transaction occured).

104. By Kevin Wright on 2013-07-04

This commit continues the work to support the second stage of a local to remote sync transaction, where the client (aka source) begins sharing information about new data since the previous sync between the two databases (if any previous transaction occured). The code now is up to the point of initiating the post to the remote server, but at this time is showing bad request errors. The post is not sending complete data at this time, which may be the reason for the bad request error.

105. By Kevin Wright on 2013-07-04

This commit continues the work to support the second stage of a local to remote sync transaction, where the client (aka source) begins sharing information about new data since the previous sync between the two databases (if any previous transaction occured). The post is sending complete data as of this commit, but the server is still replying with a bad request error. On the surface everything appears to comply with the high level architecture documentation, but something is obviously still incorrect.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-05-01 22:49:50 +0000
+++ CMakeLists.txt	2013-07-04 14:13:28 +0000
@@ -7,11 +7,12 @@
 # Dependencies
 include(FindPkgConfig)
 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
@@ -39,4 +40,3 @@
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${QT_U1DB_PKGCONFIG_FILE}
     DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/pkgconfig
     )
-

=== 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-07-04 14:13:28 +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-07-04 14:13:28 +0000
@@ -0,0 +1,227 @@
+/*
+ * 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.Database {
+            id: aTargetDatabase
+            path: "aTargetDatabase6"
+        }
+
+       U1db.Document {
+            id: aDocument1
+            database: aDatabase
+            docId: 'helloworld'
+            create: true
+            defaults:{"hello": { "world": { "message":"Hello World", "id": 1 } } }
+
+        }
+
+       U1db.Document {
+            id: aDocument2
+            database: aTargetDatabase
+            docId: 'helloworld'
+            create: true
+            defaults:{"hello": { "world": [
+                        { "message":"Hello World", "id": 2 },
+                        { "message":"Hello World", "id": 2.5 }
+                    ] } }
+        }
+
+       U1db.Index{
+           database: aDatabase
+           id: by_helloworld
+           expression: ["hello.world.id","hello.world.message"]
+       }
+
+       U1db.Query{
+           id: aQuery
+           index: by_helloworld
+           query: [{"id":"*"},{"message":"Hel*"}]
+       }
+
+       U1db.Index{
+           database: aTargetDatabase
+           id: by_target_helloworld
+           expression: ["hello.world.id","hello.world.message"]
+       }
+
+       U1db.Query{
+           id: aTargetQuery
+           index: by_target_helloworld
+           query: [{"id":"*"},{"message":"Hel*"}]
+       }
+
+       U1db.Synchronizer{
+           id: aSynchronizer
+           source: aDatabase
+           targets: [{remote:true},
+               {remote:false,
+                   id:aTargetQuery.index.database,
+                   resolve_to_source: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(20)
+                            anchors.top: sourceLabel.bottom;
+                            model: aQuery
+
+                            delegate: Text {
+                                wrapMode: Text.WordWrap
+                                x: 6; y: 77
+                                text: {
+                                    text: "(" + index + ") '" + contents.message + " " + contents.id + "'"
+                                }
+                            }
+                        }
+
+                        Text {
+                            id: targetLabel
+                            anchors.top: sourceListView.bottom;
+                            font.bold: true
+                            text: "aTargetDatabase6 Contents"
+                        }
+
+
+                        ListView {
+
+                            width: units.gu(45)
+                            height: units.gu(20)
+                            anchors.top: targetLabel.bottom;
+                            model: aTargetQuery
+
+                            delegate: Text {
+                                wrapMode: Text.WordWrap
+                                x: 6; y: 77
+                                text: {
+                                    text: "(" + index + ") '" + contents.message + " " + contents.id + "'"
+                                }
+                            }
+                        }
+                    }
+
+                   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: errors
+                                }
+                            }
+                        }
+
+                       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-07-04 14:13:28 +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-07-04 14:13:28 +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-04-23 10:39:54 +0000
+++ src/CMakeLists.txt	2013-07-04 14:13:28 +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 lib${LIB_SUFFIX}
     )
 
-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-07-04 14:13:28 +0000
@@ -106,7 +106,11 @@
     /* 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())
+<<<<<<< TREE
         m_db = QSqlDatabase::addDatabase("QSQLITE", QUuid::createUuid().toString());
+=======
+        m_db = QSqlDatabase::addDatabase("QSQLITE",QUuid::createUuid().toString());
+>>>>>>> MERGE-SOURCE
     if (!m_db.isValid())
         return setError("QSqlDatabase error");
     m_db.setDatabaseName(path);
@@ -250,6 +254,7 @@
     return QVariant();
 }
 
+
 /*!
     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
@@ -284,6 +289,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,6 +299,233 @@
 }
 
 /*!
+    The getNextDocRevisionNumber(QString doc_id) 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;
+
+            /* ##KW## 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;
+
+}
+
+/*!
+
+    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();
+        }
+
+    }
+    return QString();
+}
+
+/*!
+ * \brief Database::updateSyncLog
+ * \param uid
+ * \param generation
+ * \param transaction_id
+ *
+ * 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())
+    {
+        qDebug() << query.lastError();
+
+    }
+
+}
+
+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())
+    {
+        qDebug() << query.lastError();
+
+    }
+
+}
+
+/*!
+    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());
+
+        }
+
+    }
+
+    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
@@ -308,12 +543,16 @@
     /* FIXME: Conflicts */
 
     int newRev = increaseVectorClockRev(7/*contents.rev*/);
+    // ##KW## maybe this can be removed as it is replaced by revision_number.
+
+    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);
@@ -323,6 +562,9 @@
         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;
+
+        createNewTransaction(newOrEmptyDocId);
+
     }
     else
     {
@@ -333,12 +575,14 @@
 
         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;
+
+        createNewTransaction(newOrEmptyDocId);
     }
 
     beginResetModel();
@@ -353,6 +597,14 @@
     return newRev;
 }
 
+void Database::resetModel(){
+
+    beginResetModel();
+    endResetModel();
+
+}
+
+
 /*!
     Returns a list of all stored documents by their docId.
  */
@@ -516,6 +768,71 @@
     return list;
 }
 
+/* Handy functions for synchronization. */
+
+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;
+
+}
+
+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;
+        }
+
+    }
+
+    /* Below does not work from the Database class.
+     * This is leftover from the migration of this function
+     * from the Synchronizer class.
+     *
+     * Why is it left here? As a reminder to do something to
+     * resolve the issue of not being able to update Sychnronizer's
+     * m_errors from the Database class.
+     */
+
+    //m_errors.append(m_db.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-07-04 14:13:28 +0000
@@ -36,10 +36,12 @@
 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);
@@ -51,6 +53,18 @@
     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 +77,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 +87,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/index.cpp'
--- src/index.cpp	2013-05-10 13:22:44 +0000
+++ src/index.cpp	2013-07-04 14:13:28 +0000
@@ -146,7 +146,19 @@
     if (m_expression == expression)
         return;
 
-    m_expression = expression;
+<<<<<<< TREE
+    m_expression = expression;
+=======
+    m_expression = expression;
+
+    if (m_database)
+    {
+        m_database->putIndex(m_name, expression);
+        Q_EMIT dataInvalidated();
+    }
+
+
+>>>>>>> MERGE-SOURCE
 
     if (m_database)
     {

=== modified file 'src/query.cpp'
--- src/query.cpp	2013-05-01 23:06:01 +0000
+++ src/query.cpp	2013-07-04 14:13:28 +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,16 @@
 
     }
 
+    resetModel();
+
     Q_EMIT documentsChanged(m_documents);
     Q_EMIT resultsChanged(m_results);
+
+}
+
+void Query::resetModel(){
+    beginResetModel();
+    endResetModel();
 }
 
 /*!

=== modified file 'src/query.h'
--- src/query.h	2013-04-25 13:38:33 +0000
+++ src/query.h	2013-07-04 14:13:28 +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-07-04 14:13:28 +0000
@@ -0,0 +1,879 @@
+/*
+ * 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 methods that are standards in declarative API design. They include the element instantiation, default settings for properties and get/set methods for properties.
+
+*/
+
+/*!
+    Instantiate a new Synchronizer 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.
+
+ */
+
+Synchronizer::Synchronizer(QObject *parent) :
+    QAbstractListModel(parent), m_synchronize(false)
+{
+    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) // errors
+        return m_errors.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_errors.count();
+}
+
+/*!
+    \internal
+    Used to implement QAbstractListModel
+    Defines \b{errors} as the variable exposed to the Delegate in a model
+    \b{index} is supported out of the box.
+ */
+QHash<int, QByteArray>
+Synchronizer::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles.insert(0, "errors");
+    return roles;
+}
+
+
+/*!
+    \property Synchronizer::source
+ */
+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
+ */
+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::errors
+ */
+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);
+}
+
+/*!
+    \property Synchronizer::errors
+ */
+void Synchronizer::setErrors(QList<QString> errors)
+{
+     if (m_errors == errors)
+        return;
+
+    m_errors = errors;
+    Q_EMIT errorsChanged(errors);
+}
+
+/*!
+
+ */
+Database* Synchronizer::getSource()
+{
+     return m_source;
+}
+
+/*!
+
+ */
+QVariant Synchronizer::getTargets()
+{
+     return m_targets;
+}
+
+
+/*!
+
+ */
+bool Synchronizer::getSync()
+{
+     return m_synchronize;
+}
+
+
+/*!
+
+ */
+bool Synchronizer::getResolveToSource(){
+    return m_resolve_to_source;
+}
+
+/*!
+
+ */
+QList<QString> Synchronizer::getErrors(){
+    return m_errors;
+}
+
+
+
+/*
+
+ Below this line represents the unique API methods that are not part of standard declarative API design.
+
+*/
+
+/*!
+  The onSyncChanged(bool synchronize) method is where all the sync
+magic starts to happen.
+
+ */
+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");
+    validator.insert("errors", "QStringList");
+
+    /*!
+     * 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 errorsChanged and syncCompleted are
+emitted after the model has been reset.
+          */
+
+        Q_EMIT errorsChanged(m_errors);
+        Q_EMIT syncCompleted();
+
+        /*!
+         * The sync boolean value is reset to its default value (false)
+         *once all sync activity is complete.
+         */
+
+        setSync(false);
+
+    }
+    else{
+
+    }
+}
+
+
+void Synchronizer::remotePostSyncInfoFinished(QNetworkReply* reply)
+{
+
+    QUrl postUrl = reply->request().url();
+
+    QByteArray data = reply->readAll();
+
+    QString replyData = QString(data);
+
+    qDebug() << replyData;
+
+    reply->close();
+
+}
+
+void Synchronizer::remoteGetSyncInfoFinished(QNetworkReply* reply)
+{
+
+    QUrl postUrl = reply->request().url();
+
+    QByteArray data = reply->readAll();
+
+    QString replyData = QString(data);
+
+    reply->close();
+
+    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_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();
+
+    QNetworkRequest request(postUrl);
+
+    request.setHeader(QNetworkRequest::ContentTypeHeader,"application/x-u1db-sync-stream");
+
+    QNetworkAccessManager *manager = new QNetworkAccessManager(this);
+
+    connect(manager, &QNetworkAccessManager::finished, this, &Synchronizer::remotePostSyncInfoFinished);
+
+    QString postData;
+
+    postData = "[\r\n";
+    postData += "{\"last_known_generation\": 0, \"last_known_trans_id\": \"\"},\r\n";
+
+    QList<QString> transactions = m_source->listTransactionsSince(source_replica_generation);
+
+    Q_FOREACH(QString transaction,transactions){
+        QStringList transactionData = transaction.split("|");
+        postData +=  "{\"id\": \""+transactionData[1]+"\", \"rev\": \""+m_source->getCurrentDocRevisionNumber(transactionData[1])+"\", \"content\": \"{}\", \"generation\": "+transactionData[0]+", \"trans_id\": \""+transactionData[2]+"\"},\r\n";
+    }
+
+
+    postData += "]";
+
+    QNetworkReply *nextReply = manager->post(QNetworkRequest(request),postData.toUtf8());
+
+    qDebug()<<nextReply->errorString() << " " << postData.toUtf8();
+
+
+}
+
+/*!
+ * \brief Synchronizer::getValidTargets confirms that each sync target definition is valid.
+ * \param validator
+ * \param mandatory
+ * \return
+ */
+
+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();
+
+            //qDebug() << i.value().typeName();
+
+            if(validator.contains(i.key())&&validator[i.key()]!=i.value().typeName()){
+                valid = false;
+
+                m_errors.append("<b><font color=\"red\">Database "+index_number+"</font></b>: For Key: `" + i.key() + "` Expecting type `" + validator[i.key()] + "`, but received type `" + i.value().typeName()+"`");
+                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)){
+                        m_errors.append("<b><font color=\"red\">Database "+index_number+"</font></b>: Expected key `" + value + "`, but it is not present.");
+                        target.insert("sync",false);
+                        targets.removeOne(target);
+                        complete = false;
+                        break;
+                    }
+                }
+                if(complete==false){
+                    break;
+                }
+
+            }
+        }
+
+        if(target.contains("sync")&&target["sync"]==false){
+            m_errors.append("<b><font color=\"red\">Error</font></b>: Database Index "+index_number+" was not synced due to errors. Please check its properties and try again later.");
+        }
+        else
+        {
+            target.insert("sync",true);
+            sync_targets.append(target);
+        }
+
+    }
+
+    return sync_targets;
+
+}
+
+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){
+                        m_errors.append("<b><font color=\"green\">Log</font></b>: Valid target index "+QString::number(target_index)+" good for local to local sync with source database.");
+                        syncLocalToLocal(source, target_map);
+                    }
+                }
+                else if(target_map.contains("remote")&&target_map["remote"]==true){
+                    if(target_map.contains("sync")&&target_map["sync"]==true){
+                        m_errors.append("<b><font color=\"red\">Error</font></b>: Remote database sync is under construction. Valid target index "+QString::number(target_index)+" was not synced. Try again later.");
+                        //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;
+
+                        QNetworkAccessManager *manager = new QNetworkAccessManager(this);
+
+
+                        QUrl url(full_get_request);
+                        url.setPort(7777);
+
+
+                        QNetworkRequest request(url);
+
+                        connect(manager, &QNetworkAccessManager::finished,                                this, &Synchronizer::remoteGetSyncInfoFinished);
+
+                        QNetworkReply *reply = manager->get(QNetworkRequest(request));
+
+                        qDebug() << "Reply: " << reply->errorString();
+
+                    }
+                }
+                else{
+                    m_errors.append("<b><font color=\"red\">Undefined Error</font></b>: Valid target index "+QString::number(target_index)+" was not synced. Please check its properties and try again later.");
+                }
+            }
+
+
+        }
+
+    }
+
+}
+
+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;
+
+    /*
+     * ##KW## The two lists below are currently not used for anything
+     * as they were added for functionality that turned out not to be
+     * necessary. They are left here in case they might be convenient
+     * for something else.
+     *
+     * Note: These relate to the function syncDocument's return value.
+     */
+
+    QList<QVariant> source_results;
+    QList<QVariant> target_results;
+
+    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){
+        m_errors.append("<b><font color=\"Red\">Error</font></b>: Either the source or target database does not exist or is not active.");
+        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)
+    {
+
+        m_errors.append("<b><font color=\"green\">Log</font></b>:"+sourceDb->getPath()+" and "+target_db_name+" have previously been synced. Sync procedure will commence.");
+
+        //Do some syncing
+
+        transactionsFromSource = sourceDb->listTransactionsSince(lastSyncInformation["source_replica_generation"].toInt());
+
+        transactionsFromTarget = targetDb->listTransactionsSince(lastSyncInformation["target_replica_generation"].toInt());
+
+
+    }
+    else{
+
+        m_errors.append("<b><font color=\"Orange\">Warning</font></b>:"+sourceDb->getPath()+" and "+target_db_name+" have no details of ever being synced.");
+
+        //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 transactions IDs are searched for in the list of changes
+     * from the other database since the last sync (or from the start
+     * if this is the first sync) to determine whether to update an
+     * existing document, or create a new one, depending on conditions.
+     */
+
+    Q_FOREACH(QString sourceTransaction, transactionIdsFromSource){
+
+        if(transactionIdsFromTarget.contains(sourceTransaction)){
+            if(target["resolve_to_source"].toBool()==true)
+
+                //Update a Document from Source to Target
+
+                if(target.contains("id")){
+                    target_results.append(syncDocument(sourceDb, targetDb, sourceTransaction));
+                }
+        }
+        else{
+
+            //New Document from Source to Target
+
+            if(target.contains("id")){
+                target_results.append(syncDocument(sourceDb, targetDb, sourceTransaction));
+            }
+
+        }
+
+    }
+
+    Q_FOREACH(QString targetTransaction, transactionIdsFromTarget){
+
+        if(transactionIdsFromSource.contains(targetTransaction)){
+            if(target["resolve_to_source"].toBool()==false){
+
+                //Update a Document from Target to Source
+
+                if(target.contains("id")){
+                    source_results.append(syncDocument(targetDb, sourceDb, targetTransaction));
+                }
+            }
+        }
+        else{
+
+            //New Document from Target to Source
+
+            if(target.contains("id")){
+                source_results.append(syncDocument(targetDb, sourceDb, targetTransaction));
+            }
+        }
+    }
+    
+    
+    if(lastSyncInformation["target_replica_transaction_id"].toInt()==-1&&lastSyncInformation["source_replica_transaction_id"].toInt()==-1){
+        //targetDb->updateSyncLog(true, QString uid, QString generation, QString transaction_id);
+        //sourceDb->updateSyncLog(true, QString uid, QString generation, QString transaction_id);
+    }
+    else{
+        //targetDb->updateSyncLog(false, QString uid, QString generation, QString transaction_id);
+        //sourceDb->updateSyncLog(true, QString uid, QString generation, QString transaction_id);
+    }
+    
+
+
+    /* 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.*/
+
+
+}
+
+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;
+}
+
+QMap<QString,QVariant> Synchronizer::getLastSyncInformation(Database *sourceDb, Database *targetDb, bool remote, QMap<QString,QVariant> lastSyncInformation){
+
+    if(remote == true){
+
+        m_errors.append("<b><font color=\"red\">Error</font></b>: Remote database sync is under construction. Nothing was synced. Try again later.");
+
+        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;
+
+}
+
+
+QString Synchronizer::getUidFromLocalDb(QString dbFileName)
+{
+
+    QString dbUid;
+
+    QSqlDatabase db;
+
+    db = QSqlDatabase::addDatabase("QSQLITE",QUuid::createUuid().toString());
+
+    QFile db_file(dbFileName);
+
+    if(!db_file.exists())
+    {
+        m_errors.append("<b><font color\"red\">Error</font></b>: Local database " + dbFileName + " does not exist.");
+        return dbUid;
+    }
+    else
+    {
+        db.setDatabaseName(dbFileName);
+        if (!db.open()){
+            m_errors.append(db.lastError().text());
+        }
+        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;
+}
+
+
+
+
+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-07-04 14:13:28 +0000
@@ -0,0 +1,112 @@
+/*
+ * 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<QString> errors READ getErrors WRITE setErrors NOTIFY errorsChanged)
+
+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<QString> getErrors();
+
+    void setSource(Database* source);
+    void setTargets(QVariant targets);
+    void setSync(bool synchronize);
+    void setResolveToSource(bool resolve_to_source);
+    void setErrors(QList<QString> errors);
+
+
+    void syncWithLocalTarget(Database *source, Database *target, bool resolve_to_source);
+    void syncWithRemoteTarget(Database *source, QString target_url, bool resolve_to_source);
+    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);
+
+
+
+
+Q_SIGNALS:
+    void sourceChanged(Database* source);
+    void targetsChanged(QVariant targets);
+    void syncChanged(bool synchronize);
+    void resolveToSourceChanged(bool resolve_to_source);
+    void errorsChanged(QList<QString> errors);
+    void syncCompleted();
+private:
+    //Q_DISABLE_COPY(Synchronizer)
+    Database* m_source;
+    bool m_synchronize;
+    bool m_resolve_to_source;
+    QVariant m_targets;
+    QList<QString> m_errors;
+
+    void onSyncChanged(bool synchronize);
+    void remoteGetSyncInfoFinished(QNetworkReply* reply);
+    void remotePostSyncInfoFinished(QNetworkReply* reply);
+
+};
+
+QT_END_NAMESPACE_U1DB
+
+
+
+#endif // U1DB_SYNCHRONIZER_H
+
+