Ticket #492: customized_entry.diff

opensync/group/opensync_group.h

@@ -35 +35 @@
-        OSYNC_CONFLICT_RESOLUTION_DUPLICATE,
-        OSYNC_CONFLICT_RESOLUTION_IGNORE,
-        OSYNC_CONFLICT_RESOLUTION_NEWER,
-
+
+
-} OSyncConflictResolution;
-
-OSYNC_EXPORT OSyncGroup *osync_group_new(OSyncError **error);

opensync/engine/opensync_obj_engine.h

@@ -53 +53 @@
-osync_bool osync_mapping_engine_solve(OSyncMappingEngine *engine, OSyncChange *change, OSyncError **error);
-osync_bool osync_mapping_engine_ignore(OSyncMappingEngine *engine, OSyncError **error);
-osync_bool osync_mapping_engine_use_latest(OSyncMappingEngine *engine, OSyncError **error);
+osync_bool osync_mapping_engine_customized(OSyncMappingEngine *engine, OSyncChange *customized_change, OSyncError **error);
-osync_bool osync_mapping_engine_duplicate(OSyncMappingEngine *existingMapping, OSyncError **error);
-
-#endif /*OPENSYNC_OBJ_ENGINE_H_*/

opensync/engine/opensync_engine.c

@@ -389 +389 @@
-        return TRUE;
-}
-
+osync_bool osync_engine_mapping_customized(OSyncEngine *engine, OSyncMappingEngine *mapping_engine, OSyncData *data, OSyncError **error)
+{
+        osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, mapping_engine, error);
+        
+        OSyncEngineCommand *cmd = osync_try_malloc0(sizeof(OSyncEngineCommand), error);
+        if (!cmd) {
+                osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
+                return FALSE;
+        }
+
+        OSyncChange *customized_change = osync_change_new(error);
+        if (!customized_change) {
+                osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
+                return FALSE;
+        }
+
+        osync_change_set_data(customized_change, data);
+        
+        cmd->cmd = OSYNC_ENGINE_COMMAND_SOLVE;
+        cmd->mapping_engine = mapping_engine;
+        /* We recycle the master struct member which prefectly fits our needs as OSyncChange. */
+        cmd->master = customized_change;
+        cmd->solve_type = OSYNC_ENGINE_SOLVE_CUSTOM;
+        
+        g_async_queue_push(engine->command_queue, cmd);
+        
+        osync_trace(TRACE_EXIT, "%s", __func__);
+        return TRUE;
+}
+
-/*! @brief This will create a new engine for the given group
- * 
- * This will create a new engine for the given group
@@ -1214 +1244 @@
-                                        if (!osync_mapping_engine_use_latest(command->mapping_engine, &engine->error))
-                                                goto error;
-                                        break;
+                                case OSYNC_ENGINE_SOLVE_CUSTOM:
+                                        if (!osync_mapping_engine_customized(command->mapping_engine, command->master, &engine->error))
+                                                goto error;
+                                        break;
-                        }
-                        break;
-                case OSYNC_ENGINE_COMMAND_DISCOVER:

opensync/engine/opensync_engine_internals.h

@@ -25 +25 @@
-        OSYNC_ENGINE_SOLVE_DUPLICATE,
-        OSYNC_ENGINE_SOLVE_CHOOSE,
-        OSYNC_ENGINE_SOLVE_IGNORE,
-
+
+
-} OSyncEngineSolveType;
-
-typedef struct OSyncEngineCommand {

opensync/engine/opensync_engine.h

@@ -187 +187 @@
-osync_bool osync_engine_mapping_duplicate(OSyncEngine *engine, OSyncMappingEngine *mapping_engine, OSyncError **error);
-osync_bool osync_engine_mapping_ignore_conflict(OSyncEngine *engine, OSyncMappingEngine *mapping_engine, OSyncError **error);
-osync_bool osync_engine_mapping_use_latest(OSyncEngine *engine, OSyncMappingEngine *mapping_engine, OSyncError **error);
+osync_bool osync_engine_mapping_customized(OSyncEngine *engine, OSyncMappingEngine *mapping_engine, OSyncData *data, OSyncError **error);
-
-#endif /*OPENSYNC_ENGINE_H_*/

opensync/engine/opensync_obj_engine.c

@@ -768 +768 @@
-        return FALSE;
-}
-
+osync_bool osync_mapping_engine_customized(OSyncMappingEngine *engine, OSyncChange *customized_change, OSyncError **error)
+{
+        osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, engine, error);
+        
+        GList *e = engine->entries;
+        for (; e; e = e->next) {
+                OSyncMappingEntryEngine *existingEntry = e->data;
+                OSyncChange *existingChange = osync_entry_engine_get_change(existingEntry);
+                OSyncData *customized_data = osync_change_get_data(customized_change);
+
+                OSyncData *cloned_data = osync_data_clone(customized_data, error);
+                if (!cloned_data)
+                        goto error;
+
+                osync_change_set_data(existingChange, cloned_data);
+
+                osync_entry_engine_set_dirty(existingEntry, TRUE);
+
+                /* Set the last entry as the master */
+                osync_mapping_engine_set_master(engine, existingEntry);
+
+        }
+        
+        engine->conflict = FALSE;
+        osync_status_update_mapping(engine->parent->parent, engine, OSYNC_MAPPING_EVENT_SOLVED, NULL);
+        engine->parent->conflicts = g_list_remove(engine->parent->conflicts, engine);
+        
+        if (osync_engine_check_get_changes(engine->parent->parent) && BitCount(engine->parent->sink_errors | engine->parent->sink_get_changes) == g_list_length(engine->parent->sink_engines)) {
+                OSyncError *error = NULL;
+                if (!osync_obj_engine_command(engine->parent, OSYNC_ENGINE_COMMAND_WRITE, &error))
+                        goto error;
+        } else
+                osync_trace(TRACE_INTERNAL, "Not triggering write. didnt receive all reads yet");
+        
+        osync_trace(TRACE_EXIT, "%s", __func__);
+        return TRUE;
+
+error:
+        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
+        return FALSE;
+}
+
-static OSyncMappingEngine *_create_mapping_engine(OSyncObjEngine *engine, OSyncError **error)
-{
-        /* If there is none, create one */