void test_cache()
{
/*---init HLFS with cache on by conf file---*/
int ret = 0;
g_message("test begin...");
g_assert(fixture.ctrl->cctrl->block_size == 8192);
g_assert(fixture.ctrl->cctrl->cache_size == 1024);
g_assert(fixture.ctrl->cctrl->flush_interval == 10);
g_assert(fixture.ctrl->cctrl->flush_trigger_level == 80);
g_assert(fixture.ctrl->cctrl->flush_once_size == 100);
ret = g_trash_stack_height(&(fixture.ctrl->cctrl->block_cache));
g_message("height of cache blocks:%d", ret);
g_assert(ret == 1024);
g_assert(fixture.ctrl->cctrl->dirty_block != NULL);
g_assert(g_queue_get_length(fixture.ctrl->cctrl->dirty_block) == 0);
g_assert(fixture.ctrl->cctrl->block_map != NULL);
g_assert(fixture.ctrl->cctrl->flush_waken_cond != NULL);
g_message("initializing HLFS successfully");
/*---Write something and check when flush---*/
uint64_t pos = 0;
int loop = 0;
char *buf = (char *)g_malloc0(8192);
if (0 > hlfs_open(fixture.ctrl, 1)) {
g_message("open HLFS error");
return;
}
struct stat *_stat = (struct stat *)g_malloc0(sizeof(struct stat));
for (loop = 0; loop < BLK_NO; loop++) {
if (0 > hlfs_write(fixture.ctrl, buf, BLK_NO, pos)) {
g_message("hlfs_write error");
return;
}
g_message("write the %dth blk", loop);
pos += BLK_NO;
if (!g_file_test("/tmp/testenv/testfs/0.seg", G_FILE_TEST_EXISTS)) {
g_message("file not exists");
} else {
memset(_stat, 0, sizeof(_stat));
ret = stat("/tmp/testenv/testfs/0.seg", _stat);
if (ret < 0) {
g_message("error no: %d", errno);
perror("stat error:");
}
g_assert(ret == 0);
g_message("size of 0.seg:%d", _stat->st_size);
g_message("inode of 0.seg:%d", _stat->st_ino);
g_message("atime of 0.seg:%d", _stat->st_atime);
//sleep(1);
}
}
}
static void
hlfs_get_all_snapshots_setup(Fixture *fixture, const void *data) {
const char *test_dir = (const char *)data;
g_print("test env dir is %s\n", test_dir);
char *fs_dir = g_build_filename(test_dir, "testfs", NULL);
// g_assert(g_mkdir(fs_dir, 0700) == 0);
char *uri = g_malloc0(128);
g_assert(uri != NULL);
snprintf(uri, 128, "%s%s", "local://", fs_dir);
// char *uri = g_build_path(tmp, fs_dir, NULL);
g_print("uri is %s\n", uri);
pid_t status;
const char cmd[256];
memset((char *) cmd, 0, 256);
sprintf((char *) cmd, "%s %s %s %s %d %s %d %s %d", "../mkfs.hlfs",
"-u", uri,
"-b", 8192,
"-s", 67108864,
"-m", 1024);
g_message("cmd is [%s]", cmd);
status = system(cmd);
#if 0
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", 8196);
g_key_file_set_integer(sb_keyfile, "METADATA", \
"segment_size", 67108864);
g_key_file_set_integer(sb_keyfile, "METADATA", \
"max_fs_size", 671088640);
gchar *content = g_key_file_to_data(sb_keyfile, NULL, NULL);
char *sb_file_path = g_build_filename(fs_dir, "superblock", NULL);
g_print("sb file path is %s\n", sb_file_path);
GError *error = NULL;
if (TRUE != g_file_set_contents(sb_file_path, content, \
strlen(content) + 1, &error)) {
g_print("error msg is %s", error->message);
error = NULL;
}
#endif
fixture->uri = uri;
g_print("fixture->uri is %s\n", fixture->uri);
fixture->ctrl = init_hlfs(fixture->uri);
g_assert(fixture->ctrl != NULL);
int ret = hlfs_open(fixture->ctrl, 1);
g_assert(ret == 0);
take_snapshot(fixture, data);
// test_hlfs_find_inode_before_time(fixture, data);
// g_key_file_free(sb_keyfile);
// g_free(sb_file_path);
g_free(fs_dir);
return ;
}
void case_setup()
{
#if 1
system("rm -rf /tmp/testenv");
system("mkdir /tmp/testenv -p");
system("cd ../../../ && ./output/bin/mkfs.hlfs -u \
local:///tmp/testenv/testfs -b 8192 -s 67108864 -m 1024");
system("cd -");
char *uri = "local:///tmp/testenv/testfs";
fixture.hctrl = init_hlfs(uri);
g_assert(NULL != fixture.hctrl);
int ret = 0;
ret = hlfs_open(fixture.hctrl,1);
g_assert(ret == 0);
g_print("TEST hlfs open over \n");
int i = 0;
int offset = 0;
int BATCHSIZE = 8192;
char content[BATCHSIZE];
for (i = 0;i < 8192 * 3;i++) {
hlfs_write(fixture.hctrl, content, BATCHSIZE, offset);
offset = offset + BATCHSIZE;
if (offset == 8192 * 8192) {
ret = hlfs_take_snapshot(fixture.hctrl, "test_snapshot1");
g_assert(ret == 0);
g_print("take snapshot 1\n");
}
if (offset == 8192 * 8192 * 2) {
ret = hlfs_take_snapshot(fixture.hctrl, "test_snapshot2");
g_assert(ret == 0);
g_print("take snapshot 2\n");
}
if (offset == 8192 * 8192 * 2 + 8192 * 1) {
ret = hlfs_take_snapshot(fixture.hctrl, "test_snapshot3");
g_assert(ret == 0);
g_print("take snapshot 3\n");
}
}
hlfs_close(fixture.hctrl);
deinit_hlfs(fixture.hctrl);
#endif
}
/*
* ./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;
}
/* 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;
}
