mirror of
https://git.haproxy.org/git/haproxy.git/
synced 2025-09-21 22:01:31 +02:00
bf47aeb946
This patch has 2 goals : 1. I wanted to test the appsession feature with a small PHP code, using PHPSESSID. The problem is that when PHP gets an unknown session id, it creates a new one with this ID. So, when sending an unknown session to PHP, persistance is broken : haproxy won't see any new cookie in the response and will never attach this session to a specific server. This also happens when you restart haproxy : the internal hash becomes empty and all sessions loose their persistance (load balancing the requests on all backend servers, creating a new session on each one). For a user, it's like the service is unusable. The patch modifies the code to make haproxy also learn the persistance from the client : if no session is sent from the server, then the session id found in the client part (using the URI or the client cookie) is used to associated the server that gave the response. As it's probably not a feature usable in all cases, I added an option to enable it (by default it's disabled). The syntax of appsession becomes : appsession <cookie> len <length> timeout <holdtime> [request-learn] This helps haproxy repair the persistance (with the risk of losing its session at the next request, as the user will probably not be load balanced to the same server the first time). 2. This patch also tries to reduce the memory usage. Here is a little example to explain the current behaviour : - Take a Tomcat server where /session.jsp is valid. - Send a request using a cookie with an unknown value AND a path parameter with another unknown value : curl -b "JSESSIONID=12345678901234567890123456789012" http://<haproxy>/session.jsp;jsessionid=00000000000000000000000000000001 (I know, it's unexpected to have a request like that on a live service) Here, haproxy finds the URI session ID and stores it in its internal hash (with no server associated). But it also finds the cookie session ID and stores it again. - As a result, session.jsp sends a new session ID also stored in the internal hash, with a server associated. => For 1 request, haproxy has stored 3 entries, with only 1 which will be usable The patch modifies the behaviour to store only 1 entry (maximum).
-------------------
H A - P r o x y
How to build it
-------------------
version 1.3.15
willy tarreau
2008/05/25
To build haproxy, you will need :
- GNU make. Neither Solaris nor OpenBSD's make work with this makefile.
However, specific Makefiles for BSD and OSX are provided.
- GCC between 2.91 and 4.3. Others may work, but not tested.
- GNU ld
Also, you might want to build with libpcre support, which will provide a very
efficient regex implementation and will also fix some badness on Solaris's one.
To build haproxy, you have to choose your target OS amongst the following ones
and assign it to the TARGET variable :
- linux22 for Linux 2.2
- linux24 for Linux 2.4 and above (default)
- linux24e for Linux 2.4 with support for a working epoll (> 0.21)
- linux26 for Linux 2.6 and above
- solaris for Solaris 8 or 10 (others untested)
- freebsd for FreeBSD 5 to 6.2 (others untested)
- openbsd for OpenBSD 3.1 to 3.7 (others untested)
- cygwin for Cygwin
- generic for any other OS.
- custom to manually adjust every setting
You may also choose your CPU to benefit from some optimizations. This is
particularly important on UltraSparc machines. For this, you can assign
one of the following choices to the CPU variable :
- i686 for intel PentiumPro, Pentium 2 and above, AMD Athlon
- i586 for intel Pentium, AMD K6, VIA C3.
- ultrasparc : Sun UltraSparc I/II/III/IV processor
- generic : any other processor or no specific optimization. (default)
Alternatively, you may just set the CPU_CFLAGS value to the optimal GCC options
for your platform.
You may want to build specific target binaries which do not match your native
compiler's target. This is particularly true on 64-bit systems when you want
to build a 32-bit binary. Use the ARCH variable for this purpose. Right now
it only knows about a few x86 variants (i386,i486,i586,i686,x86_64) and sets
-m32/-m64 as well as -march=<arch> accordingly.
If your system supports PCRE (Perl Compatible Regular Expressions), then you
really should build with libpcre which is between 2 and 10 times faster than
other libc implementations. Regex are used for header processing (deletion,
rewriting, allow, deny). The only inconvenient of libpcre is that it is not
yet widely spread, so if you build for other systems, you might get into
trouble if they don't have the dynamic library. In this situation, you should
statically link libpcre into haproxy so that it will not be necessary to
install it on target systems. Available build options for PCRE are :
- USE_PCRE=1 to use libpcre, in whatever form is available on your system
(shared or static)
- USE_STATIC_PCRE=1 to use a static version of libpcre even if the dynamic
one is available. This will enhance portability.
- with no option, use your OS libc's standard regex implemntation (default).
Warning! group references on Solaris seem broken. Use static-pcre whenever
possible.
By default, the DEBUG variable is set to '-g' to enable debug symbols. It is
not wise to disable it on uncommon systems, because it's often the only way to
get a complete core when you need one. Otherwise, you can set DEBUG to '-s' to
strip the binary.
For example, I use this to build for Solaris 8 :
$ make TARGET=solaris CPU=ultrasparc USE_STATIC_PCRE=1
And I build it this way on OpenBSD or FreeBSD :
$ make -f Makefile.bsd REGEX=pcre DEBUG= COPTS.generic="-Os -fomit-frame-pointer -mgnu"
In order to build a 32-bit binary on an x86_64 Linux system :
$ make TARGET=linux26 ARCH=i386
If you need to pass other defines, includes, libraries, etc... then please
check the Makefile to see which ones will be available in your case, and
use the USE_* variables in the GNU Makefile, or ADDINC, ADDLIB, and DEFINE
variables in the BSD makefiles.
-- end