~measurement-factory/squid/bag5

#include <limits.h>

#endif

 

#define REBUILD_TIMESTAMP_DELTA_MAX 2

 

#define STORE_IN_MEM_BUCKETS            (229)

{

    /* This object can be cached for a long time */

 

        setPublicKey();

}

 

    /* This object should never be cached at all */

    expireNow();

    releaseRequest(); /* delete object when not used */

}

 

void

{

    /* This object may be negatively cached */

    negativeCache();

}

 

size_t

        mem_obj->setNoDelay(newValue);

}

 

store_client_t

StoreEntry::storeClientType() const

{

     * offset 0 in the memory object is the HTTP headers.

     */

 

    assert(mem_obj);

 

    if (mem_obj->inmem_lo)

            if (swap_status == SWAPOUT_DONE) {

                debugs(20,7, HERE << mem_obj << " lo: " << mem_obj->inmem_lo << " hi: " << mem_obj->endOffset() << " size: " << mem_obj->object_sz);

                if (mem_obj->endOffset() == mem_obj->object_sz) {

                    return STORE_MEM_CLIENT;

                }

            } else {

 

StoreEntry::StoreEntry() :

        mem_obj(NULL),

}

 

StoreEntry::~StoreEntry()

{

}

 

#if USE_ADAPTATION

StoreEntry::destroyMemObject()

{

    debugs(20, 3, HERE << "destroyMemObject " << mem_obj);

}

 

void

    if (e == NullStoreEntry::getInstance())

        return;

 

    e->destroyMemObject();

 

    e->hashDelete();

void

StoreEntry::hashInsert(const cache_key * someKey)

{

    key = storeKeyDup(someKey);

    hash_join(store_table, this);

}

 

    debugs(20, 3, "StoreEntry::purgeMem: Freeing memory-copy of " << getMD5Text());

 

 

    if (swap_status != SWAPOUT_DONE)

        release();

    debugs(20, 3, "StoreEntry::setReleaseFlag: '" << getMD5Text() << "'");

 

    EBIT_SET(flags, RELEASE_REQUEST);

}

 

void

    if (EBIT_TEST(flags, RELEASE_REQUEST))

        return;

 

 

    setPrivateKey();

}

        return;                 /* is already private */

 

    if (key) {

        if (swap_filen > -1)

            storeDirSwapLog(this, SWAP_LOG_DEL);

 

        hashDelete();

    }

 

        mem_obj->id = getKeyCounter();

    } else {

        newkey = storeKeyPrivate("JUNK", Http::METHOD_NONE, getKeyCounter());

    }

void

StoreEntry::setPublicKey()

{

    const cache_key *newkey;

 

    if (key && !EBIT_TEST(flags, KEY_PRIVATE))

     * store clients won't be able to access object data which has

     * been freed from memory.

     *

     */

#if MORE_DEBUG_OUTPUT

 

                 * to record the new variance key

                 */

                safe_free(request->vary_headers);       /* free old "bad" variance key */

                    pe->release();

            }

 

 

        // TODO: storeGetPublic() calls below may create unlocked entries.

        // We should add/use storeHas() API or lock/unlock those entries.

            /* Create "vary" base object */

            String vary;

            /* We are allowed to do this typecast */

            HttpReply *rep = new HttpReply;

            rep->setHeaders(Http::scOkay, "Internal marker object", "x-squid-internal/vary", -1, -1, squid_curtime + 100000);

 

            pe->complete();

 

        }

 

        newkey = storeKeyPublicByRequest(mem_obj->request);

    } else

 

        e2->setPrivateKey();

        e2->release();

 

        if (mem_obj->request)

            newkey = storeKeyPublicByRequest(mem_obj->request);

        else

    }

 

    if (key)

}

 

StoreEntry *

{

    StoreEntry *e = NULL;

    debugs(20, 3, "storeCreateEntry: '" << url << "'");

 

 

    if (flags.cachable) {

        EBIT_CLR(e->flags, RELEASE_REQUEST);

    } else {

        e->releaseRequest();

    }

 

    e->store_status = STORE_PENDING;

    e->refcount = 0;

    e->lastref = squid_curtime;

    e->timestamp = -1;          /* set in StoreEntry::timestampsSet() */

    return e;

}

 

