src/server/test/vfs.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2019 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#include <cx/string.h>
#include <cx/list.h>
#include <cx/map.h>

#include "../daemon/session.h"

#include "testutils.h"

#include "vfs.h"

typedef struct TestVFS {
    CxMap *files;
    int count_unlink;
    int count_rmdir;
} TestVFS;

typedef struct TestVFSFile {
    VFSFile file;
    cxmutstr path;
    int isdir;
    CxBuffer content;
} TestVFSFile;

typedef struct TestVFSDir {
    VFSDir dir;
    TestVFSFile *file;
    CxIterator i;
    cxmutstr name;
} TestVFSDir;

/* dir io */

static const char* test_resource_name(char *url) {
    cxstring urlstr = cx_str(url);
    if(urlstr.ptr[urlstr.length-1] == '/') {
        urlstr.length--;
    }
    cxstring resname = cx_strrchr(urlstr, '/');
    if(resname.length > 1) {
        return resname.ptr+1;
    } else {
        return url;
    }
}

int testvfs_readdir(VFS_DIR dir, VFS_ENTRY *entry, int getstat) {
    TestVFS *vfs = dir->ctx->vfs->instance;
    TestVFSDir *vfsdir = (TestVFSDir*)dir;
    
    cxmutstr prefix = cx_strcat(2, vfsdir->file->path, cx_str("/"));
    
    // not the most efficient file system implementation ever, but it is only
    // for testing
    // check every entry in vfs->files and return, if the parent path
    // matches the open directory
    TestVFSFile *file = NULL;
    cx_foreach(TestVFSFile *, entry, vfsdir->i) {
        if(file) break;
        cxmutstr file_path = cx_strcat(
                2,
                prefix,
                cx_str(test_resource_name(entry->path.ptr)));
        file = cxMapGet(vfs->files, cx_hash_key(file_path.ptr, file_path.length));
        free(file_path.ptr);
    }
    free(prefix.ptr);
    
    if(file) {
        vfsdir->name = cx_strdup_a(
                pool_allocator(dir->ctx->sn->pool),
                cx_str(test_resource_name(file->path.ptr)));
        ZERO(entry, sizeof(VFS_ENTRY));
        entry->name = vfsdir->name.ptr;
        
        if(getstat) {
            ZERO(&entry->stat, sizeof(struct stat));
            if(file->isdir) {
                entry->stat.st_mode = S_IFDIR;
            }
        }
        
        return 1;
    } else {
        return 0;
    }
}

void testvfs_dir_close(VFS_DIR dir) {
    TestVFSDir *testdir = (TestVFSDir*)dir;
    pool_free(testdir->dir.ctx->sn->pool, dir);
    
}

 ssize_t testvfs_read(SYS_FILE fd, void *buf, size_t nbyte) {
     TestVFSFile *file = (TestVFSFile*)fd;
     return (ssize_t)cxBufferRead(buf, 1, nbyte, &file->content);
 }
 
 ssize_t testvfs_write(SYS_FILE fd, const void *buf, size_t nbyte) {
     TestVFSFile *file = (TestVFSFile*)fd;
     return (ssize_t)cxBufferWrite(buf, 1, nbyte, &file->content);
 }
 
 ssize_t testvfs_pread(SYS_FILE fd, void *buf, size_t nbyte, off_t offset) {
     TestVFSFile *file = (TestVFSFile*)fd;
     file->content.pos = (size_t)offset;
     return testvfs_read(fd, buf, nbyte);
 }
 
 ssize_t testvfs_pwrite(SYS_FILE fd, const void *buf, size_t nbyte, off_t offset) {
     TestVFSFile *file = (TestVFSFile*)fd;
     file->content.pos = (size_t)offset;
     return testvfs_write(fd, buf, nbyte);
 }
 
 off_t testvfs_seek(SYS_FILE fd, off_t offset, int whence) {
     TestVFSFile *file = (TestVFSFile*)fd;
     cxBufferSeek(&file->content, offset, whence);
     return (off_t)file->content.pos;
 }
 
 void testvfs_close(SYS_FILE fd) {
     TestVFSFile *file = (TestVFSFile*)fd;
     file->content.pos = 0;
 }

VFS_IO test_file_io = {
    testvfs_read,
    testvfs_write,
    testvfs_pread,
    testvfs_pwrite,
    testvfs_seek,
    testvfs_close,
    NULL, /* aio_read */
    NULL  /* aio_write */
};

