void osync_obj_engine_event(OSyncObjEngine *engine, OSyncEngineEvent event, OSyncError *error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %i, %p)", __func__, engine, event, error);
osync_assert(engine);
/* TODO: Create own enum OSyncObjEngine for objengine events. */
osync_assert_msg(event != OSYNC_ENGINE_EVENT_ERROR, "OSyncObjEngine isn't supposed to emit OSYNC_ENGINE_EVENT_ERROR events!");
/* engine event callback gets called with most recent OSyncError or NULL.
Don't use engine->error for the engine event callback. Previous appears errors
in this objengine would get passed to this engine, which will be interpeted by the
engine as error for the current event.
Example:
EVENT_CONNECTED (obj)engine->error: NULL
EVENT_READ **ERROR** (obj)engine->error: 0x....
# OSyncEngine aborts sync and emit disconnect event, we reply with:
EVENT_DISCONNECTED (obj)engine->error: 0x.....
If we would pass in this case enigne->error instead of the most recent
OSyncError, OSyncEngien would interpret this as the disconnect failed as well.
So we just pass the most recent OSyncError pointer, which could be NULL -> no error.
*/
engine->callback(engine, event, error, engine->callback_userdata);
osync_trace(TRACE_EXIT, "%s", __func__);
return;
}
static void mock_sync_done(OSyncObjTypeSink *sink, OSyncPluginInfo *info, OSyncContext *ctx, void *data)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, sink, info, ctx, data);
OSyncSinkStateDB *state_db = osync_objtype_sink_get_state_db(sink);
MockDir *dir = data;
if (mock_get_error(info->memberid, "SYNC_DONE_ERROR")) {
osync_context_report_error(ctx, OSYNC_ERROR_EXPECTED, "Triggering SYNC_DONE_ERROR error");
return;
}
if (mock_get_error(info->memberid, "SYNC_DONE_TIMEOUT"))
return;
if (mock_get_error(info->memberid, "SYNC_DONE_REPORT_UID_UPDATE")) {
unsigned int i, updates = atoi(g_getenv("SYNC_DONE_REPORT_UID_UPDATES"));
const char *olduids = g_getenv("SYNC_DONE_REPORT_UID_UPDATES_OLDUIDS");
const char *newuids = g_getenv("SYNC_DONE_REPORT_UID_UPDATES_NEWUIDS");
for (i=0; i < updates; i++) {
char *olduid = g_strdup_printf("%c", olduids[i]);
char *newuid = g_strdup_printf("%c", newuids[i]);
osync_context_report_uid_update(ctx, olduid, newuid);
}
}
osync_assert_msg(osync_sink_state_set(state_db, "path", dir->path, NULL), "Not expected to fail!");
osync_context_report_success(ctx);
osync_trace(TRACE_EXIT, "%s", __func__);
}
void osync_status_conflict(OSyncEngine *engine, OSyncMappingEngine *mapping_engine)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, engine, mapping_engine);
osync_assert_msg(engine->conflict_callback, "No conflict handler registered! OpenSync frontend very likely broken!");
engine->conflict_callback(engine, mapping_engine, engine->conflict_userdata);
osync_trace(TRACE_EXIT, "%s", __func__);
}
static osync_bool mock_write(OSyncObjTypeSink *sink, OSyncPluginInfo *info, OSyncContext *ctx, OSyncChange *change, void *data)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p, %p)", __func__, sink, info, ctx, change, data);
MockDir *dir = data;
OSyncError *error = NULL;
OSyncData *odata = NULL;
char *buffer = NULL;
unsigned int size = 0;
char *filename = g_strdup_printf ("%s/%s", dir->path, osync_change_get_uid(change));
switch (osync_change_get_changetype(change)) {
case OSYNC_CHANGE_TYPE_DELETED:
osync_assert(remove(filename) == 0);
break;
case OSYNC_CHANGE_TYPE_ADDED:
osync_assert(!g_file_test(filename, G_FILE_TEST_EXISTS));
/* No break. Continue below */
case OSYNC_CHANGE_TYPE_MODIFIED:
//FIXME add ownership for file-sync
odata = osync_change_get_data(change);
g_assert(odata);
osync_data_get_data(odata, &buffer, &size);
g_assert(buffer);
g_assert(size == sizeof(OSyncFileFormat));
OSyncFileFormat *file = (OSyncFileFormat *)buffer;
osync_assert(osync_file_write(filename, file->data, file->size, file->mode, &error));
break;
case OSYNC_CHANGE_TYPE_UNMODIFIED:
osync_assert_msg(FALSE, "Unmodified in a change function?!");
break;
case OSYNC_CHANGE_TYPE_UNKNOWN:
osync_assert_msg(FALSE, "Unknown Change Type");
break;
}
g_free(filename);
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
}
void osync_context_report_change(OSyncContext *context, OSyncChange *change)
{
OSyncData *data;
osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, context, change);
osync_assert(context);
osync_assert(change);
osync_assert_msg(osync_change_get_uid(change), "You forgot to set a uid on the change you reported!");
osync_assert_msg(osync_change_get_data(change) || osync_change_get_changetype(change) == OSYNC_CHANGE_TYPE_DELETED, "You need to report some data unless you report CHANGE_DELETED");
data = osync_change_get_data(change);
osync_assert_msg(((data && osync_data_get_objformat(data) != NULL) || osync_change_get_changetype(change) == OSYNC_CHANGE_TYPE_DELETED), "The reported change did not have a format set");
osync_assert_msg(((data && osync_data_get_objtype(data) != NULL) || osync_change_get_changetype(change) == OSYNC_CHANGE_TYPE_DELETED), "The reported change did not have a objtype set");
osync_trace(TRACE_INTERNAL, "Reporting change with uid %s, changetype %i, data %p", osync_change_get_uid(change), osync_change_get_changetype(change), osync_change_get_data(change));
osync_assert_msg(context->changes_function, "The engine must set a callback to receive changes");
context->changes_function(change, context->callback_data);
osync_trace(TRACE_EXIT, "%s", __func__);
}
static void mock_connect(OSyncObjTypeSink *sink, OSyncPluginInfo *info, OSyncContext *ctx, void *data)
{
osync_bool state_match;
OSyncSinkStateDB *state_db = osync_objtype_sink_get_state_db(sink);
MockDir *dir = data;
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, sink, info, ctx, data);
if (mock_get_error(info->memberid, "CONNECT_ERROR")) {
osync_context_report_error(ctx, OSYNC_ERROR_EXPECTED, "Triggering CONNECT_ERROR error");
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, "Triggering CONNECT_ERROR error");
return;
}
if (mock_get_error(info->memberid, "CONNECT_TIMEOUT")) {
/* Don't report context back ... let it timeout! */
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, "Triggering CONNECT_TIMEOUT error");
return;
}
if (mock_get_error(info->memberid, "CONNECT_SLOWSYNC"))
osync_context_report_slowsync(ctx);
/* Skip Objtype related stuff like hashtable and state db */
if (mock_get_error(info->memberid, "MAINSINK_CONNECT"))
goto end;
/* From this line MockDir *dir is required, for ObjTypeSink specific stuff: #821 */
osync_assert(dir);
dir->committed_all = TRUE;
/* Sanity check for connect_done - reset it to FALSE.
* To make sure it get reseted to TRUE before get_changes().
*/
dir->connect_done = FALSE;
osync_assert_msg(osync_sink_state_equal(state_db, "path", dir->path, &state_match, NULL), "Not expected to fail");
if (!state_match)
osync_context_report_slowsync(ctx);
osync_assert(g_file_test(dir->path, G_FILE_TEST_IS_DIR));
end:
osync_context_report_success(ctx);
osync_trace(TRACE_EXIT, "%s", __func__);
return;
}
/* Here we actually tell opensync which sinks are available. For this plugin, we
* go through the list of directories and enable all, since all have been configured */
static osync_bool mock_discover(OSyncPluginInfo *info, void *data, OSyncError **error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, error);
OSyncPluginConfig *config = osync_plugin_info_get_config(info);
osync_assert_msg(config, "No OSyncPluginConfig set for mock_discover!");
/*
OSyncFormatEnv *formatenv = osync_plugin_info_get_format_env(info);
osync_assert_msg(config, "No OSyncFormatEnv set for mock_discover!");
*/
OSyncList *r = osync_plugin_config_get_resources(config);
for (; r; r = r->next) {
OSyncPluginResource *res = r->data;
OSyncObjTypeSink *sink;
const char *objtype = osync_plugin_resource_get_objtype(res);
/* Check for ObjType sink */
if ((sink = osync_plugin_info_find_objtype(info, objtype)))
osync_objtype_sink_set_available(sink, TRUE);
}
OSyncVersion *version = osync_version_new(error);
osync_version_set_plugin(version, "mock-sync");
//osync_version_set_vendor(version, "version");
//osync_version_set_modelversion(version, "version");
//osync_version_set_firmwareversion(version, "firmwareversion");
//osync_version_set_softwareversion(version, "softwareversion");
//osync_version_set_hardwareversion(version, "hardwareversion");
osync_plugin_info_set_version(info, version);
osync_version_unref(version);
/* we can set here the capabilities, but for the file-sync
* plugin they are static and shipped with opensync */
if (mock_get_error(info->memberid, "MOCK_DISCOVER_ERROR")) {
osync_error_set(error, OSYNC_ERROR_EXPECTED, "MOCK_DISCOVER_ERROR on purpose!");
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return FALSE;
}
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
}
