src/tests/testUfs.cc

   1 #define SQUID_UNIT_TEST 1
   2 #include "squid.h"
   3
   4 #include "DiskIO/DiskIOModule.h"
   5 #include "fs/ufs/UFSSwapDir.h"
   6 #include "globals.h"
   7 #include "HttpHeader.h"
   8 #include "HttpReply.h"
   9 #include "Mem.h"
  10 #include "MemObject.h"
  11 #include "protos.h"
  12 #include "Store.h"
  13 #include "SwapDir.h"
  14 #include "testStoreSupport.h"
  15 #include "testUfs.h"
  16
  17 #if HAVE_STDEXCEPT
  18 #include <stdexcept>
  19 #endif
  20
  21 #define TESTDIR "testUfs__testUfsSearch"
  22
  23 CPPUNIT_TEST_SUITE_REGISTRATION( testUfs );
  24
  25 typedef RefCount<Fs::Ufs::UFSSwapDir> SwapDirPointer;
  26 extern REMOVALPOLICYCREATE createRemovalPolicy_lru;     /* XXX fails with --enable-removal-policies=heap */
  27
  28 static void
  29 addSwapDir(SwapDirPointer aStore)
  30 {
  31     allocate_new_swapdir(&Config.cacheSwap);
  32     Config.cacheSwap.swapDirs[Config.cacheSwap.n_configured] = aStore.getRaw();
  33     ++Config.cacheSwap.n_configured;
  34 }
  35
  36 /* TODO make this a cbdata class */
  37
  38 static bool cbcalled;
  39
  40 static void
  41 searchCallback(void *cbdata)
  42 {
  43     cbcalled = true;
  44 }
  45
  46 void
  47 testUfs::commonInit()
  48 {
  49     static bool inited = false;
  50
  51     if (inited)
  52         return;
  53
  54     Config.Store.avgObjectSize = 1024;
  55
  56     Config.Store.objectsPerBucket = 20;
  57
  58     Config.Store.maxObjectSize = 2048;
  59
  60     Config.store_dir_select_algorithm = xstrdup("round-robin");
  61
  62     Config.replPolicy = new RemovalPolicySettings;
  63
  64     Config.replPolicy->type = xstrdup ("lru");
  65
  66     /* garh garh */
  67     storeReplAdd("lru", createRemovalPolicy_lru);
  68
  69     Mem::Init();
  70
  71     comm_init();
  72
  73     httpHeaderInitModule();     /* must go before any header processing (e.g. the one in errorInitialize) */
  74
  75     httpReplyInitModule();      /* must go before accepting replies */
  76
  77     inited = true;
  78 }
  79
  80 void
  81 testUfs::testUfsSearch()
  82 {
  83     /* test sequence
  84      * make a valid working ufs swapdir
  85      * put two entries in it and sync logs
  86      * search the ufs dir
  87      * check the entries we find are what we want
  88      */
  89
  90     if (0 > system ("rm -rf " TESTDIR))
  91         throw std::runtime_error("Failed to clean test work directory");
  92
  93     Store::Root(new StoreController);
  94
  95     SwapDirPointer aStore (new Fs::Ufs::UFSSwapDir("ufs", "Blocking"));
  96
  97     aStore->IO = new Fs::Ufs::UFSStrategy(DiskIOModule::Find("Blocking")->createStrategy());
  98
  99     addSwapDir(aStore);
 100
 101     commonInit();
 102     mem_policy = createRemovalPolicy(Config.replPolicy);
 103
 104     char *path=xstrdup(TESTDIR);
 105
 106     char *config_line=xstrdup("foo 100 1 1");
 107
 108     visible_appname_string = xstrdup(PACKAGE "/" VERSION);
 109
 110     strtok(config_line, w_space);
 111
 112     aStore->parse(0, path);
 113
 114     safe_free(path);
 115
 116     safe_free(config_line);
 117
 118     /* ok, ready to create */
 119     aStore->create();
 120
 121     /* ok, ready to use - inits store & hash too */
 122     Store::Root().init();
 123
 124     /* our swapdir must be scheduled to rebuild */
 125     CPPUNIT_ASSERT_EQUAL(2, StoreController::store_dirs_rebuilding);
 126
 127     /* rebuild is a scheduled event */
 128     StockEventLoop loop;
 129
 130     while (StoreController::store_dirs_rebuilding > 1)
 131         loop.runOnce();
 132
 133     /* cannot use loop.run(); as the loop will never idle: the store-dir
 134      * clean() scheduled event prevents it
 135      */
 136
 137     /* nothing left to rebuild */
 138     CPPUNIT_ASSERT_EQUAL(1, StoreController::store_dirs_rebuilding);
 139
 140     /* add an entry */
 141     {
 142         /* Create "vary" base object */
 143         request_flags flags;
 144         flags.cachable = 1;
 145         StoreEntry *pe = storeCreateEntry("dummy url", "dummy log url", flags, METHOD_GET);
 146         HttpReply *rep = (HttpReply *) pe->getReply();  // bypass const
 147         rep->setHeaders(HTTP_OK, "dummy test object", "x-squid-internal/test", -1, -1, squid_curtime + 100000);
 148
 149         pe->setPublicKey();
 150
 151         pe->buffer();
 152         /* TODO: remove this when the metadata is separated */
 153         {
 154             Packer p;
 155             packerToStoreInit(&p, pe);
 156             pe->getReply()->packHeadersInto(&p);
 157             packerClean(&p);
 158         }
 159
 160         pe->flush();
 161         pe->timestampsSet();
 162         pe->complete();
 163         pe->swapOut();
 164         CPPUNIT_ASSERT(pe->swap_dirn == 0);
 165         CPPUNIT_ASSERT(pe->swap_filen == 0);
 166         pe->unlock();
 167     }
 168
 169     storeDirWriteCleanLogs(0);
 170
 171     /* here we cheat: we know that UFSSwapDirs search off disk. If we did an init call to a new
 172      * swapdir instance, we'd not be testing a clean build.
 173      */
 174     StoreSearchPointer search = aStore->search (NULL, NULL); /* search for everything in the store */
 175
 176     /* nothing should be immediately available */
 177 #if 0
 178
 179     CPPUNIT_ASSERT(search->next() == false);
 180 #endif
 181
 182     CPPUNIT_ASSERT(search->error() == false);
 183     CPPUNIT_ASSERT(search->isDone() == false);
 184     CPPUNIT_ASSERT(search->currentItem() == NULL);
 185
 186     /* trigger a callback */
 187     cbcalled = false;
 188     search->next(searchCallback, NULL);
 189     CPPUNIT_ASSERT(cbcalled == true);
 190
 191     /* we should have access to a entry now, that matches the entry we had before */
 192     //CPPUNIT_ASSERT(search->next() == false);
 193     CPPUNIT_ASSERT(search->error() == false);
 194     CPPUNIT_ASSERT(search->isDone() == false);
 195     CPPUNIT_ASSERT(search->currentItem() != NULL);
 196
 197     /* trigger another callback */
 198     cbcalled = false;
 199     search->next(searchCallback, NULL);
 200     CPPUNIT_ASSERT(cbcalled == true);
 201
 202     /* now we should have no error, we should have finished and have no current item */
 203     //CPPUNIT_ASSERT(search->next() == false);
 204     CPPUNIT_ASSERT(search->error() == false);
 205     CPPUNIT_ASSERT(search->isDone() == true);
 206     CPPUNIT_ASSERT(search->currentItem() == NULL);
 207
 208     Store::Root(NULL);
 209
 210     free_cachedir(&Config.cacheSwap);
 211
 212     /* todo: here we should test a dirty rebuild */
 213
 214     safe_free(Config.replPolicy->type);
 215     delete Config.replPolicy;
 216
 217     if (0 > system ("rm -rf " TESTDIR))
 218         throw std::runtime_error("Failed to clean test work directory");
 219 }
 220
 221 /* The UFS store should always configure an IO engine even if none is
 222  * supplied on the configuration line.
 223  */
 224 void
 225 testUfs::testUfsDefaultEngine()
 226 {
 227     /* boring common test boilerplate */
 228     if (0 > system ("rm -rf " TESTDIR))
 229         throw std::runtime_error("Failed to clean test work directory");
 230
 231     // This assertion may fail if previous test cases fail.
 232     // Apparently, CPPUNIT_ASSERT* failure may prevent destructors of local
 233     // objects such as "StorePointer aRoot" from being called.
 234     CPPUNIT_ASSERT(!store_table); // or StoreHashIndex ctor will abort below
 235
 236     Store::Root(new StoreController);
 237     SwapDirPointer aStore (new Fs::Ufs::UFSSwapDir("ufs", "Blocking"));
 238     addSwapDir(aStore);
 239     commonInit();
 240     Config.replPolicy = new RemovalPolicySettings;
 241     Config.replPolicy->type = xstrdup ("lru");
 242     mem_policy = createRemovalPolicy(Config.replPolicy);
 243
 244     char *path=xstrdup(TESTDIR);
 245     char *config_line=xstrdup("foo 100 1 1");
 246     strtok(config_line, w_space);
 247     aStore->parse(0, path);
 248     safe_free(path);
 249     safe_free(config_line);
 250     CPPUNIT_ASSERT(aStore->IO->io != NULL);
 251
 252     Store::Root(NULL);
 253     free_cachedir(&Config.cacheSwap);
 254     safe_free(Config.replPolicy->type);
 255     delete Config.replPolicy;
 256
 257     if (0 > system ("rm -rf " TESTDIR))
 258         throw std::runtime_error("Failed to clean test work directory");
 259 }