VFS_DIRIO test_dir_io = {
    testvfs_readdir,
    testvfs_dir_close
};


/* vfs funcs */

SYS_FILE testvfs_open(VFSContext *ctx, const char *path, int oflags) {
    TestVFS *vfs = ctx->vfs->instance;  
    TestVFSFile *file = NULL;
    
    cxstring s_path = cx_str((char*)path);
    if(cx_strsuffix(s_path, cx_str("/"))) {
        s_path.length--;
    }
    
    file = cxMapGet(vfs->files, cx_hash_key_bytes((const unsigned char*)s_path.ptr, s_path.length));
    if(!file) {
        if((oflags & O_CREAT) == O_CREAT) {
            file = pool_malloc(ctx->sn->pool, sizeof(TestVFSFile));
            ZERO(file, sizeof(TestVFSFile));
            file->file.ctx = ctx;
            file->path = cx_strdup_a(pool_allocator(ctx->sn->pool), s_path);
            file->file.io = &test_file_io;
            
            cxBufferInit(&file->content, pool_malloc(ctx->sn->pool, 2048), 2048, pool_allocator(ctx->sn->pool), 0);
            
            cxMapPut(vfs->files, cx_hash_key((void*)s_path.ptr, s_path.length), file);
        } else {
            ctx->vfs_errno = ENOENT;
        }
    }
    
    return (SYS_FILE)file;
}

int testvfs_stat(VFSContext *ctx, const char *path, struct stat *buf) {
    TestVFS *vfs = ctx->vfs->instance;  
    TestVFSFile *file = NULL;
    
    cxstring s_path = cx_str((char*)path);
    if(cx_strsuffix(s_path, cx_str("/"))) {
        s_path.length--;
    }
    
    file = cxMapGet(vfs->files, cx_hash_key((void*)s_path.ptr, s_path.length));
    if(!file) {
        ctx->vfs_errno = ENOENT;
        return 1;
    }
    
    ZERO(buf, sizeof(struct stat));
    if(file->isdir) {
        buf->st_mode = S_IFDIR;
    }
    
    return 0;
}

int testvfs_fstat(VFSContext *ctx, SYS_FILE fd, struct stat *buf) {
    return 0;
}

VFS_DIR testvfs_opendir(VFSContext *ctx, const char *path) {
    TestVFS *vfs = ctx->vfs->instance;  
    TestVFSFile *file = NULL;
    
    cxstring s_path = cx_str((char*)path);
    if(cx_strsuffix(s_path, cx_str("/"))) {
        s_path.length--;
    }
    
    file = cxMapGet(vfs->files, cx_hash_key((void*)s_path.ptr, s_path.length));
    if(!file) {
        ctx->vfs_errno = ENOENT;
        return NULL;
    }
    
    if(!file->isdir) {
        return NULL;
    }
    
    TestVFSDir *dir = pool_malloc(ctx->sn->pool, sizeof(TestVFSDir));
    ZERO(dir, sizeof(TestVFSDir));
    dir->file = file;
    dir->i = cxMapIteratorValues(vfs->files);
    
    dir->dir.ctx = ctx;
    dir->dir.io = &test_dir_io;
    
    return (VFS_DIR)dir;
}

VFS_DIR testvfs_fdopendir(VFSContext *ctx, SYS_FILE fd) {
    TestVFS *vfs = ctx->vfs->instance;  
    TestVFSFile *file = (TestVFSFile*)fd;
    if(!file->isdir) {
        return NULL;
    }
    
    TestVFSDir *dir = pool_malloc(ctx->sn->pool, sizeof(TestVFSDir));
    ZERO(dir, sizeof(TestVFSDir));
    dir->file = file;
    dir->i = cxMapIteratorValues(vfs->files);
    
    dir->dir.ctx = ctx;
    dir->dir.io = &test_dir_io;
    
    return (VFS_DIR)dir;
}

int testvfs_mkdir(VFSContext *ctx, const char *path) {
    SYS_FILE fd = testvfs_open(ctx, path, O_CREAT);
    if(!fd) {
        return 1;
    }
    
    TestVFSFile *file = (TestVFSFile*)fd;
    file->isdir = 1;
    
    return 0;
}