/* Mark object as expired */

void

StoreEntry::expireNow()

}

 

void

StoreEntry::write (StoreIOBuffer writeBuffer)

{

    assert(mem_obj != NULL);

    PROF_start(StoreEntry_write);

    assert(store_status == STORE_PENDING);

 

    debugs(20, 5, "storeWrite: writing " << writeBuffer.length << " bytes for '" << getMD5Text() << "'");

    PROF_stop(StoreEntry_write);

    storeGetMemSpace(writeBuffer.length);

}

 

/* Append incoming data from a primary server to an entry. */

        if (store_status == STORE_OK && EBIT_TEST(flags, ENTRY_BAD_LENGTH)) {

            debugs(20, 2, "StoreEntry::checkCachable: NO: wrong content-length");

            ++store_check_cachable_hist.no.wrong_content_length;

            debugs(20, 2, "StoreEntry::checkCachable: NO: not cachable");

        } else if (EBIT_TEST(flags, ENTRY_NEGCACHED)) {

            debugs(20, 3, "StoreEntry::checkCachable: NO: negative cached");

            ++store_check_cachable_hist.no.negative_cached;

        }

 

    releaseRequest();

    return 0;

}

 

    assert(mem_obj != NULL);

    debugs(20, 6, "storeAbort: " << getMD5Text());

 

    negativeCache();

 

    releaseRequest();

    // abort swap out, invalidating what was created so far (release follows)

    swapOutFileClose(StoreIOState::writerGone);

 

}

 

/**

StoreEntry::release()

{

    PROF_start(storeRelease);

    /* If, for any reason we can't discard this object because of an

     * outstanding request, mark it for pending release */

 

        return;

    }

 

    if (StoreController::store_dirs_rebuilding && swap_filen > -1) {

        setPrivateKey();

 

        if (swap_filen > -1) {

            /*

             * Fake a call to StoreEntry->lock()  When rebuilding is done,

             * we'll just call StoreEntry->unlock() on these.

             */

            setReleaseFlag();

            LateReleaseStack.push_back(this);

        } else {

        unlink();

    }

 

    destroyStoreEntry(static_cast<hash_link *>(this));

    PROF_stop(storeRelease);

}

            return;

        }

 

        ++n;

    }

 

    if (lock_count)

        return 1;

 

    /*

     */

    if (EBIT_TEST(flags, ENTRY_SPECIAL))

        if (!EBIT_TEST(flags, KEY_PRIVATE))

    if (EBIT_TEST(flags, ENTRY_ABORTED))

        return 0;

 

    return 1;

}

 

 

    // are we using a shared memory cache?

    if (Config.memShared && IamWorkerProcess()) {

        // This method was designed to update replacement policy, not to

        // actually purge something from the memory cache (TODO: rename?).

        // Shared memory cache does not have a policy that needs updates.

        assert(mem_obj->inmem_lo == 0);

 

        if (EBIT_TEST(flags, ENTRY_SPECIAL)) {

        } else {

            mem_policy->Add(mem_policy, this, &mem_obj->repl);

        }

 

        ++hot_obj_count; // TODO: maintain for the shared hot cache as well

    } else {

        if (EBIT_TEST(flags, ENTRY_SPECIAL)) {

        } else {

            mem_policy->Remove(mem_policy, this, &mem_obj->repl);

        }

 

        --hot_obj_count;

    else if (mem_obj == NULL)

        return "[null_mem_obj]";

    else

}

 

void

{

}

 

/* this just sets DELAY_SENDING */

 

    rep->packHeadersInto(&p);

    mem_obj->markEndOfReplyHeaders();

 

    rep->body.packInto(&p);

 

    if (EBIT_TEST(flags, ENTRY_SPECIAL))

        return; // cannot trim because we do not load them again

 

}

 

bool

 

std::ostream &operator <<(std::ostream &os, const StoreEntry &e)

{

}

 

/* NullStoreEntry */