Ticket #1084: ticket1084_conversion-merge.diff

File ticket1084_conversion-merge.diff, 50.7 KB (added by dgollub, 3 years ago)

Initial implementation of a combied conversion-merge function which get capabilities and archive_data passed

  • wrapper/opensync-format.i

     
    4141                return ret; 
    4242        } 
    4343 
    44         void invoke(Data *data, const char *config) { 
     44        void invoke(Data *data, const char *config, Capabilities *caps, Data *archived_data) { 
    4545                Error *err = NULL; 
    46                 bool ret = osync_converter_invoke(self, data, config, &err); 
     46                bool ret = osync_converter_invoke(self, data, config, caps, archived_data, &err); 
    4747                if (!raise_exception_on_error(err) && !ret) 
    4848                        wrapper_exception("osync_converter_invoke failed but did not set error code"); 
    4949        } 
    … …  
    222222                return ret; 
    223223        } 
    224224 
    225         void convert(FormatConverterPath *path, Data *data) { 
     225        void convert(FormatConverterPath *path, Data *data, Capabilities *caps, Data *archived_data) { 
    226226                Error *err = NULL; 
    227                 bool ret = osync_format_env_convert(self, path, data, &err); 
     227                bool ret = osync_format_env_convert(self, path, data, caps, archived_data, &err); 
    228228                if (!raise_exception_on_error(err) && !ret) 
    229229                        wrapper_exception("osync_format_env_convert failed but did not set error code"); 
    230230        } 

  • opensync/format/opensync_objformat_private.h

     
    6161        OSyncFormatMarshalFunc marshal_func; 
    6262        OSyncFormatDemarshalFunc demarshal_func; 
    6363        OSyncFormatValidateFunc validate_func; 
    64         OSyncFormatMergeFunc merge_func; 
    65         OSyncFormatDemergeFunc demerge_func; 
    6664}; 
    6765 
    6866/*@}*/ 

  • opensync/format/opensync_objformat.c

     
    301301        return format->validate_func ? TRUE : FALSE; 
    302302} 
    303303 
    304 void osync_objformat_set_merge_func(OSyncObjFormat *format, OSyncFormatMergeFunc merge_func) 
    305 { 
    306         osync_return_if_fail(format); 
    307         format->merge_func = merge_func; 
    308 } 
    309  
    310 osync_bool osync_objformat_merge(OSyncObjFormat *format, 
    311                 char **data, unsigned int *size, 
    312                 const char *entire, unsigned int entsize, 
    313                 OSyncCapabilities *caps, OSyncError **error) 
    314 { 
    315         osync_assert(format); 
    316         osync_return_val_if_fail(format->merge_func, TRUE); 
    317         return format->merge_func(data, size, entire, entsize, caps, format->user_data, error); 
    318 } 
    319  
    320 void osync_objformat_set_demerge_func(OSyncObjFormat *format, OSyncFormatDemergeFunc demerge_func) 
    321 { 
    322         osync_return_if_fail(format); 
    323         format->demerge_func = demerge_func; 
    324 } 
    325  
    326 osync_bool osync_objformat_demerge(OSyncObjFormat *format, 
    327                 char **data, unsigned int *size, 
    328                 OSyncCapabilities *caps, OSyncError **error) 
    329 { 
    330         osync_assert(format); 
    331         osync_return_val_if_fail(format->demerge_func, TRUE); 
    332         return format->demerge_func(data, size, caps, format->user_data, error); 
    333 } 
    334  
    335  
    336 osync_bool osync_objformat_has_merger(OSyncObjFormat *format) 
    337 { 
    338         osync_return_val_if_fail(format, FALSE); 
    339         return (format->demerge_func && format->merge_func) ? TRUE : FALSE; 
    340 } 
    341  

  • opensync/format/opensync_objformat.h

     
    4444typedef osync_bool (* OSyncFormatDemarshalFunc) (OSyncMarshal *marshal, char **output, unsigned int *outpsize, void *user_data, OSyncError **error); 
    4545typedef osync_bool (* OSyncFormatValidateFunc) (const char *data, unsigned int size, void *user_data, OSyncError **error); 
    4646 
    47 typedef osync_bool (* OSyncFormatMergeFunc) (char **data, unsigned int *size, const char *entire, unsigned int entsize, OSyncCapabilities *caps, void *user_data, OSyncError **error); 
    48 typedef osync_bool (* OSyncFormatDemergeFunc) (char **data, unsigned int *size, OSyncCapabilities *caps, void *user_data, OSyncError **error); 
    49  
    5047/** 
    5148 * @brief Creates a new object format 
    5249 * @param name the name of the object format 
    … …  
    225222OSYNC_EXPORT void osync_objformat_set_validate_func(OSyncObjFormat *format, OSyncFormatValidateFunc validate_func); 
    226223 
    227224/** 
    228  * @brief Sets the optional merge function for an object format 
    229  * 
    230  * The merge function can be used to merge data for the specific 
    231  * format. This is optional. 
    232  * 
    233  * @param format Pointer to the object format 
    234  * @param merge_func The merge function to use 
    235  */ 
    236 OSYNC_EXPORT void osync_objformat_set_merge_func(OSyncObjFormat *format, OSyncFormatMergeFunc merge_func); 
    237  
    238 /** 
    239  * @brief Sets the optional demerge function for an object format 
    240  * 
    241  * The demerge function can be used to demerge data for the specific 
    242  * format. This is optional. 
    243  * 
    244  * @param format Pointer to the object format 
    245  * @param demerge_func The demerge function to use 
    246  */ 
    247 OSYNC_EXPORT void osync_objformat_set_demerge_func(OSyncObjFormat *format, OSyncFormatDemergeFunc demerge_func); 
    248  
    249 /** 
    250225 * @brief Prints the specified object 
    251226 * 
    252227 * Uses the object format's print function if set, otherwise the object's 

  • opensync/format/opensync_format_env.c

     
    626626                        OSyncFormatConverter *edge = e->data; 
    627627                        osync_converter_path_add_edge(path_tmp, edge); 
    628628                } 
    629                 if (!(osync_format_env_convert(env, path_tmp, current->data, error))) { 
     629                if (!(osync_format_env_convert(env, path_tmp, current->data, NULL, NULL, error))) { 
    630630                        osync_trace(TRACE_INTERNAL, "osync format env convert on this path failed - skipping the conversion"); 
    631631                        continue; 
    632632                } 
    … …  
    10121012                        converter = d->data; 
    10131013                        if (osync_converter_matches(converter, new_data) && osync_converter_get_type(converter) == OSYNC_CONVERTER_DECAP) { 
    10141014                                /* Run the decap */ 
    1015                                 if (!osync_converter_invoke(converter, new_data, NULL, error)) { 
     1015                                if (!osync_converter_invoke(converter, new_data, NULL, NULL, NULL, error)) { 
    10161016                                        osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to decap the change"); 
    10171017                                        goto error_free_data; 
    10181018                                } 
    … …  
    10451045        return FALSE; 
    10461046} 
    10471047 
    1048 osync_bool osync_format_env_convert(OSyncFormatEnv *env, OSyncFormatConverterPath *path, OSyncData *data, OSyncError **error) 
     1048osync_bool osync_format_env_convert(OSyncFormatEnv *env, OSyncFormatConverterPath *path, OSyncData *data, OSyncCapabilities *caps, OSyncData *archived_data, OSyncError **error) 
    10491049{ 
    10501050        OSyncObjFormat *source = NULL; 
    10511051        int length = 0; 
    10521052        char *buffer = NULL; 
    10531053         
    1054         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, env, path, data, error); 
     1054        osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p, %p, %p)", __func__, env, path, data, caps, archived_data, error); 
    10551055        osync_assert(data); 
    10561056        osync_assert(env); 
    10571057        osync_assert(path); 
    … …  
    10821082                for (i = 0; i < length; i++) { 
    10831083                        OSyncFormatConverter *converter = osync_converter_path_nth_edge(path, i); 
    10841084                         
    1085                         if (!osync_converter_invoke(converter, data, osync_converter_path_get_config(path), error)) { 
     1085                        if (!osync_converter_invoke(converter, data, osync_converter_path_get_config(path), caps, archived_data, error)) { 
    10861086                                osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); 
    10871087                                return FALSE; 
    10881088                        } 

  • opensync/format/opensync_format_env.h

     
    187187 * @param env The conversion environment to use 
    188188 * @param path The conversion path to follow 
    189189 * @param data The data object to convert 
     190 * @param caps The capabilities information. optional and can be NULL 
     191 * @param archived_data The data object which got archived and should be used for merging. optional and can be NULL 
    190192 * @param error The error-return location 
    191193 * @returns TRUE on success, FALSE otherwise 
    192194 *  
    193195 */ 
    194 OSYNC_EXPORT osync_bool osync_format_env_convert(OSyncFormatEnv *env, OSyncFormatConverterPath *path, OSyncData *data, OSyncError **error); 
     196OSYNC_EXPORT osync_bool osync_format_env_convert(OSyncFormatEnv *env, OSyncFormatConverterPath *path, OSyncData *data,  OSyncCapabilities *caps, OSyncData *archived_data, OSyncError **error); 
    195197 
    196198/** @brief Find a conversion path between two formats 
    197199 *  

  • opensync/format/opensync_objformat_internals.h

     
    178178 */ 
    179179osync_bool osync_objformat_must_validate(OSyncObjFormat *format); 
    180180 
    181 /** 
    182  * @brief Merge supplied data in format specific way 
    183  * 
    184  * @param format Pointer to the object format 
    185  * @param data Reference of buffer which stores data to merge 
    186  * @param size Reference of size in bytes of the buffer specified by the data paramter 
    187  * @param entire 
    188  * @param entsize Size in bytes of the base data buffer specified by the entire parameter 
    189  * @param caps The capabilities list which describes what must get merged: entire -> input 
    190  * @param error Pointer to an error struct 
    191  * @returns TRUE if data got merged successfully, otherwise FALSE 
    192  */ 
    193 OSYNC_TEST_EXPORT osync_bool osync_objformat_merge(OSyncObjFormat *format, 
    194                 char **data, unsigned int *size, 
    195                 const char *entire, unsigned int entsize, 
    196                 OSyncCapabilities *caps, OSyncError **error); 
    197  
    198 /** 
    199  * @brief Demerge supplied data in format specific way 
    200  * 
    201  * @param format Pointer to the object format 
    202  * @param data Pointer to the buffer which should get demerged  
    203  * @param size Reference of size in bytes of the buffer specified by the data parameter 
    204  * @param caps The capabilities list which describes what must get demerged 
    205  * @param error Pointer to an error struct 
    206  * @returns TRUE if data got demerged successfully, otherwise FALSE 
    207  */ 
    208 OSYNC_TEST_EXPORT osync_bool osync_objformat_demerge(OSyncObjFormat *format, 
    209                 char **data, unsigned int *size, 
    210                 OSyncCapabilities *caps, OSyncError **error); 
    211  
    212 /** 
    213  * @brief Check if specific format is able to merge/demerge  
    214  * 
    215  * If merge and demerge function are set for the specific format then merger 
    216  * and demerger get invoked. Merger/Demerge still can be disabled in group 
    217  * configuration, by disabling the merger, or not providing capabilities for 
    218  * the member. 
    219  * 
    220  * @param format Pointer to the object format 
    221  * @returns TRUE if merge and demerge is support for this format, otherwise FALSE 
    222  */ 
    223 osync_bool osync_objformat_has_merger(OSyncObjFormat *format); 
    224  
    225181/*@}*/ 
    226182 
    227183#endif /* _OPENSYNC_OBJFORMAT_INTERNALS_H_ */ 

  • opensync/format/opensync_converter.c

     
    169169        return NULL; 
    170170} 
    171171 
    172 osync_bool osync_converter_invoke(OSyncFormatConverter *converter, OSyncData *data, const char *config, OSyncError **error) 
     172osync_bool osync_converter_invoke(OSyncFormatConverter *converter, OSyncData *data, const char *config, OSyncCapabilities *caps, OSyncData *archived, OSyncError **error) 
    173173{ 
    174174        char *input_data = NULL; 
    175175        unsigned int input_size = 0; 
    176176        char *output_data = NULL; 
    177177        unsigned int output_size = 0; 
     178        char *archived_data = NULL; 
     179        unsigned int archived_size = 0; 
    178180        osync_bool free_input = FALSE; 
    179181         
    180182        osync_assert(converter); 
    181183        osync_assert(data); 
    182184         
    183         osync_trace(TRACE_ENTRY, "%s(%p, %p, %s, %p)", __func__, converter, data, __NULLSTR(config), error); 
     185        osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p, %s, %p)", __func__, converter, data, caps, archived, __NULLSTR(config), error); 
    184186        osync_trace(TRACE_INTERNAL, "Converter of type %i, from %p(%s) to %p(%s)", converter->type, converter->source_format, osync_objformat_get_name(converter->source_format), converter->target_format, osync_objformat_get_name(converter->target_format)); 
    185187         
    186188        if (converter->type != OSYNC_CONVERTER_DETECTOR) { 
    … …  
    188190                osync_data_steal_data(data, &input_data, &input_size); 
    189191                if (input_data) { 
    190192                        osync_assert(converter->convert_func); 
     193 
     194                        if (archived) 
     195                                osync_data_get_data(archived, &archived_data, &archived_size); 
    191196                 
    192197                        /* Invoke the converter */ 
    193                         if (!converter->convert_func(input_data, input_size, &output_data, &output_size, &free_input, config, converter->userdata, error)) 
     198                        if (!converter->convert_func(input_data, input_size, &output_data, &output_size, &free_input, caps, archived_data, archived_size, config, converter->userdata, error)) 
    194199                                goto error; 
    195200 
    196201                        /* Validate if for this objformat are format-plugin validiation-function is provided */ 

  • opensync/format/opensync_converter.h

     
    4242} OSyncConverterType; 
    4343 
    4444typedef osync_bool (* OSyncFormatDetectFunc) (const char *data, int size, void *userdata); 
    45 typedef osync_bool (* OSyncFormatConvertFunc) (char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error); 
     45typedef osync_bool (* OSyncFormatConvertFunc) (char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size,  const char *config, void *userdata, OSyncError **error); 
    4646typedef void * (* OSyncFormatConverterInitializeFunc) (const char *config, OSyncError **error); 
    4747typedef void (* OSyncFormatConverterFinalizeFunc) (void *userdata); 
    4848 
    … …  
    117117 * @param converter Pointer to the converter 
    118118 * @param data Pointer to OSyncData object which should be detected 
    119119 * @param config Format converter configuration 
     120 * @param caps Pointer to capabilities for merging. optional, can be NULL 
     121 * @param archived Pointer to archived data, which should get used for merging. optional, can be NULL 
    120122 * @param error Pointer to an error struct 
    121123 * @returns TRUE on successful conversion, FALSE on error 
    122124 */ 
    123 OSYNC_EXPORT osync_bool osync_converter_invoke(OSyncFormatConverter *converter, OSyncData *data, const char *config, OSyncError **error); 
     125OSYNC_EXPORT osync_bool osync_converter_invoke(OSyncFormatConverter *converter, OSyncData *data, const char *config, OSyncCapabilities *caps, OSyncData *archived, OSyncError **error); 
    124126 
    125127/** 
    126128 * @brief Checks if the Format Converter fits the Object Format of OSyncData object 

  • opensync/engine/opensync_mapping_entry_engine_internals.h

     
    108108 */ 
    109109void osync_entry_engine_set_dirty(OSyncMappingEntryEngine *engine, osync_bool dirty); 
    110110 
    111 /** @brief Demerge the entry in the OSyncMappingEntryEngine 
     111/** @brief Archive the entry in the OSyncMappingEntryEngine 
    112112 * 
    113  * The demerge includes storing the "entire" entry in the Archive. The demerging is done 
    114  * based on the supplied OSyncCapabilities. 
     113 * This stores the "entire" entry in the Archive. 
    115114 * 
    116115 * @param engine Pointer to an OSyncMappingEntryEngine 
    117116 * @param archive Pointer to the Archive to store the "entire" entry before demerging 
    118  * @param caps Pointer to Capabilities to use for demerging 
    119117 * @param error Pointer to error struct, which get set on any error 
    120118 * @returns TRUE on successful demerge, FALSE otherwise 
    121119 */ 
    122 osync_bool osync_entry_engine_demerge(OSyncMappingEntryEngine *engine, OSyncArchive *archive, OSyncCapabilities *caps, OSyncError **error); 
     120osync_bool osync_entry_engine_archive(OSyncMappingEntryEngine *engine, OSyncArchive *archive, OSyncError **error); 
    123121 
    124122/** @brief convert the entry in the OSyncMappingEntryEngine  
    125123 * 
    … …  
    134132 * @param formatenv Pointer to format environment  
    135133 * @param objtype_sink Pointer to Object Type Sink which stores format configurations  
    136134 * @param path Reference to OSyncFormatConverterPath to supplied or store the cache conversion path 
     135 * @param caps Pointer to capabilities of the peer which will retrieve the conversion result. optional, can be NULL 
    137136 * @param error Pointer to error struct, which get set on any error 
    138137 * @returns TRUE on successful demerge, FALSE otherwise 
    139138 */ 
    140139 
    141 osync_bool osync_entry_engine_convert(OSyncMappingEntryEngine *engine, OSyncFormatEnv *formatenv, OSyncObjTypeSink *objtype_sink, OSyncFormatConverterPath **path, OSyncError **error); 
     140osync_bool osync_entry_engine_convert(OSyncMappingEntryEngine *engine, OSyncFormatEnv *formatenv, OSyncObjTypeSink *objtype_sink, OSyncFormatConverterPath **path, OSyncCapabilities *caps, OSyncError **error); 
    142141 
    143142/*@}*/ 
    144143 

  • opensync/engine/opensync_sink_engine.c

     
    124124        return osync_client_proxy_get_member(engine->proxy); 
    125125} 
    126126 
    127 osync_bool osync_sink_engine_demerge(OSyncSinkEngine *engine, OSyncArchive *archive, OSyncError **error) 
     127osync_bool osync_sink_engine_archive(OSyncSinkEngine *engine, OSyncArchive *archive, OSyncError **error) 
    128128{ 
    129129        OSyncList *o; 
    130130        OSyncMember *member; 
    … …  
    150150                if (osync_change_get_changetype(entry_engine->change) == OSYNC_CHANGE_TYPE_DELETED) 
    151151                        continue; 
    152152 
    153                 if (!osync_objformat_has_merger(osync_change_get_objformat(entry_engine->change))) 
    154                         continue; 
    155  
    156                 if (!osync_entry_engine_demerge(entry_engine, archive, caps, error)) 
     153                if (!osync_entry_engine_archive(entry_engine, archive, error)) 
    157154                        goto error; 
    158155 
    159156        } 
    … …  
    170167        OSyncObjTypeSink *objtype_sink; 
    171168        const char *objtype; 
    172169        OSyncFormatConverterPath *path = NULL; 
     170        OSyncCapabilities *caps; 
    173171 
    174172        osync_assert(engine); 
    175173        osync_assert(formatenv); 
    … …  
    177175        member = osync_client_proxy_get_member(engine->proxy); 
    178176        osync_assert(member); 
    179177 
     178        caps = osync_member_get_capabilities(member);  
     179 
    180180        objtype = osync_obj_engine_get_objtype(engine->engine); 
    181181        objtype_sink = osync_member_find_objtype_sink(member, objtype); 
    182182        osync_assert(objtype_sink); 
    … …  
    191191                if (osync_change_get_changetype(entry_engine->change) == OSYNC_CHANGE_TYPE_DELETED) 
    192192                        continue; 
    193193 
    194                 if (!osync_entry_engine_convert(entry_engine, formatenv, objtype_sink, &path, error)) 
     194                if (!osync_entry_engine_convert(entry_engine, formatenv, objtype_sink, &path, caps, error)) 
    195195                        goto error; 
    196196        } 
    197197 

  • opensync/engine/opensync_obj_engine.c

     
    13371337                OSyncSinkEngine *sinkengine = p->data; 
    13381338 
    13391339                if (merger_enabled 
    1340                         && !osync_sink_engine_demerge(sinkengine, engine->archive, error)) 
     1340                        && !osync_sink_engine_archive(sinkengine, engine->archive, error)) 
    13411341                        goto error; 
    13421342 
    13431343                if (converter_enabled 

  • opensync/engine/opensync_mapping_entry_engine.c

     
    158158        engine->dirty = dirty; 
    159159} 
    160160 
    161 osync_bool osync_entry_engine_demerge(OSyncMappingEntryEngine *entry_engine, OSyncArchive *archive, OSyncCapabilities *caps, OSyncError **error) 
     161osync_bool osync_entry_engine_archive(OSyncMappingEntryEngine *entry_engine, OSyncArchive *archive, OSyncError **error) 
    162162{ 
    163163 
    164164        char *buffer = NULL, *marshalbuf; 
    … …  
    190190                goto error_free_marshal; 
    191191        } 
    192192 
    193         if (!osync_objformat_demerge(objformat, &buffer, &size, caps, error)) 
    194                 goto error_free_marshal; 
    195  
    196         osync_trace(TRACE_SENSITIVE, "Post Demerge:\n%s\n", 
    197                         osync_objformat_print(objformat, buffer, size)); 
    198  
    199193        osync_marshal_unref(marshal); 
    200194 
    201195        return TRUE; 
    … …  
    206200        return FALSE; 
    207201} 
    208202 
    209 osync_bool osync_entry_engine_convert(OSyncMappingEntryEngine *entry_engine, OSyncFormatEnv *formatenv, OSyncObjTypeSink *objtype_sink, OSyncFormatConverterPath **cachedpath, OSyncError **error) 
     203osync_bool osync_entry_engine_convert(OSyncMappingEntryEngine *entry_engine, OSyncFormatEnv *formatenv, OSyncObjTypeSink *objtype_sink, OSyncFormatConverterPath **cachedpath, OSyncCapabilities *caps, OSyncError **error) 
    210204{ 
    211205        char *objtype = NULL; 
    212206        OSyncList *format_sinks = NULL; 
    … …  
    245239                osync_converter_path_set_config(path, osync_objformat_sink_get_config(formatsink)); 
    246240        } 
    247241         
    248         if (!osync_format_env_convert(formatenv, path, osync_change_get_data(entry_engine->change), error)) { 
     242        if (!osync_format_env_convert(formatenv, path, osync_change_get_data(entry_engine->change), caps, NULL, error)) { 
    249243                goto error_free_path; 
    250244        } 
    251245        osync_trace(TRACE_INTERNAL, "converted to format %s", osync_objformat_get_name(osync_change_get_objformat(entry_engine->change))); 

  • opensync/engine/opensync_engine.c

     
    170170        osync_converter_path_unref(converter_path); 
    171171} 
    172172 
     173osync_bool osync_engine_load_archived_entry(OSyncEngine *engine, OSyncChange *change, OSyncData **archived_entry, OSyncError **error) 
     174{ 
     175        int ret; 
     176        char *entirebuf; 
     177        unsigned int entsize; 
     178        OSyncMarshal *marshal; 
     179 
     180        osync_assert(engine); 
     181        osync_assert(change); 
     182        osync_assert(archived_entry); 
     183 
     184        *archived_entry = NULL; 
     185 
     186        /* TODO: Merger save the archive data with the member so we have to load it only for one time*/ 
     187        ret = osync_archive_load_data(engine->archive, osync_change_get_uid(change), osync_change_get_objtype(change), &entirebuf, &entsize, error); 
     188 
     189        if (ret < 0) 
     190                goto error;  
     191        else if (ret == 0) 
     192                goto done; 
     193 
     194        marshal = osync_marshal_new(error); 
     195        if (!marshal) 
     196                goto error; 
     197 
     198        /* Create a dummy marshal object - to later demarshal changes which got 
     199         * stored in a marshaled/serialized format. 
     200         */ 
     201        osync_marshal_write_data(marshal, entirebuf, entsize); 
     202 
     203        if (!osync_objformat_demarshal(osync_change_get_objformat(change), marshal, &entirebuf, &entsize, error)) { 
     204                osync_marshal_unref(marshal); 
     205                goto error; 
     206        } 
     207 
     208        osync_marshal_unref(marshal); 
     209                 
     210done: 
     211        return TRUE; 
     212error: 
     213        return FALSE; 
     214} 
     215 
     216static osync_bool osync_engine_merge_and_convert(OSyncEngine *engine, OSyncClientProxy *proxy, 
     217                OSyncChange *change, OSyncObjFormat *destformat, OSyncError **error) 
     218{ 
     219        OSyncCapabilities *caps; 
     220        OSyncFormatConverterPath *path = NULL; 
     221        OSyncObjFormatSink *formatsink = NULL; 
     222        OSyncData *archived_data = NULL; 
     223        OSyncMember *member; 
     224        char *member_objtype = NULL; 
     225        long long int memberid; 
     226        OSyncObjTypeSink *objtype_sink = NULL; 
     227 
     228        osync_assert(engine); 
     229        osync_assert(proxy); 
     230        osync_assert(change); 
     231 
     232        if (!destformat) 
     233                goto done; 
     234 
     235        /* Do not convert anything if the chagetype is DELETED. */ 
     236        if (osync_change_get_changetype(change) == OSYNC_CHANGE_TYPE_DELETED) 
     237                goto done; 
     238 
     239        member = osync_client_proxy_get_member(proxy); 
     240        memberid = osync_member_get_id(member); 
     241        member_objtype = osync_strdup_printf("%lli_%s", memberid, osync_change_get_objtype(change));  
     242        caps = osync_member_get_capabilities(member); 
     243        objtype_sink = osync_member_find_objtype_sink(member, osync_change_get_objtype(change)); 
     244 
     245 
     246        osync_trace(TRACE_INTERNAL, "converting to format %s", osync_objformat_get_name(destformat)); 
     247 
     248        path = _osync_engine_get_converter_path(engine, member_objtype); 
     249        if (!path) { 
     250                path = osync_format_env_find_path_with_detectors(engine->formatenv, osync_change_get_data(change), destformat, NULL, error); 
     251                _osync_engine_set_converter_path(engine, member_objtype, path); 
     252        } 
     253 
     254        osync_free(member_objtype); 
     255 
     256        if (!path) 
     257                goto error; 
     258 
     259        /* Load archived entry if available */ 
     260        if (!osync_engine_load_archived_entry(engine, change, &archived_data, error)) 
     261                goto error; 
     262         
     263        /* Get the current configured format to honor the plugin configuration! */ 
     264        formatsink = osync_objtype_sink_find_objformat_sink(objtype_sink, osync_change_get_objformat(change)); 
     265        if (formatsink) { 
     266                const char *config = osync_objformat_sink_get_config(formatsink);  
     267                osync_converter_path_set_config(path, config); 
     268        } 
     269 
     270        if (!osync_format_env_convert(engine->formatenv, path, osync_change_get_data(change), caps, archived_data, error)) 
     271                goto error; 
     272 
     273        osync_data_unref(archived_data); 
     274 
     275done: 
     276        return TRUE; 
     277error: 
     278        return FALSE; 
     279} 
     280 
     281 
    173282static void _osync_engine_receive_change(OSyncClientProxy *proxy, void *userdata, OSyncChange *change) 
    174283{ 
    175284        OSyncEngine *engine = userdata; 
    176285        OSyncError *error = NULL; 
    177286        osync_bool found = FALSE; 
    178287        OSyncMember *member = NULL; 
    179         long long int memberid = 0; 
    180288        const char *uid = NULL; 
    181289        OSyncChangeType changetype = 0; 
    182290        const char *format = NULL; 
    183291        const char *objtype = NULL; 
    184         OSyncObjTypeSink *objtype_sink = NULL; 
    185         char *member_objtype = NULL; 
    186292        OSyncData *data = NULL; 
    187293        OSyncObjFormat *internalFormat = NULL; 
    188294        OSyncObjFormat *detected_format = NULL; 
     295        OSyncObjFormat *destformat = NULL; 
    189296         
    190297        osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, proxy, userdata, change); 
    191298 
    192299        member = osync_client_proxy_get_member(proxy); 
    193         memberid = osync_member_get_id(member); 
     300 
    194301        uid = osync_change_get_uid(change);              
    195302        changetype = osync_change_get_changetype(change); 
    196303        format = osync_objformat_get_name(osync_change_get_objformat(change)); 
    197304        objtype = osync_change_get_objtype(change); 
    198305 
    199         objtype_sink = osync_member_find_objtype_sink(member, objtype); 
     306        osync_trace(TRACE_INTERNAL, "Received change %s, changetype %i, format %s, objtype %s from member %lli", uid, changetype, format, objtype, osync_member_get_id(member)); 
    200307 
    201         osync_trace(TRACE_INTERNAL, "Received change %s, changetype %i, format %s, objtype %s from member %lli", uid, changetype, format, objtype, memberid); 
    202  
    203308        data = osync_change_get_data(change); 
    204309 
    205310        /* try to detect encapsulated formats */ 
    … …  
    214319                objtype = osync_objformat_get_objtype(detected_format); 
    215320        } 
    216321         
    217         member_objtype = osync_strdup_printf("%lli_%s", memberid, objtype);  
     322        /* Convert the format to the internal format */ 
     323        if ((internalFormat = _osync_engine_get_internal_format(engine, objtype))) 
     324                destformat = internalFormat; 
     325        else 
     326                destformat = detected_format; 
     327         
    218328 
    219         /* Convert the format to the internal format */ 
    220         internalFormat = _osync_engine_get_internal_format(engine, objtype); 
    221329        osync_trace(TRACE_INTERNAL, "common format %p for objtype %s", internalFormat, objtype); 
    222330 
    223331        /* Only convert if the engine is allowed to convert and if an "internal" or detected format is available.  
    224                  The reason that the engine isn't allowed to convert could be backup. dumping the changes.  
    225                  Do not convert anything if the chagetype is DELETED. */ 
    226  
    227         /* TODO: Move common format conversion into objengine. Use this conversion only for 
    228          * encapsulating formats, if required. 
    229          */ 
    230         if ((internalFormat || detected_format) && osync_group_get_converter_enabled(engine->group) && (osync_change_get_changetype(change) != OSYNC_CHANGE_TYPE_DELETED)) { 
    231                 OSyncFormatConverterPath *path = NULL; 
    232                 OSyncObjFormatSink *formatsink = NULL; 
    233                 OSyncObjFormat *common_format = internalFormat ? internalFormat : detected_format; 
    234                 osync_trace(TRACE_INTERNAL, "converting to format %s", osync_objformat_get_name(common_format)); 
    235  
    236                 path = _osync_engine_get_converter_path(engine, member_objtype); 
    237                 if(!path) { 
    238                         path = osync_format_env_find_path_with_detectors(engine->formatenv, osync_change_get_data(change), common_format, NULL, &error); 
    239                         _osync_engine_set_converter_path(engine, member_objtype, path); 
    240                 } 
    241  
    242                 if (!path) 
     332                 The reason that the engine isn't allowed to convert could be backup. dumping the changes. */ 
     333        if (osync_group_get_converter_enabled(engine->group)) 
     334                if (!osync_engine_merge_and_convert(engine, proxy, change, destformat, &error)) 
    243335                        goto error; 
    244336         
    245                 /* Get the current configured format to honor the plugin configuration! */ 
    246                 formatsink = osync_objtype_sink_find_objformat_sink(objtype_sink, osync_change_get_objformat(change)); 
    247                 if (formatsink) { 
    248                         const char *config = osync_objformat_sink_get_config(formatsink);  
    249                         osync_converter_path_set_config(path, config); 
    250                 } 
    251  
    252                 if (!osync_format_env_convert(engine->formatenv, path, data, &error)) { 
    253                         goto error; 
    254                 } 
    255         } 
    256          
    257         /* TODO: Move this into the objengine. */ 
    258         /* Merger - Merge lost information to the change (don't merger anything when changetype is DELETED.) */ 
    259         if( osync_group_get_merger_enabled(engine->group) && 
    260                         osync_group_get_converter_enabled(engine->group) &&      
    261                         (osync_change_get_changetype(change) != OSYNC_CHANGE_TYPE_DELETED) && 
    262                         /* only use the merger if the objformat has merger registered. */ 
    263                         osync_objformat_has_merger(osync_change_get_objformat(change)) ) 
    264  
    265                 { 
    266                         OSyncCapabilities *caps; 
    267                         OSyncObjFormat *objformat = osync_change_get_objformat(change); 
    268                         char *entirebuf, *buffer; 
    269                         unsigned int entsize, size = 0; 
    270                         osync_trace(TRACE_INTERNAL, "Merge."); 
    271  
    272                         member = osync_client_proxy_get_member(proxy); 
    273                         caps = osync_member_get_capabilities(member); 
    274  
    275                         if(caps) { 
    276  
    277                                 /* TODO: Merger save the archive data with the member so we have to load it only for one time*/ 
    278                                 // osync_archive_load_data() is fetching the mappingid by uid in the db 
    279                                 int ret = osync_archive_load_data(engine->archive, uid, osync_change_get_objtype(change), &entirebuf, &entsize, &error); 
    280                                 if (ret < 0) { 
    281                                         goto error;  
    282                                 }  
    283                          
    284                                 if (ret > 0) { 
    285                                         OSyncMarshal *marshal; 
    286  
    287                                         marshal = osync_marshal_new(&error); 
    288                                         if (!marshal) 
    289                                                 goto error; 
    290  
    291                                         osync_marshal_write_data(marshal, entirebuf, entsize); 
    292  
    293                                         if (!osync_objformat_demarshal(objformat, marshal, &entirebuf, &entsize, &error)) { 
    294                                                 osync_marshal_unref(marshal); 
    295                                                 goto error; 
    296                                         } 
    297  
    298                                         osync_marshal_unref(marshal); 
    299                                          
    300                                         osync_data_get_data(osync_change_get_data(change), &buffer, &size); 
    301  
    302                                         ret = osync_objformat_merge(objformat, &buffer, &size, entirebuf, entsize, caps, &error); 
    303                                         osync_free(entirebuf); 
    304  
    305                                         if (ret != TRUE) 
    306                                                 goto error; 
    307  
    308                                         osync_trace(TRACE_SENSITIVE, "Merge result:\n%s\n", 
    309                                                 osync_objformat_print(objformat, buffer, size)); 
    310                                 } 
    311                         } 
    312                 } 
    313          
    314337        /* Search for the correct objengine */ 
    315338        {OSyncList * o = NULL; 
    316339                for (o = engine->object_engines; o; o = o->next) { 
    … …  
    328351                goto error; 
    329352        } 
    330353 
    331         osync_free(member_objtype); 
    332          
    333354        osync_trace(TRACE_EXIT, "%s", __func__); 
    334355        return; 
    335356 
    336357 error: 
    337         osync_free(member_objtype); 
    338          
    339358        osync_engine_set_error(engine, error); 
    340359        osync_status_update_member(engine, osync_client_proxy_get_member(proxy), OSYNC_ENGINE_MEMBER_EVENT_ERROR, NULL, error); 
    341360        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&error)); 

  • opensync/engine/opensync_sink_engine_internals.h

     
    4444void osync_sink_engine_unref(OSyncSinkEngine *engine); 
    4545osync_bool osync_sink_engine_is_connected(OSyncSinkEngine *engine); 
    4646 
    47 /** @brief Demerge all entries of OSyncSinkEngine 
     47/** @brief Archive all entries of OSyncSinkEngine 
    4848 * 
    4949 * If the Member/Client of the OSyncSinkEngine doesn't have capabilities 
    5050 * this functions is NOOP and just returns with TRUE, without error. 
    5151 * 
    52  * Changes with a current OSyncObjFormat, without merge/demerge get skipped. 
     52 * Changes with a current OSyncObjFormat 
    5353 * 
    54  * @param engine Pointer to an OSyncSinkEngine which should demerge 
    55  * @param archive Pointer to an OSyncArchive to store the dermerged information 
     54 * @param engine Pointer to an OSyncSinkEngine which should archive all entries 
     55 * @param archive Pointer to an OSyncArchive which is used for storing the entries 
    5656 * @param error Pointer to error struct, which get set on any error 
    5757 * @returns TRUE on success, FALSE otherwise 
    5858 */ 
    59 osync_bool osync_sink_engine_demerge(OSyncSinkEngine *engine, OSyncArchive *archive, OSyncError **error); 
     59osync_bool osync_sink_engine_archive(OSyncSinkEngine *engine, OSyncArchive *archive, OSyncError **error); 
    6060 
    6161/** @brief Convert all entries of OSyncSinkEngine to destitination format 
    6262 * 

  • tests/mock-plugin/mock_format.c

     
    7676        return OSYNC_CONV_DATA_MISMATCH; 
    7777} 
    7878 
    79 static osync_bool conv_mockformat1_to_mockformat2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     79static osync_bool conv_mockformat1_to_mockformat2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    8080{ 
    8181        osync_trace(TRACE_INTERNAL, "Converting file to plain"); 
    8282         
    … …  
    9393        return TRUE; 
    9494} 
    9595 
    96 static osync_bool conv_mockformat2_to_mockformat1(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     96static osync_bool conv_mockformat2_to_mockformat1(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    9797{ 
    9898        osync_trace(TRACE_INTERNAL, "Converting plain to file"); 
    9999         

  • tests/format-tests/check_conv.c

     
    118118} 
    119119END_TEST 
    120120 
    121 osync_bool convert_func(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void* user_data, OSyncError **error) 
     121osync_bool convert_func(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void* user_data, OSyncError **error) 
    122122{ 
    123123        *free_input = TRUE; 
    124124        *output = g_strdup("test"); 
    … …  
    12701270} 
    12711271END_TEST 
    12721272 
    1273 static osync_bool convert_addtest(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     1273static osync_bool convert_addtest(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    12741274{ 
    12751275        *free_input = TRUE; 
    12761276        *output = g_strdup_printf("%stest", input); 
    … …  
    12781278        return TRUE; 
    12791279} 
    12801280 
    1281 static osync_bool convert_remtest(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     1281static osync_bool convert_remtest(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    12821282{ 
    12831283        *free_input = TRUE; 
    12841284        *output = strdup(input); 
    … …  
    12941294        } 
    12951295} 
    12961296 
    1297 static osync_bool convert_addtest2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     1297static osync_bool convert_addtest2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    12981298{ 
    12991299        *output = g_strdup_printf("%stest2", input); 
    13001300        *outpsize = inpsize + 5; 
    … …  
    13021302        return TRUE; 
    13031303} 
    13041304 
    1305 static osync_bool convert_remtest2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     1305static osync_bool convert_remtest2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    13061306{ 
    13071307        *free_input = TRUE; 
    13081308        *output = strdup(input); 
    … …  
    13651365 
    13661366        OSyncFormatConverterPath *path = NULL; 
    13671367        path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error); 
    1368         osync_format_env_convert(env, path, data, &error);  
     1368        osync_format_env_convert(env, path, data, NULL, NULL, &error);  
    13691369        fail_unless(error == NULL, NULL); 
    13701370 
    13711371        char *buf; 
    … …  
    14381438 
    14391439        OSyncFormatConverterPath *path = NULL; 
    14401440        path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error); 
    1441         osync_format_env_convert(env, path, data, &error);  
     1441        osync_format_env_convert(env, path, data, NULL, NULL, &error);  
    14421442        fail_unless(error == NULL, NULL); 
    14431443 
    14441444        char *buf; 
    … …  
    14551455 
    14561456        path = NULL; 
    14571457        path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error); 
    1458         osync_format_env_convert(env, path, data, &error);  
     1458        osync_format_env_convert(env, path, data, NULL, NULL, &error);  
    14591459        fail_unless(error == NULL, NULL); 
    14601460        fail_unless(path != NULL, NULL); 
    14611461 
    … …  
    15281528 
    15291529        OSyncFormatConverterPath *path = NULL; 
    15301530        path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error); 
    1531         osync_format_env_convert(env, path, data, &error);  
     1531        osync_format_env_convert(env, path, data, NULL, NULL, &error);  
    15321532        fail_unless(error == NULL, NULL); 
    15331533 
    15341534        char *buf; 
    … …  
    15451545 
    15461546        path = NULL; 
    15471547        path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error); 
    1548         osync_format_env_convert(env, path, data, &error);  
     1548        osync_format_env_convert(env, path, data, NULL, NULL, &error);  
    15491549        fail_unless(error == NULL, NULL); 
    15501550        fail_unless(path != NULL, NULL); 
    15511551 
    … …  
    16761676        path = osync_format_env_find_path_with_detectors(env, data, format6, NULL, &error); 
    16771677        fail_unless(path != NULL, NULL); 
    16781678 
    1679         osync_format_env_convert(env, path, data, &error);  
     1679        osync_format_env_convert(env, path, data, NULL, NULL, &error);  
    16801680        fail_unless(error == NULL, NULL); 
    16811681 
    16821682        char *buf; 
    … …  
    16931693        path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error); 
    16941694        fail_unless(path != NULL, NULL); 
    16951695 
    1696         osync_format_env_convert(env, path, data, &error);  
     1696        osync_format_env_convert(env, path, data, NULL, NULL, &error);  
    16971697        fail_unless(error == NULL, NULL); 
    16981698 
    16991699        osync_data_get_data(data, &buf, &size); 
    … …  
    18011801        path = osync_format_env_find_path_with_detectors(env, data, format4, NULL, &error); 
    18021802        fail_unless(path != NULL, NULL); 
    18031803 
    1804         osync_format_env_convert(env, path, data, &error); 
     1804        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    18051805        fail_unless(error == NULL, NULL); 
    18061806 
    18071807        char *buf; 
    … …  
    18181818        path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error); 
    18191819        fail_unless(path != NULL, NULL); 
    18201820 
    1821         osync_format_env_convert(env, path, data, &error); 
     1821        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    18221822        fail_unless(error == NULL, NULL); 
    18231823 
    18241824        osync_data_get_data(data, &buf, &size); 
    … …  
    19231923        path = osync_format_env_find_path_with_detectors(env, data, format5, NULL, &error); 
    19241924        fail_unless(path != NULL, NULL); 
    19251925 
    1926         osync_format_env_convert(env, path, data, &error); 
     1926        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    19271927        fail_unless(error == NULL, NULL); 
    19281928 
    19291929        mark_point(); 
    … …  
    20302030        path = osync_format_env_find_path_formats_with_detectors(env, data, fmtlist, NULL, &error); 
    20312031        fail_unless(path != NULL, NULL); 
    20322032 
    2033         osync_format_env_convert(env, path, data, &error); 
     2033        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    20342034        fail_unless(error == NULL, NULL); 
    20352035 
    20362036        mark_point(); 
    … …  
    21392139        path = osync_format_env_find_path_formats_with_detectors(env, data, fmtlist, NULL, &error); 
    21402140        fail_unless(path != NULL, NULL); 
    21412141 
    2142         osync_format_env_convert(env, path, data, &error); 
     2142        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    21432143        fail_unless(error == NULL, NULL); 
    21442144 
    21452145        mark_point(); 
    … …  
    22212221        /* FIXME: clarify - this is really intended to fail?! If so deref error. */ 
    22222222        osync_error_unref(&error); 
    22232223 
    2224         //fail_unless(!osync_format_env_convert(env, path, data, &error), NULL); // path is supposed to be null and this function has an assert on path 
     2224        //fail_unless(!osync_format_env_convert(env, path, data, NULL, NULL, &error), NULL); // path is supposed to be null and this function has an assert on path 
    22252225} 
    22262226END_TEST 
    22272227 
    … …  
    22962296 
    22972297        mark_point(); 
    22982298 
    2299         osync_format_env_convert(env, path, data, &error); 
     2299        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    23002300        fail_unless(error == NULL, NULL); 
    23012301 
    23022302        osync_data_get_data(data, &buf, &size); 
    … …  
    23112311        path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error); 
    23122312        fail_unless(path != NULL, NULL); 
    23132313 
    2314         osync_format_env_convert(env, path, data, &error); 
     2314        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    23152315        fail_unless(error == NULL, NULL); 
    23162316 
    23172317        mark_point(); 
    … …  
    23322332        return FALSE; 
    23332333} 
    23342334 
    2335 static osync_bool convert_f1_to_f2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     2335static osync_bool convert_f1_to_f2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    23362336{ 
    23372337        fail_unless(!strcmp(input, "F1"), NULL); 
    23382338         
    … …  
    23422342        return TRUE; 
    23432343} 
    23442344 
    2345 static osync_bool convert_f2_to_f1(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     2345static osync_bool convert_f2_to_f1(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    23462346{ 
    23472347        fail_unless(!strcmp(input, "F2"), NULL); 
    23482348         
    … …  
    24212421 
    24222422        mark_point(); 
    24232423 
    2424         osync_format_env_convert(env, path, data, &error); 
     2424        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    24252425        fail_unless(error == NULL, NULL); 
    24262426 
    24272427        osync_data_get_data(data, &buf, &size); 
    … …  
    24362436        path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error); 
    24372437        fail_unless(path != NULL, NULL); 
    24382438 
    2439         osync_format_env_convert(env, path, data, &error); 
     2439        osync_format_env_convert(env, path, data, NULL, NULL, &error); 
    24402440        fail_unless(error == NULL, NULL); 
    24412441 
    24422442        mark_point(); 

  • tests/format-tests/check_converter.c

     
    55 
    66#include "opensync/format/opensync_converter_internals.h" 
    77 
    8 osync_bool converter_conv(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     8osync_bool converter_conv(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    99{ 
    1010        return TRUE; 
    1111} 
    … …  
    2727        g_free(data); 
    2828} 
    2929 
    30 osync_bool conv_format1_to_format2_const(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     30osync_bool conv_format1_to_format2_const(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    3131{ 
    3232        osync_assert(!strcmp(input, "format1")); 
    3333        osync_assert(inpsize == 8); 
    … …  
    4242        return TRUE; 
    4343} 
    4444 
    45 osync_bool decap_format1_to_format2_const(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     45osync_bool decap_format1_to_format2_const(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    4646{ 
    4747        testdata *data = (testdata *)input; 
    4848        *output = data->string1; 
    … …  
    5353        return TRUE; 
    5454} 
    5555 
    56 osync_bool encap_format1_to_format2_const(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     56osync_bool encap_format1_to_format2_const(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    5757{ 
    5858        osync_assert(!strcmp(input, "format1")); 
    5959        osync_assert(inpsize == 8); 
    … …  
    6868        return TRUE; 
    6969} 
    7070 
    71 osync_bool conv_format1_to_format2_dup(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     71osync_bool conv_format1_to_format2_dup(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    7272{ 
    7373        osync_assert(!strcmp(input, "format1")); 
    7474        osync_assert(inpsize == 8); 
    … …  
    8181        return TRUE; 
    8282} 
    8383 
    84 osync_bool decap_format1_to_format2_dup(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     84osync_bool decap_format1_to_format2_dup(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    8585{ 
    8686        osync_assert(!strncmp(input, "SHELL", 5)); 
    8787         
    … …  
    9393        return TRUE; 
    9494} 
    9595 
    96 osync_bool encap_format1_to_format2_dup(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     96osync_bool encap_format1_to_format2_dup(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    9797{ 
    9898        osync_assert(!strcmp(input, "format1")); 
    9999        osync_assert(inpsize == 8); 
    … …  
    319319        fail_unless(data != NULL, NULL); 
    320320        fail_unless(error == NULL, NULL); 
    321321         
    322         fail_unless(osync_converter_invoke(converter, data, NULL, &error) == TRUE, NULL); 
     322        fail_unless(osync_converter_invoke(converter, data, NULL, NULL, NULL, &error) == TRUE, NULL); 
    323323        fail_unless(error == NULL, NULL); 
    324324         
    325325        fail_unless(osync_data_get_objformat(data) == format2, NULL); 
    … …  
    391391        fail_unless(data != NULL, NULL); 
    392392        fail_unless(error == NULL, NULL); 
    393393         
    394         fail_unless(osync_converter_invoke(converter, data, "test", &error) == TRUE, NULL); 
     394        fail_unless(osync_converter_invoke(converter, data, "test", NULL, NULL, &error) == TRUE, NULL); 
    395395        fail_unless(error == NULL, NULL); 
    396396         
    397397        fail_unless(osync_data_get_objformat(data) == format2, NULL); 
    … …  
    434434        fail_unless(data != NULL, NULL); 
    435435        fail_unless(error == NULL, NULL); 
    436436         
    437         fail_unless(osync_converter_invoke(converter, data, "test", &error) == TRUE, NULL); 
     437        fail_unless(osync_converter_invoke(converter, data, "test", NULL, NULL, &error) == TRUE, NULL); 
    438438        fail_unless(error == NULL, NULL); 
    439439         
    440440        fail_unless(osync_data_get_objformat(data) == format2, NULL); 
    … …  
    477477        fail_unless(data != NULL, NULL); 
    478478        fail_unless(error == NULL, NULL); 
    479479         
    480         fail_unless(osync_converter_invoke(converter, data, "test", &error) == TRUE, NULL); 
     480        fail_unless(osync_converter_invoke(converter, data, "test", NULL, NULL, &error) == TRUE, NULL); 
    481481        fail_unless(error == NULL, NULL); 
    482482         
    483483        fail_unless(osync_data_get_objformat(data) == format2, NULL); 
    … …  
    519519        fail_unless(data != NULL, NULL); 
    520520        fail_unless(error == NULL, NULL); 
    521521         
    522         fail_unless(osync_converter_invoke(converter, data, "test", &error) == TRUE, NULL); 
     522        fail_unless(osync_converter_invoke(converter, data, "test", NULL, NULL, &error) == TRUE, NULL); 
    523523        fail_unless(error == NULL, NULL); 
    524524         
    525525        fail_unless(osync_data_get_objformat(data) == format2, NULL); 
    … …  
    564564        fail_unless(data != NULL, NULL); 
    565565        fail_unless(error == NULL, NULL); 
    566566         
    567         fail_unless(osync_converter_invoke(converter, data, "test", &error) == TRUE, NULL); 
     567        fail_unless(osync_converter_invoke(converter, data, "test", NULL, NULL, &error) == TRUE, NULL); 
    568568        fail_unless(error == NULL, NULL); 
    569569         
    570570        fail_unless(osync_data_get_objformat(data) == format2, NULL); 
    … …  
    607607        fail_unless(data != NULL, NULL); 
    608608        fail_unless(error == NULL, NULL); 
    609609         
    610         fail_unless(osync_converter_invoke(converter, data, "test", &error) == TRUE, NULL); 
     610        fail_unless(osync_converter_invoke(converter, data, "test", NULL, NULL, &error) == TRUE, NULL); 
    611611        fail_unless(error == NULL, NULL); 
    612612         
    613613        fail_unless(osync_data_get_objformat(data) == format2, NULL); 

  • tests/format-tests/check_format_env.c

     
    119119} 
    120120END_TEST 
    121121 
    122 osync_bool convert_func(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error) 
     122osync_bool convert_func(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, OSyncCapabilities *caps, const char *archived_data, unsigned int archived_size, const char *config, void *userdata, OSyncError **error) 
    123123{ 
    124124        return TRUE; 
    125125} 

  • opensync.sym

     
    345345osync_objformat_set_copy_func 
    346346osync_objformat_set_create_func 
    347347osync_objformat_set_demarshal_func 
    348 osync_objformat_set_demerge_func 
    349348osync_objformat_set_destroy_func 
    350349osync_objformat_set_duplicate_func 
    351350osync_objformat_set_finalize_func 
    352351osync_objformat_set_initialize_func 
    353352osync_objformat_set_marshal_func 
    354 osync_objformat_set_merge_func 
    355353osync_objformat_set_print_func 
    356354osync_objformat_set_revision_func 
    357355osync_objformat_set_validate_func