static void connect(void *userdata, OSyncPluginInfo *info, OSyncContext *ctx)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, userdata, info, ctx);
//Each time you get passed a context (which is used to track
//calls to your plugin) you can get the data your returned in
//initialize via this call:
// plugin_environment *env = (plugin_environment *)userdata;
//The sink specific userdata you can get with this calls:
OSyncObjTypeSink *sink = osync_plugin_info_get_sink(info);
sink_environment *sinkenv = osync_objtype_sink_get_userdata(sink);
OSyncError *error = NULL;
/*
* Now connect to your devices and report
*
* an error via:
* osync_context_report_error(ctx, ERROR_CODE, "Some message");
*
* or success via:
* osync_context_report_success(ctx);
*
* You have to use one of these 2 somewhere to answer the context.
*
*/
//If you need a hashtable you make it here
char *tablepath = osync_strdup_printf("%s/hashtable.db", osync_plugin_info_get_configdir(info));
sinkenv->hashtable = osync_hashtable_new(tablepath, osync_objtype_sink_get_name(sink), &error);
osync_free(tablepath);
if (!sinkenv->hashtable)
goto error;
//you can also use the anchor system to detect a device reset
//or some parameter change here. Check the docs to see how it works
char *lanchor = NULL;
//Now you get the last stored anchor from the device
char *anchorpath = osync_strdup_printf("%s/anchor.db", osync_plugin_info_get_configdir(info));
if (!osync_anchor_compare(anchorpath, "lanchor", lanchor))
osync_objtype_sink_set_slowsync(sink, TRUE);
osync_free(anchorpath);
osync_context_report_success(ctx);
osync_trace(TRACE_EXIT, "%s", __func__);
return;
error:
osync_context_report_osyncerror(ctx, error);
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&error));
osync_error_unref(&error);
}
OSyncHashTable *hashtable_load(const char *path, const char *objtype, unsigned int entries)
{
OSyncError *error = NULL;
OSyncHashTable *table = osync_hashtable_new(path, objtype, NULL, &error);
fail_unless(table != NULL, NULL);
fail_unless(error == NULL, NULL);
fail_unless(osync_hashtable_load(table, &error), NULL);
fail_unless(osync_hashtable_num_entries(table) == entries, NULL);
return table;
}
static void dump_hash(OSyncGroupEnv *env, const char *objtype, const char *groupname, char *memberid)
{
OSyncGroup *group = osync_group_env_find_group(env, groupname);
#if 0 /* Unused */
OSyncError *error = NULL;
long long int id = 0;
OSyncMember *member = NULL;
char *path = NULL;
OSyncHashTable *table = NULL;
#endif
if (!group) {
printf("Unable to find group with name \"%s\"\n", groupname);
return;
}
printf("Dumping hashtable is currently not implemented!\n");
return;
/* FIXME: public interface osync_hashltable_new() is gone!
* no interface to access the disk directly!
* */
#if 0
id = atoi(memberid);
member = osync_group_find_member(group, id);
if (!member) {
printf("Unable to find member with id %s\n", memberid);
return;
}
path = g_strdup_printf("%s/hashtable.db", osync_member_get_configdir(member));
table = osync_hashtable_new(path, objtype, &error);
if (!table)
goto error;
g_free(path);
if (!osync_hashtable_load(table, &error))
goto error;
osync_hashtable_foreach(table, print_hashtable, NULL);
osync_hashtable_unref(table);
error:
printf("ERROR: %s", osync_error_print(&error));
osync_error_unref(&error);
#endif
}
static osync_bool check_hashtables(OSyncEngine *engine)
{
GList *m;
for (m = members; m; m = m->next) {
member_info *meminfo = m->data;
OSyncHashTable *table = osync_hashtable_new();
osync_hashtable_load(table, meminfo->member, NULL);
/*if (osync_hashtable_num_entries(table) != g_list_length(meminfo->changes)) {
printf("Hashtable for member %i has wrong number %i compared to %i\n", osync_member_get_id(meminfo->member), osync_hashtable_num_entries(table), g_list_length(meminfo->changes));
abort();
}*/
printf("hashtable %p\n", table);
if (osync_hashtable_num_entries(table) && g_list_length(engine->maptable->mappings) != osync_hashtable_num_entries(table)) {
printf("Number of mappings do not match hastable for member %lli, %i compared to %i\n", osync_member_get_id(meminfo->member), g_list_length(engine->maptable->mappings), osync_hashtable_num_entries(table));
return FALSE;
}
osync_hashtable_close(table);
}
return TRUE;
}
static void dump_hash(OSyncGroupEnv *env, const char *objtype, const char *groupname, char *memberid)
{
OSyncError *error = NULL;
OSyncGroup *group = osync_group_env_find_group(env, groupname);
long long int id = 0;
OSyncMember *member = NULL;
char *path = NULL;
OSyncHashTable *table = NULL;
if (!group) {
printf("Unable to find group with name \"%s\"\n", groupname);
return;
}
id = atoi(memberid);
member = osync_group_find_member(group, id);
if (!member) {
printf("Unable to find member with id %s\n", memberid);
return;
}
path = g_strdup_printf("%s/hashtable.db", osync_member_get_configdir(member));
table = osync_hashtable_new(path, objtype, &error);
if (!table)
goto error;
g_free(path);
osync_hashtable_foreach(table, print_hashtable, NULL);
osync_hashtable_unref(table);
return;
error:
printf("ERROR: %s", osync_error_print(&error));
osync_error_unref(&error);
}
END_TEST
START_TEST (hashtable_reload)
{
OSyncError *error = NULL;
char *testbed = setup_testbed(NULL);
osync_bool new_hashtable = FALSE;
reset_hashtable_counters();
char *hashpath = g_strdup_printf("%s%chashtable.db", testbed, G_DIR_SEPARATOR);
OSyncHashTable *table = osync_hashtable_new(hashpath, "contact", &new_hashtable, &error);
fail_unless(!error, NULL);
fail_unless(table != NULL, NULL);
fail_unless(new_hashtable != FALSE, NULL); /* Expecting a new/fresh hastable */
/***** load */
fail_unless(osync_hashtable_load(table, &error), NULL);
OSyncChange *fakechange = osync_change_new(&error);
osync_change_set_uid(fakechange, "test1");
char *rndhash = osync_rand_str(g_random_int_range(100, 200), &error);
osync_assert(error == NULL);
osync_change_set_hash(fakechange, rndhash);
osync_change_set_changetype(fakechange, OSYNC_CHANGE_TYPE_ADDED);
osync_hashtable_update_change(table, fakechange);
osync_change_unref(fakechange);
/*** store - commit hashtable */
fail_unless(osync_hashtable_save(table, &error), NULL);
fail_unless(!error, NULL);
osync_hashtable_unref(table);
table = NULL;
/** reload the hashtable */
OSyncHashTable *newtable = osync_hashtable_new(hashpath, "contact", &new_hashtable, &error);
fail_unless(!error, NULL);
fail_unless(newtable != NULL, NULL);
fail_unless(new_hashtable != TRUE, NULL); /* We expect here no new hashtable */
/* 0 entries - since not loaded! */
fail_unless(osync_hashtable_num_entries(newtable) == 0, NULL);
/* load and count and compare hashs */
fail_unless(osync_hashtable_load(newtable, &error), NULL);
fail_unless(osync_hashtable_num_entries(newtable) == 1, NULL);
const char *newhash = osync_hashtable_get_hash(newtable, "test1");
fail_unless(newhash != NULL, NULL);
fail_unless(!strcmp(newhash, rndhash), NULL);
g_free(rndhash);
g_free(hashpath);
destroy_testbed(testbed);
}
static void *initialize(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **error)
{
/*
* get the config
*/
OSyncPluginConfig *config = osync_plugin_info_get_config(info);
if (!config) {
osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to get config.");
goto error;
}
/*
* You need to specify the <some name>_environment somewhere with
* all the members you need
*/
plugin_environment *env = osync_try_malloc0(sizeof(plugin_environment), error);
if (!env)
goto error;
env->sink_envs = NULL;
osync_trace(TRACE_INTERNAL, "The config: %s", osync_plugin_info_get_config(info));
/*
* Process the config here and set the options on your environment
*/
/*
* Process plugin specific advanced options
*/
OSyncList *optslist = osync_plugin_config_get_advancedoptions(config);
for (; optslist; optslist = optslist->next) {
OSyncPluginAdvancedOption *option = optslist->data;
const char *val = osync_plugin_advancedoption_get_value(option);
const char *name = osync_plugin_advancedoption_get_name(option);
if (!strcmp(name,"<your-option>")) {
if (!strcmp(val, "<your-value>")) {
/*
* set a varaible to a specific value
*/;
}
}
}
/*
* Process Ressource options
*/
int i, numobjs = osync_plugin_info_num_objtypes(info);
for (i = 0; i < numobjs; i++) {
sink_environment *sinkenv = osync_try_malloc0(sizeof(sink_environment), error);
if (!sinkenv)
goto error_free_env;
sinkenv->sink = osync_plugin_info_nth_objtype(info, i);
osync_assert(sinkenv->sink);
const char *objtype = osync_objtype_sink_get_name(sinkenv->sink);
OSyncPluginResource *res = osync_plugin_config_find_active_resource(config, objtype);
/* get objformat sinks */
OSyncList *s = osync_plugin_resource_get_objformat_sinks(res);
for (; s; s = s->next) {
OSyncObjFormatSink *fsink = s->data; // there could be only one sink
const char *objformat = osync_objformat_sink_get_objformat(fsink);
osync_assert(objformat);
osync_trace(TRACE_INTERNAL, "objtype %s has objformat %s", objtype, objformat);
}
/* Every sink can have different functions ... */
OSyncObjTypeSinkFunctions functions;
memset(&functions, 0, sizeof(functions));
functions.connect = connect;
functions.disconnect = disconnect;
functions.get_changes = get_changes;
functions.commit = commit_change;
functions.sync_done = sync_done;
/* We pass the OSyncFileDir object to the sink, so we dont have to look it up
* again once the functions are called */
osync_objtype_sink_set_functions(sinkenv->sink, functions, sinkenv);
osync_trace(TRACE_INTERNAL, "The configdir: %s", osync_plugin_info_get_configdir(info));
char *tablepath = osync_strdup_printf("%s/hashtable.db", osync_plugin_info_get_configdir(info));
sinkenv->hashtable = osync_hashtable_new(tablepath, objtype, error);
osync_free(tablepath);
env->sink_envs = osync_list_append(env->sink_envs, sinkenv);
}
//Now your return your struct.
return (void *) env;
error_free_env:
free_env(env);
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
