1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
PKG_PROJECT=jakarta
PKG_SUBPRJ=commons
PKG_NAME=daemon
SPELL=${PKG_PROJECT}-${PKG_SUBPRJ}-${PKG_NAME}
VERSION=20030402
SOURCE=${PKG_SUBPRJ}-${PKG_NAME}-src-${VERSION}.tar.gz
SOURCE_DIRECTORY=$BUILD_DIRECTORY/${PKG_SUBPRJ}-${PKG_NAME}
SOURCE_URL[0]=http://cvs.apache.org/builds/${PKG_PROJECT}-${PKG_SUBPRJ}/nightly/${PKG_SUBPRJ}-${PKG_NAME}/${SOURCE}
SOURCE_HASH=sha512:9328bacd966b07eb7877ffb68075b80c8ecd534e526725f8d16a28b8da658d99725498fb817417fb0db6e5985810a1b2ad78e62857d82860f6d7d0cb57723c80
LICENSE[0]=APACHE
WEB_SITE=http://jakarta.apache.org/commons/sandbox/daemon/index.html
KEYWORDS="java"
ENTERED=20030403
SHORT="Jakarta Commons Daemon."
cat << EOF
Since 1994, the Java programming language evolved and became a valid tool
to develop, other than applets and client applications, reliable and
performant server applications. The major disadvantage of the Java platform
is that still today the only portable way to start a Java application
relies on a single point of entry: the public static void main(String[])
method.
Having a single-point of entry is a valid solution for client applications,
where interactively a user can command to the application to quit (which
can terminate the Virtual Machine process at calling the System.exit(int)
method), but in those cases where the application is not interactive (server
applications) there is currently no portable way to notify the Virtual
Machine of its imminent shutdown.
A server application written in Java might have to perform several tasks
before being able to shutdown the Virtual Machine process. For example in
the case of a Servlet container, before the VM process is shut down,
sessions might need to be serialized to disk, and web applications need
to be destroyed.
One common solution to this problem is to create (for example) a ServerSocket
and wait for a particular message to be issued. When the message is received,
all operations required to shut down the server applications are performed
and at the end the System.exit method is called to terminate the Virtual
Machine process. This method, however, implies several disadvantages and
risks: for example in case of a system-wide shutdown, it might happen that
the Virtual Machine process will be shut down directly by the operating system,
without notifying the running server application. Or, for example, if an
attacker finds out what is the required message to send to the server, and
discovers a way to send this message to the running server application, he
can easily interrupt the operation of a server, bypassing all the security
restrictions implemented in the operating system.
Most multi-user operating systems already have a way in which server
applications are started and stopped, under Unix based operating systems
non interactive server applications are called daemons and are controlled
by the operating system with a set of specified signals. Under Windows such
programs are called services and are controlled by appropriate calls to
specific functions defined in the application binary, but although the
ways of dealing with the problem are different, in both cases the operating
system can notify a server application of its imminent shutdown, and the
application has the ability to perform certain tasks before its process of
execution is destroyed.
EOF
|
