version 1.2, 2003/04/18 02:59:31
|
version 1.4, 2003/04/24 10:56:55
|
Line 100 my %ActiveClients; # Serial numbers of
|
Line 100 my %ActiveClients; # Serial numbers of
|
my $WorkQueue = Queue->new(); # Queue of pending transactions. |
my $WorkQueue = Queue->new(); # Queue of pending transactions. |
my $ClientQueue = Queue->new(); # Queue of clients causing xactinos. |
my $ClientQueue = Queue->new(); # Queue of clients causing xactinos. |
my $ConnectionCount = 0; |
my $ConnectionCount = 0; |
|
my $IdleSeconds = 0; # Number of seconds idle. |
|
|
# |
# |
|
|
=pod |
=pod |
=head 2 GetPeerName |
|
Returns the name of the host that a socket object is connected |
=head2 GetPeerName |
to. |
|
|
Returns the name of the host that a socket object is connected to. |
|
|
=cut |
=cut |
|
|
sub GetPeername { |
sub GetPeername { |
Line 127 sub GetPeername {
|
Line 130 sub GetPeername {
|
} |
} |
#----------------------------- Timer management ------------------------ |
#----------------------------- Timer management ------------------------ |
=pod |
=pod |
|
|
=head2 Debug |
=head2 Debug |
Invoked to issue a debug message. |
|
|
Invoked to issue a debug message. |
|
|
=cut |
=cut |
|
|
sub Debug { |
sub Debug { |
my $level = shift; |
my $level = shift; |
my $message = shift; |
my $message = shift; |
Line 145 sub SocketDump {
|
Line 152 sub SocketDump {
|
$socket->Dump(); |
$socket->Dump(); |
} |
} |
} |
} |
|
|
=pod |
=pod |
|
|
=head2 Tick |
=head2 Tick |
Invoked each timer tick. |
|
|
Invoked each timer tick. |
|
|
=cut |
=cut |
|
|
sub Tick { |
sub Tick { |
my $client; |
my $client; |
|
$0 = 'lonc: '.GetServerHost()." Connection count: ".$ConnectionCount; |
Debug(6, "Tick"); |
Debug(6, "Tick"); |
Debug(6, " Current connection count: ".$ConnectionCount); |
Debug(6, " Current connection count: ".$ConnectionCount); |
foreach $client (keys %ActiveClients) { |
foreach $client (keys %ActiveClients) { |
Debug(7, " Have client: with id: ".$ActiveClients{$client}); |
Debug(7, " Have client: with id: ".$ActiveClients{$client}); |
} |
} |
|
# Is it time to prune connection count: |
|
|
|
|
|
if($IdleConnections->Count() && |
|
($WorkQueue->Count() == 0)) { # Idle connections and nothing to do? |
|
$IdleSeconds++; |
|
if($IdleSeconds > $IdleTimeout) { # Prune a connection... |
|
$Socket = $IdleConnections->pop(); |
|
KillSocket($Socket, 0); |
|
} |
|
} else { |
|
$IdleSeconds = 0; # Reset idle count if not idle. |
|
} |
} |
} |
|
|
=pod |
=pod |
|
|
=head2 SetupTimer |
=head2 SetupTimer |
Sets up a 1 per sec recurring timer event. The event handler is used to: |
|
|
|
=item Trigger timeouts on communications along active sockets. |
Sets up a 1 per sec recurring timer event. The event handler is used to: |
=item Trigger disconnections of idle sockets. |
|
|
=item |
|
|
|
Trigger timeouts on communications along active sockets. |
|
|
|
=item |
|
|
|
Trigger disconnections of idle sockets. |
|
|
=cut |
=cut |
|
|
Line 173 sub SetupTimer {
|
Line 204 sub SetupTimer {
|
Debug(6, "SetupTimer"); |
Debug(6, "SetupTimer"); |
Event->timer(interval => 1, debug => 1, cb => \&Tick ); |
Event->timer(interval => 1, debug => 1, cb => \&Tick ); |
} |
} |
|
|
=pod |
=pod |
|
|
=head2 ServerToIdle |
=head2 ServerToIdle |
This function is called when a connection to the server is |
|
ready for more work. |
This function is called when a connection to the server is |
If there is work in the Work queue the top element is dequeued |
ready for more work. |
|
|
|
If there is work in the Work queue the top element is dequeued |
and the connection will start to work on it. If the work queue is |
and the connection will start to work on it. If the work queue is |
empty, the connection is pushed on the idle connection stack where |
empty, the connection is pushed on the idle connection stack where |
it will either get another work unit, or alternatively, if it sits there |
it will either get another work unit, or alternatively, if it sits there |
long enough, it will be shut down and released. |
long enough, it will be shut down and released. |
|
|
|
|
=cut |
=cut |
|
|
sub ServerToIdle { |
sub ServerToIdle { |
my $Socket = shift; # Get the socket. |
my $Socket = shift; # Get the socket. |
|
|
Line 208 sub ServerToIdle {
|
Line 243 sub ServerToIdle {
|
$IdleConnections->push($Socket); |
$IdleConnections->push($Socket); |
} |
} |
} |
} |
|
|
=pod |
=pod |
|
|
=head2 ClientWritable |
=head2 ClientWritable |
Event callback for when a client socket is writable. |
|
This callback is established when a transaction reponse is |
Event callback for when a client socket is writable. |
avaiable from lond. The response is forwarded to the unix socket |
|
as it becomes writable in this sub. |
This callback is established when a transaction reponse is |
|
avaiable from lond. The response is forwarded to the unix socket |
|
as it becomes writable in this sub. |
|
|
Parameters: |
Parameters: |
|
|
=item Event - The event that has been triggered. Event->w->data is |
=item Event |
the data and Event->w->fd is the socket to write. |
|
|
The event that has been triggered. Event->w->data is |
|
the data and Event->w->fd is the socket to write. |
|
|
=cut |
=cut |
|
|
sub ClientWritable { |
sub ClientWritable { |
my $Event = shift; |
my $Event = shift; |
my $Watcher = $Event->w; |
my $Watcher = $Event->w; |
Line 280 sub ClientWritable {
|
Line 323 sub ClientWritable {
|
} |
} |
|
|
=pod |
=pod |
|
|
=head2 CompleteTransaction |
=head2 CompleteTransaction |
Called when the reply data has been received for a lond |
|
|
Called when the reply data has been received for a lond |
transaction. The reply data must now be sent to the |
transaction. The reply data must now be sent to the |
ultimate client on the other end of the Unix socket. This is |
ultimate client on the other end of the Unix socket. This is |
done by setting up a writable event for the socket with the |
done by setting up a writable event for the socket with the |
data the reply data. |
data the reply data. |
|
|
Parameters: |
Parameters: |
=item Socket - Socket on which the lond transaction occured. This |
|
is a LondConnection. The data received is in the |
=item Socket |
TransactionReply member. |
|
=item Client - Unix domain socket open on the ultimate client. |
Socket on which the lond transaction occured. This is a |
|
LondConnection. The data received is in the TransactionReply member. |
|
|
|
=item Client |
|
|
|
Unix domain socket open on the ultimate client. |
|
|
=cut |
=cut |
|
|
sub CompleteTransaction { |
sub CompleteTransaction { |
&Debug(6,"Complete transaction"); |
&Debug(6,"Complete transaction"); |
my $Socket = shift; |
my $Socket = shift; |
Line 310 sub CompleteTransaction {
|
Line 362 sub CompleteTransaction {
|
cb => \&ClientWritable, |
cb => \&ClientWritable, |
data => $data); |
data => $data); |
} |
} |
|
=pod |
|
=head2 FailTransaction |
|
|
|
Finishes a transaction with failure because the associated lond socket |
|
disconnected. It is up to our client to retry if desired. |
|
|
|
Parameters: |
|
|
|
=item client |
|
|
|
The UNIX domain socket open on our client. |
|
|
|
=cut |
|
|
|
sub FailTransaction { |
|
my $client = shift; |
|
|
|
&Debug(8, "Failing transaction due to disconnect"); |
|
my $Serial = $ActiveClients{$client}; |
|
my $desc = sprintf("Connection to lonc client %d", $Serial); |
|
my $data = "error: Connection to lond lost\n"; |
|
|
|
Event->io(fd => $client, |
|
poll => "w", |
|
desc => $desc, |
|
cb => \&ClientWritable, |
|
data => $data); |
|
|
|
} |
|
|
|
=pod |
|
|
|
=head2 KillSocket |
|
|
|
Destroys a socket. This function can be called either when a socket |
|
has died of 'natural' causes or because a socket needs to be pruned due to |
|
idleness. If the socket has died naturally, if there are no longer any |
|
live connections a new connection is created (in case there are transactions |
|
in the queue). If the socket has been pruned, it is never re-created. |
|
|
|
Parameters: |
|
|
|
=item Socket |
|
|
|
The socket to kill off. |
|
|
|
=item Restart |
|
|
|
nonzero if we are allowed to create a new connection. |
|
|
|
|
|
=cut |
|
sub KillSocket { |
|
my $Socket = shift; |
|
my $Restart= shift; |
|
|
|
# If the socket came from the active connection set, delete it. |
|
# otherwise it came from the idle set and has already been destroyed: |
|
|
|
if(exists($ActiveTransactions{$Socket})) { |
|
delete ($ActiveTransactions{$Socket}); |
|
} |
|
if(exists($ActiveConnections{$Socket})) { |
|
delete($ActiveConnections{$Socket}); |
|
} |
|
$ConnectionCount--; |
|
if( ($ConnectionCount = 0) && ($Restart)) { |
|
MakeLondConnection(); |
|
} |
|
|
|
} |
|
|
=pod |
=pod |
|
|
=head2 LondReadable |
=head2 LondReadable |
|
|
This function is called whenever a lond connection |
This function is called whenever a lond connection |
is readable. The action is state dependent: |
is readable. The action is state dependent: |
|
|
=head3 State = Initialized |
=head3 State=Initialized |
We''re waiting for the challenge, this is a no-op until the |
|
|
We''re waiting for the challenge, this is a no-op until the |
state changes. |
state changes. |
|
|
=head3 State=Challenged |
=head3 State=Challenged |
The challenge has arrived we need to transition to Writable. |
|
|
The challenge has arrived we need to transition to Writable. |
The connection must echo the challenge back. |
The connection must echo the challenge back. |
|
|
=head3 State=ChallengeReplied |
=head3 State=ChallengeReplied |
The challenge has been replied to. The we are receiveing the |
|
|
The challenge has been replied to. The we are receiveing the |
'ok' from the partner. |
'ok' from the partner. |
|
|
=head3 State=RequestingKey |
=head3 State=RequestingKey |
The ok has been received and we need to send the request for |
|
|
The ok has been received and we need to send the request for |
an encryption key. Transition to writable for that. |
an encryption key. Transition to writable for that. |
|
|
=head3 State=ReceivingKey |
=head3 State=ReceivingKey |
The the key has been requested, now we are reading the new key. |
|
|
The the key has been requested, now we are reading the new key. |
|
|
=head3 State=Idle |
=head3 State=Idle |
The encryption key has been negotiated or we have finished |
|
|
The encryption key has been negotiated or we have finished |
reading data from the a transaction. If the callback data has |
reading data from the a transaction. If the callback data has |
a client as well as the socket iformation, then we are |
a client as well as the socket iformation, then we are |
doing a transaction and the data received is relayed to the client |
doing a transaction and the data received is relayed to the client |
before the socket is put on the idle list. |
before the socket is put on the idle list. |
|
|
=head3 State=SendingRequest |
=head3 State=SendingRequest |
I do not think this state can be received here, but if it is, |
|
|
I do not think this state can be received here, but if it is, |
the appropriate thing to do is to transition to writable, and send |
the appropriate thing to do is to transition to writable, and send |
the request. |
the request. |
|
|
=head3 State=ReceivingReply |
=head3 State=ReceivingReply |
We finished sending the request to the server and now transition |
|
|
We finished sending the request to the server and now transition |
to readable to receive the reply. |
to readable to receive the reply. |
|
|
The parameter to this function are: |
The parameter to this function are: |
|
|
The event. Implicit in this is the watcher and its data. The data |
The event. Implicit in this is the watcher and its data. The data |
contains at least the lond connection object and, if a |
contains at least the lond connection object and, if a |
transaction is in progress, the socket attached to the local client. |
transaction is in progress, the socket attached to the local client. |
|
|
|
|
=cut |
=cut |
|
|
sub LondReadable { |
sub LondReadable { |
my $Event = shift; |
my $Event = shift; |
my $Watcher = $Event->w; |
my $Watcher = $Event->w; |
Line 365 sub LondReadable {
|
Line 505 sub LondReadable {
|
SocketDump(6, $Socket); |
SocketDump(6, $Socket); |
|
|
if($Socket->Readable() != 0) { |
if($Socket->Readable() != 0) { |
# bad return from socket read. |
# bad return from socket read. Currently this means that |
|
# The socket has become disconnected. We fail the transaction. |
|
|
|
if(exists($ActiveTransactions{$Socket})) { |
|
Debug(3,"Lond connection lost failing transaction"); |
|
FailTransaction($ActiveTransactions{$Socket}); |
|
} |
|
$Watcher->cancel(); |
|
KillSocket($Socket, 1); |
|
return; |
} |
} |
SocketDump(6,$Socket); |
SocketDump(6,$Socket); |
|
|
Line 422 sub LondReadable {
|
Line 571 sub LondReadable {
|
Debug(4, "Invalid state in LondReadable"); |
Debug(4, "Invalid state in LondReadable"); |
} |
} |
} |
} |
|
|
=pod |
=pod |
|
|
=head2 LondWritable |
=head2 LondWritable |
|
|
This function is called whenever a lond connection |
This function is called whenever a lond connection |
becomes writable while there is a writeable monitoring |
becomes writable while there is a writeable monitoring |
event. The action taken is very state dependent: |
event. The action taken is very state dependent: |
|
|
=head3 State = Connected |
=head3 State = Connected |
The connection is in the process of sending the |
|
'init' hailing to the lond on the remote end. |
The connection is in the process of sending the 'init' hailing to the |
The connection object''s Writable member is called. |
lond on the remote end. The connection object''s Writable member is |
On error, ConnectionError is called to destroy |
called. On error, ConnectionError is called to destroy the connection |
the connection and remove it from the ActiveConnections |
and remove it from the ActiveConnections hash |
hash |
|
=head3 Initialized |
=head3 Initialized |
'init' has been sent, writability monitoring is |
|
removed and readability monitoring is started |
'init' has been sent, writability monitoring is removed and |
with LondReadable as the callback. |
readability monitoring is started with LondReadable as the callback. |
|
|
=head3 ChallengeReceived |
=head3 ChallengeReceived |
The connection has received the who are you |
|
challenge from the remote system, and is in the |
The connection has received the who are you challenge from the remote |
process of sending the challenge response. |
system, and is in the process of sending the challenge |
Writable is called. |
response. Writable is called. |
|
|
=head3 ChallengeReplied |
=head3 ChallengeReplied |
The connection has replied to the initial challenge |
|
The we switch to monitoring readability looking |
The connection has replied to the initial challenge The we switch to |
for the server to reply with 'ok'. |
monitoring readability looking for the server to reply with 'ok'. |
|
|
=head3 RequestingKey |
=head3 RequestingKey |
The connection is in the process of requesting its |
|
encryption key. Writable is called. |
The connection is in the process of requesting its encryption key. |
|
Writable is called. |
|
|
=head3 ReceivingKey |
=head3 ReceivingKey |
The connection has sent the request for a key. |
|
Switch to readability monitoring to accept the key |
The connection has sent the request for a key. Switch to readability |
|
monitoring to accept the key |
|
|
=head3 SendingRequest |
=head3 SendingRequest |
The connection is in the process of sending a |
|
request to the server. This request is part of |
The connection is in the process of sending a request to the server. |
a client transaction. All the states until now |
This request is part of a client transaction. All the states until |
represent the client setup protocol. Writable |
now represent the client setup protocol. Writable is called. |
is called. |
|
=head3 ReceivingReply |
=head3 ReceivingReply |
The connection has sent a request. Now it must |
|
receive a reply. Readability monitoring is |
|
requested. |
|
|
|
This function is an event handler and therefore receives as |
The connection has sent a request. Now it must receive a reply. |
|
Readability monitoring is requested. |
|
|
|
This function is an event handler and therefore receives as |
a parameter the event that has fired. The data for the watcher |
a parameter the event that has fired. The data for the watcher |
of this event is a reference to a list of one or two elements, |
of this event is a reference to a list of one or two elements, |
depending on state. The first (and possibly only) element is the |
depending on state. The first (and possibly only) element is the |
Line 472 socket. The second (present only if a r
|
Line 632 socket. The second (present only if a r
|
is the socket on which to return a reply to the caller. |
is the socket on which to return a reply to the caller. |
|
|
=cut |
=cut |
|
|
sub LondWritable { |
sub LondWritable { |
my $Event = shift; |
my $Event = shift; |
my $Watcher = $Event->w; |
my $Watcher = $Event->w; |
Line 489 sub LondWritable {
|
Line 650 sub LondWritable {
|
SocketDump(6,$Socket); |
SocketDump(6,$Socket); |
|
|
if ($State eq "Connected") { |
if ($State eq "Connected") { |
# "init" is being sent... |
|
|
|
if ($Socket->Writable() != 0) { |
if ($Socket->Writable() != 0) { |
# The write resulted in an error. |
# The write resulted in an error. |
|
# We'll treat this as if the socket got disconnected: |
|
if(exists($ActiveTransactions{$Socket})) { |
|
Debug(3, "Lond connection lost, failing transactions"); |
|
FailTransaction($ActiveTransactions{$Socket}); |
|
} |
|
$Watcher->cancel(); |
|
KillSocket($Socket, 1); |
|
return; |
} |
} |
|
# "init" is being sent... |
|
|
|
|
} elsif ($State eq "Initialized") { |
} elsif ($State eq "Initialized") { |
|
|
Line 564 sub LondWritable {
|
Line 734 sub LondWritable {
|
} |
} |
|
|
=pod |
=pod |
|
|
=head2 MakeLondConnection |
=head2 MakeLondConnection |
Create a new lond connection object, and start it towards |
|
its initial idleness. Once idle, it becomes elligible to |
Create a new lond connection object, and start it towards its initial |
receive transactions from the work queue. If the work queue |
idleness. Once idle, it becomes elligible to receive transactions |
is not empty when the connection is completed and becomes idle, |
from the work queue. If the work queue is not empty when the |
it will dequeue an entry and start off on it. |
connection is completed and becomes idle, it will dequeue an entry and |
|
start off on it. |
|
|
=cut |
=cut |
|
|
sub MakeLondConnection { |
sub MakeLondConnection { |
Debug(4,"MakeLondConnection to ".GetServerHost()." on port " |
Debug(4,"MakeLondConnection to ".GetServerHost()." on port " |
.GetServerPort()); |
.GetServerPort()); |
Line 600 sub MakeLondConnection {
|
Line 774 sub MakeLondConnection {
|
cb => \&LondWritable, |
cb => \&LondWritable, |
data => ($Connection, undef), |
data => ($Connection, undef), |
desc => 'Connection to lond server'); |
desc => 'Connection to lond server'); |
$ActiveConnections{$Lond} = $event; |
$ActiveConnections{$Connection} = $event; |
|
|
$ConnectionCount++; |
$ConnectionCount++; |
|
|
|
|
} |
} |
|
|
=pod |
=pod |
|
|
=head2 StartRequest |
=head2 StartRequest |
Starts a lond request going on a specified lond connection. |
|
parameters are: |
Starts a lond request going on a specified lond connection. |
=item $Lond - Connection to the lond that will send the transaction |
parameters are: |
and receive the reply. |
|
=item $Client - Connection to the client that is making this request |
=item $Lond |
We got the request from this socket, and when the request has |
|
been relayed to lond and we get a reply back from lond it will |
Connection to the lond that will send the transaction and receive the |
get sent to this socket. |
reply. |
=item $Request - The text of the request to send. |
|
|
=item $Client |
|
|
|
Connection to the client that is making this request We got the |
|
request from this socket, and when the request has been relayed to |
|
lond and we get a reply back from lond it will get sent to this |
|
socket. |
|
|
|
=item $Request |
|
|
|
The text of the request to send. |
|
|
=cut |
=cut |
|
|
sub StartRequest { |
sub StartRequest { |
Line 641 sub StartRequest {
|
Line 828 sub StartRequest {
|
} |
} |
|
|
=pod |
=pod |
|
|
=head2 QueueTransaction |
=head2 QueueTransaction |
- If there is an idle lond connection, it is put to |
|
work doing this transaction. Otherwise, the transaction is |
If there is an idle lond connection, it is put to work doing this |
placed in the work queue. If placed in the work queue and the |
transaction. Otherwise, the transaction is placed in the work queue. |
maximum number of connections has not yet been created, a new |
If placed in the work queue and the maximum number of connections has |
connection will be started. Our goal is to eventually have |
not yet been created, a new connection will be started. Our goal is |
a sufficient number of connections that the work queue will |
to eventually have a sufficient number of connections that the work |
typically be empty. |
queue will typically be empty. parameters are: |
parameters are: |
|
=item Socket open on the lonc client. |
=item Socket |
=item Request data to send to the lond. |
|
|
open on the lonc client. |
|
|
|
=item Request |
|
|
|
data to send to the lond. |
|
|
=cut |
=cut |
|
|
sub QueueTransaction { |
sub QueueTransaction { |
my $requestSocket = shift; |
my $requestSocket = shift; |
my $requestData = shift; |
my $requestData = shift; |
Line 676 sub QueueTransaction {
|
Line 870 sub QueueTransaction {
|
} |
} |
|
|
#-------------------------- Lonc UNIX socket handling --------------------- |
#-------------------------- Lonc UNIX socket handling --------------------- |
|
|
=pod |
=pod |
|
|
=head2 ClientRequest |
=head2 ClientRequest |
Callback that is called when data can be read from the |
|
UNIX domain socket connecting us with an apache server process. |
Callback that is called when data can be read from the UNIX domain |
|
socket connecting us with an apache server process. |
|
|
=cut |
=cut |
|
|
Line 716 sub ClientRequest {
|
Line 913 sub ClientRequest {
|
|
|
|
|
=pod |
=pod |
|
|
=head2 NewClient |
=head2 NewClient |
Callback that is called when a connection is received on the |
|
unix socket for a new client of lonc. The callback is parameterized |
Callback that is called when a connection is received on the unix |
by the event.. which is a-priori assumed to be an io event, and therefore |
socket for a new client of lonc. The callback is parameterized by the |
has an fd member that is the Listener socket. We Accept the connection |
event.. which is a-priori assumed to be an io event, and therefore has |
and register a new event on the readability of that socket: |
an fd member that is the Listener socket. We Accept the connection |
|
and register a new event on the readability of that socket: |
|
|
=cut |
=cut |
|
|
sub NewClient { |
sub NewClient { |
Debug(6, "NewClient"); |
Debug(6, "NewClient"); |
my $event = shift; # Get the event parameters. |
my $event = shift; # Get the event parameters. |
Line 744 sub NewClient {
|
Line 945 sub NewClient {
|
$ActiveClients{$connection} = $ClientConnection; |
$ActiveClients{$connection} = $ClientConnection; |
$ClientConnection++; |
$ClientConnection++; |
} |
} |
=pod GetLoncSocketPath |
|
Returns the name of the UNIX socket on which to listen for client |
=pod |
connections. |
|
|
=head2 GetLoncSocketPath |
|
|
|
Returns the name of the UNIX socket on which to listen for client |
|
connections. |
|
|
=cut |
=cut |
|
|
sub GetLoncSocketPath { |
sub GetLoncSocketPath { |
return $UnixSocketDir."/".GetServerHost(); |
return $UnixSocketDir."/".GetServerHost(); |
} |
} |
|
|
=pod GetServerHost |
=pod |
Returns the host whose lond we talk with. |
|
|
=head2 GetServerHost |
|
|
|
Returns the host whose lond we talk with. |
|
|
=cut |
=cut |
|
|
sub GetServerHost { # Stub - get this from config. |
sub GetServerHost { # Stub - get this from config. |
return $RemoteHost; # Setup by the fork. |
return $RemoteHost; # Setup by the fork. |
} |
} |
=pod GetServerPort |
|
Returns the lond port number. |
=pod |
|
|
|
=head2 GetServerPort |
|
|
|
Returns the lond port number. |
|
|
=cut |
=cut |
|
|
sub GetServerPort { # Stub - get this from config. |
sub GetServerPort { # Stub - get this from config. |
return $perlvar{londPort}; |
return $perlvar{londPort}; |
} |
} |
=pod SetupLoncListener |
|
Setup a lonc listener event. The event is called when |
=pod |
the socket becomes readable.. that corresponds to the |
|
receipt of a new connection. The event handler established |
=head2 SetupLoncListener |
will accept the connection (creating a communcations channel), that |
|
int turn will establish another event handler to subess requests. |
Setup a lonc listener event. The event is called when the socket |
|
becomes readable.. that corresponds to the receipt of a new |
|
connection. The event handler established will accept the connection |
|
(creating a communcations channel), that int turn will establish |
|
another event handler to subess requests. |
|
|
=cut |
=cut |
|
|
sub SetupLoncListener { |
sub SetupLoncListener { |
|
|
my $socket; |
my $socket; |
Line 790 sub SetupLoncListener {
|
Line 1012 sub SetupLoncListener {
|
} |
} |
|
|
=pod |
=pod |
|
|
=head2 ChildProcess |
=head2 ChildProcess |
|
|
This sub implements a child process for a single lonc daemon. |
This sub implements a child process for a single lonc daemon. |
Line 875 while(1) {
|
Line 1098 while(1) {
|
} |
} |
|
|
=head1 Theory |
=head1 Theory |
The event class is used to build this as a single process with |
|
an event driven model. The following events are handled: |
The event class is used to build this as a single process with an |
|
event driven model. The following events are handled: |
|
|
=item UNIX Socket connection Received |
=item UNIX Socket connection Received |
|
|
Line 890 All sockets are run in non-blocking mode
|
Line 1114 All sockets are run in non-blocking mode
|
handler prevents hung connections. |
handler prevents hung connections. |
|
|
Key data structures: |
Key data structures: |
=item RequestQueue - A queue of requests received from UNIX sockets that are |
|
waiting for a chance to be forwarded on a lond connection socket. |
|
|
|
=item ActiveConnections - A hash of lond connections that have transactions |
=item RequestQueue |
in process that are available to be timed out. |
|
|
A queue of requests received from UNIX sockets that are |
|
waiting for a chance to be forwarded on a lond connection socket. |
|
|
|
=item ActiveConnections |
|
|
|
A hash of lond connections that have transactions in process that are |
|
available to be timed out. |
|
|
|
=item ActiveTransactions |
|
|
|
A hash indexed by lond connections that contain the client reply |
|
socket for each connection that has an active transaction on it. |
|
|
|
=item IdleConnections |
|
|
|
A hash of lond connections that have no work to do. These connections |
|
can be closed if they are idle for a long enough time. |
|
|
=item ActiveTransactions - A hash indexed by lond connections that |
|
contain the client reply socket for each connection that has an active |
|
transaction on it. |
|
|
|
=item IdleConnections - A hash of lond connections that have no work |
|
to do. These connections can be closed if they are idle for a long |
|
enough time. |
|
=cut |
=cut |