bool mprRemoveCache(MprCache *cache, cchar *key)
{
CacheItem *item;
bool result;
mprAssert(cache);
mprAssert(key && *key);
if (cache->shared) {
cache = cache->shared;
mprAssert(cache == shared);
}
lock(cache);
if (key) {
if ((item = mprLookupKey(cache->store, key)) != 0) {
cache->usedMem -= (slen(key) + slen(item->data));
mprRemoveKey(cache->store, key);
result = 1;
} else {
result = 0;
}
} else {
/* Remove all keys */
result = mprGetHashLength(cache->store) ? 1 : 0;
cache->store = mprCreateHash(CACHE_HASH_SIZE, 0);
cache->usedMem = 0;
}
unlock(cache);
return result;
}
static int mdbDeleteRow(Edi *edi, cchar *tableName, cchar *key)
{
Mdb *mdb;
MdbTable *table;
int r, rc;
mprAssert(edi);
mprAssert(tableName && *tableName);
mprAssert(key && *key);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((r = lookupRow(table, key)) < 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
rc = mprRemoveItemAtPos(table->rows, r);
if (table->index) {
mprRemoveKey(table->index, key);
}
autoSave(mdb, table);
unlock(mdb);
return rc;
}
int espRemoveHeader(HttpConn *conn, cchar *key)
{
mprAssert(key && *key);
if (conn->tx == 0) {
return MPR_ERR_CANT_ACCESS;
}
return mprRemoveKey(conn->tx->headers, key);
}
static void removeItem(MprCache *cache, CacheItem *item)
{
mprAssert(cache);
mprAssert(item);
lock(cache);
mprRemoveKey(cache->store, item->key);
cache->usedMem -= (slen(item->key) + slen(item->data));
unlock(cache);
}
/*
Create a per user session database clone.
Used for demos so one users updates to not change anothers view of the database.
*/
static void pruneDatabases(Esp *esp)
{
MprKey *kp;
lock(esp);
for (ITERATE_KEYS(esp->databases, kp)) {
if (!httpLookupSessionID(kp->key)) {
mprRemoveKey(esp->databases, kp->key);
/* Restart scan */
kp = 0;
}
}
unlock(esp);
}
static void pruneFlash(HttpConn *conn)
{
EspReq *req;
MprKey *kp, *lp;
req = conn->reqData;
if (req->flash && req->lastFlash) {
for (ITERATE_KEYS(req->flash, kp)) {
for (ITERATE_KEYS(req->lastFlash, lp)) {
if (smatch(kp->key, lp->key)) {
mprRemoveKey(req->flash, kp->key);
}
}
}
}
}
static void finalizeFlash(HttpConn *conn)
{
EspReq *req;
MprKey *kp, *lp;
req = conn->data;
if (req->flash) {
mprAssert(req->flash->fn);
if (req->lastFlash) {
mprAssert(req->lastFlash->fn);
for (ITERATE_KEYS(req->flash, kp)) {
for (ITERATE_KEYS(req->lastFlash, lp)) {
if (smatch(kp->key, lp->key) && kp->data == lp->data) {
mprRemoveKey(req->flash, kp->key);
}
}
}
}
static void testInsertAndRemoveHash(MprTestGroup *gp)
{
MprHash *table;
MprKey *sp;
cchar *str;
int rc;
table = mprCreateHash(0, MPR_HASH_STATIC_KEYS | MPR_HASH_STATIC_VALUES);
assert(table != 0);
/*
Single insert
*/
sp = mprAddKey(table, "Peter", "123 Madison Ave");
assert(sp != 0);
sp = mprGetFirstKey(table);
assert(sp != 0);
assert(sp->key != 0);
assert(strcmp(sp->key, "Peter") == 0);
assert(sp->data != 0);
assert(strcmp(sp->data, "123 Madison Ave") == 0);
/*
Lookup
*/
str = mprLookupKey(table, "Peter");
assert(str != 0);
assert(strcmp(str, "123 Madison Ave") == 0);
rc = mprRemoveKey(table, "Peter");
assert(rc == 0);
assert(mprGetHashLength(table) == 0);
sp = mprGetFirstKey(table);
assert(sp == 0);
str = mprLookupKey(table, "Peter");
assert(str == 0);
}
/*
OPT
*/
bool httpValidateLimits(HttpEndpoint *endpoint, int event, HttpConn *conn)
{
HttpLimits *limits;
Http *http;
cchar *action;
int count, level, dir;
limits = conn->limits;
dir = HTTP_TRACE_RX;
action = "unknown";
mprAssert(conn->endpoint == endpoint);
http = endpoint->http;
lock(http);
switch (event) {
case HTTP_VALIDATE_OPEN_CONN:
/*
This measures active client systems with unique IP addresses.
*/
if (endpoint->clientCount >= limits->clientMax) {
unlock(http);
/* Abort connection */
httpError(conn, HTTP_ABORT | HTTP_CODE_SERVICE_UNAVAILABLE,
"Too many concurrent clients %d/%d", endpoint->clientCount, limits->clientMax);
return 0;
}
count = (int) PTOL(mprLookupKey(endpoint->clientLoad, conn->ip));
mprAddKey(endpoint->clientLoad, conn->ip, ITOP(count + 1));
endpoint->clientCount = (int) mprGetHashLength(endpoint->clientLoad);
action = "open conn";
dir = HTTP_TRACE_RX;
break;
case HTTP_VALIDATE_CLOSE_CONN:
count = (int) PTOL(mprLookupKey(endpoint->clientLoad, conn->ip));
if (count > 1) {
mprAddKey(endpoint->clientLoad, conn->ip, ITOP(count - 1));
} else {
mprRemoveKey(endpoint->clientLoad, conn->ip);
}
endpoint->clientCount = (int) mprGetHashLength(endpoint->clientLoad);
action = "close conn";
dir = HTTP_TRACE_TX;
break;
case HTTP_VALIDATE_OPEN_REQUEST:
mprAssert(conn->rx);
if (endpoint->requestCount >= limits->requestMax) {
unlock(http);
httpError(conn, HTTP_CODE_SERVICE_UNAVAILABLE, "Server overloaded");
mprLog(2, "Too many concurrent requests %d/%d", endpoint->requestCount, limits->requestMax);
return 0;
}
endpoint->requestCount++;
conn->rx->flags |= HTTP_LIMITS_OPENED;
action = "open request";
dir = HTTP_TRACE_RX;
break;
case HTTP_VALIDATE_CLOSE_REQUEST:
if (conn->rx && conn->rx->flags & HTTP_LIMITS_OPENED) {
/* Requests incremented only when conn->rx is assigned */
endpoint->requestCount--;
mprAssert(endpoint->requestCount >= 0);
action = "close request";
dir = HTTP_TRACE_TX;
conn->rx->flags &= ~HTTP_LIMITS_OPENED;
}
break;
case HTTP_VALIDATE_OPEN_PROCESS:
if (http->processCount >= limits->processMax) {
unlock(http);
httpError(conn, HTTP_CODE_SERVICE_UNAVAILABLE, "Server overloaded");
mprLog(2, "Too many concurrent processes %d/%d", http->processCount, limits->processMax);
return 0;
}
http->processCount++;
action = "start process";
dir = HTTP_TRACE_RX;
break;
case HTTP_VALIDATE_CLOSE_PROCESS:
http->processCount--;
mprAssert(http->processCount >= 0);
break;
}
if (event == HTTP_VALIDATE_CLOSE_CONN || event == HTTP_VALIDATE_CLOSE_REQUEST) {
if ((level = httpShouldTrace(conn, dir, HTTP_TRACE_LIMITS, NULL)) >= 0) {
LOG(4, "Validate request for %s. Active connections %d, active requests: %d/%d, active client IP %d/%d",
action, mprGetListLength(http->connections), endpoint->requestCount, limits->requestMax,
endpoint->clientCount, limits->clientMax);
}
}
unlock(http);
return 1;
}
