Author: jfrederic.clere(a)jboss.com Date: 2009-01-13 10:56:52 -0500 (Tue, 13 Jan 2009) New Revision: 2164 Added: trunk/mod_cluster/native/include/sessionid.h trunk/mod_cluster/native/mod_manager/sessionid.c Modified: trunk/mod_cluster/native/include/mod_clustersize.h trunk/mod_cluster/native/mod_manager/Makefile.in trunk/mod_cluster/native/mod_manager/mod_manager.c trunk/mod_cluster/native/mod_proxy_cluster/mod_proxy_cluster.c Log: Add logic to store sessionid in shared memory. Modified: trunk/mod_cluster/native/include/mod_clustersize.h =================================================================== --- trunk/mod_cluster/native/include/mod_clustersize.h 2009-01-12 19:03:09 UTC (rev 2163) +++ trunk/mod_cluster/native/include/mod_clustersize.h 2009-01-13 15:56:52 UTC (rev 2164) @@ -45,4 +45,7 @@ #define COOKNAMESZ 30 #define PATHNAMESZ 30 +/* For sessionid.h */ +#define SESSIONIDSZ 128 + #endif /* MOD_CLUSTERSIZE_H */ Added: trunk/mod_cluster/native/include/sessionid.h =================================================================== --- trunk/mod_cluster/native/include/sessionid.h (rev 0) +++ trunk/mod_cluster/native/include/sessionid.h 2009-01-13 15:56:52 UTC (rev 2164) @@ -0,0 +1,156 @@ +/* + * mod_cluster + * + * Copyright(c) 2009 Red Hat Middleware, LLC, + * and individual contributors as indicated by the @authors tag. + * See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library in the file COPYING.LIB; + * if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * @author Jean-Frederic Clere + * @version $Revision$ + */ + +#ifndef SESSIONID_H +#define SESSIONID_H + +/** + * @file sessionid.h + * @brief sessionid description Storage Module for Apache + * + * @defgroup MEM sessionids + * @ingroup APACHE_MODS + * @{ + */ + +#define SESSIONIDEXE ".sessionid" + +#ifndef MEM_T +typedef struct mem mem_t; +#define MEM_T +#endif + +#include "mod_clustersize.h" + +/* status of the sessionid as read/store in httpd. */ +struct sessionidinfo { + char sessionid[SESSIONIDSZ]; /* Sessionid value */ + char JVMRoute[JVMROUTESZ]; /* corresponding node */ + + unsigned long updatetime; /* time of last received message */ + int id; /* id in table */ +}; +typedef struct sessionidinfo sessionidinfo_t; + + +/** + * Insert(alloc) and update a sessionid record in the shared table + * @param pointer to the shared table. + * @param sessionid sessionid to store in the shared table. + * @return APR_SUCCESS if all went well + * + */ +apr_status_t insert_update_sessionid(mem_t *s, sessionidinfo_t *sessionid); + +/** + * read a sessionid record from the shared table + * @param pointer to the shared table. + * @param sessionid sessionid to read from the shared table. + * @return address of the read sessionid or NULL if error. + */ +sessionidinfo_t * read_sessionid(mem_t *s, sessionidinfo_t *sessionid); + +/** + * get a sessionid record from the shared table + * @param pointer to the shared table. + * @param sessionid address of the sessionid read from the shared table. + * @return APR_SUCCESS if all went well + */ +apr_status_t get_sessionid(mem_t *s, sessionidinfo_t **sessionid, int ids); + +/** + * remove(free) a sessionid record from the shared table + * @param pointer to the shared table. + * @param sessionid sessionid to remove from the shared table. + * @return APR_SUCCESS if all went well + */ +apr_status_t remove_sessionid(mem_t *s, sessionidinfo_t *sessionid); + +/* + * get the ids for the used (not free) sessionids in the table + * @param pointer to the shared table. + * @param ids array of int to store the used id (must be big enough). + * @return number of sessionid existing or -1 if error. + */ +int get_ids_used_sessionid(mem_t *s, int *ids); + +/* + * get the size of the table (max size). + * @param pointer to the shared table. + * @return size of the existing table or -1 if error. + */ +int get_max_size_sessionid(mem_t *s); + +/** + * attach to the shared sessionid table + * @param name of an existing shared table. + * @param address to store the size of the shared table. + * @param p pool to use for allocations. + * @return address of struct used to access the table. + */ +mem_t * get_mem_sessionid(char *string, int *num, apr_pool_t *p, slotmem_storage_method *storage); +/** + * create a shared sessionid table + * @param name to use to create the table. + * @param size of the shared table. + * @param persist tell if the slotmem element are persistent. + * @param p pool to use for allocations. + * @return address of struct used to access the table. + */ +mem_t * create_mem_sessionid(char *string, int *num, int persist, apr_pool_t *p, slotmem_storage_method *storage); + +/** + * provider for the mod_proxy_cluster or mod_jk modules. + */ +struct sessionid_storage_method { +/** + * the sessionid corresponding to the ident + * @param ids ident of the sessionid to read. + * @param sessionid address of pointer to return the sessionid. + * @return APR_SUCCESS if all went well + */ +apr_status_t (* read_sessionid)(int ids, sessionidinfo_t **sessionid); +/** + * read the list of ident of used sessionids. + * @param ids address to store the idents. + * @return APR_SUCCESS if all went well + */ +int (* get_ids_used_sessionid)(int *ids); +/** + * read the max number of sessionids in the shared table + */ +int (*get_max_size_sessionid)(); +/* + * Remove the sessionid from shared memory (free the slotmem) + */ +apr_status_t (*remove_sessionid)(sessionidinfo_t *sessionid); +/* + * Insert a new sessionid or update existing one. + */ +apr_status_t (*insert_update_sessionid)(sessionidinfo_t *sessionid); +}; +#endif /*SESSIONID_H*/ Modified: trunk/mod_cluster/native/mod_manager/Makefile.in =================================================================== --- trunk/mod_cluster/native/mod_manager/Makefile.in 2009-01-12 19:03:09 UTC (rev 2163) +++ trunk/mod_cluster/native/mod_manager/Makefile.in 2009-01-13 15:56:52 UTC (rev 2164) @@ -15,8 +15,8 @@ mod_manager.so: mod_manager.la $(APACHE_BASE)/build/instdso.sh SH_LIBTOOL='$(LIBTOOL)' mod_manager.la `pwd` -mod_manager.la: mod_manager.slo node.slo context.slo host.slo balancer.slo - $(SH_LINK) -rpath $(libexecdir) -module -avoid-version mod_manager.lo node.lo context.lo host.lo balancer.lo +mod_manager.la: mod_manager.slo node.slo context.slo host.slo balancer.slo sessionid.slo + $(SH_LINK) -rpath $(libexecdir) -module -avoid-version mod_manager.lo node.lo context.lo host.lo balancer.lo sessionid.lo clean: rm -f *.o *.lo *.slo *.so Modified: trunk/mod_cluster/native/mod_manager/mod_manager.c =================================================================== --- trunk/mod_cluster/native/mod_manager/mod_manager.c 2009-01-12 19:03:09 UTC (rev 2163) +++ trunk/mod_cluster/native/mod_manager/mod_manager.c 2009-01-13 15:56:52 UTC (rev 2164) @@ -48,11 +48,13 @@ #include "host.h" #include "context.h" #include "balancer.h" +#include "sessionid.h" -#define DEFMAXCONTEXT 100 -#define DEFMAXNODE 10 -#define DEFMAXHOST 20 -#define MAXMESSSIZE 1024 +#define DEFMAXCONTEXT 100 +#define DEFMAXNODE 10 +#define DEFMAXHOST 20 +#define DEFMAXSESSIONID 2048 +#define MAXMESSSIZE 1024 /* Error messages */ #define TYPESYNTAX 1 @@ -88,6 +90,7 @@ mem_t *nodestatsmem = NULL; mem_t *hoststatsmem = NULL; mem_t *balancerstatsmem = NULL; +mem_t *sessionidstatsmem = NULL; slotmem_storage_method *storage = NULL; balancer_method *balancerhandler = NULL; @@ -104,6 +107,8 @@ int maxnode; /* max munber of host supported */ int maxhost; + /* max munber of session supported */ + int maxsessionid; /* last time the node update logic was called */ apr_time_t last_updated; @@ -132,7 +137,7 @@ { return (remove_node(nodestatsmem, node)); } -static apr_status_t loc_find_node(nodeinfo_t *node, char *route) +static apr_status_t loc_find_node(nodeinfo_t **node, const char *route) { return (find_node(nodestatsmem, node, route)); } @@ -262,6 +267,37 @@ loc_get_ids_used_balancer, loc_get_max_size_balancer }; +/* + * routines for the sessionid_storage_method + */ +static apr_status_t loc_read_sessionid(int ids, sessionidinfo_t **sessionid) +{ + return (get_sessionid(sessionidstatsmem, sessionid, ids)); +} +static int loc_get_ids_used_sessionid(int *ids) +{ + return(get_ids_used_sessionid(sessionidstatsmem, ids)); +} +static int loc_get_max_size_sessionid() +{ + return(get_max_size_sessionid(sessionidstatsmem)); +} +static apr_status_t loc_remove_sessionid(sessionidinfo_t *sessionid) +{ + return (remove_sessionid(sessionidstatsmem, sessionid)); +} +static apr_status_t loc_insert_update_sessionid(sessionidinfo_t *sessionid) +{ + return (insert_update_sessionid(sessionidstatsmem, sessionid)); +} +static const struct sessionid_storage_method sessionid_storage = +{ + loc_read_sessionid, + loc_get_ids_used_sessionid, + loc_get_max_size_sessionid, + loc_remove_sessionid, + loc_insert_update_sessionid +}; /* helper for the handling of the Alias: host1,... Context: context1,... */ struct cluster_host { @@ -281,6 +317,7 @@ char *context; char *host; char *balancer; + char *sessionid; void *data; const char *userdata_key = "mod_manager_init"; mod_manager_config *mconf = ap_get_module_config(s->module_config, &manager_module); @@ -296,11 +333,13 @@ context = apr_pstrcat(ptemp, mconf->basefilename, ".context", NULL); host = apr_pstrcat(ptemp, mconf->basefilename, ".host", NULL); balancer = apr_pstrcat(ptemp, mconf->basefilename, ".balancer", NULL); + sessionid = apr_pstrcat(ptemp, mconf->basefilename, ".sessionid", NULL); } else { node = ap_server_root_relative(ptemp, "logs/manager.node"); context = ap_server_root_relative(ptemp, "logs/manager.context"); host = ap_server_root_relative(ptemp, "logs/manager.host"); balancer = ap_server_root_relative(ptemp, "logs/manager.balancer"); + sessionid = ap_server_root_relative(ptemp, "logs/manager.sessionid"); } /* Get a provider to handle the shared memory */ @@ -334,6 +373,12 @@ return !OK; } + sessionidstatsmem = create_mem_sessionid(sessionid, &mconf->maxhost, mconf->persistent, p, storage); + if (sessionidstatsmem == NULL) { + ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, 0, s, "create_mem_sessionid failed"); + return !OK; + } + /* Get a provider to ping/pong logics */ balancerhandler = ap_lookup_provider("proxy_cluster", "balancer", "0"); @@ -1312,6 +1357,7 @@ char *context; char *host; char *balancer; + char *sessionid; mod_manager_config *mconf = ap_get_module_config(s->module_config, &manager_module); if (mconf->basefilename) { @@ -1319,11 +1365,13 @@ context = apr_pstrcat(p, mconf->basefilename, ".context", NULL); host = apr_pstrcat(p, mconf->basefilename, ".host", NULL); balancer = apr_pstrcat(p, mconf->basefilename, ".balancer", NULL); + sessionid = apr_pstrcat(p, mconf->basefilename, ".sessionid", NULL); } else { node = ap_server_root_relative(p, "logs/manager.node"); context = ap_server_root_relative(p, "logs/manager.context"); host = ap_server_root_relative(p, "logs/manager.host"); balancer = ap_server_root_relative(p, "logs/manager.balancer"); + sessionid = ap_server_root_relative(p, "logs/manager.sessionid"); } nodestatsmem = get_mem_node(node, &mconf->maxnode, p, storage); @@ -1349,6 +1397,12 @@ ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, 0, s, "get_mem_balancer failed"); return; } + + sessionidstatsmem = get_mem_sessionid(sessionid, &mconf->maxsessionid, p, storage); + if (sessionidstatsmem == NULL) { + ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, 0, s, "get_mem_sessionid failed"); + return; + } } /* @@ -1372,6 +1426,12 @@ mconf->maxhost = atoi(word); return NULL; } +static const char *cmd_manager_maxsessionid(cmd_parms *cmd, void *mconfig, const char *word) +{ + mod_manager_config *mconf = ap_get_module_config(cmd->server->module_config, &manager_module); + mconf->maxsessionid = atoi(word); + return NULL; +} static const char *cmd_manager_memmanagerfile(cmd_parms *cmd, void *mconfig, const char *word) { mod_manager_config *mconf = ap_get_module_config(cmd->server->module_config, &manager_module); @@ -1424,6 +1484,13 @@ "Maxhost - number max host (Alias in virtual hosts) supported by mod_cluster" ), AP_INIT_TAKE1( + "Maxsessionid", + cmd_manager_maxsessionid, + NULL, + OR_ALL, + "Maxsessionid - number session (Used to track number of sessions per nodes) supported by mod_cluster" + ), + AP_INIT_TAKE1( "MemManagerFile", cmd_manager_memmanagerfile, NULL, @@ -1484,6 +1551,7 @@ mconf->maxcontext = DEFMAXCONTEXT; mconf->maxnode = DEFMAXNODE; mconf->maxhost = DEFMAXHOST; + mconf->maxsessionid = DEFMAXSESSIONID; mconf->last_updated = 0; mconf->persistent = 0; return mconf; @@ -1526,6 +1594,11 @@ else if (mconf1->maxhost != DEFMAXHOST) mconf->maxhost = mconf1->maxhost; + if (mconf2->maxsessionid != DEFMAXSESSIONID) + mconf->maxsessionid = mconf2->maxsessionid; + else if (mconf1->maxsessionid != DEFMAXSESSIONID) + mconf->maxsessionid = mconf1->maxsessionid; + if (mconf2->persistent != 0) mconf->persistent = mconf2->persistent; else if (mconf1->persistent != 0) Added: trunk/mod_cluster/native/mod_manager/sessionid.c =================================================================== --- trunk/mod_cluster/native/mod_manager/sessionid.c (rev 0) +++ trunk/mod_cluster/native/mod_manager/sessionid.c 2009-01-13 15:56:52 UTC (rev 2164) @@ -0,0 +1,226 @@ +/* + * mod_cluster + * + * Copyright(c) 2009 Red Hat Middleware, LLC, + * and individual contributors as indicated by the @authors tag. + * See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library in the file COPYING.LIB; + * if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * @author Jean-Frederic Clere + * @version $Revision$ + */ + +/** + * @file sessionid.c + * @brief sessionid description Storage Module for Apache + * + * @defgroup MEM sessionids + * @ingroup APACHE_MODS + * @{ + */ + +#include "apr.h" +#include "apr_strings.h" +#include "apr_pools.h" +#include "apr_time.h" + +#include "slotmem.h" +#include "sessionid.h" + +struct mem { + ap_slotmem_t *slotmem; + const slotmem_storage_method *storage; + int num; + apr_pool_t *p; +}; + +static mem_t * create_attach_mem_sessionid(char *string, int *num, int type, apr_pool_t *p, slotmem_storage_method *storage) { + mem_t *ptr; + const char *storename; + apr_status_t rv; + + ptr = apr_pcalloc(p, sizeof(mem_t)); + if (!ptr) { + return NULL; + } + ptr->storage = storage; + storename = apr_pstrcat(p, string, SESSIONIDEXE, NULL); + if (type) + rv = ptr->storage->ap_slotmem_create(&ptr->slotmem, storename, sizeof(sessionidinfo_t), *num, type, p); + else { + apr_size_t size = sizeof(sessionidinfo_t); + rv = ptr->storage->ap_slotmem_attach(&ptr->slotmem, storename, &size, num, p); + } + if (rv != APR_SUCCESS) { + return NULL; + } + ptr->num = *num; + ptr->p = p; + return ptr; +} +/** + * Insert(alloc) and update a sessionid record in the shared table + * @param pointer to the shared table. + * @param sessionid sessionid to store in the shared table. + * @return APR_SUCCESS if all went well + * + */ +static apr_status_t insert_update(void* mem, void **data, int id, apr_pool_t *pool) +{ + sessionidinfo_t *in = (sessionidinfo_t *)*data; + sessionidinfo_t *ou = (sessionidinfo_t *)mem; + if (strcmp(in->sessionid, ou->sessionid) == 0) { + memcpy(ou, in, sizeof(sessionidinfo_t)); + ou->id = id; + ou->updatetime = apr_time_sec(apr_time_now()); + *data = ou; + return APR_SUCCESS; + } + return APR_NOTFOUND; +} +apr_status_t insert_update_sessionid(mem_t *s, sessionidinfo_t *sessionid) +{ + apr_status_t rv; + sessionidinfo_t *ou; + int ident; + + sessionid->id = 0; + rv = s->storage->ap_slotmem_do(s->slotmem, insert_update, &sessionid, s->p); + if (sessionid->id != 0 && rv == APR_SUCCESS) { + return APR_SUCCESS; /* updated */ + } + + /* we have to insert it */ + rv = s->storage->ap_slotmem_alloc(s->slotmem, &ident, (void **) &ou); + if (rv != APR_SUCCESS) { + return rv; + } + memcpy(ou, sessionid, sizeof(sessionidinfo_t)); + ou->id = ident; + ou->updatetime = apr_time_sec(apr_time_now()); + + return APR_SUCCESS; +} + +/** + * read a sessionid record from the shared table + * @param pointer to the shared table. + * @param sessionid sessionid to read from the shared table. + * @return address of the read sessionid or NULL if error. + */ +static apr_status_t loc_read_sessionid(void* mem, void **data, int id, apr_pool_t *pool) { + sessionidinfo_t *in = (sessionidinfo_t *)*data; + sessionidinfo_t *ou = (sessionidinfo_t *)mem; + + if (strcmp(in->sessionid, ou->sessionid) == 0) { + *data = ou; + return APR_SUCCESS; + } + return APR_NOTFOUND; +} +sessionidinfo_t * read_sessionid(mem_t *s, sessionidinfo_t *sessionid) +{ + apr_status_t rv; + sessionidinfo_t *ou = sessionid; + + if (sessionid->id) + rv = s->storage->ap_slotmem_mem(s->slotmem, sessionid->id, (void **) &ou); + else { + rv = s->storage->ap_slotmem_do(s->slotmem, loc_read_sessionid, &ou, s->p); + } + if (rv == APR_SUCCESS) + return ou; + return NULL; +} +/** + * get a sessionid record from the shared table + * @param pointer to the shared table. + * @param sessionid address where the sessionid is locate in the shared table. + * @param ids in the sessionid table. + * @return APR_SUCCESS if all went well + */ +apr_status_t get_sessionid(mem_t *s, sessionidinfo_t **sessionid, int ids) +{ + return(s->storage->ap_slotmem_mem(s->slotmem, ids, (void **) sessionid)); +} + +/** + * remove(free) a sessionid record from the shared table + * @param pointer to the shared table. + * @param sessionid sessionid to remove from the shared table. + * @return APR_SUCCESS if all went well + */ +apr_status_t remove_sessionid(mem_t *s, sessionidinfo_t *sessionid) +{ + apr_status_t rv; + sessionidinfo_t *ou = sessionid; + if (sessionid->id) + s->storage->ap_slotmem_free(s->slotmem, sessionid->id, sessionid); + else { + /* XXX: for the moment January 2007 ap_slotmem_free only uses ident to remove */ + rv = s->storage->ap_slotmem_do(s->slotmem, loc_read_sessionid, &ou, s->p); + if (rv == APR_SUCCESS) + rv = s->storage->ap_slotmem_free(s->slotmem, ou->id, sessionid); + } + return rv; +} + +/* + * get the ids for the used (not free) sessionids in the table + * @param pointer to the shared table. + * @param ids array of int to store the used id (must be big enough). + * @return number of sessionid existing or -1 if error. + */ +int get_ids_used_sessionid(mem_t *s, int *ids) +{ + return (s->storage->ap_slotmem_get_used(s->slotmem, ids)); +} + +/* + * read the size of the table. + * @param pointer to the shared table. + * @return number of sessionid existing or -1 if error. + */ +int get_max_size_sessionid(mem_t *s) +{ + return (s->storage->ap_slotmem_get_max_size(s->slotmem)); +} + +/** + * attach to the shared sessionid table + * @param name of an existing shared table. + * @param address to store the size of the shared table. + * @param p pool to use for allocations. + * @return address of struct used to access the table. + */ +mem_t * get_mem_sessionid(char *string, int *num, apr_pool_t *p, slotmem_storage_method *storage) +{ + return(create_attach_mem_sessionid(string, num, 0, p, storage)); +} +/** + * create a shared sessionid table + * @param name to use to create the table. + * @param size of the shared table. + * @param persist tell if the slotmem element are persistent. + * @param p pool to use for allocations. + * @return address of struct used to access the table. + */ +mem_t * create_mem_sessionid(char *string, int *num, int persist, apr_pool_t *p, slotmem_storage_method *storage) +{ + return(create_attach_mem_sessionid(string, num, CREATE_SLOTMEM|persist, p, storage)); +} Modified: trunk/mod_cluster/native/mod_proxy_cluster/mod_proxy_cluster.c =================================================================== --- trunk/mod_cluster/native/mod_proxy_cluster/mod_proxy_cluster.c 2009-01-12 19:03:09 UTC (rev 2163) +++ trunk/mod_cluster/native/mod_proxy_cluster/mod_proxy_cluster.c 2009-01-13 15:56:52 UTC (rev 2164) @@ -1948,6 +1948,8 @@ if (worker && worker->s->busy) worker->s->busy--; + /* XXX: Add information about sessions corresponding to a node */ + return OK; }