int testvfs_unlink(VFSContext *ctx, const char *path) {
    TestVFS *vfs = ctx->vfs->instance;
    CxHashKey path_key = cx_hash_key_str(path);
    TestVFSFile *file = cxMapGet(vfs->files, path_key);
    if(!file) {
        return 1;
    }
    
    if(file->isdir) {
        return 1;
    }
    
    cxMapRemove(vfs->files, path_key);
    vfs->count_unlink++;
    return 0;
}

int testvfs_rmdir(VFSContext *ctx, const char *path) {
    TestVFS *vfs = ctx->vfs->instance;
    CxHashKey path_key = cx_hash_key_str(path);
    TestVFSFile *dir = cxMapGet(vfs->files, path_key);
    if(!dir) {
        ctx->vfs_errno = ENOENT;
        return 1;
    }
    
    if(!dir->isdir) {
        return 1;
    }
    
    CxIterator i = cxMapIteratorValues(vfs->files);
    cx_foreach(TestVFSFile *, f, i) {
        if(f->path.length > dir->path.length && cx_strprefix(cx_strcast(f->path), cx_strcast(dir->path))){
            return 1; // dir not empty
        }
    }
    
    cxMapRemove(vfs->files, path_key);
    vfs->count_rmdir++;
    return 0;
}

static VFS testVFSClass = {
    testvfs_open,
    testvfs_stat,
    testvfs_fstat,
    testvfs_opendir,
    testvfs_fdopendir,
    testvfs_mkdir,
    testvfs_unlink,
    testvfs_rmdir,
    0,
    NULL
};


VFS* testvfs_create(Session *sn) {
    TestVFS *vfs = pool_malloc(sn->pool, sizeof(TestVFS));
    vfs->count_unlink = 0;
    vfs->count_rmdir = 0;
    vfs->files = cxHashMapCreate(pool_allocator(sn->pool), CX_STORE_POINTERS, 64);
    
    testVFSClass.instance = vfs;
    return &testVFSClass;
}


/* ------------------------------------------------------------------------- */
//
// VFS Tests
//
/* ------------------------------------------------------------------------- */

UCX_TEST(test_vfs_open) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = testvfs_create(sn);
    
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    UCX_TEST_BEGIN;
    
    UCX_TEST_ASSERT(vfs, "vfs is NULL");
    
    SYS_FILE f1 = vfs_open(vfs, "/file1", O_CREAT);
    UCX_TEST_ASSERT(f1, "f1 not opened");
    
    SYS_FILE f2 = vfs_open(vfs, "/file1", 0);
    UCX_TEST_ASSERT(f2, "f2 not opened");
    
    UCX_TEST_END;
    
    testutil_destroy_session(sn);
}

UCX_TEST(test_vfs_mkdir) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = testvfs_create(sn);
    
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    UCX_TEST_BEGIN;
    
    int err = vfs_mkdir(vfs, "/dir");
    UCX_TEST_ASSERT(err == 0, "error not 0");
    
    SYS_FILE fd = vfs_open(vfs, "/dir", 0);
    UCX_TEST_ASSERT(fd, "no fd");
    
    UCX_TEST_END;
    
    testutil_destroy_session(sn);
}

UCX_TEST(test_vfs_opendir) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = testvfs_create(sn);
    
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    UCX_TEST_BEGIN;
    
    int err = vfs_mkdir(vfs, "/dir");
    UCX_TEST_ASSERT(err == 0, "error not 0");
    
    VFSDir *dir = vfs_opendir(vfs, "/dir");
    UCX_TEST_ASSERT(dir, "no dir");
    
    UCX_TEST_END;
    
    testutil_destroy_session(sn);
}

UCX_TEST(test_vfs_readdir) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = testvfs_create(sn);
    
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    UCX_TEST_BEGIN;
    
    int err = vfs_mkdir(vfs, "/dir");
    UCX_TEST_ASSERT(err == 0, "error not 0");
    
    // add some test file to /dir
    UCX_TEST_ASSERT(vfs_open(vfs, "/dir/file1", O_CREAT), "creation of file1 failed");
    UCX_TEST_ASSERT(vfs_open(vfs, "/dir/file2", O_CREAT), "creation of file2 failed");
    UCX_TEST_ASSERT(vfs_open(vfs, "/dir/file3", O_CREAT), "creation of file3 failed");
    UCX_TEST_ASSERT(vfs_open(vfs, "/dir/file4", O_CREAT), "creation of file4 failed");
    
    VFSDir *dir = vfs_opendir(vfs, "/dir");
    UCX_TEST_ASSERT(dir, "dir not opened");
    
    CxMap *files = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 8);
    
    VFSEntry entry;
    while(vfs_readdir(dir, &entry)) {
        cxMapPut(files, cx_hash_key_str(entry.name), dir);
    }
    
    UCX_TEST_ASSERT(files->size == 4, "wrong files count");
    UCX_TEST_ASSERT(cxMapGet(files, cx_hash_key_str("file1")), "file1 missing");
    UCX_TEST_ASSERT(cxMapGet(files, cx_hash_key_str("file2")), "file2 missing");
    UCX_TEST_ASSERT(cxMapGet(files, cx_hash_key_str("file3")), "file3 missing");
    UCX_TEST_ASSERT(cxMapGet(files, cx_hash_key_str("file4")), "file4 missing");
    
    cxMapDestroy(files);
    
    UCX_TEST_END;
    
    testutil_destroy_session(sn);
}

