static void dump_map(OSyncGroupEnv *env, const char *groupname) { OSyncGroup *group = osync_group_env_find_group(env, groupname); int num_objtypes; if (!group) { printf("Unable to find group with name \"%s\"\n", groupname); return; } OSyncList *objtypes = osync_group_get_objtypes(group); num_objtypes = osync_list_length(objtypes); if (num_objtypes == 0) { printf("Group has no objtypes. Have the objtypes already been discovered?\n"); return; } OSyncList *o; for (o = objtypes; o; o = o->next) { const char *objtype = (char *) o->data; printf("Mappings for objtype \"%s\":\n", objtype); dump_map_objtype(env, objtype, groupname); } osync_list_free(objtypes); }
OSyncFormatConverterPath *osync_format_env_find_path_formats_with_detectors(OSyncFormatEnv *env, OSyncData *sourcedata, OSyncList *targets, const char *preferred_format, OSyncError **error) { OSyncFormatConverterPath *path = NULL; GString *string = g_string_new(""); OSyncList *t; guint size = osync_list_length(targets); guint count = 0; for (t = targets; t; t = t->next) { OSyncObjFormatSink *format_sink = t->data; count ++; g_string_append(string, osync_objformat_sink_get_objformat(format_sink)); if (size > 1 && count < size) g_string_append(string, " - "); } osync_trace(TRACE_ENTRY, "%s(%p, %p, %p:%s, %s, %p)", __func__, env, sourcedata, targets, string->str, preferred_format ? preferred_format:"NONE", error); g_string_free(string, TRUE); path = osync_format_env_find_path_fn(env, sourcedata, osync_format_converter_path_vertice_target_fn_format_sinks, osync_format_converter_tree_target_fn_format_sinks_reached_lastconverter, targets, preferred_format, error); if (!path) { osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return NULL; } osync_trace(TRACE_EXIT, "%s: %p", __func__, path); return path; }
int main(int argc, char *argv[]) { OSyncList *groups, *g; int i = 0; osync_bool couldloadgroups; OSyncGroup *group = NULL; OSyncGroupEnv *groupenv = NULL; groupenv = osync_group_env_new(NULL); /* load groups from default dir */ couldloadgroups = osync_group_env_load_groups(groupenv, NULL, NULL); if ( !couldloadgroups ) { /* print error */ printf("Could not load groups."); return -1; } groups = osync_group_env_get_groups(groupenv); printf("found %i groups\n", osync_list_length(groups)); for (g = groups; g; g = g->next) { group = (OSyncGroup *) g->data; printf("group nr. %i is %s\n", i+1, osync_group_get_name(group)); } /* Free the list */ osync_list_free(groups); /* free env */ osync_group_env_unref(groupenv); return 0; }
/* In initialize, we get the config for the plugin. Here we also must register * all _possible_ objtype sinks. */ static void *mock_initialize(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **error) { osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, plugin, info, error); if (mock_get_error(info->memberid, "INIT_NULL_NOERROR")) { osync_trace(TRACE_EXIT, "%s: %s", __func__, "Everything is fine. I don't need plugin userdata."); return NULL; } if (mock_get_error(info->memberid, "INIT_NULL")) { osync_error_set(error, OSYNC_ERROR_EXPECTED, "Triggering INIT_NULL error"); osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return NULL; } mock_env *env = osync_try_malloc0(sizeof(mock_env), error); osync_assert(env); OSyncFormatEnv *formatenv = osync_plugin_info_get_format_env(info); osync_assert(formatenv); OSyncPluginConfig *config = osync_plugin_info_get_config(info); osync_assert(config); if (mock_get_error(info->memberid, "MAINSINK_CONNECT")) { env->mainsink = osync_objtype_main_sink_new(error); osync_objtype_sink_set_connect_func(env->mainsink, mock_connect); osync_objtype_sink_set_disconnect_func(env->mainsink, mock_mainsink_disconnect); osync_objtype_sink_set_userdata(env->mainsink, env); osync_plugin_info_set_main_sink(info, env->mainsink); } /* Now we register the objtypes that we can sync. This plugin is special. It can * synchronize any objtype we configure it to sync and where a conversion * path to the file format can be found */ OSyncList *objtypesinks = osync_plugin_info_get_objtype_sinks(info); OSyncList *list = NULL; for (list = objtypesinks;list; list = list->next) { MockDir *dir = osync_try_malloc0(sizeof(MockDir), error); osync_assert(dir); dir->committed_all = TRUE; OSyncObjTypeSink *sink = (OSyncObjTypeSink*)list->data; osync_assert(sink); const char *objtype = osync_objtype_sink_get_name(sink); dir->res = osync_plugin_config_find_active_resource(config, objtype); osync_plugin_resource_ref(dir->res); dir->path = osync_plugin_resource_get_path(dir->res); osync_assert(dir->path); OSyncList *format_sinks = osync_plugin_resource_get_objformat_sinks(dir->res); osync_assert(osync_list_length(format_sinks) == 1); OSyncObjFormatSink *format_sink = osync_list_nth_data(format_sinks, 0); const char *objformat_str = osync_objformat_sink_get_objformat(format_sink); osync_assert(objformat_str); dir->objformat = osync_format_env_find_objformat(formatenv, objformat_str); osync_assert(dir->objformat); osync_objformat_ref(dir->objformat); osync_list_free(format_sinks); /* const char *objformat = osync_objformat_get_name(dir->objformat); OSyncObjFormatSink *format_sink = osync_objformat_sink_new(objformat, error); if (!format_sink) return NULL; osync_objtype_sink_add_objformat_sink(sink, format_sink); */ /* Sanity check for connect_done */ dir->connect_done = TRUE; if (!mock_get_error(info->memberid, "MAINSINK_CONNECT")) { osync_objtype_sink_set_connect_func(sink, mock_connect); osync_objtype_sink_set_connect_done_func(sink, mock_connect_done); osync_objtype_sink_set_disconnect_func(sink, mock_disconnect); } osync_objtype_sink_set_get_changes_func(sink, mock_get_changes); osync_objtype_sink_set_committed_all_func(sink, mock_committed_all); osync_objtype_sink_set_commit_func(sink, mock_commit_change); osync_objtype_sink_set_read_func(sink, mock_read); osync_objtype_sink_set_sync_done_func(sink, mock_sync_done); /* We pass the MockDir object to the sink, so we dont have to look it up * again once the functions are called */ osync_objtype_sink_set_userdata(sink, dir); /* Request an Anchor */ osync_objtype_sink_enable_state_db(sink, TRUE); /* Request an Hashtable */ osync_objtype_sink_enable_hashtable(sink, TRUE); //Lets reduce the timeouts a bit so the checks work faster osync_objtype_sink_set_connect_timeout(sink, 2); osync_objtype_sink_set_getchanges_timeout(sink, 2); osync_objtype_sink_set_commit_timeout(sink, 4); osync_objtype_sink_set_committedall_timeout(sink, 4); osync_objtype_sink_set_syncdone_timeout(sink, 2); osync_objtype_sink_set_disconnect_timeout(sink, 2); osync_objtype_sink_set_read_timeout(sink, 2); /* XXX No testcase is currently using this at all! */ #if 0 if (g_getenv("NO_TIMEOUTS")) { /* XXX Timeout value of wouldn't work out, since the Sink object would fallback to the default timeout value: sink->timeout.connect ? sink->timeout.connect : OSYNC_SINK_TIMEOUT_CONNECT; Really needed?! */ osync_objtype_sink_set_connect_timeout(sink, 0); osync_objtype_sink_set_getchanges_timeout(sink, 0); osync_objtype_sink_set_commit_timeout(sink, 0); osync_objtype_sink_set_committedall_timeout(sink, 0); osync_objtype_sink_set_syncdone_timeout(sink, 0); osync_objtype_sink_set_disconnect_timeout(sink, 0); osync_objtype_sink_set_read_timeout(sink, 0); } /* What is meant by this?! Maybe OSyncPlugin.useable?! Not used at all... if (g_getenv("IS_AVAILABLE")) info->functions.is_available = mock_is_available; */ #endif env->directories = g_list_append(env->directories, dir); } osync_list_free(objtypesinks); osync_trace(TRACE_EXIT, "%s: %p", __func__, env); return (void *)env; }