data/src/check_memdb.c

   1 /*
   2   Copyright (C) 2010 - 2020 Proxmox Server Solutions GmbH
   3
   4   This program is free software: you can redistribute it and/or modify
   5   it under the terms of the GNU Affero General Public License as published by
   6   the Free Software Foundation, either version 3 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU Affero General Public License for more details.
  13
  14   You should have received a copy of the GNU Affero General Public License
  15   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17   Author: Dietmar Maurer <dietmar@proxmox.com>
  18
  19 */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <glib.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <check.h>
  27 #include <errno.h>
  28 #include <unistd.h>
  29
  30 #include "cfs-utils.h"
  31 #include "status.h"
  32 #include "memdb.h"
  33
  34 cfs_t cfs = {
  35         .debug = 0,
  36         .nodename = "testnode",
  37 };
  38
  39 #define TESTDB "/tmp/test.db"
  40
  41 static memdb_t *memdb;
  42
  43 static void
  44 setup(void)
  45 {
  46         unlink(TESTDB);
  47         memdb = memdb_open(TESTDB);
  48         fail_unless (memdb != NULL);
  49
  50         struct statvfs stbuf;
  51         fail_unless(memdb_statfs(memdb, &stbuf) == 0);
  52
  53         int count = stbuf.f_files - stbuf.f_ffree;
  54         fail_unless(count == 1);
  55 }
  56
  57 void
  58 teardown(void)
  59 {
  60         fail_unless (memdb != NULL);
  61
  62         memdb_close(memdb);
  63 }
  64
  65 START_TEST(test_indextest1)
  66 {
  67         char namebuf[100];
  68
  69         time_t ctime = 1234;
  70         int testsize = 1024*32;
  71         gchar *testdata = g_malloc0(testsize);
  72
  73         for (int i = 0; i < 100; i++) {
  74                 sprintf(namebuf, "testfile%d", i);
  75
  76                 fail_unless(memdb_create(memdb, namebuf, 0, ctime) == 0);
  77                 fail_unless(memdb_write(memdb, namebuf, 0, ctime, testdata, testsize, 0, 0) == testsize);
  78         }
  79
  80         struct statvfs stbuf;
  81         fail_unless(memdb_statfs(memdb, &stbuf) == 0);
  82
  83         int count = stbuf.f_files - stbuf.f_ffree;
  84         fail_unless(count == 101);
  85
  86         memdb_index_t *idx = memdb_encode_index(memdb->index, memdb->root);
  87         fail_unless(idx != NULL);
  88
  89         fail_unless(idx->version == 201);
  90         fail_unless(idx->last_inode == 200);
  91         fail_unless(idx->writer == 0);
  92         fail_unless(idx->size == 101);
  93         fail_unless(idx->bytes == (101*40 + sizeof( memdb_index_t)));
  94
  95         GChecksum *sha256 = g_checksum_new(G_CHECKSUM_SHA256);
  96         fail_unless(sha256 != NULL);
  97         g_checksum_update(sha256, (unsigned char *)idx, idx->bytes);
  98         const char *csum = g_checksum_get_string(sha256);
  99         fail_unless(strcmp(csum, "913fd95015af9d93f10dd51ba2a7bb11351bcfe040be21e95fcba834adc3ec10") == 0, "wrong idx checksum %s", csum);
 100         g_free(idx);
 101         g_free(testdata);
 102
 103 }
 104 END_TEST
 105
 106 START_TEST (test_dirtest1)
 107 {
 108         const char *dn = "/dir1";
 109         const char *sdn = "/dir1/sdir1";
 110         time_t ctime = 1234;
 111
 112         fail_unless(memdb_mkdir(memdb, sdn, 0, ctime) == -ENOENT);
 113         fail_unless(memdb_delete(memdb, dn, 0, ctime) == -ENOENT);
 114
 115         fail_unless(memdb_mkdir(memdb, dn, 0, ctime) == 0);
 116         fail_unless(memdb_mkdir(memdb, dn, 0, ctime) == -EEXIST);
 117         fail_unless(memdb_mkdir(memdb, sdn, 0, ctime) == 0);
 118         fail_unless(memdb_mkdir(memdb, sdn, 0, ctime) == -EEXIST);
 119         fail_unless(memdb_delete(memdb, dn, 0, ctime) == -ENOTEMPTY);
 120         fail_unless(memdb_delete(memdb, sdn, 0, ctime) == 0);
 121         fail_unless(memdb_delete(memdb, dn, 0, ctime) == 0);
 122 }
 123 END_TEST
 124
 125 START_TEST (test_filetest1)
 126 {
 127         const char *dn = "/dir1";
 128         const char *fn = "/dir1/f1";
 129         time_t ctime = 1234;
 130         gpointer data;
 131
 132         char buf[1024];
 133         memset(buf, 0, sizeof(buf));
 134
 135         fail_unless(memdb_read(memdb, fn, &data) == -ENOENT);
 136
 137         fail_unless(memdb_mkdir(memdb, dn, 0, ctime) == 0);
 138
 139         fail_unless(memdb_read(memdb, fn, &data) == -ENOENT);
 140
 141         fail_unless(memdb_write(memdb, fn, 0, ctime, buf, sizeof(buf), 0, 0) == -ENOENT);
 142
 143         fail_unless(memdb_create(memdb, fn, 0, ctime) == 0);
 144
 145         fail_unless(memdb_write(memdb, fn, 0, ctime, buf, sizeof(buf), 0, 0) == sizeof(buf));
 146
 147         fail_unless(memdb_read(memdb, fn, &data) == sizeof(buf));
 148
 149         fail_unless(memcmp(buf, data, sizeof(buf)) == 0);
 150
 151         g_free(data);
 152
 153         fail_unless(memdb_write(memdb, fn, 0, ctime, "0123456789", 10, 0, 1) == 10);
 154
 155         fail_unless(memdb_read(memdb, fn, &data) == 10);
 156         g_free(data);
 157
 158         fail_unless(memdb_write(memdb, fn, 0, ctime, "X", 1, 3, 0) == 1);
 159
 160         fail_unless(memdb_write(memdb, fn, 0, ctime, "X", 1, 6, 0) == 1);
 161
 162         fail_unless(memdb_read(memdb, fn, &data) == 10);
 163
 164         fail_unless(strncmp(data, "012X45X789", 10) == 0);
 165         g_free(data);
 166
 167         fail_unless(memdb_delete(memdb, fn, 0, ctime) == 0);
 168
 169         fail_unless(memdb_delete(memdb, fn, 0, ctime) == -ENOENT);
 170
 171         fail_unless(memdb_delete(memdb, dn, 0, ctime) == 0);
 172 }
 173 END_TEST
 174
 175 /* Nornmaly, parent inode number is always less than contained inode,
 176  * but this is not allways the case. A simple move can destroy that
 177  * ordering. This code test the placeholder algorithm in
 178  * bdb_backend_load_index()
 179  */
 180 START_TEST (test_loaddb1)
 181 {
 182         time_t ctime = 1234;
 183
 184         fail_unless(memdb_mkdir(memdb, "dir1", 0, ctime) == 0);
 185
 186         fail_unless(memdb_create(memdb, "dir1/file1", 0, ctime) == 0);
 187
 188         fail_unless(memdb_create(memdb, "dir1/file2", 0, ctime) == 0);
 189
 190         fail_unless(memdb_mkdir(memdb, "dir2", 0, ctime) == 0);
 191
 192         fail_unless(memdb_rename(memdb, "dir1/file1", "dir2/file1", 0, ctime) == 0);
 193
 194         fail_unless(memdb_rename(memdb, "dir1/file2", "dir2/file2", 0, ctime) == 0);
 195
 196         fail_unless(memdb_create(memdb, "dir2/file1", 0, ctime) == -EEXIST);
 197
 198         fail_unless(memdb_create(memdb, "dir2/file2", 0, ctime) == -EEXIST);
 199
 200         //memdb_dump(memdb);
 201
 202         memdb_close(memdb);
 203
 204         memdb = memdb_open(TESTDB);
 205         fail_unless (memdb != NULL);
 206
 207         fail_unless(memdb_create(memdb, "dir2/file1", 0, ctime) == -EEXIST);
 208
 209         fail_unless(memdb_create(memdb, "dir2/file2", 0, ctime) == -EEXIST);
 210
 211         //memdb_dump(memdb);
 212
 213 }
 214 END_TEST
 215
 216 START_TEST (test_loaddb2)
 217 {
 218         time_t ctime = 1234;
 219
 220         fail_unless(memdb_mkdir(memdb, "dir1", 0, ctime) == 0);
 221
 222         fail_unless(memdb_mkdir(memdb, "dir1/sd1", 0, ctime) == 0);
 223
 224         fail_unless(memdb_create(memdb, "dir1/file1", 0, ctime) == 0);
 225
 226         fail_unless(memdb_create(memdb, "dir1/file2", 0, ctime) == 0);
 227
 228         fail_unless(memdb_mkdir(memdb, "dir2", 0, ctime) == 0);
 229
 230         fail_unless(memdb_rename(memdb, "dir1/sd1", "dir2/sd1", 0, ctime) == 0);
 231
 232         fail_unless(memdb_rename(memdb, "dir1/file1", "dir2/sd1/file1", 0, ctime) == 0);
 233
 234         fail_unless(memdb_rename(memdb, "dir1/file2", "dir2/sd1/file2", 0, ctime) == 0);
 235
 236         fail_unless(memdb_create(memdb, "dir2/file3", 0, ctime) == 0);
 237
 238         fail_unless(memdb_mkdir(memdb, "dir2/sd1", 0, ctime) == -EEXIST);
 239
 240         //memdb_dump(memdb);
 241
 242         memdb_close(memdb);
 243
 244         memdb = memdb_open(TESTDB);
 245         fail_unless (memdb != NULL);
 246
 247         fail_unless(memdb_mkdir(memdb, "dir2/sd1", 0, ctime) == -EEXIST);
 248
 249         //memdb_dump(memdb);
 250
 251 }
 252 END_TEST
 253
 254 static void
 255 add_test(
 256         Suite *s,
 257         TFun tf,
 258         const char *name)
 259 {
 260         TCase *tc = tcase_create (name);
 261         tcase_add_checked_fixture (tc, setup, teardown);
 262         tcase_add_test (tc, tf);
 263         suite_add_tcase (s, tc);
 264 }
 265
 266 static Suite *
 267 memdb_suite(void)
 268 {
 269         Suite *s = suite_create ("memdb");
 270
 271         add_test(s, test_dirtest1, "dirtest1");
 272
 273         add_test(s, test_filetest1, "filetest1");
 274
 275         add_test(s, test_indextest1, "indextest1");
 276
 277         add_test(s, test_loaddb1, "loaddb1");
 278
 279         add_test(s, test_loaddb2, "loaddb2");
 280
 281         return s;
 282 }
 283
 284 int
 285 main(void)
 286 {
 287         int number_failed;
 288
 289         cfs_status_init();
 290
 291         Suite *s = memdb_suite();
 292         SRunner *sr = srunner_create(s);
 293         srunner_run_all(sr, CK_NORMAL);
 294         number_failed = srunner_ntests_failed(sr);
 295         srunner_free(sr);
 296
 297         return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 298 }
 299