Changeset 3299

Show
Ignore:
Timestamp:
04/27/08 15:51:24 (3 months ago)
Author:
dgollub
Message:

Ported file-sync to new hashtable API.

Quick porting description:

1. osync_hashtable_free() -> osync_hashtable_unref()
2. add osync_hashtable_load() in plugin initialize function, right

after osync_hashtable_new()

3. remove osync_hashtable_report() and osync_hashtable_reset_reports(),

they're deprecated.

4. osync_hashtable_update_hash() -> osync_hashtable_update_change()

Parameter list now takes just the hashtable object and the change
object.

5. Order functions in get_changes() plugin function so

osync_hashtable_update_change() get called with the new OSyncChange, when
the change entry got uid, hash and changetype set.

6. Make sure osync_hashtable_update_change() get called for every entry.

Don't skip this call, even if the changetype is UNMODIFIED.

7. osync_hashtable_get_deleted() returns now instead of a char* array,

an OSyncList. The entries are (const char*) strings which store the
UID. No need to free the UIDs.

8. Iterate over the list like this:

OSyncList *u, *uids = osync_hashtable_get_deleted(YourHashtable?);
for (u = uids; u; u = u->next) {

const char *uid = u->data;
...

}
osync_list_free(uids);
...

9. Call osync_hashtable_save() in your sync_done() function.
10. Test your plugin :)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • plugins/file-sync/src/file_sync.c

    r3157 r3299  
    3939 
    4040        if (dir->hashtable) 
    41                 osync_hashtable_free(dir->hashtable); 
     41                osync_hashtable_unref(dir->hashtable); 
    4242 
    4343        g_free(dir); 
     
    452452                        relative_filename = g_build_filename(subdir, de, NULL); 
    453453                         
    454                 osync_hashtable_report(directory->hashtable, relative_filename); 
    455454                osync_trace(TRACE_INTERNAL, "path2 %s %s", filename, relative_filename); 
    456455                 
     
    463462                        struct stat buf; 
    464463                        stat(filename, &buf); 
    465                         char *hash = osync_filesync_generate_hash(&buf); 
    466                          
    467  
    468                         OSyncChangeType type = osync_hashtable_get_changetype(directory->hashtable, relative_filename, hash); 
    469                         if (type == OSYNC_CHANGE_TYPE_UNMODIFIED) { 
    470                                 g_free(hash); 
    471                                 g_free(filename); 
    472                                 g_free(relative_filename); 
    473                                 continue; 
    474                         } 
    475                         osync_hashtable_update_hash(directory->hashtable, type, relative_filename, hash); 
    476464 
    477465                        /* Report normal files */ 
     
    480468                                osync_context_report_osyncwarning(ctx, error); 
    481469                                osync_error_unref(&error); 
    482                                 g_free(hash); 
    483                                 g_free(filename); 
    484470                                g_free(relative_filename); 
    485471                                continue; 
    486472                        } 
    487                          
     473 
    488474                        osync_change_set_uid(change, relative_filename); 
     475 
     476                        char *hash = osync_filesync_generate_hash(&buf); 
    489477                        osync_change_set_hash(change, hash); 
     478                        g_free(hash); 
     479 
     480                        OSyncChangeType type = osync_hashtable_get_changetype(directory->hashtable, change); 
    490481                        osync_change_set_changetype(change, type); 
    491482 
    492                         g_free(hash); 
    493                          
     483                        osync_hashtable_update_change(directory->hashtable, change); 
     484 
     485                        if (type == OSYNC_CHANGE_TYPE_UNMODIFIED) { 
     486                                g_free(filename); 
     487                                g_free(relative_filename); 
     488                                osync_change_unref(change); 
     489                                continue; 
     490                        } 
    494491 
    495492                        char *data; 
     
    501498                                osync_error_unref(&error); 
    502499                                g_free(filename); 
     500                                g_free(relative_filename); 
    503501                                continue; 
    504502                        } 
     
    516514                                        osync_error_unref(&error); 
    517515                                        g_free(data); 
     516                                        g_free(filename); 
     517                                        g_free(relative_filename); 
     518 
    518519                                        continue; 
    519520                                } 
     
    541542                                        osync_error_unref(&error); 
    542543                                        g_free(data); 
     544                                        g_free(filename); 
     545                                        g_free(relative_filename); 
     546                                        g_free(file->path); 
    543547                                        continue; 
    544548                                } 
     
    575579 
    576580         
    577         osync_hashtable_reset_reports(dir->hashtable); 
    578581        if (osync_objtype_sink_get_slowsync(dir->sink)) { 
    579582                osync_trace(TRACE_INTERNAL, "Slow sync requested"); 
     
    591594        osync_filesync_report_dir(dir, info, NULL, ctx); 
    592595         
    593         char **uids = osync_hashtable_get_deleted(dir->hashtable); 
    594         for (i = 0; uids[i]; i++) { 
     596        OSyncList *u, *uids = osync_hashtable_get_deleted(dir->hashtable); 
     597        for (u = uids; uids; u = u->next) { 
    595598                OSyncChange *change = osync_change_new(&error); 
    596599                if (!change) { 
    597                         g_free(uids[i]); 
    598600                        osync_context_report_osyncwarning(ctx, error); 
    599601                        osync_error_unref(&error); 
     
    601603                } 
    602604                 
    603                 osync_change_set_uid(change, uids[i]); 
     605                const char *uid = u->data; 
     606                osync_change_set_uid(change, uid); 
    604607                osync_change_set_changetype(change, OSYNC_CHANGE_TYPE_DELETED); 
    605608                 
    606609                OSyncData *odata = osync_data_new(NULL, 0, dir->objformat_output, &error); 
    607610                if (!odata) { 
    608                         g_free(uids[i]); 
    609611                        osync_change_unref(change); 
    610612                        osync_context_report_osyncwarning(ctx, error); 
     
    619621                osync_context_report_change(ctx, change); 
    620622                 
    621                 osync_hashtable_update_hash(dir->hashtable, osync_change_get_changetype(change), osync_change_get_uid(change), NULL); 
     623                osync_hashtable_update_change(dir->hashtable, change); 
    622624         
    623625                osync_change_unref(change); 
    624                 g_free(uids[i]); 
    625         } 
    626         g_free(uids); 
     626        } 
     627        osync_list_free(uids); 
    627628         
    628629        osync_context_report_success(ctx); 
     
    653654        g_free(filename); 
    654655 
    655         osync_hashtable_update_hash(dir->hashtable, osync_change_get_changetype(change), osync_change_get_uid(change), hash); 
     656        osync_hashtable_update_change(dir->hashtable, change); 
    656657        g_free(hash); 
    657658         
     
    664665{ 
    665666        osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, ctx); 
     667 
     668        OSyncError *error = NULL; 
     669 
    666670        OSyncObjTypeSink *sink = osync_plugin_info_get_sink(info); 
    667671        OSyncFileDir *dir = osync_objtype_sink_get_userdata(sink); 
     
    672676        g_free(anchorpath); 
    673677        g_free(path_field); 
     678 
     679        if (!osync_hashtable_save(dir->hashtable, &error)) 
     680                goto error; 
    674681         
    675682        osync_context_report_success(ctx); 
    676683         
    677684        osync_trace(TRACE_EXIT, "%s", __func__); 
     685        return; 
     686 
     687error: 
     688        osync_context_report_osyncerror(ctx, error); 
     689        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&error)); 
     690        osync_error_unref(&error); 
     691        return; 
    678692} 
    679693 
     
    746760                        goto error_free_env; 
    747761 
     762                if (!osync_hashtable_load(dir->hashtable, error)) 
     763                        goto error_free_env; 
     764 
    748765                char *anchorpath = g_strdup_printf("%s/anchor.db", osync_plugin_info_get_configdir(info)); 
    749766                char *path_field = g_strdup_printf("path_%s", osync_objtype_sink_get_name(sink));