Menu
▾
▴
[Opensync-commits] r5407 - in trunk: . opensync opensync/engine tests wrapper
|
From: <svn...@op...> - 2009-03-28 21:42:21
|
Author: dgollub Date: Sat Mar 28 22:42:14 2009 New Revision: 5407 URL: http://www.opensync.org/changeset/5407 Log: Cleaned up engine interface namespaces. And unexported Update struct and repalced them with an anonymous typdef struct. Renamed enum namespaces: OSYNC_MAPPING_EVENT_ to OSYNC_ENGINE_MAPPING_EVENT_ OSYNC_CLIENT_EVENT_ to OSYNC_ENGINE_MEMBER_EVENT_ OSYNC_CHANGE_EVENT_ to OSYNC_ENGINE_CHANGE_EVENT_ OSYNC_MAPPING_EVENT_ to OSYNC_ENGINE_MAPPING_EVENT_ Renamed structs and unexported to anonymouse typedefs: OSyncChangeUpdate to OSyncEngineChangeUpdate OSyncMemberUpdate to OSyncEngineMemberUpdate OSyncMappingUpdate to OSyncEngineMappingUpdate Added following interface to get data from the Update structs inside the Update-callbacks: OSyncError *osync_engine_change_update_get_error(OSyncEngineChangeUpdate *update); OSyncEngineChangeEvent osync_engine_change_update_get_event(OSyncEngineChangeUpdate *update); OSyncMember *osync_engine_change_update_get_member(OSyncEngineChangeUpdate *update); OSyncChange *osync_engine_change_update_get_change(OSyncEngineChangeUpdate *update); OSyncError *osync_engine_member_update_get_error(OSyncEngineMemberUpdate *update); OSyncEngineMemberEvent osync_engine_member_update_get_event(OSyncEngineMemberUpdate *update); OSyncMember *osync_engine_member_update_get_member(OSyncEngineMemberUpdate *update); const char *osync_engine_member_update_get_objtype(OSyncEngineMemberUpdate *update); OSyncError *osync_engine_mapping_update_get_error(OSyncEngineMappingUpdate *update); OSyncEngineMappingEvent osync_engine_mapping_update_get_event(OSyncEngineMappingUpdate *update); OSyncError *osync_engine_update_get_error(OSyncEngineUpdate *update); OSyncEngineEvent osync_engine_update_get_event(OSyncEngineUpdate *update); Modified: trunk/opensync.sym trunk/opensync/engine/opensync_engine.c trunk/opensync/engine/opensync_engine.h trunk/opensync/engine/opensync_engine_private.h trunk/opensync/engine/opensync_mapping_engine.c trunk/opensync/engine/opensync_obj_engine.c trunk/opensync/engine/opensync_status.c trunk/opensync/engine/opensync_status_internals.h trunk/opensync/opensync.h trunk/tests/support.c trunk/tests/support.h trunk/wrapper/opensync-engine.i Modified: trunk/opensync.sym ============================================================================== --- trunk/opensync.sym Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync.sym Sat Mar 28 22:42:14 2009 (r5407) @@ -86,6 +86,10 @@ osync_data_set_objtype osync_data_unref osync_engine_abort +osync_engine_change_update_get_change +osync_engine_change_update_get_error +osync_engine_change_update_get_event +osync_engine_change_update_get_member osync_engine_continue osync_engine_discover osync_engine_discover_and_block @@ -95,7 +99,13 @@ osync_engine_mapping_duplicate osync_engine_mapping_ignore_conflict osync_engine_mapping_solve +osync_engine_mapping_update_get_error +osync_engine_mapping_update_get_event osync_engine_mapping_use_latest +osync_engine_member_update_get_error +osync_engine_member_update_get_event +osync_engine_member_update_get_member +osync_engine_member_update_get_objtype osync_engine_new osync_engine_nth_objengine osync_engine_num_objengines @@ -110,6 +120,8 @@ osync_engine_synchronize osync_engine_synchronize_and_block osync_engine_unref +osync_engine_update_get_error +osync_engine_update_get_event osync_engine_wait_sync_end osync_entry_engine_get_changetype osync_entry_engine_is_dirty Modified: trunk/opensync/engine/opensync_engine.c ============================================================================== --- trunk/opensync/engine/opensync_engine.c Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/engine/opensync_engine.c Sat Mar 28 22:42:14 2009 (r5407) @@ -337,7 +337,7 @@ osync_free(member_objtype); osync_engine_set_error(engine, error); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&error)); } @@ -1264,10 +1264,10 @@ if (error) { osync_engine_set_error(engine, error); engine->proxy_errors = engine->proxy_errors | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); } else { engine->proxy_connects = engine->proxy_connects | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_CONNECTED, NULL, NULL); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_CONNECTED, NULL, NULL); } /* If MainSink request a SlowSync, flag all objengines with SlowSync */ @@ -1294,10 +1294,10 @@ if (error) { osync_engine_set_error(engine, error); engine->proxy_errors = engine->proxy_errors | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); } else { engine->proxy_connect_done = engine->proxy_connect_done | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_CONNECT_DONE, NULL, NULL); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_CONNECT_DONE, NULL, NULL); } _osync_engine_generate_connect_done_event(engine); @@ -1316,10 +1316,10 @@ if (error) { osync_engine_set_error(engine, error); engine->proxy_errors = engine->proxy_errors | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); } else { engine->proxy_disconnects = engine->proxy_disconnects | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_DISCONNECTED, NULL, NULL); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_DISCONNECTED, NULL, NULL); } _osync_engine_generate_disconnected_event(engine); @@ -1338,10 +1338,10 @@ if (error) { osync_engine_set_error(engine, error); engine->proxy_errors = engine->proxy_errors | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); } else { engine->proxy_get_changes = engine->proxy_get_changes | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_READ, NULL, NULL); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_READ, NULL, NULL); } _osync_engine_generate_get_changes_event(engine); @@ -1360,10 +1360,10 @@ if (error) { osync_engine_set_error(engine, error); engine->proxy_errors = engine->proxy_errors | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); } else { engine->proxy_written = engine->proxy_written | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_WRITTEN, NULL, NULL); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_WRITTEN, NULL, NULL); } _osync_engine_generate_written_event(engine); @@ -1382,10 +1382,10 @@ if (error) { osync_engine_set_error(engine, error); engine->proxy_errors = engine->proxy_errors | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); } else { engine->proxy_sync_done = engine->proxy_sync_done | (0x1 << position); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_SYNC_DONE, NULL, NULL); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_SYNC_DONE, NULL, NULL); } _osync_engine_generate_sync_done_event(engine); @@ -1516,9 +1516,9 @@ if (error) { osync_engine_set_error(engine, error); - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, NULL, error); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); } else { - osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_DISCOVERED, NULL, NULL); + osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_DISCOVERED, NULL, NULL); } g_mutex_lock(engine->syncing_mutex); @@ -2337,24 +2337,94 @@ engine->changestat_userdata = user_data; } +OSyncError *osync_engine_change_update_get_error(OSyncEngineChangeUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->error; +} + +OSyncEngineChangeEvent osync_engine_change_update_get_event(OSyncEngineChangeUpdate *update) +{ + osync_return_val_if_fail(update, 0); + return update->type; +} + +OSyncMember *osync_engine_change_update_get_member(OSyncEngineChangeUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->member; +} + +OSyncChange *osync_engine_change_update_get_change(OSyncEngineChangeUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->change; +} + void osync_engine_set_mappingstatus_callback(OSyncEngine *engine, osync_status_mapping_cb callback, void *user_data) { engine->mapstat_callback = callback; engine->mapstat_userdata = user_data; } +OSyncError *osync_engine_mapping_update_get_error(OSyncEngineMappingUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->error; +} + +OSyncEngineMappingEvent osync_engine_mapping_update_get_event(OSyncEngineMappingUpdate *update) +{ + osync_return_val_if_fail(update, 0); + return update->type; +} + void osync_engine_set_enginestatus_callback(OSyncEngine *engine, osync_status_engine_cb callback, void *user_data) { engine->engstat_callback = callback; engine->engstat_userdata = user_data; } +OSyncError *osync_engine_update_get_error(OSyncEngineUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->error; +} + +OSyncEngineEvent osync_engine_update_get_event(OSyncEngineUpdate *update) +{ + osync_return_val_if_fail(update, 0); + return update->type; +} + void osync_engine_set_memberstatus_callback(OSyncEngine *engine, osync_status_member_cb callback, void *user_data) { engine->mebstat_callback = callback; engine->mebstat_userdata = user_data; } +OSyncError *osync_engine_member_update_get_error(OSyncEngineMemberUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->error; +} + +OSyncEngineMemberEvent osync_engine_member_update_get_event(OSyncEngineMemberUpdate *update) +{ + osync_return_val_if_fail(update, 0); + return update->type; +} +OSyncMember *osync_engine_member_update_get_member(OSyncEngineMemberUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->member; +} +const char *osync_engine_member_update_get_objtype(OSyncEngineMemberUpdate *update) +{ + osync_return_val_if_fail(update, NULL); + return update->objtype; +} + osync_bool osync_engine_abort(OSyncEngine *engine, OSyncError **error) { OSyncError *locerror = NULL; @@ -2546,7 +2616,7 @@ case OSYNC_ENGINE_EVENT_PREPARED_MAP: eventstr = "PREPARE_MAP"; break; - } + } return eventstr; } Modified: trunk/opensync/engine/opensync_engine.h ============================================================================== --- trunk/opensync/engine/opensync_engine.h Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/engine/opensync_engine.h Sat Mar 28 22:42:14 2009 (r5407) @@ -142,81 +142,26 @@ } OSyncEngineEvent; typedef enum { - OSYNC_CLIENT_EVENT_CONNECTED = 1, - OSYNC_CLIENT_EVENT_CONNECT_DONE, - OSYNC_CLIENT_EVENT_ERROR, - OSYNC_CLIENT_EVENT_READ, - OSYNC_CLIENT_EVENT_WRITTEN, - OSYNC_CLIENT_EVENT_SYNC_DONE, - OSYNC_CLIENT_EVENT_DISCONNECTED, - OSYNC_CLIENT_EVENT_DISCOVERED -} OSyncMemberEvent; + OSYNC_ENGINE_MEMBER_EVENT_CONNECTED = 1, + OSYNC_ENGINE_MEMBER_EVENT_CONNECT_DONE, + OSYNC_ENGINE_MEMBER_EVENT_ERROR, + OSYNC_ENGINE_MEMBER_EVENT_READ, + OSYNC_ENGINE_MEMBER_EVENT_WRITTEN, + OSYNC_ENGINE_MEMBER_EVENT_SYNC_DONE, + OSYNC_ENGINE_MEMBER_EVENT_DISCONNECTED, + OSYNC_ENGINE_MEMBER_EVENT_DISCOVERED +} OSyncEngineMemberEvent; typedef enum { - OSYNC_CHANGE_EVENT_READ = 1, - OSYNC_CHANGE_EVENT_WRITTEN = 2, - OSYNC_CHANGE_EVENT_ERROR = 3 -} OSyncChangeEvent; + OSYNC_ENGINE_CHANGE_EVENT_READ = 1, + OSYNC_ENGINE_CHANGE_EVENT_WRITTEN, + OSYNC_ENGINE_CHANGE_EVENT_ERROR +} OSyncEngineChangeEvent; typedef enum { - OSYNC_MAPPING_EVENT_SOLVED = 1, - //OSYNC_MAPPING_EVENT_WRITTEN = 2, - OSYNC_MAPPING_EVENT_ERROR = 3 -} OSyncMappingEvent; - - -/** - * @brief Struct for the member status callback - */ -typedef struct OSyncMemberUpdate { - /** The type of the status update */ - OSyncMemberEvent type; - char *objtype; - /** The member for which the status update is */ - OSyncMember *member; - /** If the status was a error, this error will be set */ - OSyncError *error; -} OSyncMemberUpdate; - -/** - * @brief Struct for the change status callback - */ -typedef struct OSyncChangeUpdate { - /** The type of the status update */ - OSyncChangeEvent type; - /** The change for which the status update is */ - OSyncChange *change; - /** The id of the member which sent this change */ - OSyncMember *member; - /** The id of the mapping to which this change belongs if any */ - int mapping_id; - /** If the status was a error, this error will be set */ - OSyncError *error; -} OSyncChangeUpdate; - -/** - * @brief Struct for the mapping status callback - */ -typedef struct OSyncMappingUpdate { - /** The type of the status update */ - OSyncMappingEvent type; - /** If the mapping was already solved, this will have the id if the winning entry */ - long long int winner; - /** The mapping for which the status update is */ - OSyncMapping *mapping; - /** If the status was a error, this error will be set */ - OSyncError *error; -} OSyncMappingUpdate; - -/** - * @brief Struct for the engine status callback - */ -typedef struct OSyncEngineUpdate { - /** The type of the status update */ - OSyncEngineEvent type; - /** If the status was a error, this error will be set */ - OSyncError *error; -} OSyncEngineUpdate; + OSYNC_ENGINE_MAPPING_EVENT_SOLVED = 1, + OSYNC_ENGINE_MAPPING_EVENT_ERROR +} OSyncEngineMappingEvent; /** @brief This will create a new engine for the given group * @@ -342,11 +287,27 @@ OSYNC_EXPORT osync_bool osync_engine_continue(OSyncEngine *engine, OSyncError **error); typedef void (* osync_conflict_cb) (OSyncEngine *, OSyncMappingEngine *, void *); -typedef void (* osync_status_change_cb) (OSyncChangeUpdate *, void *); -typedef void (* osync_status_mapping_cb) (OSyncMappingUpdate *, void *); typedef void (* osync_multiply_cb) (OSyncEngine *, void *); -typedef void (* osync_status_member_cb) (OSyncMemberUpdate *, void *); + +typedef void (* osync_status_change_cb) (OSyncEngineChangeUpdate *, void *); +OSYNC_EXPORT OSyncError *osync_engine_change_update_get_error(OSyncEngineChangeUpdate *update); +OSYNC_EXPORT OSyncEngineChangeEvent osync_engine_change_update_get_event(OSyncEngineChangeUpdate *update); +OSYNC_EXPORT OSyncMember *osync_engine_change_update_get_member(OSyncEngineChangeUpdate *update); +OSYNC_EXPORT OSyncChange *osync_engine_change_update_get_change(OSyncEngineChangeUpdate *update); + +typedef void (* osync_status_member_cb) (OSyncEngineMemberUpdate *, void *); +OSYNC_EXPORT OSyncError *osync_engine_member_update_get_error(OSyncEngineMemberUpdate *update); +OSYNC_EXPORT OSyncEngineMemberEvent osync_engine_member_update_get_event(OSyncEngineMemberUpdate *update); +OSYNC_EXPORT OSyncMember *osync_engine_member_update_get_member(OSyncEngineMemberUpdate *update); +OSYNC_EXPORT const char *osync_engine_member_update_get_objtype(OSyncEngineMemberUpdate *update); + +typedef void (* osync_status_mapping_cb) (OSyncEngineMappingUpdate *, void *); +OSYNC_EXPORT OSyncError *osync_engine_mapping_update_get_error(OSyncEngineMappingUpdate *update); +OSYNC_EXPORT OSyncEngineMappingEvent osync_engine_mapping_update_get_event(OSyncEngineMappingUpdate *update); + typedef void (* osync_status_engine_cb) (OSyncEngineUpdate *, void *); +OSYNC_EXPORT OSyncError *osync_engine_update_get_error(OSyncEngineUpdate *update); +OSYNC_EXPORT OSyncEngineEvent osync_engine_update_get_event(OSyncEngineUpdate *update); /** @brief This will set the conflict handler for the given engine * Modified: trunk/opensync/engine/opensync_engine_private.h ============================================================================== --- trunk/opensync/engine/opensync_engine_private.h Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/engine/opensync_engine_private.h Sat Mar 28 22:42:14 2009 (r5407) @@ -141,6 +141,59 @@ }; /** + * @brief Struct for the member status callback + */ +struct OSyncEngineMemberUpdate { + /** The type of the status update */ + OSyncEngineMemberEvent type; + char *objtype; + /** The member for which the status update is */ + OSyncMember *member; + /** If the status was a error, this error will be set */ + OSyncError *error; +}; + +/** + * @brief Struct for the change status callback + */ +struct OSyncEngineChangeUpdate { + /** The type of the status update */ + OSyncEngineChangeEvent type; + /** The change for which the status update is */ + OSyncChange *change; + /** The id of the member which sent this change */ + OSyncMember *member; + /** The id of the mapping to which this change belongs if any */ + int mapping_id; + /** If the status was a error, this error will be set */ + OSyncError *error; +} ; + +/** + * @brief Struct for the mapping status callback + */ +struct OSyncEngineMappingUpdate { + /** The type of the status update */ + OSyncEngineMappingEvent type; + /** If the mapping was already solved, this will have the id if the winning entry */ + long long int winner; + /** The mapping for which the status update is */ + OSyncMapping *mapping; + /** If the status was a error, this error will be set */ + OSyncError *error; +}; + +/** + * @brief Struct for the engine status callback + */ +struct OSyncEngineUpdate { + /** The type of the status update */ + OSyncEngineEvent type; + /** If the status was a error, this error will be set */ + OSyncError *error; +}; + +/** * @brief Set error for OSyncEngine. * * Stack error message. If an error is already set, the error get stacked. Modified: trunk/opensync/engine/opensync_mapping_engine.c ============================================================================== --- trunk/opensync/engine/opensync_mapping_engine.c Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/engine/opensync_mapping_engine.c Sat Mar 28 22:42:14 2009 (r5407) @@ -493,7 +493,7 @@ return TRUE; } osync_assert(engine->master); - osync_status_update_mapping(engine->parent->parent, engine, OSYNC_MAPPING_EVENT_SOLVED, NULL); + osync_status_update_mapping(engine->parent->parent, engine, OSYNC_ENGINE_MAPPING_EVENT_SOLVED, NULL); if (is_same == prod(osync_list_length(engine->entries) - 1)) { OSyncList *e = NULL; @@ -583,7 +583,7 @@ entry = _osync_mapping_engine_find_entry(engine, change); engine->conflict = FALSE; osync_mapping_engine_set_master(engine, entry); - osync_status_update_mapping(engine->parent->parent, engine, OSYNC_MAPPING_EVENT_SOLVED, NULL); + osync_status_update_mapping(engine->parent->parent, engine, OSYNC_ENGINE_MAPPING_EVENT_SOLVED, NULL); engine->parent->conflicts = osync_list_remove(engine->parent->conflicts, engine); if (!osync_obj_engine_command(engine->parent, OSYNC_ENGINE_COMMAND_END_CONFLICTS, error)) @@ -619,7 +619,7 @@ osync_archive_save_ignored_conflict(archive, objtype, id, osync_change_get_changetype(entry->change), error); } - osync_status_update_mapping(engine->parent->parent, engine, OSYNC_MAPPING_EVENT_SOLVED, NULL); + osync_status_update_mapping(engine->parent->parent, engine, OSYNC_ENGINE_MAPPING_EVENT_SOLVED, NULL); engine->parent->conflicts = osync_list_remove(engine->parent->conflicts, engine); if (!osync_obj_engine_command(engine->parent, OSYNC_ENGINE_COMMAND_END_CONFLICTS, error)) @@ -646,7 +646,7 @@ osync_mapping_engine_set_master(engine, latest_entry); engine->conflict = FALSE; - osync_status_update_mapping(engine->parent->parent, engine, OSYNC_MAPPING_EVENT_SOLVED, NULL); + osync_status_update_mapping(engine->parent->parent, engine, OSYNC_ENGINE_MAPPING_EVENT_SOLVED, NULL); engine->parent->conflicts = osync_list_remove(engine->parent->conflicts, engine); if (!osync_obj_engine_command(engine->parent, OSYNC_ENGINE_COMMAND_END_CONFLICTS, error)) @@ -785,7 +785,7 @@ } objengine->conflicts = osync_list_remove(objengine->conflicts, existingMapping); - osync_status_update_mapping(objengine->parent, existingMapping, OSYNC_MAPPING_EVENT_SOLVED, NULL); + osync_status_update_mapping(objengine->parent, existingMapping, OSYNC_ENGINE_MAPPING_EVENT_SOLVED, NULL); if (!osync_obj_engine_command(objengine, OSYNC_ENGINE_COMMAND_END_CONFLICTS, error)) goto error; Modified: trunk/opensync/engine/opensync_obj_engine.c ============================================================================== --- trunk/opensync/engine/opensync_obj_engine.c Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/engine/opensync_obj_engine.c Sat Mar 28 22:42:14 2009 (r5407) @@ -95,10 +95,10 @@ osync_trace(TRACE_INTERNAL, "Obj Engine received connect error: %s", osync_error_print(&error)); osync_obj_engine_set_error(engine, error); engine->sink_errors = engine->sink_errors | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, engine->objtype, error); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, engine->objtype, error); } else { engine->sink_connects = engine->sink_connects | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_CONNECTED, engine->objtype, NULL); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_CONNECTED, engine->objtype, NULL); } if (slowsync) { @@ -131,10 +131,10 @@ if (error) { osync_obj_engine_set_error(engine, error); engine->sink_errors = engine->sink_errors | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, engine->objtype, error); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, engine->objtype, error); } else { engine->sink_connect_done = engine->sink_connect_done | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_CONNECT_DONE, engine->objtype, NULL); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_CONNECT_DONE, engine->objtype, NULL); } if (osync_bitcount(engine->sink_errors | engine->sink_connect_done) == osync_obj_engine_num_sinkengines(engine)) { @@ -183,10 +183,10 @@ if (error) { osync_obj_engine_set_error(engine, error); engine->sink_errors = engine->sink_errors | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, engine->objtype, error); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, engine->objtype, error); } else { engine->sink_disconnects = engine->sink_disconnects | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_DISCONNECTED, engine->objtype, NULL); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_DISCONNECTED, engine->objtype, NULL); } _osync_obj_engine_generate_event_disconnected(engine, error); @@ -368,10 +368,10 @@ if (error) { osync_obj_engine_set_error(engine, error); engine->sink_errors = engine->sink_errors | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, engine->objtype, error); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, engine->objtype, error); } else { engine->sink_get_changes = engine->sink_get_changes | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_READ, engine->objtype, NULL); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_READ, engine->objtype, NULL); } if (osync_bitcount(engine->sink_errors | engine->sink_get_changes) == osync_obj_engine_num_sinkengines(engine)) { @@ -414,14 +414,14 @@ if (osync_entry_engine_matches(mapping_engine, change)) { osync_entry_engine_update(mapping_engine, change); - osync_status_update_change(sinkengine->engine->parent, change, osync_client_proxy_get_member(proxy), mapping_engine->mapping_engine->mapping, OSYNC_CHANGE_EVENT_READ, NULL); + osync_status_update_change(sinkengine->engine->parent, change, osync_client_proxy_get_member(proxy), mapping_engine->mapping_engine->mapping, OSYNC_ENGINE_CHANGE_EVENT_READ, NULL); osync_trace(TRACE_EXIT, "%s: Updated", __func__); return TRUE; } } - osync_status_update_change(sinkengine->engine->parent, change, osync_client_proxy_get_member(proxy), NULL, OSYNC_CHANGE_EVENT_READ, NULL); + osync_status_update_change(sinkengine->engine->parent, change, osync_client_proxy_get_member(proxy), NULL, OSYNC_ENGINE_CHANGE_EVENT_READ, NULL); /* If we couldnt find a match entry, we will append it the unmapped changes * and take care of it later */ @@ -530,8 +530,8 @@ /* Error handling (tests: single_commit_error, ...) */ /* TODO: Review differences between Mapping and Change status events - Are both really needed?! */ - osync_status_update_change(engine->parent, entry_engine->change, osync_client_proxy_get_member(proxy), entry_engine->mapping_engine->mapping, OSYNC_CHANGE_EVENT_ERROR, error); - osync_status_update_mapping(engine->parent, entry_engine->mapping_engine, OSYNC_MAPPING_EVENT_ERROR, error); + osync_status_update_change(engine->parent, entry_engine->change, osync_client_proxy_get_member(proxy), entry_engine->mapping_engine->mapping, OSYNC_ENGINE_CHANGE_EVENT_ERROR, error); + osync_status_update_mapping(engine->parent, entry_engine->mapping_engine, OSYNC_ENGINE_MAPPING_EVENT_ERROR, error); osync_obj_engine_set_error(engine, error); engine->sink_errors = engine->sink_errors | (0x1 << sinkengine->position); @@ -553,7 +553,7 @@ } osync_assert(entry_engine->mapping_engine); - osync_status_update_change(engine->parent, entry_engine->change, osync_client_proxy_get_member(proxy), entry_engine->mapping_engine->mapping, OSYNC_CHANGE_EVENT_WRITTEN, NULL); + osync_status_update_change(engine->parent, entry_engine->change, osync_client_proxy_get_member(proxy), entry_engine->mapping_engine->mapping, OSYNC_ENGINE_CHANGE_EVENT_WRITTEN, NULL); osync_entry_engine_update(entry_engine, NULL); osync_trace(TRACE_EXIT, "%s", __func__); @@ -574,10 +574,10 @@ if (error) { osync_obj_engine_set_error(engine, error); engine->sink_errors = engine->sink_errors | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, engine->objtype, error); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, engine->objtype, error); } else { engine->sink_written = engine->sink_written | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_WRITTEN, engine->objtype, NULL); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_WRITTEN, engine->objtype, NULL); } _osync_obj_engine_generate_written_event(engine, error); @@ -596,10 +596,10 @@ if (error) { osync_obj_engine_set_error(engine, error); engine->sink_errors = engine->sink_errors | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_ERROR, engine->objtype, error); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, engine->objtype, error); } else { engine->sink_sync_done = engine->sink_sync_done | (0x1 << sinkengine->position); - osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_CLIENT_EVENT_SYNC_DONE, engine->objtype, NULL); + osync_status_update_member(engine->parent, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_SYNC_DONE, engine->objtype, NULL); } if (osync_bitcount(engine->sink_errors | engine->sink_sync_done) == osync_obj_engine_num_sinkengines(engine)) { Modified: trunk/opensync/engine/opensync_status.c ============================================================================== --- trunk/opensync/engine/opensync_status.c Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/engine/opensync_status.c Sat Mar 28 22:42:14 2009 (r5407) @@ -32,7 +32,7 @@ #include "opensync_mapping_engine_internals.h" -void osync_status_free_member_update(OSyncMemberUpdate *update) +void osync_status_free_member_update(OSyncEngineMemberUpdate *update) { osync_assert(update); @@ -57,7 +57,7 @@ osync_free(update); } -void osync_status_free_change_update(OSyncChangeUpdate *update) +void osync_status_free_change_update(OSyncEngineChangeUpdate *update) { osync_assert(update); @@ -72,7 +72,7 @@ osync_free(update); } -void osync_status_free_mapping_update(OSyncMappingUpdate *update) +void osync_status_free_mapping_update(OSyncEngineMappingUpdate *update) { osync_assert(update); @@ -116,13 +116,13 @@ osync_trace(TRACE_EXIT, "%s", __func__); } -void osync_status_update_member(OSyncEngine *engine, OSyncMember *member, OSyncMemberEvent type, const char *objtype, OSyncError *error) +void osync_status_update_member(OSyncEngine *engine, OSyncMember *member, OSyncEngineMemberEvent type, const char *objtype, OSyncError *error) { osync_trace(TRACE_ENTRY, "%s(%p, %p, %i, %s, %p)", __func__, engine, member, type, objtype, error); if (engine->mebstat_callback) { OSyncError *internal_error = NULL; - OSyncMemberUpdate *update = osync_try_malloc0(sizeof(OSyncMemberUpdate), &internal_error); + OSyncEngineMemberUpdate *update = osync_try_malloc0(sizeof(OSyncEngineMemberUpdate), &internal_error); if (!update) { osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&internal_error)); osync_error_unref(&internal_error); @@ -148,13 +148,13 @@ osync_trace(TRACE_EXIT, "%s", __func__); } -void osync_status_update_change(OSyncEngine *engine, OSyncChange *change, OSyncMember *member, OSyncMapping *mapping, OSyncChangeEvent type, OSyncError *error) +void osync_status_update_change(OSyncEngine *engine, OSyncChange *change, OSyncMember *member, OSyncMapping *mapping, OSyncEngineChangeEvent type, OSyncError *error) { osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p, %i, %p)", __func__, engine, change, member, mapping, type, error); if (engine->changestat_callback) { OSyncError *internal_error = NULL; - OSyncChangeUpdate *update = osync_try_malloc0(sizeof(OSyncChangeUpdate), &internal_error); + OSyncEngineChangeUpdate *update = osync_try_malloc0(sizeof(OSyncEngineChangeUpdate), &internal_error); if (!update) { osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&internal_error)); osync_error_unref(&internal_error); @@ -181,13 +181,13 @@ osync_trace(TRACE_EXIT, "%s", __func__); } -void osync_status_update_mapping(OSyncEngine *engine, OSyncMappingEngine *mapping, OSyncMappingEvent type, OSyncError *error) +void osync_status_update_mapping(OSyncEngine *engine, OSyncMappingEngine *mapping, OSyncEngineMappingEvent type, OSyncError *error) { osync_trace(TRACE_ENTRY, "%s(%p, %p, %i, %p)", __func__, engine, mapping, type, error); if (engine->mapstat_callback) { OSyncError *internal_error = NULL; - OSyncMappingUpdate *update = osync_try_malloc0(sizeof(OSyncMappingUpdate), &internal_error); + OSyncEngineMappingUpdate *update = osync_try_malloc0(sizeof(OSyncEngineMappingUpdate), &internal_error); if (!update) { osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&internal_error)); osync_error_unref(&internal_error); Modified: trunk/opensync/engine/opensync_status_internals.h ============================================================================== --- trunk/opensync/engine/opensync_status_internals.h Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/engine/opensync_status_internals.h Sat Mar 28 22:42:14 2009 (r5407) @@ -29,17 +29,17 @@ /*@{*/ -void osync_status_free_member_update(OSyncMemberUpdate *update); +void osync_status_free_member_update(OSyncEngineMemberUpdate *update); void osync_status_free_engine_update(OSyncEngineUpdate *update); -void osync_status_free_change_update(OSyncChangeUpdate *update); -void osync_status_free_mapping_update(OSyncMappingUpdate *update); +void osync_status_free_change_update(OSyncEngineChangeUpdate *update); +void osync_status_free_mapping_update(OSyncEngineMappingUpdate *update); -void osync_status_update_member(OSyncEngine *engine, OSyncMember *member, OSyncMemberEvent type, const char *objtype, OSyncError *error); +void osync_status_update_member(OSyncEngine *engine, OSyncMember *member, OSyncEngineMemberEvent type, const char *objtype, OSyncError *error); void osync_status_update_engine(OSyncEngine *engine, OSyncEngineEvent type, OSyncError *error); -void osync_status_update_change(OSyncEngine *engine, OSyncChange *change, OSyncMember *member, OSyncMapping *mapping, OSyncChangeEvent type, OSyncError *error); +void osync_status_update_change(OSyncEngine *engine, OSyncChange *change, OSyncMember *member, OSyncMapping *mapping, OSyncEngineChangeEvent type, OSyncError *error); -void osync_status_update_mapping(OSyncEngine *engine, OSyncMappingEngine *mapping, OSyncMappingEvent type, OSyncError *error); +void osync_status_update_mapping(OSyncEngine *engine, OSyncMappingEngine *mapping, OSyncEngineMappingEvent type, OSyncError *error); /** * @brief Send conflict status for a mapping Modified: trunk/opensync/opensync.h ============================================================================== --- trunk/opensync/opensync.h Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/opensync/opensync.h Sat Mar 28 22:42:14 2009 (r5407) @@ -217,6 +217,11 @@ typedef struct OSyncMappingEntryEngine OSyncMappingEntryEngine; typedef struct OSyncMappingEngine OSyncMappingEngine; +typedef struct OSyncEngineMemberUpdate OSyncEngineMemberUpdate; +typedef struct OSyncEngineChangeUpdate OSyncEngineChangeUpdate; +typedef struct OSyncEngineMappingUpdate OSyncEngineMappingUpdate; +typedef struct OSyncEngineUpdate OSyncEngineUpdate; + /* Client component */ typedef struct OSyncClient OSyncClient; typedef struct OSyncClientProxy OSyncClientProxy; Modified: trunk/tests/support.c ============================================================================== --- trunk/tests/support.c Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/tests/support.c Sat Mar 28 22:42:14 2009 (r5407) @@ -298,83 +298,86 @@ g_free(content); } -void member_status(OSyncMemberUpdate *status, void *user_data) +void member_status(OSyncEngineMemberUpdate *status, void *user_data) { - osync_trace(TRACE_ENTRY, "%s(%p (%i), %p)", __func__, status, status->type, user_data); + osync_trace(TRACE_ENTRY, "%s(%p), %p)", __func__, status, user_data); fail_unless(GINT_TO_POINTER(1) == user_data, NULL); + + OSyncError *error = osync_engine_member_update_get_error(status); + const char *objtype = osync_engine_member_update_get_objtype(status); - switch (status->type) { - case OSYNC_CLIENT_EVENT_CONNECTED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + switch (osync_engine_member_update_get_event(status)) { + case OSYNC_ENGINE_MEMBER_EVENT_CONNECTED: + fail_unless(!osync_error_is_set(&(error)), NULL); - if (status->objtype == NULL) { + if (objtype == NULL) { num_client_main_connected++; } else { - fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL); + fail_unless(!strncmp(objtype, "mockobjtype", 11), NULL); num_client_connected++; } break; - case OSYNC_CLIENT_EVENT_CONNECT_DONE: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MEMBER_EVENT_CONNECT_DONE: + fail_unless(!osync_error_is_set(&(error)), NULL); - if (status->objtype == NULL) { + if (objtype == NULL) { num_client_main_connect_done++; } else { - fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL); + fail_unless(!strncmp(objtype, "mockobjtype", 11), NULL); num_client_connect_done++; } break; - case OSYNC_CLIENT_EVENT_DISCONNECTED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MEMBER_EVENT_DISCONNECTED: + fail_unless(!osync_error_is_set(&(error)), NULL); - if (status->objtype == NULL) { + if (objtype == NULL) { num_client_main_disconnected++; } else { - fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL); + fail_unless(!strncmp(objtype, "mockobjtype", 11), NULL); num_client_disconnected++; } break; - case OSYNC_CLIENT_EVENT_READ: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MEMBER_EVENT_READ: + fail_unless(!osync_error_is_set(&(error)), NULL); - if (status->objtype == NULL) { + if (objtype == NULL) { num_client_main_read++; } else { - fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL); + fail_unless(!strncmp(objtype, "mockobjtype", 11), NULL); num_client_read++; } break; - case OSYNC_CLIENT_EVENT_WRITTEN: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MEMBER_EVENT_WRITTEN: + fail_unless(!osync_error_is_set(&(error)), NULL); - if (status->objtype == NULL) { + if (objtype == NULL) { num_client_main_written++; } else { - fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL); + fail_unless(!strncmp(objtype, "mockobjtype", 11), NULL); num_client_written++; } break; - case OSYNC_CLIENT_EVENT_ERROR: - fail_unless(osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MEMBER_EVENT_ERROR: + fail_unless(osync_error_is_set(&(error)), NULL); num_client_errors++; break; - case OSYNC_CLIENT_EVENT_SYNC_DONE: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MEMBER_EVENT_SYNC_DONE: + fail_unless(!osync_error_is_set(&(error)), NULL); - if (status->objtype == NULL) { + if (objtype == NULL) { num_client_main_sync_done++; } else { - fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL); + fail_unless(!strncmp(objtype, "mockobjtype", 11), NULL); num_client_sync_done++; } break; - case OSYNC_CLIENT_EVENT_DISCOVERED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MEMBER_EVENT_DISCOVERED: + fail_unless(!osync_error_is_set(&(error)), NULL); num_client_discovered++; break; } @@ -382,21 +385,23 @@ osync_trace(TRACE_EXIT, "%s", __func__); } -void entry_status(OSyncChangeUpdate *status, void *user_data) +void entry_status(OSyncEngineChangeUpdate *status, void *user_data) { - osync_trace(TRACE_ENTRY, "%s(%p (%i), %p)", __func__, status, status->type, user_data); + osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, status, user_data); + + OSyncError *error = osync_engine_change_update_get_error(status); - switch (status->type) { - case OSYNC_CHANGE_EVENT_READ: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + switch (osync_engine_change_update_get_event(status)) { + case OSYNC_ENGINE_CHANGE_EVENT_READ: + fail_unless(!osync_error_is_set(&(error)), NULL); num_change_read++; break; - case OSYNC_CHANGE_EVENT_WRITTEN: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_CHANGE_EVENT_WRITTEN: + fail_unless(!osync_error_is_set(&(error)), NULL); num_change_written++; break; - case OSYNC_CHANGE_EVENT_ERROR: - fail_unless(osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_CHANGE_EVENT_ERROR: + fail_unless(osync_error_is_set(&(error)), NULL); num_change_error++; break; } @@ -406,62 +411,65 @@ void engine_status(OSyncEngineUpdate *status, void *user_data) { - osync_trace(TRACE_ENTRY, "%s(%p(%i), %p)", __func__, status, status->type, user_data); - switch (status->type) { + osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, status, user_data); + + OSyncError *error = osync_engine_update_get_error(status); + + switch (osync_engine_update_get_event(status)) { case OSYNC_ENGINE_EVENT_CONNECTED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_connected++; break; case OSYNC_ENGINE_EVENT_CONNECT_DONE: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_connect_done++; break; case OSYNC_ENGINE_EVENT_READ: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_read++; break; case OSYNC_ENGINE_EVENT_PREPARED_MAP: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_prepared_map++; break; case OSYNC_ENGINE_EVENT_MAPPED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_mapped++; break; case OSYNC_ENGINE_EVENT_MULTIPLIED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_multiplied++; break; case OSYNC_ENGINE_EVENT_PREPARED_WRITE: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_prepared_write++; break; case OSYNC_ENGINE_EVENT_WRITTEN: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_written++; break; case OSYNC_ENGINE_EVENT_DISCONNECTED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_disconnected++; break; case OSYNC_ENGINE_EVENT_ERROR: - fail_unless(osync_error_is_set(&(status->error)), NULL); + fail_unless(osync_error_is_set(&(error)), NULL); num_engine_errors++; break; case OSYNC_ENGINE_EVENT_SUCCESSFUL: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_successful++; break; case OSYNC_ENGINE_EVENT_PREV_UNCLEAN: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_prev_unclean++; break; case OSYNC_ENGINE_EVENT_END_CONFLICTS: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_end_conflicts++; break; case OSYNC_ENGINE_EVENT_SYNC_DONE: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + fail_unless(!osync_error_is_set(&(error)), NULL); num_engine_sync_done++; break; } @@ -469,19 +477,21 @@ osync_trace(TRACE_EXIT, "%s", __func__); } -void mapping_status(OSyncMappingUpdate *status, void *user_data) +void mapping_status(OSyncEngineMappingUpdate *status, void *user_data) { - switch (status->type) { - case OSYNC_MAPPING_EVENT_SOLVED: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + OSyncError *error = osync_engine_mapping_update_get_error(status); + + switch (osync_engine_mapping_update_get_event(status)) { + case OSYNC_ENGINE_MAPPING_EVENT_SOLVED: + fail_unless(!osync_error_is_set(&(error)), NULL); num_mapping_solved++; break; - /*case OSYNC_MAPPING_EVENT_WRITTEN: - fail_unless(!osync_error_is_set(&(status->error)), NULL); + /*case OSYNC_ENGINE_MAPPING_EVENT_WRITTEN: + fail_unless(!osync_error_is_set(&(error)), NULL); num_mapping_written++; break;*/ - case OSYNC_MAPPING_EVENT_ERROR: - fail_unless(osync_error_is_set(&(status->error)), NULL); + case OSYNC_ENGINE_MAPPING_EVENT_ERROR: + fail_unless(osync_error_is_set(&(error)), NULL); num_mapping_errors++; break; } Modified: trunk/tests/support.h ============================================================================== --- trunk/tests/support.h Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/tests/support.h Sat Mar 28 22:42:14 2009 (r5407) @@ -107,10 +107,10 @@ void discover_all_once(OSyncEngine *engine, OSyncError **error); /* Status callbacks */ -void member_status(OSyncMemberUpdate *status, void *user_data); -void entry_status(OSyncChangeUpdate *status, void *user_data); +void member_status(OSyncEngineMemberUpdate *status, void *user_data); +void entry_status(OSyncEngineChangeUpdate *status, void *user_data); void engine_status(OSyncEngineUpdate *status, void *user_data); -void mapping_status(OSyncMappingUpdate *status, void *user_data); +void mapping_status(OSyncEngineMappingUpdate *status, void *user_data); /* Conflict handlers */ void conflict_handler_choose_first(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data); Modified: trunk/wrapper/opensync-engine.i ============================================================================== --- trunk/wrapper/opensync-engine.i Sat Mar 28 21:06:04 2009 (r5406) +++ trunk/wrapper/opensync-engine.i Sat Mar 28 22:42:14 2009 (r5407) @@ -28,22 +28,22 @@ %constant int ENGINE_EVENT_PREV_UNCLEAN = OSYNC_ENGINE_EVENT_PREV_UNCLEAN; typedef enum {} MemberEvent; -%constant int CLIENT_EVENT_CONNECTED = OSYNC_CLIENT_EVENT_CONNECTED; -%constant int CLIENT_EVENT_ERROR = OSYNC_CLIENT_EVENT_ERROR; -%constant int CLIENT_EVENT_READ = OSYNC_CLIENT_EVENT_READ; -%constant int CLIENT_EVENT_WRITTEN = OSYNC_CLIENT_EVENT_WRITTEN; -%constant int CLIENT_EVENT_SYNC_DONE = OSYNC_CLIENT_EVENT_SYNC_DONE; -%constant int CLIENT_EVENT_DISCONNECTED = OSYNC_CLIENT_EVENT_DISCONNECTED; -%constant int CLIENT_EVENT_DISCOVERED = OSYNC_CLIENT_EVENT_DISCOVERED; +%constant int ENGINE_MEMBER_EVENT_CONNECTED = OSYNC_ENGINE_MEMBER_EVENT_CONNECTED; +%constant int ENGINE_MEMBER_EVENT_ERROR = OSYNC_ENGINE_MEMBER_EVENT_ERROR; +%constant int ENGINE_MEMBER_EVENT_READ = OSYNC_ENGINE_MEMBER_EVENT_READ; +%constant int ENGINE_MEMBER_EVENT_WRITTEN = OSYNC_ENGINE_MEMBER_EVENT_WRITTEN; +%constant int ENGINE_MEMBER_EVENT_SYNC_DONE = OSYNC_ENGINE_MEMBER_EVENT_SYNC_DONE; +%constant int ENGINE_MEMBER_EVENT_DISCONNECTED = OSYNC_ENGINE_MEMBER_EVENT_DISCONNECTED; +%constant int ENGINE_MEMBER_EVENT_DISCOVERED = OSYNC_ENGINE_MEMBER_EVENT_DISCOVERED; typedef enum {} ChangeEvent; -%constant int CHANGE_EVENT_READ = OSYNC_CHANGE_EVENT_READ; -%constant int CHANGE_EVENT_WRITTEN = OSYNC_CHANGE_EVENT_WRITTEN; -%constant int CHANGE_EVENT_ERROR = OSYNC_CHANGE_EVENT_ERROR; +%constant int ENGINE_CHANGE_EVENT_READ = OSYNC_ENGINE_CHANGE_EVENT_READ; +%constant int ENGINE_CHANGE_EVENT_WRITTEN = OSYNC_ENGINE_CHANGE_EVENT_WRITTEN; +%constant int ENGINE_CHANGE_EVENT_ERROR = OSYNC_ENGINE_CHANGE_EVENT_ERROR; typedef enum {} MappingEvent; -%constant int MAPPING_EVENT_SOLVED = OSYNC_MAPPING_EVENT_SOLVED; -%constant int MAPPING_EVENT_ERROR = OSYNC_MAPPING_EVENT_ERROR; +%constant int ENGINE_MAPPING_EVENT_SOLVED = OSYNC_ENGINE_MAPPING_EVENT_SOLVED; +%constant int ENGINE_MAPPING_EVENT_ERROR = OSYNC_ENGINE_MAPPING_EVENT_ERROR; /* modified from SWIG docs, typemap to pass a python callable (function) object */ %typemap(in) PyObject *pyfunc { @@ -176,9 +176,12 @@ static void enginestatus_cb_wrapper(OSyncEngineUpdate *arg, void *clientdata) { PyGILState_STATE pystate = PyGILState_Ensure(); + OSyncError *error = osync_engine_update_get_error(arg); + OSyncEngineEvent event = osync_engine_update_get_event(arg); + PyObject *pyfunc = clientdata; - PyObject *errobj = SWIG_NewPointerObj(arg->error, SWIGTYPE_p_Error, 0); - PyObject *args = Py_BuildValue("(iO)", arg->type, errobj); + PyObject *errobj = SWIG_NewPointerObj(error, SWIGTYPE_p_Error, 0); + PyObject *args = Py_BuildValue("(iO)", event, errobj); PyObject *result = PyEval_CallObject(pyfunc, args); Py_DECREF(args); Py_XDECREF(result); |