UCX_TEST(test_vfs_unlink) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = testvfs_create(sn);
    
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    UCX_TEST_BEGIN;
    // prepare test
    int err;
    err = vfs_mkdir(vfs, "/dir1");
    UCX_TEST_ASSERT(err == 0, "mkdir 1: error not 0");
    err = vfs_mkdir(vfs, "/dir2");
    UCX_TEST_ASSERT(err == 0, "mkdir 1: error not 0");
    
    SYS_FILE f1 = vfs_open(vfs, "/file1", O_CREAT);
    UCX_TEST_ASSERT(f1, "f1 not opened");
    
    SYS_FILE f2 = vfs_open(vfs, "/file2", O_CREAT);
    UCX_TEST_ASSERT(f1, "f2 not opened");
    
    SYS_FILE f3 = vfs_open(vfs, "/dir1/file3", O_CREAT);
    UCX_TEST_ASSERT(f1, "f3 not opened");
    
    // test unlink
    err = vfs_unlink(vfs, "/file1");
    UCX_TEST_ASSERT(err == 0, "unlink /file1 failed");
    err = vfs_unlink(vfs, "/dir1/file3");
    UCX_TEST_ASSERT(err == 0, "unlink /dir1/file3 failed");
    
    err = vfs_unlink(vfs, "/filex");
    UCX_TEST_ASSERT(err != 0, "unlink /filex should fail");
    
    // check if files were removed
    SYS_FILE o1 = vfs_open(vfs, "/file1", O_RDONLY);
    UCX_TEST_ASSERT(o1 == NULL, "/file1 not deleted");
    SYS_FILE o3 = vfs_open(vfs, "/dir1/file3", O_RDONLY);
    UCX_TEST_ASSERT(o1 == NULL, "/dir1/file3 not deleted");
    
    // file2 should still be there
    SYS_FILE o2 = vfs_open(vfs, "/file2", O_RDONLY);
    UCX_TEST_ASSERT(o2, "/file2 deleted");
    
    // check if dir unlink fails
    err = vfs_unlink(vfs, "/dir1");
    UCX_TEST_ASSERT(err != 0, "unlink dir1 should fail");
    
    UCX_TEST_END;
    
    testutil_destroy_session(sn);
}

UCX_TEST(test_vfs_rmdir) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = testvfs_create(sn);
    
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    UCX_TEST_BEGIN;
    // prepare test
    int err;
    err = vfs_mkdir(vfs, "/dir1");
    UCX_TEST_ASSERT(err == 0, "mkdir 1: error not 0");
    err = vfs_mkdir(vfs, "/dir2");
    UCX_TEST_ASSERT(err == 0, "mkdir 1: error not 0");
    
    SYS_FILE f1 = vfs_open(vfs, "/dir1/file1", O_CREAT);
    UCX_TEST_ASSERT(f1, "f1 not opened");
    
    err = vfs_rmdir(vfs, "/dir1");
    UCX_TEST_ASSERT(err != 0, "rmdir /dir1 should fail");
    err = vfs_rmdir(vfs, "/dir2");
    UCX_TEST_ASSERT(err == 0, "rmdir /dir2 failed");
    
    err = vfs_unlink(vfs, "/dir1/file1");
    UCX_TEST_ASSERT(err == 0, "unlink failed");
    err = vfs_rmdir(vfs, "/dir1");
    UCX_TEST_ASSERT(err == 0, "rmdir /dir1 (2) failed");
    
    UCX_TEST_END;
    
    testutil_destroy_session(sn);
}