/*
- * $Id: Store.h,v 1.31 2007/04/20 23:10:59 wessels Exp $
+ * $Id: Store.h,v 1.32 2007/04/20 23:53:41 wessels Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
void unlink();
void makePublic();
void makePrivate();
- void cacheNegatively();
+ void setPublicKey();
+ void setPrivateKey();
+ void expireNow();
+ void releaseRequest();
+ void negativeCache();
+ void cacheNegatively(); /* argh, why both? */
+ void invokeHandlers();
+ void purgeMem();
void swapOut();
bool swapOutAble() const;
void swapOutFileClose();
SQUIDCEXTERN StoreEntry *storeGetPublicByRequest(HttpRequest * request);
SQUIDCEXTERN StoreEntry *storeGetPublicByRequestMethod(HttpRequest * request, const method_t method);
SQUIDCEXTERN StoreEntry *storeCreateEntry(const char *, const char *, request_flags, method_t);
-SQUIDCEXTERN void storeSetPublicKey(StoreEntry *);
SQUIDCEXTERN void storeCreateMemObject(StoreEntry *, const char *, const char *);
SQUIDCEXTERN void storeInit(void);
extern void storeRegisterWithCacheManager(CacheManager & manager);
SQUIDCEXTERN void storeAppend(StoreEntry *, const char *, int);
-SQUIDCEXTERN void storeExpireNow(StoreEntry *);
-SQUIDCEXTERN void storeReleaseRequest(StoreEntry *);
SQUIDCEXTERN void storeConfigure(void);
SQUIDCEXTERN int storeCheckNegativeHit(StoreEntry *);
-SQUIDCEXTERN void storeNegativeCache(StoreEntry *);
SQUIDCEXTERN void storeFreeMemory(void);
SQUIDCEXTERN int expiresMoreThan(time_t, time_t);
SQUIDCEXTERN int storeEntryValidToSend(StoreEntry *);
#endif
SQUIDCEXTERN void storeAppendVPrintf(StoreEntry *, const char *, va_list ap);
SQUIDCEXTERN int storeCheckCachable(StoreEntry * e);
-SQUIDCEXTERN void storeSetPrivateKey(StoreEntry *);
SQUIDCEXTERN ssize_t objectLen(const StoreEntry * e);
SQUIDCEXTERN int storeTooManyDiskFilesOpen(void);
SQUIDCEXTERN void storeEntryReset(StoreEntry *);
/*
- * $Id: client_side_reply.cc,v 1.118 2007/04/20 22:17:06 wessels Exp $
+ * $Id: client_side_reply.cc,v 1.119 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 88 Client-side Reply Routines
* AUTHOR: Robert Collins (Originally Duane Wessels in client_side.c)
http->logType = LOG_TCP_REDIRECT;
#endif
- storeReleaseRequest(http->storeEntry());
+ http->storeEntry()->releaseRequest();
rep->redirect(http->redirect.status, http->redirect.location);
http->storeEntry()->replaceHttpReply(rep);
http->storeEntry()->complete();
tempBuffer.data = next->readBuffer.data;
storeClientCopy(sc, http->storeEntry(),
tempBuffer, SendMoreData, this);
- storeReleaseRequest(http->storeEntry());
+ http->storeEntry()->releaseRequest();
storeBuffer(http->storeEntry());
HttpReply *rep = new HttpReply;
HttpVersion version(1,0);
/*
- * $Id: client_side_request.cc,v 1.81 2007/04/20 22:17:06 wessels Exp $
+ * $Id: client_side_request.cc,v 1.82 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 85 Client-side Request Routines
* AUTHOR: Robert Collins (Originally Duane Wessels in client_side.c)
// because we did not initiate that pipe (ConnStateData did)
/* the ICP check here was erroneous
- * - storeReleaseRequest was always called if entry was valid
+ * - StoreEntry::releaseRequest was always called if entry was valid
*/
assert(logType < LOG_TYPE_MAX);
/*
- * $Id: errorpage.cc,v 1.220 2006/11/07 03:00:52 hno Exp $
+ * $Id: errorpage.cc,v 1.221 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 4 Error Generation
* AUTHOR: Duane Wessels
EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
storeBufferFlush(entry);
entry->complete();
- storeNegativeCache(entry);
- storeReleaseRequest(entry);
+ entry->negativeCache();
+ entry->releaseRequest();
entry->unlock();
errorStateFree(err);
}
/*
- * $Id: forward.cc,v 1.158 2007/04/16 18:35:29 wessels Exp $
+ * $Id: forward.cc,v 1.159 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 17 Request Forwarding
* AUTHOR: Duane Wessels
} else {
EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
entry->complete();
- storeReleaseRequest(entry);
+ entry->releaseRequest();
}
}
/*
- * $Id: store_dir_coss.cc,v 1.68 2006/09/14 00:51:10 robertc Exp $
+ * $Id: store_dir_coss.cc,v 1.69 2007/04/20 23:53:42 wessels Exp $
* vim: set et :
*
* DEBUG: section 47 Store COSS Directory Routines
* because adding to store_swap_size happens in
* the cleanup procedure.
*/
- storeExpireNow(e);
- storeReleaseRequest(e);
+ e->expireNow();
+ e->releaseRequest();
if (e->swap_filen > -1) {
e->swap_filen = -1;
/*
- * $Id: ufscommon.cc,v 1.8 2007/04/12 23:51:58 wessels Exp $
+ * $Id: ufscommon.cc,v 1.9 2007/04/20 23:53:42 wessels Exp $
* vim: set et :
*
* DEBUG: section 47 Store Directory Routines
* because adding to store_swap_size happens in
* the cleanup procedure.
*/
- storeExpireNow(currentEntry());
- storeReleaseRequest(currentEntry());
+ currentEntry()->expireNow();
+ currentEntry()->releaseRequest();
if (currentEntry()->swap_filen > -1) {
UFSSwapDir *sdForThisEntry = dynamic_cast<UFSSwapDir *>(INDEXSD(currentEntry()->swap_dirn));
} else if (currentEntry()) {
/* key already exists, this swapfile not being used */
/* junk old, load new */
- storeExpireNow(currentEntry());
- storeReleaseRequest(currentEntry());
+ currentEntry()->expireNow();
+ currentEntry()->releaseRequest();
if (currentEntry()->swap_filen > -1) {
UFSSwapDir *sdForThisEntry = dynamic_cast<UFSSwapDir *>(INDEXSD(currentEntry()->swap_dirn));
/*
- * $Id: ftp.cc,v 1.412 2007/04/16 21:49:03 wessels Exp $
+ * $Id: ftp.cc,v 1.413 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 9 File Transfer Protocol (FTP)
* AUTHOR: Harvest Derived
*/
e->release();
} else if (EBIT_TEST(e->flags, ENTRY_CACHABLE) && !restarted_offset) {
- storeSetPublicKey(e);
+ e->setPublicKey();
} else {
e->release();
}
/*
- * $Id: gopher.cc,v 1.200 2006/09/19 07:56:57 adrian Exp $
+ * $Id: gopher.cc,v 1.201 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 10 Gopher
* AUTHOR: Harvest Derived
comm_write(fd, buf, strlen(buf), gopherSendComplete, gopherState, NULL);
if (EBIT_TEST(gopherState->entry->flags, ENTRY_CACHABLE))
- storeSetPublicKey(gopherState->entry); /* Make it public */
+ gopherState->entry->setPublicKey(); /* Make it public */
}
CBDATA_TYPE(GopherStateData);
/*
- * $Id: htcp.cc,v 1.72 2007/04/12 05:03:54 wessels Exp $
+ * $Id: htcp.cc,v 1.73 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 31 Hypertext Caching Protocol
* AUTHOR: Duane Wesssels
htcpClrStoreEntry(StoreEntry * e)
{
debug(31, 4) ("htcpClrStoreEntry: Clearing store for entry: %s\n", storeUrl(e));
- storeReleaseRequest(e);
+ e->releaseRequest();
}
static int
/*
- * $Id: http.cc,v 1.513 2007/04/15 14:46:16 serassio Exp $
+ * $Id: http.cc,v 1.514 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 11 Hypertext Transfer Protocol (HTTP)
* AUTHOR: Harvest Derived
* for example, the request to this neighbor fails.
*/
if (_peer->options.proxy_only)
- storeReleaseRequest(entry);
+ entry->releaseRequest();
#if DELAY_POOLS
/*
- * $Id: mime.cc,v 1.128 2006/09/20 06:29:10 adrian Exp $
+ * $Id: mime.cc,v 1.129 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 25 MIME Parsing
* AUTHOR: Harvest Derived
METHOD_GET);
assert(e != NULL);
EBIT_SET(e->flags, ENTRY_SPECIAL);
- storeSetPublicKey(e);
+ e->setPublicKey();
storeBuffer(e);
HttpRequest *r = HttpRequest::CreateFromUrl(url);
/*
- * $Id: neighbors.cc,v 1.345 2007/04/20 07:29:47 wessels Exp $
+ * $Id: neighbors.cc,v 1.346 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 15 Neighbor Routines
* AUTHOR: Harvest Derived
EBIT_SET(fake->flags, ENTRY_ABORTED);
HTTPMSGUNLOCK(fake->mem_obj->request);
- storeReleaseRequest(fake);
+ fake->releaseRequest();
fake->unlock();
HTTPMSGUNLOCK(psstate->request);
cbdataFree(psstate);
/*
- * $Id: peer_digest.cc,v 1.119 2007/04/12 23:30:09 wessels Exp $
+ * $Id: peer_digest.cc,v 1.120 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 72 Peer Digest Routines
* AUTHOR: Alex Rousskov
if (fetch->old_entry) {
debug(72, 3) ("peerDigestFetchReply: got new digest, releasing old one\n");
storeUnregister(fetch->old_sc, fetch->old_entry, fetch);
- storeReleaseRequest(fetch->old_entry);
+ fetch->old_entry->releaseRequest();
fetch->old_entry->unlock();
fetch->old_entry = NULL;
}
if (fetch->old_entry) {
debug(72, 2) ("peerDigestFetchFinish: deleting old entry\n");
storeUnregister(fetch->old_sc, fetch->old_entry, fetch);
- storeReleaseRequest(fetch->old_entry);
+ fetch->old_entry->releaseRequest();
fetch->old_entry->unlock();
fetch->old_entry = NULL;
}
/*
- * $Id: protos.h,v 1.541 2007/04/17 23:05:17 wessels Exp $
+ * $Id: protos.h,v 1.542 2007/04/20 23:53:41 wessels Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
SQUIDCEXTERN store_client *storeClientListAdd(StoreEntry * e, void *data);
SQUIDCEXTERN int storeClientCopyPending(store_client *, StoreEntry * e, void *data);
SQUIDCEXTERN int storeUnregister(store_client * sc, StoreEntry * e, void *data);
-SQUIDCEXTERN void InvokeHandlers(StoreEntry * e);
SQUIDCEXTERN int storePendingNClients(const StoreEntry * e);
SQUIDCEXTERN int storeClientIsThisAClient(store_client * sc, void *someClient);
/*
- * $Id: store.cc,v 1.607 2007/04/20 23:10:59 wessels Exp $
+ * $Id: store.cc,v 1.608 2007/04/20 23:53:41 wessels Exp $
*
* DEBUG: section 20 Storage Manager
* AUTHOR: Harvest Derived
static void storeGetMemSpace(int);
static void storeHashDelete(StoreEntry *);
static void destroy_MemObject(StoreEntry *);
-static void storePurgeMem(StoreEntry *);
static int getKeyCounter(void);
static int storeKeepInMemory(const StoreEntry *);
static OBJH storeCheckCachableStats;
/* This object can be cached for a long time */
if (EBIT_TEST(flags, ENTRY_CACHABLE))
- storeSetPublicKey(this);
+ setPublicKey();
}
void
StoreEntry::makePrivate()
{
/* This object should never be cached at all */
- storeExpireNow(this);
- storeReleaseRequest(this); /* delete object when not used */
- /* storeReleaseRequest clears ENTRY_CACHABLE flag */
+ expireNow();
+ releaseRequest(); /* delete object when not used */
+ /* releaseRequest clears ENTRY_CACHABLE flag */
}
void
StoreEntry::cacheNegatively()
{
/* This object may be negatively cached */
- storeNegativeCache(this);
+ negativeCache();
if (EBIT_TEST(flags, ENTRY_CACHABLE))
- storeSetPublicKey(this);
+ setPublicKey();
}
size_t
/* get rid of memory copy of the object */
-static void
-storePurgeMem(StoreEntry * e)
+void
+StoreEntry::purgeMem()
{
- if (e->mem_obj == NULL)
+ if (mem_obj == NULL)
return;
- debug(20, 3) ("storePurgeMem: Freeing memory-copy of %s\n",
- e->getMD5Text());
+ debug(20, 3) ("StoreEntry::purgeMem: Freeing memory-copy of %s\n",
+ getMD5Text());
- destroy_MemObject(e);
+ destroy_MemObject(this);
- if (e->swap_status != SWAPOUT_DONE)
- e->release();
+ if (swap_status != SWAPOUT_DONE)
+ release();
}
/* RBC 20050104 this is wrong- memory ref counting
}
void
-storeReleaseRequest(StoreEntry * e)
+StoreEntry::releaseRequest()
{
- if (EBIT_TEST(e->flags, RELEASE_REQUEST))
+ if (EBIT_TEST(flags, RELEASE_REQUEST))
return;
- e->setReleaseFlag();
+ setReleaseFlag();
/*
* Clear cachable flag here because we might get called before
* anyone else even looks at the cachability flag. Also, this
* prevents httpMakePublic from really setting a public key.
*/
- EBIT_CLR(e->flags, ENTRY_CACHABLE);
+ EBIT_CLR(flags, ENTRY_CACHABLE);
- storeSetPrivateKey(e);
+ setPrivateKey();
}
/* unlock object, return -1 if object get released after unlock
if (EBIT_TEST(flags, KEY_PRIVATE))
debug(20, 1) ("WARNING: %s:%d: found KEY_PRIVATE\n", __FILE__, __LINE__);
- /* storePurgeMem may free e */
- storePurgeMem(this);
+ /* StoreEntry::purgeMem may free e */
+ purgeMem();
}
return 0;
* concept'.
*/
void
-storeSetPrivateKey(StoreEntry * e)
+StoreEntry::setPrivateKey()
{
const cache_key *newkey;
- MemObject *mem = e->mem_obj;
- if (e->key && EBIT_TEST(e->flags, KEY_PRIVATE))
+ if (key && EBIT_TEST(flags, KEY_PRIVATE))
return; /* is already private */
- if (e->key) {
- if (e->swap_filen > -1)
- storeDirSwapLog(e, SWAP_LOG_DEL);
+ if (key) {
+ if (swap_filen > -1)
+ storeDirSwapLog(this, SWAP_LOG_DEL);
- storeHashDelete(e);
+ storeHashDelete(this);
}
- if (mem != NULL) {
- mem->id = getKeyCounter();
- newkey = storeKeyPrivate(mem->url, mem->method, mem->id);
+ if (mem_obj != NULL) {
+ mem_obj->id = getKeyCounter();
+ newkey = storeKeyPrivate(mem_obj->url, mem_obj->method, mem_obj->id);
} else {
newkey = storeKeyPrivate("JUNK", METHOD_NONE, getKeyCounter());
}
assert(hash_lookup(store_table, newkey) == NULL);
- EBIT_SET(e->flags, KEY_PRIVATE);
- storeHashInsert(e, newkey);
+ EBIT_SET(flags, KEY_PRIVATE);
+ storeHashInsert(this, newkey);
}
void
-storeSetPublicKey(StoreEntry * e)
+StoreEntry::setPublicKey()
{
StoreEntry *e2 = NULL;
const cache_key *newkey;
- MemObject *mem = e->mem_obj;
- if (e->key && !EBIT_TEST(e->flags, KEY_PRIVATE))
+ if (key && !EBIT_TEST(flags, KEY_PRIVATE))
return; /* is already public */
- assert(mem);
+ assert(mem_obj);
/*
* We can't make RELEASE_REQUEST objects public. Depending on
* been freed from memory.
*
* If RELEASE_REQUEST is set, then ENTRY_CACHABLE should not
- * be set, and storeSetPublicKey() should not be called.
+ * be set, and StoreEntry::setPublicKey() should not be called.
*/
#if MORE_DEBUG_OUTPUT
- if (EBIT_TEST(e->flags, RELEASE_REQUEST))
+ if (EBIT_TEST(flags, RELEASE_REQUEST))
debug(20, 1) ("assertion failed: RELEASE key %s, url %s\n",
- e->key, mem->url);
+ key, mem->url);
#endif
- assert(!EBIT_TEST(e->flags, RELEASE_REQUEST));
+ assert(!EBIT_TEST(flags, RELEASE_REQUEST));
- if (mem->request) {
- HttpRequest *request = mem->request;
+ if (mem_obj->request) {
+ HttpRequest *request = mem_obj->request;
- if (!mem->vary_headers) {
+ if (!mem_obj->vary_headers) {
/* First handle the case where the object no longer varies */
safe_free(request->vary_headers);
} else {
- if (request->vary_headers && strcmp(request->vary_headers, mem->vary_headers) != 0) {
+ if (request->vary_headers && strcmp(request->vary_headers, mem_obj->vary_headers) != 0) {
/* Oops.. the variance has changed. Kill the base object
* to record the new variance key
*/
safe_free(request->vary_headers); /* free old "bad" variance key */
- StoreEntry *pe = storeGetPublic(mem->url, mem->method);
+ StoreEntry *pe = storeGetPublic(mem_obj->url, mem_obj->method);
if (pe)
pe->release();
/* Make sure the request knows the variance status */
if (!request->vary_headers) {
- const char *vary = httpMakeVaryMark(request, mem->getReply());
+ const char *vary = httpMakeVaryMark(request, mem_obj->getReply());
if (vary)
request->vary_headers = xstrdup(vary);
}
}
- if (mem->vary_headers && !storeGetPublic(mem->url, mem->method)) {
+ if (mem_obj->vary_headers && !storeGetPublic(mem_obj->url, mem_obj->method)) {
/* Create "vary" base object */
String vary;
- StoreEntry *pe = storeCreateEntry(mem->url, mem->log_url, request->flags, request->method);
+ StoreEntry *pe = storeCreateEntry(mem_obj->url, mem_obj->log_url, request->flags, request->method);
HttpVersion version(1, 0);
/* We are allowed to do this typecast */
HttpReply *rep = new HttpReply;
rep->setHeaders(version, HTTP_OK, "Internal marker object", "x-squid-internal/vary", -1, -1, squid_curtime + 100000);
- vary = mem->getReply()->header.getList(HDR_VARY);
+ vary = mem_obj->getReply()->header.getList(HDR_VARY);
if (vary.size()) {
/* Again, we own this structure layout */
}
#if X_ACCELERATOR_VARY
- vary = mem->getReply()->header.getList(HDR_X_ACCELERATOR_VARY);
+ vary = mem_obj->getReply()->header.getList(HDR_X_ACCELERATOR_VARY);
if (vary.buf()) {
/* Again, we own this structure layout */
pe->unlock();
}
- newkey = storeKeyPublicByRequest(mem->request);
+ newkey = storeKeyPublicByRequest(mem_obj->request);
} else
- newkey = storeKeyPublic(mem->url, mem->method);
+ newkey = storeKeyPublic(mem_obj->url, mem_obj->method);
if ((e2 = (StoreEntry *) hash_lookup(store_table, newkey))) {
- debug(20, 3) ("storeSetPublicKey: Making old '%s' private.\n", mem->url);
- storeSetPrivateKey(e2);
+ debug(20, 3) ("StoreEntry::setPublicKey: Making old '%s' private.\n", mem_obj->url);
+ e2->setPrivateKey();
e2->release();
- if (mem->request)
- newkey = storeKeyPublicByRequest(mem->request);
+ if (mem_obj->request)
+ newkey = storeKeyPublicByRequest(mem_obj->request);
else
- newkey = storeKeyPublic(mem->url, mem->method);
+ newkey = storeKeyPublic(mem_obj->url, mem_obj->method);
}
- if (e->key)
- storeHashDelete(e);
+ if (key)
+ storeHashDelete(this);
- EBIT_CLR(e->flags, KEY_PRIVATE);
+ EBIT_CLR(flags, KEY_PRIVATE);
- storeHashInsert(e, newkey);
+ storeHashInsert(this, newkey);
- if (e->swap_filen > -1)
- storeDirSwapLog(e, SWAP_LOG_ADD);
+ if (swap_filen > -1)
+ storeDirSwapLog(this, SWAP_LOG_ADD);
}
StoreEntry *
mem->method = method;
if (neighbors_do_private_keys || !flags.hierarchical)
- storeSetPrivateKey(e);
+ e->setPrivateKey();
else
- storeSetPublicKey(e);
+ e->setPublicKey();
if (flags.cachable) {
EBIT_SET(e->flags, ENTRY_CACHABLE);
EBIT_CLR(e->flags, RELEASE_REQUEST);
} else {
- /* storeReleaseRequest() clears ENTRY_CACHABLE */
- storeReleaseRequest(e);
+ /* StoreEntry::releaseRequest() clears ENTRY_CACHABLE */
+ e->releaseRequest();
}
e->store_status = STORE_PENDING;
/* Mark object as expired */
void
-storeExpireNow(StoreEntry * e)
+StoreEntry::expireNow()
{
- debug(20, 3) ("storeExpireNow: '%s'\n", e->getMD5Text());
- e->expires = squid_curtime;
+ debug(20, 3) ("StoreEntry::expireNow: '%s'\n", getMD5Text());
+ expires = squid_curtime;
}
void
return;
}
- InvokeHandlers(e);
+ e->invokeHandlers();
PROF_stop(storeWriteComplete);
}
* -RBC 20060903
*/
PROF_stop(StoreEntry_write);
- InvokeHandlers(this);
+ invokeHandlers();
return;
}
return 1;
}
- storeReleaseRequest(e);
- /* storeReleaseRequest() cleared ENTRY_CACHABLE */
+ e->releaseRequest();
+ /* StoreEntry::releaseRequest() cleared ENTRY_CACHABLE */
return 0;
}
if (!validLength()) {
EBIT_SET(flags, ENTRY_BAD_LENGTH);
- storeReleaseRequest(this);
+ releaseRequest();
}
#if USE_CACHE_DIGESTS
#endif
/*
- * We used to call InvokeHandlers, then storeSwapOut. However,
+ * We used to call invokeHandlers, then storeSwapOut. However,
* Madhukar Reddy <myreddy@persistence.com> reported that
* responses without content length would sometimes get released
* in client_side, thinking that the response is incomplete.
*/
- InvokeHandlers(this);
+ invokeHandlers();
}
/*
lock()
; /* lock while aborting */
- storeNegativeCache(this);
+ negativeCache();
- storeReleaseRequest(this);
+ releaseRequest();
EBIT_SET(flags, ENTRY_ABORTED);
* unneeded disk swapping triggered?
*/
/* Notify the client side */
- InvokeHandlers(this);
+ invokeHandlers();
/* Close any swapout file */
swapOutFileClose();
walker = mem_policy->PurgeInit(mem_policy, 100000);
while ((e = walker->Next(walker))) {
- storePurgeMem(e);
+ e->purgeMem();
released++;
if (mem_node::InUseCount() + pages_needed < store_pages_max)
* outstanding request, mark it for pending release */
if (storeEntryLocked(this)) {
- storeExpireNow(this);
+ expireNow();
debug(20, 3) ("storeRelease: Only setting RELEASE_REQUEST bit\n");
- storeReleaseRequest(this);
+ releaseRequest();
PROF_stop(storeRelease);
return;
}
if (StoreController::store_dirs_rebuilding && swap_filen > -1) {
- storeSetPrivateKey(this);
+ setPrivateKey();
if (mem_obj)
destroy_MemObject(this);
}
void
-storeNegativeCache(StoreEntry * e)
+StoreEntry::negativeCache()
{
- e->expires = squid_curtime + Config.negativeTtl;
- EBIT_SET(e->flags, ENTRY_NEGCACHED);
+ expires = squid_curtime + Config.negativeTtl;
+ EBIT_SET(flags, ENTRY_NEGCACHED);
}
void
{
if (EBIT_TEST(flags, DELAY_SENDING)) {
EBIT_CLR(flags, DELAY_SENDING);
- InvokeHandlers(this);
+ invokeHandlers();
}
}
* so we must make it PRIVATE. This is tricky/ugly because
* for the most part, we treat swapable == cachable here.
*/
- storeReleaseRequest(this);
+ releaseRequest();
mem_obj->trimUnSwappable ();
} else {
mem_obj->trimSwappable ();
/*
- * $Id: store_client.cc,v 1.153 2007/04/20 23:10:59 wessels Exp $
+ * $Id: store_client.cc,v 1.154 2007/04/20 23:53:42 wessels Exp $
*
* DEBUG: section 90 Storage Manager Client-Side Interface
* AUTHOR: Duane Wessels
/* Call handlers waiting for data to be appended to E. */
void
-InvokeHandlers(StoreEntry * e)
+StoreEntry::invokeHandlers()
{
/* Commit what we can to disk, if appropriate */
- e->swapOut();
+ swapOut();
int i = 0;
- MemObject *mem = e->mem_obj;
store_client *sc;
dlink_node *nx = NULL;
dlink_node *node;
- PROF_start(InvokeHandlers);
+ PROF_start(StoreEntry::invokeHandlers);
- debug(90, 3) ("InvokeHandlers: %s\n", e->getMD5Text());
+ debug(90, 3) ("StoreEntry::invokeHandlers: %s\n", getMD5Text());
/* walk the entire list looking for valid callbacks */
- for (node = mem->clients.head; node; node = nx) {
+ for (node = mem_obj->clients.head; node; node = nx) {
sc = (store_client *)node->data;
nx = node->next;
- debug(90, 3) ("InvokeHandlers: checking client #%d\n", i++);
+ debug(90, 3) ("StoreEntry::invokeHandlers: checking client #%d\n", i++);
if (!sc->_callback.pending())
continue;
if (sc->flags.disk_io_pending)
continue;
- storeClientCopy2(e, sc);
+ storeClientCopy2(this, sc);
}
- PROF_stop(InvokeHandlers);
+ PROF_stop(StoreEntry::invokeHandlers);
}
int
/*
- * $Id: store_digest.cc,v 1.71 2007/04/20 07:29:47 wessels Exp $
+ * $Id: store_digest.cc,v 1.72 2007/04/20 23:53:42 wessels Exp $
*
* DEBUG: section 71 Store Digest Manager
* AUTHOR: Alex Rousskov
sd_state.rewrite_offset = 0;
EBIT_SET(e->flags, ENTRY_SPECIAL);
/* setting public key will purge old digest entry if any */
- storeSetPublicKey(e);
+ e->setPublicKey();
/* fake reply */
HttpReply *rep = new HttpReply;
HttpVersion version(1, 0);
/*
- * $Id: store_swapout.cc,v 1.113 2007/04/20 23:10:59 wessels Exp $
+ * $Id: store_swapout.cc,v 1.114 2007/04/20 23:53:42 wessels Exp $
*
* DEBUG: section 20 Storage Manager Swapout Functions
* AUTHOR: Duane Wessels
e->swap_status = SWAPOUT_NONE;
- storeReleaseRequest(e);
+ e->releaseRequest();
} else {
/* swapping complete */
debug(20, 3) ("storeSwapOutFileClosed: SwapOut complete: '%s' to %d, %08X\n",
/*
- * $Id: stub_store_client.cc,v 1.1 2005/01/03 16:08:27 robertc Exp $
+ * $Id: stub_store_client.cc,v 1.2 2007/04/20 23:53:48 wessels Exp $
*
* DEBUG: section 84 Helper process maintenance
* AUTHOR: Robert Collins
#include "squid.h"
#include "StoreClient.h"
+#include "Store.h"
int
storePendingNClients(const StoreEntry * e)
/* Garh, too many stub files */
void
-InvokeHandlers(StoreEntry * e)
+StoreEntry::invokeHandlers()
{}
void
HttpReply *rep = (HttpReply *) pe->getReply(); // bypass const
rep->setHeaders(version, HTTP_OK, "dummy test object", "x-squid-internal/test", -1, -1, squid_curtime + 100000);
- storeSetPublicKey(pe);
+ pe->setPublicKey();
storeBuffer(pe);
/* TODO: remove this when the metadata is separated */
HttpReply *rep = (HttpReply *) pe->getReply(); // bypass const
rep->setHeaders(version, HTTP_OK, "dummy test object", "x-squid-internal/test", -1, -1, squid_curtime + 100000);
- storeSetPublicKey(pe);
+ pe->setPublicKey();
storeBuffer(pe);
/* TODO: remove this when the metadata is separated */
HttpReply *rep = (HttpReply *) pe->getReply(); // bypass const
rep->setHeaders(version, HTTP_OK, "dummy test object", "x-squid-internal/test", -1, -1, squid_curtime + 100000);
- storeSetPublicKey(pe);
+ pe->setPublicKey();
storeBuffer(pe);
/* TODO: remove this when the metadata is separated */
/*
- * $Id: whois.cc,v 1.38 2006/09/19 07:56:57 adrian Exp $
+ * $Id: whois.cc,v 1.39 2007/04/20 23:53:42 wessels Exp $
*
* DEBUG: section 75 WHOIS protocol
* AUTHOR: Duane Wessels, Kostas Anagnostakis
storeBufferFlush(entry);
if (!EBIT_TEST(entry->flags, RELEASE_REQUEST))
- storeSetPublicKey(entry);
+ entry->setPublicKey();
fwd->complete();
projects / thirdparty / squid.git / commitdiff
