void osync_plugin_info_unref(OSyncPluginInfo *info)
{
osync_assert(info);
if (g_atomic_int_dec_and_test(&(info->ref_count))) {
if (info->config)
osync_plugin_config_unref(info->config);
if (info->configdir)
osync_free(info->configdir);
if (info->groupname)
osync_free(info->groupname);
while (info->objtype_sinks) {
OSyncObjTypeSink *sink = info->objtype_sinks->data;
osync_objtype_sink_unref(sink);
info->objtype_sinks = osync_list_remove(info->objtype_sinks, sink);
}
if (info->main_sink)
osync_objtype_sink_unref(info->main_sink);
if (info->version)
osync_version_unref(info->version);
if (info->capabilities)
osync_capabilities_unref(info->capabilities);
if (info->formatenv)
osync_format_env_unref(info->formatenv);
osync_free(info);
}
}
/* Here we actually tell opensync which sinks are available. */
static osync_bool discover(void *userdata, OSyncPluginInfo *info, OSyncError **error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, userdata, info, error);
// plugin_environment *env = (plugin_environment *)userdata;
// Report avaliable sinks...
OSyncObjTypeSink *sink = osync_plugin_info_find_objtype(info, "<objtype e.g. note>");
if (!sink) {
return FALSE;
}
osync_objtype_sink_set_available(sink, TRUE);
OSyncVersion *version = osync_version_new(error);
osync_version_set_plugin(version, "<your plugin-name>");
//osync_version_set_version(version, "version");
//osync_version_set_modelversion(version, "version");
//osync_version_set_firmwareversion(version, "firmwareversion");
//osync_version_set_softwareversion(version, "softwareversion");
//osync_version_set_hardwareversion(version, "hardwareversion");
osync_plugin_info_set_version(info, version);
osync_version_unref(version);
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
}
void osync_plugin_info_set_version(OSyncPluginInfo *info, OSyncVersion *version)
{
osync_assert(info);
osync_assert(version);
if(info->version)
osync_version_unref(info->version);
osync_version_ref(version);
info->version = version;
}
/* Here we actually tell opensync which sinks are available. For this plugin, we
* go through the list of directories and enable all, since all have been configured */
static osync_bool mock_discover(OSyncPluginInfo *info, void *data, OSyncError **error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, error);
OSyncPluginConfig *config = osync_plugin_info_get_config(info);
osync_assert_msg(config, "No OSyncPluginConfig set for mock_discover!");
/*
OSyncFormatEnv *formatenv = osync_plugin_info_get_format_env(info);
osync_assert_msg(config, "No OSyncFormatEnv set for mock_discover!");
*/
OSyncList *r = osync_plugin_config_get_resources(config);
for (; r; r = r->next) {
OSyncPluginResource *res = r->data;
OSyncObjTypeSink *sink;
const char *objtype = osync_plugin_resource_get_objtype(res);
/* Check for ObjType sink */
if ((sink = osync_plugin_info_find_objtype(info, objtype)))
osync_objtype_sink_set_available(sink, TRUE);
}
OSyncVersion *version = osync_version_new(error);
osync_version_set_plugin(version, "mock-sync");
//osync_version_set_vendor(version, "version");
//osync_version_set_modelversion(version, "version");
//osync_version_set_firmwareversion(version, "firmwareversion");
//osync_version_set_softwareversion(version, "softwareversion");
//osync_version_set_hardwareversion(version, "hardwareversion");
osync_plugin_info_set_version(info, version);
osync_version_unref(version);
/* we can set here the capabilities, but for the file-sync
* plugin they are static and shipped with opensync */
if (mock_get_error(info->memberid, "MOCK_DISCOVER_ERROR")) {
osync_error_set(error, OSYNC_ERROR_EXPECTED, "MOCK_DISCOVER_ERROR on purpose!");
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return FALSE;
}
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
}
static osync_bool discover(OSyncPluginInfo *info, void *data, OSyncError **error)
{
printf("[EXTERNAL-DEMO]: %s\n", __func__);
OSyncList *s, *sinks = osync_plugin_info_get_objtype_sinks(info);
for (s = sinks; s; s = s->next) {
OSyncObjTypeSink *sink = (OSyncObjTypeSink *) s->data;
osync_objtype_sink_set_available(sink, TRUE);
}
osync_list_free(sinks);
OSyncVersion *version = osync_version_new(error);
osync_version_set_plugin(version, "external-demo");
osync_plugin_info_set_version(info, version);
osync_version_unref(version);
return TRUE;
}
END_TEST
START_TEST (version_load_from_descriptions)
{
char *testbed = setup_testbed(NULL);
OSyncError *error = NULL;
OSyncList *versions = osync_version_load_from_descriptions(&error, testbed, testbed);
//fail_unless(versions != NULL, NULL);
fail_unless(error == NULL, NULL);
OSyncList *cur = osync_list_first(versions);
while(cur) {
osync_version_unref(cur->data);
cur = cur->next;
}
osync_list_free(versions);
destroy_testbed(testbed);
}
OSyncList *osync_version_load_from_descriptions(OSyncError **error, const char *descriptiondir, const char *schemadir)
{
GDir *dir = NULL;
GError *gerror = NULL;
const char *descpath = descriptiondir ? descriptiondir : OPENSYNC_DESCRIPTIONSDIR;
const char *schemapath = schemadir ? schemadir : OPENSYNC_SCHEMASDIR;
char *filename = NULL;
const gchar *de = NULL;
OSyncList *versions = NULL;
OSyncVersion *version = NULL;
xmlDocPtr doc;
xmlNodePtr root;
xmlNodePtr cur;
xmlNodePtr child;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
dir = g_dir_open(descpath, 0, &gerror);
if (!dir) {
/* If description directory doesn't exist (e.g. unittests), just ignore this. */
osync_trace(TRACE_EXIT, "Unable to open directory %s: %s", descpath, gerror->message);
g_error_free(gerror);
return NULL;
}
while ((de = g_dir_read_name(dir))) {
char *schemafilepath = NULL;
osync_bool res;
filename = osync_strdup_printf ("%s%c%s", descpath, G_DIR_SEPARATOR, de);
if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR) || !g_pattern_match_simple("*.xml", filename)) {
osync_free(filename);
continue;
}
doc = xmlReadFile(filename, NULL, XML_PARSE_NOBLANKS);
if(!doc) {
osync_free(filename);
continue;
}
osync_free(filename);
root = xmlDocGetRootElement(doc);
if(!root || !xmlStrEqual(root->name, BAD_CAST "versions")) {
osync_xml_free_doc(doc);
continue;
}
schemafilepath = osync_strdup_printf("%s%c%s", schemapath, G_DIR_SEPARATOR, "descriptions.xsd");
res = osync_xml_validate_document(doc, schemafilepath);
osync_free(schemafilepath);
if(res == FALSE) {
osync_xml_free_doc(doc);
continue;
}
cur = root->children;
for(; cur != NULL; cur = cur->next) {
version = osync_version_new(error);
if(!version) {
OSyncList *cur = NULL;
osync_xml_free_doc(doc);
cur = osync_list_first(versions);
while(cur) {
osync_version_unref(cur->data);
cur = cur->next;
}
goto error;
}
child = cur->children;
osync_version_set_plugin(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_priority(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_vendor(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_modelversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_firmwareversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_softwareversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_hardwareversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_identifier(version, (const char *)osync_xml_node_get_content(child));
versions = osync_list_append(versions, version);
}
osync_xml_free_doc(doc);
}
g_dir_close(dir);
osync_trace(TRACE_EXIT, "%s: %p", __func__, versions);
return versions;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
OSyncCapabilities *osync_version_find_capabilities(OSyncVersion *version, OSyncError **error)
{
int priority = -1;
OSyncVersion *winner = NULL;
OSyncCapabilities *capabilities = NULL;
OSyncList *versions = NULL;
OSyncList *cur = NULL;
osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, version, error);
osync_assert(version);
versions = osync_version_load_from_default_descriptions(error);
if (*error) /* versions can be null */
goto error;
cur = osync_list_first(versions);
while(cur) {
int curpriority = osync_version_matches(cur->data, version, error);
if (curpriority == -1) {
if (versions)
osync_list_free(versions);
if (winner)
osync_version_unref(winner);
goto error;
}
if( curpriority > 0 && curpriority > priority) {
if(winner)
osync_version_unref(winner);
winner = cur->data;
osync_version_ref(winner);
priority = curpriority;
}
osync_version_unref(cur->data);
cur = cur->next;
}
osync_list_free(versions);
/* we found or own capabilities */
if(priority > 0)
{
osync_trace(TRACE_INTERNAL, "Found capabilities file by version: %s ", (const char*)osync_version_get_identifier(winner));
capabilities = osync_capabilities_load_identifier((const char*)osync_version_get_identifier(winner), error);
osync_version_unref(winner);
if (!capabilities)
goto error;
}
osync_trace(TRACE_EXIT, "%s: %p", __func__, capabilities);
return capabilities;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}