osync_bool osync_obj_engine_map_changes(OSyncObjEngine *engine, OSyncError **error)
{
OSyncMappingEngine *mapping_engine = NULL;
GList *new_mappings = NULL, *v = NULL;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, engine);
//osync_trace_disable();
/* Go through all sink engines that are available */
for (v = engine->sink_engines; v; v = v->next) {
OSyncSinkEngine *sinkengine = v->data;
/* We use a temp list to speed things up. We dont have to compare with newly created mappings for
* the current sinkengine, since there will be only one entry (for the current sinkengine) so there
* is no need to compare */
new_mappings = NULL;
/* For each sinkengine, go through all unmapped changes */
while (sinkengine->unmapped) {
OSyncChange *change = sinkengine->unmapped->data;
OSyncConvCmpResult result = 0;
OSyncMappingEntryEngine *entry_engine = NULL;
osync_trace(TRACE_INTERNAL, "Looking for mapping for change %s, changetype %i from member %lli", osync_change_get_uid(change), osync_change_get_changetype(change), osync_member_get_id(osync_client_proxy_get_member(sinkengine->proxy)));
/* See if there is an exisiting mapping, which fits the unmapped change */
result = _osync_obj_engine_mapping_find(engine, change, sinkengine, &mapping_engine);
if (result == OSYNC_CONV_DATA_MISMATCH) {
/* If there is none, create one */
mapping_engine = _osync_obj_engine_create_mapping_engine(engine, error);
if (!mapping_engine)
goto error;
osync_trace(TRACE_INTERNAL, "Unable to find mapping. Creating new mapping with id %lli", osync_mapping_get_id(mapping_engine->mapping));
new_mappings = g_list_append(new_mappings, mapping_engine);
} else if (result == OSYNC_CONV_DATA_SIMILAR) {
mapping_engine->conflict = TRUE;
}
/* Update the entry which belongs to our sinkengine with the the change */
entry_engine = osync_mapping_engine_get_entry(mapping_engine, sinkengine);
osync_assert(entry_engine);
osync_entry_engine_update(entry_engine, change);
sinkengine->unmapped = g_list_remove(sinkengine->unmapped, sinkengine->unmapped->data);
osync_change_unref(change);
}
engine->mapping_engines = g_list_concat(engine->mapping_engines, new_mappings);
}
//osync_trace_enable();
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
error:
osync_trace_enable();
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return FALSE;
}
void osync_trace(OSyncTraceType type, const char *message, ...)
{
#ifdef OPENSYNC_TRACE
va_list arglist;
char *buffer = NULL;
int tabs = 0;
unsigned long int id = 0;
#ifdef _WIN32
int pid = 0;
char tmp_buf[1024];
#else
pid_t pid = 0;
#endif
char *logfile = NULL;
GString *tabstr = NULL;
int i = 0;
GTimeVal curtime;
char *logmessage = NULL;
GError *error = NULL;
GIOChannel *chan = NULL;
gsize writen;
const char *endline = NULL;
if (!g_thread_supported ()) g_thread_init (NULL);
if (!trace_disabled || !g_private_get(trace_disabled)) {
_osync_trace_init();
osync_trace_enable();
}
if (GPOINTER_TO_INT(g_private_get(trace_disabled)))
return;
if (!current_tabs)
current_tabs = g_private_new (NULL);
else
tabs = GPOINTER_TO_INT(g_private_get(current_tabs));
#ifdef _WIN32
pid = _getpid();
endline = "\r\n";
#else
pid = getpid();
endline = "\n";
#endif
id = (unsigned long int)g_thread_self();
logfile = g_strdup_printf("%s%cThread%lu-%i.log", trace, G_DIR_SEPARATOR, id, pid);
va_start(arglist, message);
#ifdef _WIN32
vsnprintf(tmp_buf, 1024, message, arglist);
buffer = g_strdup(tmp_buf);
#else
buffer = g_strdup_vprintf(message, arglist);
#endif
tabstr = g_string_new("");
for (i = 0; i < tabs; i++) {
tabstr = g_string_append(tabstr, "\t");
}
g_get_current_time(&curtime);
switch (type) {
case TRACE_ENTRY:
logmessage = g_strdup_printf("[%li.%06li]\t%s>>>>>>> %s%s", curtime.tv_sec, curtime.tv_usec, tabstr->str, buffer, endline);
tabs++;
break;
case TRACE_INTERNAL:
logmessage = g_strdup_printf("[%li.%06li]\t%s%s%s", curtime.tv_sec, curtime.tv_usec, tabstr->str, buffer, endline);
break;
case TRACE_SENSITIVE:
if (GPOINTER_TO_INT(g_private_get(trace_sensitive)))
logmessage = g_strdup_printf("[%li.%06li]\t%s[SENSITIVE] %s%s", curtime.tv_sec, curtime.tv_usec, tabstr->str, buffer, endline);
else
logmessage = g_strdup_printf("[%li.%06li]\t%s[SENSITIVE CONTENT HIDDEN]%s", curtime.tv_sec, curtime.tv_usec, tabstr->str, endline);
break;
case TRACE_EXIT:
logmessage = g_strdup_printf("[%li.%06li]%s<<<<<<< %s%s", curtime.tv_sec, curtime.tv_usec, tabstr->str, buffer, endline);
tabs--;
if (tabs < 0)
tabs = 0;
break;
case TRACE_EXIT_ERROR:
logmessage = g_strdup_printf("[%li.%06li]%s<--- ERROR --- %s%s", curtime.tv_sec, curtime.tv_usec, tabstr->str, buffer, endline);
tabs--;
if (tabs < 0)
tabs = 0;
if (print_stderr)
fprintf(stderr, "EXIT_ERROR: %s\n", buffer);
break;
case TRACE_ERROR:
logmessage = g_strdup_printf("[%li.%06li]%sERROR: %s%s", curtime.tv_sec, curtime.tv_usec, tabstr->str, buffer, endline);
if (print_stderr)
fprintf(stderr, "ERROR: %s\n", buffer);
break;
}
g_free(buffer);
g_private_set(current_tabs, GINT_TO_POINTER(tabs));
va_end(arglist);
g_string_free(tabstr, TRUE);
chan = g_io_channel_new_file(logfile, "a", &error);
if (!chan) {
printf("unable to open %s for writing: %s\n", logfile, error->message);
return;
}
g_io_channel_set_encoding(chan, NULL, NULL);
if (g_io_channel_write_chars(chan, logmessage, strlen(logmessage), &writen, NULL) != G_IO_STATUS_NORMAL) {
printf("unable to write trace to %s\n", logfile);
} else
g_io_channel_flush(chan, NULL);
g_io_channel_shutdown(chan, TRUE, NULL);
g_io_channel_unref(chan);
g_free(logmessage);
g_free(logfile);
#endif /* OPENSYNC_TRACE */
}
