netwerk/test/TestCacheCollisions.js

   1 var DEBUG = true;
   2
   3 var clientID = "HTTP";
   4 var nsICache = Components.interfaces.nsICache;
   5
   6 function getEventQueue()
   7 {
   8     var nsIEventQueueService = Components.interfaces.nsIEventQueueService;
   9     var CID = Components.classes["@mozilla.org/event-queue-service;1"];
  10     var service = CID.getService(nsIEventQueueService);
  11     return service.getSpecialEventQueue(nsIEventQueueService.CURRENT_THREAD_EVENT_QUEUE);
  12 }
  13
  14 var eventQueue = getEventQueue();
  15
  16 function getCacheService()
  17 {
  18     var nsCacheService = Components.classes["@mozilla.org/network/cache-service;1"];
  19     var service = nsCacheService.getService(Components.interfaces.nsICacheService);
  20     return service;
  21 }
  22
  23 function createCacheSession(clientID, storagePolicy, streamable)
  24 {
  25     var service = getCacheService();
  26     var session = service.createSession(clientID, storagePolicy, streamable);
  27     return session;
  28 }
  29
  30 function openCacheEntry(url, mode)
  31 {
  32     var session = createCacheSession(clientID, nsICache.STORE_ON_DISK, true);
  33     var entry = session.openCacheEntry(url, mode);
  34     return entry;
  35 }
  36
  37 function dumpLeaks()
  38 {
  39     var leakDetector = Components.classes["@mozilla.org/xpcom/leakdetector;1"].getService(Components.interfaces.nsILeakDetector);
  40     leakDetector.dumpLeaks();
  41 }
  42
  43 function wrapInputStream(input)
  44 {
  45     var nsIScriptableInputStream = Components.interfaces.nsIScriptableInputStream;
  46     var factory = Components.classes["@mozilla.org/scriptableinputstream;1"];
  47     var wrapper = factory.createInstance(nsIScriptableInputStream);
  48     wrapper.init(input);
  49     return wrapper;
  50 }
  51
  52 function download(key)
  53 {
  54     var url = new java.net.URL(key);
  55     var data = "";
  56     var buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 65536);
  57     var stream = url.openStream();
  58     while (true) {
  59         var count = stream.read(buffer);
  60         if (count <= 0)
  61             break;
  62         var str = new java.lang.String(buffer, 0, count);
  63         data += str;
  64     }
  65     stream.close();
  66     return data;
  67 }
  68
  69 function write(url, data)
  70 {
  71     var key = url.toString();
  72     var outputEntry = openCacheEntry(key, nsICache.ACCESS_WRITE);
  73     var output = outputEntry.transport.openOutputStream(0, -1, 0);
  74     var count = output.write(data, data.length);
  75
  76     // store some metadata.
  77     outputEntry.setMetaDataElement("size", data.length);
  78
  79     output.close();
  80     outputEntry.markValid();
  81     outputEntry.close();
  82
  83     return count;
  84 }
  85
  86 function CacheListener()
  87 {
  88     this.done = false;
  89 }
  90
  91 CacheListener.prototype = {
  92     QueryInterface : function(iid)
  93     {
  94         if (iid.equals(Components.interfaces.nsICacheListener))
  95             return this;
  96         throw Components.results.NS_NOINTERFACE;
  97     },
  98
  99     onCacheEntryAvailable : function(/* in nsICacheEntryDescriptor */   descriptor,
 100                                      /* in nsCacheAccessMode */         accessGranted,
 101                                      /* in nsresult */                  status)
 102     {
 103         this.descriptor = descriptor;
 104         this.status = status;
 105         this.done = true;
 106     }
 107 };
 108
 109 function asyncOpenCacheEntry(url, mode)
 110 {
 111     var session = createCacheSession(clientID, nsICache.STORE_ON_DISK, true);
 112     var listener = new CacheListener();
 113     session.asyncOpenCacheEntry(url, mode, listener);
 114     while (!listener.done)
 115         eventQueue.processPendingEvents();
 116     return listener.descriptor;
 117 }
 118
 119 function asyncWrite(key, data)
 120 {
 121     var outputEntry = asyncOpenCacheEntry(key, nsICache.ACCESS_WRITE);
 122
 123     var output = outputEntry.transport.openOutputStream(0, -1, 0);
 124     var count = output.write(data, data.length);
 125
 126     // store some metadata.
 127     outputEntry.setMetaDataElement("size", data.length);
 128
 129     output.close();
 130     outputEntry.markValid();
 131     outputEntry.close();
 132
 133     return count;
 134 }
 135
 136 function StreamListener()
 137 {
 138     this.done = false;
 139     this.data = "";
 140     this.wrapper = null;
 141 }
 142
 143 StreamListener.prototype = {
 144     QueryInterface : function(iid)
 145     {
 146         if (iid.equals(Components.interfaces.nsIStreamListener) ||
 147             iid.equals(Components.interfaces.nsIStreamObserver))
 148             return this;
 149         throw Components.results.NS_NOINTERFACE;
 150     },
 151
 152     onStartRequest : function(request, context)
 153     {
 154     },
 155
 156     onStopRequest : function(request, context, statusCode, statusText)
 157     {
 158         this.statusCode = statusCode;
 159         this.done = true;
 160     },
 161
 162     onDataAvailable : function(request, context, input, offset, count)
 163     {
 164         if (this.wrapper == null)
 165             this.wrapper = wrapInputStream(input);
 166         input = this.wrapper;
 167         this.data += input.read(count);
 168     }
 169 };
 170
 171 function asyncRead(key)
 172 {
 173     var inputEntry = asyncOpenCacheEntry(key, nsICache.ACCESS_READ);
 174     var listener = new StreamListener();
 175     inputEntry.transport.asyncRead(listener, null, 0, inputEntry.dataSize, 0);
 176     while (!listener.done)
 177         eventQueue.processPendingEvents();
 178     inputEntry.close();
 179     return listener.data;
 180 }
 181
 182 function read(key)
 183 {
 184     var inputEntry = openCacheEntry(key, nsICache.ACCESS_READ);
 185     var input = wrapInputStream(inputEntry.transport.openInputStream(0, -1, 0));
 186     var data = input.read(input.available());
 187     input.close();
 188     inputEntry.close();
 189     return data;
 190 }
 191
 192 function readMetaData(key, element)
 193 {
 194     var inputEntry = openCacheEntry(key, nsICache.ACCESS_READ);
 195     var metadata = inputEntry.getMetaDataElement(element);
 196     inputEntry.close();
 197     return metadata;
 198 }
 199
 200 function doom(url)
 201 {
 202     var key = url.toString();
 203     var doomedEntry = openCacheEntry(key, nsICache.ACCESS_READ_WRITE);
 204     doomedEntry.doom();
 205     doomedEntry.close();
 206 }
 207
 208 // two keys which are known to collide right now.
 209 var key1 = "http://a772.g.akamai.net/7/772/51/7648437e551b56/www.apple.com/t/2001/us/en/i/2.gif";
 210 var key2 = "http://a772.g.akamai.net/7/772/51/70601300d0bde6/www.apple.com/t/2001/us/en/i/1right.gif";
 211
 212 function test()
 213 {
 214     // 1. generate a collision, and close the colliding entry first.
 215     var entry1 = asyncOpenCacheEntry(key1, nsICache.ACCESS_READ_WRITE);
 216     var data1 = key1;
 217     entry1.setMetaDataElement("size", data1.length);
 218     entry1.markValid();
 219     var output1 = entry1.transport.openOutputStream(0, -1, 0);
 220     output1.write(data1, data1.length);
 221
 222     var entry2 = asyncOpenCacheEntry(key2, nsICache.ACCESS_READ_WRITE);
 223     var data2 = key2;
 224     entry2.setMetaDataElement("size", data2.length);
 225     entry2.markValid();
 226     var output2 = entry2.transport.openOutputStream(0, -1, 0);
 227     output2.write(data2, data2.length);
 228
 229     output1.close();
 230     output2.close();
 231
 232     entry1.close();
 233     entry2.close();
 234 }
 235
 236 function median(array)
 237 {
 238     var cmp = function(x, y) { return x - y; }
 239     array.sort(cmp);
 240     var middle = Math.floor(array.length / 2);
 241     return array[middle];
 242 }
 243
 244 function sum(array)
 245 {
 246     var s = 0;
 247     var len = array.length;
 248     for (var i = 0; i < len; ++i)
 249         s += array[i];
 250     return s;
 251 }
 252
 253 function time()
 254 {
 255     var N = 50;
 256     var System = java.lang.System;
 257     var url = new java.net.URL("http://www.mozilla.org");
 258     var key = url.toString();
 259     var downloadTimes = new Array();
 260     for (var i = 0; i < N; ++i) {
 261         var begin = System.currentTimeMillis();
 262         download(url);
 263         var end = System.currentTimeMillis();
 264         downloadTimes.push(end - begin);
 265     }
 266     var downloadTotal = sum(downloadTimes);
 267     var downloadMean = downloadTotal / N;
 268     var downloadMedian = median(downloadTimes);
 269     print("" + N + " downloads took " + downloadTotal + " milliseconds.");
 270     print("mean = " + downloadMean + " milliseconds.");
 271     print("median = " + downloadMedian + " milliseconds.");
 272
 273     var readTimes = new Array();
 274     for (var i = 0; i < N; ++i) {
 275         var begin = System.currentTimeMillis();
 276         asyncRead(key);
 277         var end = System.currentTimeMillis();
 278         readTimes.push(end - begin);
 279     }
 280     var readTotal = sum(readTimes);
 281     var readMean = readTotal / N;
 282     var readMedian = median(readTimes);
 283     print("" + N + " reads took " + readTotal + " milliseconds.");
 284     print("mean = " + readMean + " milliseconds.");
 285     print("median = " + readMedian + " milliseconds.");
 286 }
 287
 288 // load the cache service before doing anything with Java...
 289 getCacheService();
 290
 291 if (DEBUG) {
 292     print("cache service loaded.");
 293 } else {
 294     print("running disk cache test.");
 295     test();
 296     print("disk cache test complete.");
 297 }