Ejemplos de osengine_sync_and_block en C++ (Cpp)

Ejemplo n.º 1

Archivo: osynctest.c Proyecto: luizluca/opensync-luizluca

static void sync_now(OSyncEngine *engine)
{
	OSyncError *error = NULL;
	printf(".");
	fflush(stdout);

	if (!osengine_sync_and_block(engine, &error)) {
		printf("Error while starting synchronization: %s\n", osync_error_print(&error));
		osync_error_unref(&error);
		exit(1);
	}

	printf(".");
	fflush(stdout);
}

Ejemplo n.º 2

Archivo: osyncstress.c Proyecto: ianmartin/autoimportopensync

int main (int argc, char *argv[])
{
	int i;
	char *groupname = NULL;
	char *configdir = NULL;
	int num = -1;
	osync_bool failed = FALSE;
	osync_bool tryrecover = FALSE;
	OSyncError *error = NULL;
	OSyncEngine *engine = NULL;
	
	if (argc <= 1)
		usage (argv[0], 1);

	groupname = argv[1];
	for (i = 2; i < argc; i++) {
		char *arg = argv[i];
		if (!strcmp (arg, "--configdir")) {
			configdir = argv[i + 1];
			i++;
			if (!configdir)
				usage (argv[0], 1);
		} else if (!strcmp (arg, "--num")) {
			num = atoi(argv[i + 1]);
			i++;
			if (num <= 0)
				usage (argv[0], 1);
		} else if (!strcmp (arg, "--help")) {
			usage (argv[0], 0);
		} else if (!strcmp (arg, "--tryrecover")) {
			tryrecover = TRUE;
		} else if (!strcmp (arg, "--")) {
			break;
		} else if (arg[0] == '-') {
			usage (argv[0], 1);
		} else {
			usage (argv[0], 1);
		}
	}
	
	loop = g_main_loop_new(NULL, TRUE);	
	if (!g_thread_supported ()) g_thread_init (NULL);
	
	osync_trace(TRACE_ENTRY, "++++ Started the sync stress test +++");
	OSyncEnv *osync = osync_env_new(NULL);
	osync_env_set_option(osync, "GROUPS_DIRECTORY", configdir);
	
	if (!osync_env_initialize(osync, &error)) {
		printf("Unable to initialize environment: %s\n", osync_error_print(&error));
		osync_error_unref(&error);
		goto error_free_env;
	}
	
	OSyncGroup *group = osync_env_find_group(osync, groupname);
	
	if (!group) {
		printf("Unable to find group with name \"%s\"\n", groupname);
		goto error_free_env;
	}
	
	if (!g_thread_supported ()) g_thread_init (NULL);
	working = g_mutex_new();
	int count = 0;
	while (1) {
		engine = osengine_new(group, &error);
		if (!engine) {
			printf("Error while creating syncengine: %s\n", osync_error_print(&error));
			osync_error_unref(&error);
			goto error_free_env;
		}
		
		if (!osengine_init(engine, &error)) {
			printf("Error while initializing syncengine: %s\n", osync_error_print(&error));
			osync_error_unref(&error);
			goto error_free_engine;
		}
		
		do {
			count++;
			printf("++++++++++++++++++++++++++++++\n");
			printf("Initializing new round #%i!\n", count);
			
			if (g_random_int_range(0, 5) == 0) {
				int i;
				OSyncFormatEnv *env = osync_group_get_format_env(group);
				for (i = 0; i < osync_conv_num_objtypes(env); i++) {
					if (g_random_int_range(0, 5) == 0) {
						OSyncObjType *type = osync_conv_nth_objtype(env, i);
						osync_group_set_slow_sync(group, osync_objtype_get_name(type), TRUE);
						printf("Requesting slow-sync for: %s\n", osync_objtype_get_name(type));
					}
				}
				osync_conv_env_free(env);
			}
			
			update_change_list(engine);
			
			if (!check_mappings(engine) || !check_hashtables(engine) || !compare_content(engine)) {
				if (failed) {
					printf("already failed last round...\n");
					goto error_free_engine;
				}
				failed = TRUE;
				if (!tryrecover) {
					printf("Failed. Not trying to recover\n");
					goto error_free_engine;
				} else {
					printf("Failed. Trying to recover!\n");
					osync_group_set_slow_sync(group, "data", TRUE);
				}
			} else {
				failed = FALSE;
			}
			
			change_content(engine);

			printf("Starting to synchronize\n");
			if (!osengine_sync_and_block(engine, &error)) {
				printf("Error while starting synchronization: %s\n", osync_error_print(&error));
				osync_error_unref(&error);
				goto error_free_engine;
			}
			
			if (!compare_content(engine))
				goto error_free_engine;
			
			sleep(2);
			printf("End of synchronization\n");
			
			if (count == num)
				goto out;
		} while (g_random_int_range(0, 3) != 0);
		
		printf("Finalizing engine\n");
		osengine_finalize(engine);
		osengine_free(engine);
	}
	
out:
	osync_trace(TRACE_EXIT, "Stress test successful");
	printf("Stress test successful\n");
	return 0;
	
error_free_engine:
	osengine_free(engine);
error_free_env:
	osync_env_free(osync);
	g_main_loop_unref(loop);
	osync_trace(TRACE_EXIT_ERROR, "Stress test failed");
	printf("ERROR: Stress test failed\n");
	return 1;
}