void tg_option_tests()
{
GOptionContext *context;
GOptionContext *context1;//for testing set main group
GOptionContext *context2;//for testing add group
gboolean retval;
GError *error = NULL;
gchar **argv;
int argc;
gchar **argv1;
int argc1;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "test_description", "test_arg" },
{ NULL } };
GOptionEntry entries1 [] =
{ { "try", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "try_description", "try_arg" },
{ NULL } };
GOptionEntry entries2 [] =
{ { "again", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "again_description", "again_arg" },
{ NULL } };
GOptionGroup *main_group;
context = g_option_context_new (NULL);
context1 = g_option_context_new (NULL);
context2 = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_add_main_entries (context2, entries, NULL);
main_group = g_option_context_get_main_group (context);
//Testing g_option_context_set_main_group with another context-context1
g_option_group_add_entries (main_group,entries1);
g_option_context_set_main_group(context1,main_group);
//Testing g_option_context_set_help_enabled
//and g_option_context_get_help_enabled
//and g_option_context_get_ignore_unknown_options
g_option_context_set_help_enabled(context,TRUE);
g_assert(g_option_context_get_help_enabled(context));
g_assert(!g_option_context_get_ignore_unknown_options(context));
/* Now try parsing on context1*/
argv = split_string ("program --try 20 --try 30", &argc);
retval = g_option_context_parse (context1, &argc, &argv, &error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (arg_test1_int == 30);
g_option_group_set_error_hook (main_group, error_func);
argv = split_string ("program --none 20 --none 30", &argc);
retval = g_option_context_parse (context1, &argc, &argv, &error);
g_strfreev (argv);
g_option_context_free (context);
}
int
main(int argc, char **argv)
{
GtkWidget *window, *revealer, *grid, *widget;
GtkCssProvider *cssprovider;
GError *error = NULL;
guint x, y;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
g_option_context_add_group (context,
gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
revealer = gtk_revealer_new ();
gtk_widget_set_valign (revealer, GTK_ALIGN_START);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), reveal_time * 1000);
gtk_revealer_set_reveal_child (GTK_REVEALER (revealer), TRUE);
g_signal_connect_after (revealer, "map", G_CALLBACK (toggle_reveal), NULL);
g_signal_connect_after (revealer, "notify::child-revealed", G_CALLBACK (toggle_reveal), NULL);
gtk_container_add (GTK_CONTAINER (window), revealer);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (revealer), grid);
cssprovider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (cssprovider, "* { padding: 2px; text-shadow: 5px 5px 2px grey; }", -1, NULL);
for (x = 0; x < 10; x++)
{
for (y = 0; y < 20; y++)
{
widget = gtk_label_new ("Hello World");
gtk_style_context_add_provider (gtk_widget_get_style_context (widget),
GTK_STYLE_PROVIDER (cssprovider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
gtk_grid_attach (GTK_GRID (grid), widget, x, y, 1, 1);
}
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *viewport;
GtkWidget *grid;
GError *error = NULL;
int i;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
gtk_init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
viewport = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (viewport), grid);
for (i = 0; i < 4; i++)
{
GtkWidget *content = create_widget_factory_content ();
gtk_grid_attach (GTK_GRID (grid), content,
i % 2, i / 2, 1, 1);
g_object_unref (content);
}
gtk_widget_add_tick_callback (viewport,
scroll_viewport,
NULL,
NULL);
gtk_widget_show (window);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_main ();
return 0;
}
void
error_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
int argc;
GOptionGroup *main_group;
#ifndef SYMBIAN
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_INT, &error_test1_int, NULL, NULL },
{ NULL } };
#else
GOptionEntry entries [2];
entries[0].long_name = "test";
entries[0].short_name = 0;
entries[0].flags = 0;
entries[0].arg = G_OPTION_ARG_INT;
entries[0].arg_data = (gpointer)&error_test1_int;
entries[0].description = NULL;
entries[0].arg_description = NULL;
entries[1].long_name = NULL;
entries[1].short_name = 0;
entries[1].arg_data = NULL;
entries[1].description = NULL;
entries[1].arg_description = NULL;
#endif
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Set pre and post parse hooks */
main_group = g_option_context_get_main_group (context);
g_option_group_set_parse_hooks (main_group,
error_test1_pre_parse, error_test1_post_parse);
/* Now try parsing */
argv = split_string ("program --test 20", &argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
/* On failure, values should be reset */
g_assert (error_test1_int == 0x12345678);
g_strfreev (argv);
g_option_context_free (context);
}
/* nbd-ops -p pid -f fsname -c command */
int main(int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("- tapdisk ops...");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s\n", error->message);
exit(EXIT_FAILURE);
}
g_message("fsname: %s\n", fsname);
g_message("cmd: %s\n", cmd);
g_message("param1: %d\n" ,param1);
g_option_context_free(context);
char ctrl_region_file[128];
sprintf(ctrl_region_file,"%s%s%s","/tmp/",fsname,"-ctrl");
int fd = open(ctrl_region_file,O_RDWR);
if(fd == -1){
return -1;
}
// int offset = sysconf(_SC_PAGE_SIZE);
char *addr = mmap(NULL,sizeof(CTRL_REGION_T), PROT_WRITE, MAP_SHARED, fd, 0);
if (addr == MAP_FAILED) {
g_message("%s -- mmap failed\n", __func__);
exit(EXIT_FAILURE);
}
g_assert(addr !=NULL);
CTRL_REGION_T *ctrl_region;
ctrl_region = (CTRL_REGION_T*)addr;
gint *_is_start_clean = &ctrl_region->is_start_clean;
gint *_copy_waterlevel = &ctrl_region->copy_waterlevel;
if(0 == strncmp(cmd,"start_merge",strlen("start_merge"))){
g_message("cmd is srart merge : %s",cmd);
g_atomic_int_set(_is_start_clean,1);
}else if(0 == strncmp(cmd,"stop_merge",strlen("stop_merge"))){
g_message("cmd is stop merge : %s",cmd);
g_atomic_int_set(_is_start_clean,0);
}else if (0 == strncmp(cmd, "set_copy_waterlevel", strlen("set_copy_waterlevel"))){
g_message("cmd is set copy waterlevel: %s", cmd);
g_atomic_int_set(_copy_waterlevel,param1);
}else if (0 == strncmp(cmd, "query_stat", strlen("query_stat"))){
g_message("cmd is query_stat: %s", cmd);
g_message("is_start_clean:%d", ctrl_region->is_start_clean);
g_message("copy_waterlevel:%d",ctrl_region->copy_waterlevel);
}else{
g_assert(0);
}
return 0;
}
int
main(int argc, char **argv)
{
GError *error = NULL;
GdkMonitor *monitor;
GdkRectangle monitor_bounds;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
g_option_context_add_group (context,
gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
g_print ("# Load factor: %g\n",
load_factor);
g_print ("# Resizing?: %s\n",
cb_no_resize ? "no" : "yes");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_gravity (GTK_WINDOW (window), GDK_GRAVITY_CENTER);
gtk_widget_set_app_paintable (window, TRUE);
g_signal_connect (window, "draw",
G_CALLBACK (on_window_draw), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (window, "map-event",
G_CALLBACK (on_map_event), NULL);
on_frame (0.);
monitor = gdk_display_get_primary_monitor (gtk_widget_get_display (window));
gdk_monitor_get_geometry (monitor, &monitor_bounds);
gtk_window_move (GTK_WINDOW (window),
monitor_bounds.x + (monitor_bounds.width - window_width) / 2,
monitor_bounds.y + (monitor_bounds.height - window_height) / 2);
gtk_widget_show (window);
gtk_main ();
return 0;
}
/* mkfs_rmfs -u uri */
int main(int argc, char *argv[])
{
// if (log4c_init()) {
// g_message("log4c_init failed!");
// }
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("-hlfs rmfs");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s", error->message);
exit(EXIT_FAILURE);
}
g_print("fs uri is :%s\n", uri);
int ret = 0;
struct back_storage *storage = init_storage_handler(uri);
if (NULL == storage) {
g_message("can not get storage handler for uri:%s", uri);
ret = -1;
goto out;
}
if (0 != hlfs_rmfs(storage)){
g_printf("Can not remove fs!\n");
ret = -1;
goto out1;
}
out1:
deinit_storage_handler(storage);
out:
g_free(uri);
g_option_context_free(context);
// if (log4c_fini()) {
// g_message("log4c_fini failed!");
// }
return 0;
}
static GOptionContext *commandline_parse(int *argc, char ***argv) {
GOptionContext *context = NULL;
GError *error = NULL;
gchar *string;
string = g_strdup_printf(_("- controls extended capabilities of Roccat %s mice"), KONEXTD_DEVICE_NAME);
context = g_option_context_new(string);
g_free(string);
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_translation_domain(context, PROJECT_NAME);
g_option_group_set_parse_hooks(g_option_context_get_main_group(context), NULL, post_parse_func);
if (!g_option_context_parse(context, argc, argv, &error)) {
g_critical(_("Could not parse options: %s"), error->message);
exit(EXIT_FAILURE);
}
return context;
}
/* nbd-ops -p pid -u uri -c command */
int main(int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("- nbd ops...");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s\n", error->message);
exit(EXIT_FAILURE);
}
g_message("nspid: %d\n",nbd_server_pid);
g_message("uri: %s\n", uri);
g_message("cmd: %s\n", cmd);
g_message("param1: %d\n" ,param1);
g_option_context_free(context);
int _pid = nbd_server_pid;
char FIFO_R[128];
char FIFO_W[128];
snprintf(FIFO_W,128,"%s/%s/%d","/tmp", "nbd-0-",_pid);
snprintf(FIFO_R,128,"%s/%s/%d","/tmp", "nbd-1-",_pid);
printf("--FIFO-R :%s\n",FIFO_R);
printf("--FIFO-W :%s\n",FIFO_W);
char w_buf[512];
char r_buf[512];
int nwrite;
int msg_w_fd=open(FIFO_W,O_RDWR,0);
if(msg_w_fd == -1){
g_message("open error: %s/n", strerror(errno));
g_message("open fifo:%s failed\n",FIFO_W);
exit(-1);
}
int msg_r_fd=open(FIFO_R,O_RDWR,0);
if(msg_r_fd == -1){
g_message("open error: %s/n", strerror(errno));
g_message("open fifo:%s failed\n",FIFO_R);
exit(-1);
}
NBD_OPS_CMD_T nbd_cmd;
NBD_OPS_RSP_T nbd_rsp;
if(0 == strncmp(cmd,"start_merge",strlen("start_merge"))){
g_message("cmd is srart merge : %s",cmd);
nbd_cmd.nbd_ops_cmd = start_clean;
}else if(0 == strncmp(cmd,"stop_merge",strlen("stop_merge"))){
g_message("cmd is stop merge : %s",cmd);
nbd_cmd.nbd_ops_cmd = start_clean;
}else if (0 == strncmp(cmd, "set_copy_waterlevel", strlen("set_copy_waterlevel"))){
g_message("cmd is set copy waterlevel: %s", cmd);
nbd_cmd.nbd_ops_cmd = set_copy_waterlevel;
}else if (0 == strncmp(cmd, "query_stat", strlen("query_stat"))){
g_message("cmd is query_stat: %s", cmd);
nbd_cmd.nbd_ops_cmd = query_stat;
}else{
g_assert(0);
}
strncpy(nbd_cmd.uri,uri,128);
nbd_cmd.value = param1;
g_message("write to fifo value: %d", nbd_cmd.value);
g_message("write to fifo : %s",nbd_cmd.uri);
int reval = write(msg_w_fd,&nbd_cmd,sizeof(NBD_OPS_CMD_T));
if(reval != sizeof(NBD_OPS_CMD_T)) {
g_message("message send error");
exit(-1);
}
g_message("write over %d",reval);
sleep(1);
g_message("read from fifo");
reval = read(msg_r_fd,&nbd_rsp,sizeof(NBD_OPS_RSP_T));
if(reval != sizeof(NBD_OPS_RSP_T)){
g_message("message send error");
exit(-1);
}
g_message("rsponse reval:%d errno:%d",reval,nbd_rsp.err_no);
if(nbd_rsp.err_no == 0){
if (0 == strncmp(cmd, "query_stat", strlen("query_stat"))){
NBD_OPS_STAT nbd_stat;
reval = read(msg_r_fd,&nbd_stat,sizeof(NBD_OPS_STAT));
g_message("start clean :%d",nbd_stat.is_start_clean);
g_message("copy waterlevel :%d",nbd_stat.copy_waterlevel);
}
}
close(msg_w_fd);
close(msg_r_fd);
return 0;
}
/*
* ./test -u uri -r request_size -a total_size
* uri: /tmp/testenv/testfs
* request_size: 4096bytes
* total_size: 409600bytes
*/
int main(int argc, char *argv[]){
if (log4c_init()) {
g_message("log4c_init error!");
}
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("- hlfs test -");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s", error->message);
exit(EXIT_FAILURE);
}
g_option_context_free(context);
g_print("TEST: uri is %s, request size is %d, total size is %d\n", uri, request_size, total_size);
char *content = (char*)g_malloc0(request_size);
HLFS_CTRL * ctrl = init_hlfs(uri);
g_assert(ctrl != NULL);
uint64_t ret = 0;
ret = hlfs_open(ctrl,1);
g_assert(ret == 0);
g_print("TEST hlfs open over \n");
g_print("test hlfs write\n");
sleep(2);
int offset = 0;
while(offset < total_size){
ret = hlfs_write(ctrl,content,request_size,offset);
g_assert(ret==request_size);
offset +=request_size;
printf("offset:%d\n",offset);
}
g_print("TEST hlfs write over \n");
g_print("test hlfs read\n");
sleep(2);
offset = 0;
while(offset < total_size){
ret = hlfs_read(ctrl,content,request_size,offset);
g_assert(ret==request_size);
offset +=request_size;
printf("offset:%d\n",offset);
}
g_print("again ------------------------\n");
offset = 0;
/******************************************************************************************************************************************/
int fdd;
int len;
int rett;
int i;
//char read_buf[409600];
char *contentt = (char*)g_malloc0(40960);
if((fdd = open("test.c", O_RDONLY )) == -1){
my_err("open", __LINE__);
} else {
g_print("Open file success\n");
}
//if(write(fd, write_buf, strlen(write_buf)) != strlen(write_buf)){
// my_err("write", __LINE__);
//}
if(lseek(fdd, 0, SEEK_END) == -1){
my_err("lseek", __LINE__);
}
if((len = lseek(fdd, 0, SEEK_CUR)) == -1){
my_err("lseek", __LINE__);
}
if((lseek(fdd, 0, SEEK_SET)) == -1){
my_err("lseek", __LINE__);
}
printf("len: %d\n", len);
if((rett = read(fdd, contentt, len)) < 0){
my_err("lseek",__LINE__);
}
strcpy(content, contentt);
//for(i = 0; i< len; i ++){
g_print("%s ", contentt);
//}
g_print("\n");
g_print("/************************************************/");
if(lseek(fdd, 10, SEEK_END) == -1){
my_err("lseek", __LINE__);
}
//close (fdd);
/****************************************************************************************************/
//FILE* srcFile = NULL;
int srcLength = lseek(fdd, 0, SEEK_CUR);
int SNAPPY_OK = 0;
char* pSrcBuffer = (char*)g_malloc0(srcLength);
read(fdd, pSrcBuffer, srcLength);
size_t cbOfCompressed = 32+ srcLength + srcLength/6;
char* pCompressedBuffer = (char*)g_malloc0(cbOfCompressed);
if (snappy_compress(pSrcBuffer, srcLength, pCompressedBuffer, &cbOfCompressed) == SNAPPY_OK)
{
free(pSrcBuffer);
pSrcBuffer = NULL;
if (snappy_validate_compressed_buffer(pCompressedBuffer, cbOfCompressed) == SNAPPY_OK)
{
size_t cbDecompress = 0;
snappy_uncompressed_length(pCompressedBuffer, cbOfCompressed, &cbDecompress);
assert(cbDecompress == srcLength);
char* pDecompressedBuffer = (char*)g_malloc0(cbDecompress);
snappy_uncompress(pCompressedBuffer, cbOfCompressed, pDecompressedBuffer, (size_t*)&cbDecompress);
int file;
file = open("test1.txt", O_CREAT | O_RDWR );
//_wfopen_s(&file, _T("123.pdf"), _T("ab"));
write(file, pDecompressedBuffer, cbDecompress);
close(file);
free(pDecompressedBuffer);
pDecompressedBuffer = NULL;
}
}
close (fdd);
/******************************************************************************************************************************************/
// while(offset < total_size){
// ret = hlfs_write(ctrl,content,request_size,offset);
// g_assert(ret==request_size);
// offset +=request_size;
// printf("offset:%d\n",offset);
// }
// g_print("TEST hlfs write over \n");
// g_print("test hlfs read\n");
// sleep(2);
// offset = 0;
while(offset < len+1){
ret = hlfs_read(ctrl,content,len,offset);
g_assert(ret==len);
offset +=len;
printf("offset:%d\n",offset);
}
g_free(content);
g_free(contentt);
ret = hlfs_close(ctrl);
deinit_hlfs(ctrl);
g_print("TEST hlfs test over \n");
return 0;
}
/* mkfs.lhfs -l http://<path> -s name */
int main(int argc, char *argv[])
{
if (log4c_init()) {
g_message("log4c_init failed!");
}
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("- mkfs hlfs");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s", error->message);
exit(EXIT_FAILURE);
}
//g_print("location is :%s\n",location);
//g_print("fsname is :%s\n",fsname);
//g_print("block size is :%d\n",block_size);
//g_print("segment size is :%d\n",seg_size);
// seg_size = SEGMENT_SIZE;
if(seg_size <= 0 || seg_size%(1024*1024)!=0){
g_message("segsize <=0 or segment size must 1M margin");
return -1;
}
if(block_size <=0 || block_size%(512) != 0){
g_message("blocksize <=0 or block size must 512 margin");
return -1;
}
if(max_fs_size <=0){
g_message("max fs size <=0");
return -1;
}
struct back_storage *storage = init_storage_handler(uri);
if(NULL ==storage){
g_message("can not get storage handler for uri:%s",uri);
g_option_context_free(context);
return -1;
}
if((0==storage->bs_file_is_exist(storage,NULL)) && (0==storage->bs_file_is_exist(storage,"superblock"))){
g_message("hlfs with uri:%s has exist",uri);
g_option_context_free(context);
return 1;
}
if( 0!=storage->bs_file_mkdir(storage,NULL)){
g_message("can not mkdir for our fs %s",uri);
g_option_context_free(context);
return -1;
}
GKeyFile *sb_keyfile= g_key_file_new();
g_key_file_set_string(sb_keyfile,"METADATA","uri",uri);
g_key_file_set_integer(sb_keyfile,"METADATA","block_size",block_size);
g_key_file_set_integer(sb_keyfile,"METADATA","segment_size",seg_size);
g_key_file_set_uint64(sb_keyfile,"METADATA","max_fs_size",max_fs_size);
gchar *data = g_key_file_to_data(sb_keyfile,NULL,NULL);
g_message("key file data :%s",data);
char *head,*hostname,*dir,*fs_name;
int port;
parse_from_uri(uri,&head,&hostname,&dir,&fs_name,&port);
char *sb_file_path = g_build_filename(dir,fs_name,"superblock",NULL);
g_message("sb file path %s",sb_file_path);
bs_file_t file = storage->bs_file_create(storage,"superblock");
g_message("sb file path 1%s",sb_file_path);
//bs_file_t file = storage->bs_file_open(storage,"superblock",BS_WRITEABLE);
if (NULL == file) {
g_message("open file :superblock failed");
g_free(sb_file_path);
g_option_context_free(context);
return -1;
}
g_message("sb file path 2%s",sb_file_path);
int size = storage->bs_file_append(storage, file,(char*)data,strlen(data)+1);
if(size != strlen(data)+1){
g_message("can not write superblock file");
g_free(sb_file_path);
g_option_context_free(context);
return -1;
}
g_message("append size:%d",size);
storage->bs_file_flush(storage,file);
storage->bs_file_close(storage,file);
deinit_storage_handler(storage);
if (log4c_fini()) {
g_message("log4c_fini failed!");
}
return 0;
}
/* seg.clean -u uri -s segno -w copy_water -v verbose */
int main(int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("- segment clearn...");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s", error->message);
exit(EXIT_FAILURE);
}
g_message("uri is :%s",uri);
g_message("start segno:%d,end segno:%d",start_segno,end_segno);
g_message("copy_waterlevel is: %d",copy_waterlevel);
g_option_context_free(context);
HLFS_CTRL * ctrl = init_hlfs(uri);
g_assert(ctrl != NULL);
g_message("ctrl init over");
int ret = 0;
ret = hlfs_open(ctrl,1);
g_message("ctrl open over");
g_assert(ret == 0);
if(0!=ctrl->storage->bs_file_is_exist(ctrl->storage,SEGMENTS_USAGE_FILE)) {
g_message("seg usage file not exit");
goto OUT;
}
GHashTable *seg_usage_hashtable = g_hash_table_new_full(g_direct_hash,g_direct_equal,NULL,NULL);//TODO
GList* seg_usage_list = NULL;
ret = load_all_seg_usage(ctrl->storage,SEGMENTS_USAGE_FILE,seg_usage_hashtable);
g_assert(ret == 0);
ret = sort_all_seg_usage(seg_usage_hashtable,&seg_usage_list);
g_assert(ret == 0);
int i;
for(i=start_segno; i<=end_segno; i++) {
SEG_USAGE_T *seg_usage = g_hash_table_lookup(seg_usage_hashtable,GINT_TO_POINTER((uint32_t)i));
char segfile[128];
build_segfile_name(i, segfile);
if(seg_usage != NULL) {
g_message("seg no:%d ...",seg_usage->segno);
if (seg_usage->alive_block_num == 0) {
g_message("seg no:%d no alive block now,delete it",i);
if(0 == ctrl->storage->bs_file_is_exist(ctrl->storage,segfile)) {
ret = ctrl->storage->bs_file_delete(ctrl->storage,segfile);
g_assert(ret == 0);
} else {
g_message("seg no:%d has delete",i);
}
continue;
}
if(0 == strcmp(seg_usage->up_sname,EMPTY_UP_SNAPSHOT)) {
g_message("seg no:%d is maybe need to migrate",seg_usage->segno);
if (seg_usage->alive_block_num > copy_waterlevel) {
g_message("seg no:%d is need to migrate",seg_usage->segno);
ret = migrate_alive_blocks(ctrl,seg_usage);
g_assert(ret == 0);
seg_usage->alive_block_num =0;
seg_usage->timestamp = get_current_time();
memset(seg_usage->bitmap,0,(seg_usage->log_num-1)/sizeof(gint)+1);
ret = dump_seg_usage(ctrl->storage,SEGMENTS_USAGE_FILE,seg_usage);
g_free(seg_usage->bitmap);
g_free(seg_usage);
ret = ctrl->storage->bs_file_delete(ctrl->storage,segfile);
}
}
} else {
g_message("seg no:%d has not yet do seg usage calc",i);
}
}
OUT:
ret = hlfs_close(ctrl);
g_assert(ret == 0);
ret = deinit_hlfs(ctrl);
g_assert(ret ==0);
return 0;
}
