1POE::Component::Server:U:sTeCrP(C3o)ntributed Perl DocumPeOnEt:a:tCioomnponent::Server::TCP(3)
2
6 POE::Component::Server::TCP - a simplified TCP server
7
9 #!perl
10 use warnings;
12 use strict;
13 use POE qw(Component::Server::TCP);
15 POE::Component::Server::TCP->new(
17 Port => 12345,
18 ClientConnected => sub {
19 print "got a connection from $_[HEAP]{remote_ip}\n";
20 $_[HEAP]{client}->put("Smile from the server!");
21 },
22 ClientInput => sub {
23 my $client_input = $_[ARG0];
24 $client_input =~ tr[a-zA-Z][n-za-mN-ZA-M];
25 $_[HEAP]{client}->put($client_input);
26 },
27 );
28 POE::Kernel->run;
30 exit;
31
33 POE::Component::Server::TCP implements a generic multi-Session server.
34 Simple services may be put together in a few lines of code. For
35 example, a server that echoes input back to the client:
36 use POE qw(Component::Server::TCP);
38 POE::Component::Server::TCP->new(
39 Port => 12345,
40 ClientInput => sub { $_[HEAP]{client}->put($_[ARG0]) },
41 );
42 POE::Kernel->run();
43 Accepting Connections Yourself
45 POE::Component::Server::TCP has a default mode where it accepts new
46 connections and creates the sessions to handle them. Programs can do
47 this themselves by providing their own "Acceptor" callbacks. See
48 "Acceptor" for details.
49 Master Listener Session
51 At creation time, POE::Component::Server::TCP starts one POE::Session
52 to listen for new connections. The component's "Alias" refers to this
53 master session.
54 If "Acceptor" is specified, then it's up to that callback to deal with
56 newly accepted sockets. Its parameters are that of
57 POE::Wheel::SocketFactory's "SuccessEvent".
58 Otherwise, the default "Acceptor" callback will start a new session to
60 handle each connection. These child sessions do not have their own
61 aliases, but their "ClientConnected" and "ClientDisconnected" callbacks
62 may be used to register and unregister the sessions with a shared
63 namespace, such as a hash keyed on session IDs, or an object that
64 manages such a hash.
65 my %client_namespace;
67 sub handle_client_connected {
69 my $client_session_id = $_[SESSION]->ID;
70 $client_namespace{$client_session_id} = \%anything;
71 }
72 sub handle_client_disconnected {
74 my $client_session_id = $_[SESSION]->ID;
75 $client_namespace{$client_session_id} = \%anything;
76 }
77 The component's "Started" callback is invoked at the end of the master
79 session's start-up routine. The @_[ARG0..$#_] parameters are set to a
80 copy of the values in the server's "ListenerArgs" constructor
81 parameter. The other parameters are standard for POE::Session's _start
82 handlers.
83 The component's "Stopped" callback is invoked at the beginning of the
85 master session's _stop routine. The parameters are standard for
86 POE::Session's _stop handlers.
87 The component's "Error" callback is invoked when the server has a
89 problem listening for connections. "Error" may also be called if the
90 component's default acceptor has trouble accepting a connection.
91 "Error" receives the usual ones for "FailureEvent" in
92 POE::Wheel::SocketFactory and "ErrorEvent" in POE::Wheel::ReadWrite.
93 Default Child Connection Sessions
95 If "Acceptor" isn't specified, POE::Component::Server::TCP's default
96 handler will start a new session for each new client connection. As
97 mentioned above, these child sessions have no aliases of their own, but
98 they may set aliases or register themselves another way during their
99 "ClientConnected" and "ClientDisconnected" callbacks.
100 It can't be stressed enough that the following callbacks are executed
102 within the context of dynamic child sessions---one per client
103 connection---and not in the master listening session. This has been a
104 major point of confusion. We welcome suggestions for making this
105 clearer.
106 The component's "ClientInput" callback defines how child sessions will
108 handle input from their clients. Its parameters are that of
109 POE::Wheel::ReadWrite's "InputEvent".
110 As mentioned "ClientConnected" is called at the end of the child
112 session's "_start" routine. The "ClientConneted" callback receives the
113 same parameters as the client session's _start does. The arrayref
114 passed to the constructor's "Args" parameter is flattened and included
115 in "ClientConnected"'s parameters as @_[ARG0..$#_].
116 sub handle_client_connected {
118 my @constructor_args = @_[ARG0..$#_];
119 ...
120 }
121 "ClientPreConnect" is called before "ClientConnected", and its purpose
123 is to allow programs to reject connections or condition sockets before
124 they're given to POE::Wheel::ReadWrite for management.
125 The "ClientPreConnect" handler is called with the client socket in
127 $_[ARG0], and its return value is significant. It must return a valid
128 client socket if the connection is acceptable. It must return undef to
129 reject the connection.
130 Most $_[HEAP] values are valid in the "ClientPreConnect" handler.
132 Obviously, $_[HEAP]{client} is not because that wheel hasn't been
133 created yet.
134 In the following example, the "ClientPreConnect" handler returns the
136 client socket after it has been upgraded to an SSL connection.
137 sub handle_client_pre_connect {
139 # Make sure the remote address and port are valid.
141 return undef unless validate(
142 $_[HEAP]{remote_ip}, $_[HEAP]{remote_port}
143 );
144 # SSLify the socket, which is in $_[ARG0].
146 my $socket = eval { Server_SSLify($_[ARG0]) };
147 return undef if $@;
148 # Return the SSL-ified socket.
150 return $socket;
151 }
152 "ClientDisconnected" is called when the client has disconnected, either
154 because the remote socket endpoint has closed or the local endpoint has
155 been closed by the server. This doesn't mean the client's session has
156 ended, but the session most likely will very shortly.
157 "ClientDisconnected" is called from a couple disparate places within
158 the component, so its parameters are neither consistent nor generally
159 useful.
160 "ClientError" is called when an error has occurred on the socket. Its
162 parameters are those of POE::Wheel::ReadWrite's "ErrorEvent".
163 "ClientFlushed" is called when all pending output has been flushed to
165 the client socket. Its parameters come from POE::Wheel::ReadWrite's
166 "ErrorEvent".
167 Performance Considerations
169 This ease of use comes at a price: POE::Component::Server::TCP often
170 performs significantly slower than a comparable server written with
171 POE::Wheel::SocketFactory and POE::Wheel::ReadWrite.
172 If performance is your primary goal, POE::Kernel's select_read() and
174 select_write() perform about the same as IO::Select, but your code will
175 be portable across every event loop POE supports.
176 Special Needs Considerations
178 POE::Component::Server::TCP is written to be easy for the most common
179 use cases. Programs with more special needs should consider using
180 POE::Wheel::SocketFactory and POE::Wheel::ReadWrite instead. These are
181 lower-level modules, and using them requires more effort. They are
182 more flexible and customizable, however.
183
185 new
186 new() starts a server based on POE::Component::Server::TCP and returns
187 a session ID for the master listening session. All error handling is
188 done within the server, via the "Error" and "ClientError" callbacks.
189 The server may be shut down by posting a "shutdown" event to the master
191 session, either by its ID or the name given to it by the "Alias"
192 parameter.
193 POE::Component::Server::TCP does a lot of work in its constructor. The
195 design goal is to push as much overhead into one-time construction so
196 that ongoing run-time has less overhead. Because of this, the server's
197 constructor can take quite a daunting number of parameters.
198 POE::Component::Server::TCP always returns a POE::Session ID for the
200 session that will be listening for new connections.
201 Many of the constructor parameters have been previously described.
203 They are covered briefly again below.
204 Server Session Configuration
206 These constructor parameters affect POE::Component::Server::TCP's main
208 listening session.
209 Acceptor
211 "Acceptor" defines a CODE reference that POE::Wheel::SocketFactory's
213 "SuccessEvent" will trigger to handle new connections. Therefore the
214 parameters passed to "Acceptor" are identical to those given to
215 "SuccessEvent".
216 "Acceptor" is optional; the default handler will create a new session
218 for each connection. All the "Client" constructor parameters are used
219 to customize this session. In other words, "ClientInput" and such are
220 not used when "Acceptor" is set.
221 The default "Acceptor" adds significant convenience and flexibility to
223 POE::Component::Server::TCP, but it's not always a good fit for every
224 application. In some cases, a custom "Acceptor" or even rolling one's
225 own server with POE::Wheel::SocketFactory and POE::Wheel::ReadWrite may
226 be better and/or faster.
227 Acceptor => sub {
229 my ($socket, $remote_address, $remote_port) = @_[ARG0..ARG2];
230 # Set up something to interact with the client.
231 }
232 Address
234 "Address" defines a single interface address the server will bind to.
236 It defaults to INADDR_ANY or INADDR6_ANY, when using IPv4 or IPv6,
237 respectively. It is often used with "Port".
238 The value in "Address" is passed to POE::Wheel::SocketFactory's
240 "BindAddress" parameter, so it may be in whatever form that module
241 supports. At the time of this writing, that may be a dotted IPv4 quad,
242 an IPv6 address, a host name, or a packed Internet address. See also
243 "Hostname".
244 Address => '127.0.0.1' # Localhost IPv4
246 Address => "::1" # Localhost IPv6
247 Alias
249 "Alias" is an optional name that will be given to the server's master
251 listening session. Events sent to this name will not be delivered to
252 individual connections.
253 The server's "Alias" may be important if it's necessary to shut a
255 server down.
256 sub sigusr1_handler {
258 $_[KERNEL]->post(chargen_server => 'shutdown');
259 $_[KERNEL]->sig_handled();
260 }
261 Concurrency
263 "Concurrency" controls how many connections may be active at the same
265 time. It defaults to -1, which allows POE::Component::Server::TCP to
266 accept concurrent connections until the process runs out of resources.
267 Setting "Concurrency" to 0 prevents the server from accepting new
269 connections. This may be useful if a server must perform lengthy
270 initialization before allowing connections. When the initialization
271 finishes, it can yield(set_concurrency => -1) to enable connections.
272 Likewise, a running server may yield(set_concurrency => 0) or any other
273 number to dynamically tune its concurrency. See "EVENTS" for more
274 about the set_concurrency event.
275 Note: For "Concurrency" to work with a custom "Acceptor", the server's
277 listening session must receive a "disconnected" event whenever clients
278 disconnect. Otherwise the listener cannot mediate between its
279 connections.
280 Example:
282 Acceptor => sub {
284 # ....
285 POE::Session->create(
286 # ....
287 inline_states => {
288 _start => sub {
289 # ....
290 # remember who our parent is
291 $_[HEAP]->{server_tcp} = $_[SENDER]->ID;
292 # ....
293 },
294 got_client_disconnect => sub {
295 # ....
296 $_[KERNEL]->post( $_[HEAP]->{server_tcp} => 'disconnected' );
297 # ....
298 }
299 }
300 );
301 }
302 Domain
304 "Domain" sets the address or protocol family within which to operate.
306 The "Domain" may be any value that POE::Wheel::SocketFactory supports.
307 AF_INET (Internet address space) is used by default.
308 Use AF_INET6 for IPv6 support. This constant is exported by Socket or
310 Socket6, depending on your version of Perl. Also be sure to have
311 Socket::GetAddrInfo installed, which is required by
312 POE::Wheel::SocketFactory for IPv6 support.
313 Error
315 "Error" is the callback that will be invoked when the server socket
317 reports an error. The Error callback will be used to handle
318 POE::Wheel::SocketFactory's FailureEvent, so it will receive the same
319 parameters as discussed there.
320 A default error handler will be provided if Error is omitted. The
322 default handler will log the error to STDERR and shut down the server.
323 Active connections will be permitted to complete their transactions.
324 Error => sub {
326 my ($syscall_name, $err_num, $err_str) = @_[ARG0..ARG2];
327 # Handle the error.
328 }
329 Hostname
331 "Hostname" is the optional non-packed name of the interface the TCP
333 server will bind to. The hostname will always be resolved via
334 inet_aton() and so can either be a dotted quad or a name. Name
335 resolution is a one-time start-up action; there are no ongoing run-time
336 penalties for using it.
337 "Hostname" guarantees name resolution, where "Address" does not. It's
339 therefore preferred to use "Hostname" in cases where resolution must
340 always be done.
341 InlineStates
343 "InlineStates" is optional. If specified, it must hold a hashref of
345 named callbacks. Its syntax is that of POE:Session->create()'s
346 inline_states parameter.
347 Remember: These InlineStates handlers will be added to the client
349 sessions, not to the main listening session. A yield() in the listener
350 will not reach these handlers.
351 If POE::Kernel::ASSERT_USAGE is enabled, the constructor will croak()
353 if it detects a state that it uses internally. For example, please use
354 the "Started" and "Stopped" callbacks if you want to specify your own
355 "_start" and "_stop" events respectively.
356 ObjectStates
358 If "ObjectStates" is specified, it must holde an arrayref of objects
360 and the events they will handle. The arrayref must follow the syntax
361 for POE::Session->create()'s object_states parameter.
362 Remember: These ObjectStates handlers will be added to the client
364 sessions, not to the main listening session. A yield() in the listener
365 will not reach these handlers.
366 If POE::Kernel::ASSERT_USAGE is enabled, the constructor will croak()
368 if it detects a state that it uses internally. For example, please use
369 the "Started" and "Stopped" callbacks if you want to specify your own
370 "_start" and "_stop" events respectively.
371 PackageStates
373 When the optional "PackageStates" is set, it must hold an arrayref of
375 package names and the events they will handle The arrayref must follow
376 the syntax for POE::Session->create()'s package_states parameter.
377 Remember: These PackageStates handlers will be added to the client
379 sessions, not to the main listening session. A yield() in the listener
380 will not reach these handlers.
381 If POE::Kernel::ASSERT_USAGE is enabled, the constructor will croak()
383 if it detects a state that it uses internally. For example, please use
384 the "Started" and "Stopped" callbacks if you want to specify your own
385 "_start" and "_stop" events respectively.
386 Port
388 "Port" contains the port the listening socket will be bound to. It
390 defaults to 0, which usually lets the operating system pick a port at
391 random.
392 Port => 30023
394 It is often used with "Address".
396 Started
398 "Started" sets an optional callback that will be invoked within the
400 main server session's context. It notifies the server that it has
401 fully started. The callback's parameters are the usual for a session's
402 _start handler.
403 Stopped
405 "Stopped" sets an optional callback that will be invoked within the
407 main server session's context. It notifies the server that it has
408 fully stopped. The callback's parameters are the usual for a session's
409 _stop handler.
410 ListenerArgs
412 "ListenerArgs" is passed to the listener session as the "args"
414 parameter. In other words, it must be an arrayref, and the values are
415 passed into the "Started" handler as ARG0, ARG1, etc.
416 Connection Session Configuration
418 These constructor parameters affect the individual sessions that
420 interact with established connections.
421 ClientArgs
423 "ClientArgs" is optional. When specified, it holds an ARRAYREF that
425 will be expanded one level and passed to the "ClientConnected" callback
426 in @_[ARG0..$#_].
427 ClientConnected
429 Each new client connection is handled by a new POE::Session instance.
431 "ClientConnected" is a callback that notifies the application when a
432 client's session is started and ready for operation. Banners are often
433 sent to the remote client from this callback.
434 The @_[ARG0..$#_] parameters to "ClientConnected" are a copy of the
436 values in the "ClientArgs" constructor parameter's array reference.
437 The other @_ members are standard for a POE::Session _start handler.
438 "ClientConnected" is called once per session start-up. It will never
440 be called twice for the same connection.
441 ClientConnected => sub {
443 $_[HEAP]{client}->put("Hello, client!");
444 # Other client initialization here.
445 },
446 ClientDisconnected
448 "ClientDisconnected" is a callback that will be invoked when the client
450 disconnects or has been disconnected by the server. It's useful for
451 cleaning up global client information, such as chat room structures.
452 "ClientDisconnected" callbacks receive the usual POE parameters, but
453 nothing special is included.
454 ClientDisconnected => sub {
456 warn "Client disconnected"; # log it
457 }
458 ClientError
460 The "ClientError" callback is invoked when a client socket reports an
462 error. "ClientError" is called with POE's usual parameters, plus the
463 common error parameters: $_[ARG0] describes what was happening at the
464 time of failure. $_[ARG1] and $_[ARG2] contain the numeric and string
465 versions of $!, respectively.
466 "ClientError" is optional. If omitted, POE::Component::Server::TCP
468 will provide a default callback that logs most errors to STDERR.
469 If "ClientShutdownOnError" is set, the connection will be shut down
471 after "ClientError" returns. If "ClientDisconnected" is specified, it
472 will be called as the client session is cleaned up.
473 "ClientError" is triggered by POE::Wheel::ReadWrite's ErrorEvent, so it
475 follows that event's form. Please see the ErrorEvent documentation in
476 POE::Wheel::ReadWrite for more details.
477 ClientError => sub {
479 my ($syscall_name, $error_num, $error_str) = @_[ARG0..ARG2];
480 # Handle the client error here.
481 }
482 ClientFilter
484 "ClientFilter" specifies the POE::Filter object or class that will
486 parse input from each client and serialize output before it's sent to
487 each client.
488 "ClientFilter" may be a SCALAR, in which case it should name the
490 POE::Filter class to use. Each new connection will be given a freshly
491 instantiated filter of that class. No constructor parameters will be
492 passed.
493 ClientFilter => "POE::Filter::Stream",
495 Some filters require constructor parameters. These may be specified by
497 an ARRAYREF. The first element is the POE::Filter class name, and
498 subsequent elements are passed to the class' constructor.
499 ClientFilter => [ "POE::Filter::Line", Literal => "\n" ],
501 "ClientFilter" may also be given an archetypical POE::Filter OBJECT.
503 In this case, each new client session will receive a clone() of the
504 given object.
505 ClientFilter => POE::Filter::Line->new(Literal => "\n"),
507 "ClientFilter" is optional. The component will use "POE::Filter::Line"
509 if it is omitted. There is "ClientInputFilter" and
510 "ClientOutputFilter" if you want to specify a different filter for both
511 directions.
512 Filter modules are not automatically loaded. Be sure that the program
514 loads the class before using it.
515 ClientFlushed
517 "ClientFlushed" exposes POE::Wheel::ReadWrite's "FlushedEvent" as a
519 callback. It is called whenever the client's output buffer has been
520 fully flushed to the client socket. At this point it's safe to shut
521 down the socket without losing data.
522 "ClientFlushed" is useful for streaming servers, where a "flushed"
524 event signals the need to send more data.
525 ClientFlushed => sub {
527 my $data_source = $_[HEAP]{file_handle};
528 my $read_count = sysread($data_source, my $buffer = "", 65536);
529 if ($read_count) {
530 $_[HEAP]{client}->put($buffer);
531 }
532 else {
533 $_[KERNEL]->yield("shutdown");
534 }
535 },
536 POE::Component::Server::TCP's default "Acceptor" ensures that data is
538 flushed before finishing a client shutdown.
539 ClientInput
541 "ClientInput" defines a per-connection callback to handle client input.
543 This callback receives its parameters directly from
544 POE::Wheel::ReadWrite's "InputEvent". ARG0 contains the input record,
545 the format of which is defined by "ClientFilter" or
546 "ClientInputFilter". ARG1 has the wheel's unique ID, and so on.
547 Please see POE:Wheel::ReadWrite for an in-depth description of
548 "InputEvent".
549 "ClientInput" and "Acceptor" are mutually exclusive. Enabling one
551 prohibits the other.
552 ClientInput => sub {
554 my $input = $_[ARG0];
555 $_[HEAP]{wheel}->put("You said: $input");
556 },
557 ClientInputFilter
559 "ClientInputFilter" is used with "ClientOutputFilter" to specify
561 different protocols for input and output. Both must be used together.
562 Both follow the same usage as "ClientFilter". Overrides the filter set
563 by "ClientFilter".
564 ClientInputFilter => [ "POE::Filter::Line", Literal => "\n" ],
566 ClientOutputFilter => 'POE::Filter::Stream',
567 ClientOutputFilter
569 "ClientOutputFilter" is used with "ClientInputFilter" to specify
571 different protocols for input and output. Both must be used together.
572 Both follow the same usage as "ClientFilter". Overrides the filter set
573 by "ClientFilter".
574 ClientInputFilter => POE::Filter::Line->new(Literal => "\n"),
576 ClientOutputFilter => 'POE::Filter::Stream',
577 ClientShutdownOnError
579 "ClientShutdownOnError" tells the component whether client connections
581 should be shut down automatically if an error is detected. It defaults
582 to "true". Setting it to false (0, undef, "") turns off this feature.
583 The application is responsible for dealing with client errors if this
585 feature is disabled. Not doing so may cause the component to emit a
586 constant stream of errors, eventually bogging down the application with
587 dead connections that spin out of control.
588 Yes, this is terrible. You have been warned.
590 SessionParams
592 "SessionParams" specifies additional parameters that will be passed to
594 the "SessionType" constructor at creation time. It must be an array
595 reference.
596 SessionParams => [ options => { debug => 1, trace => 1 } ],
598 Note: POE::Component::Server::TCP supplies its own POE::Session
600 constructor parameters. Conflicts between them and "SessionParams" may
601 cause the component to behave erratically. To avoid such problems,
602 please limit SessionParams to the "options" hash. See POE::Session for
603 an known options.
604 We may enable other options later. Please let us know if you need
606 something.
607 SessionType
609 "SessionType" specifies the POE::Session subclass that will be created
611 for each new client connection. "POE::Session" is the default.
612 SessionType => "POE::Session::MultiDispatch"
614
616 It's possible to manipulate a TCP server component by sending it
617 messages.
618 Main Server Commands
620 These events must be sent to the main server, usually by the alias set
621 in its Alias parameter.
622 disconnected
624 The "disconnected" event informs the TCP server that a connection was
626 closed. It is needed when using "Concurrency" with an "Acceptor"
627 callback. The custom Acceptor must provide its own disconnect
628 notification so that the server's connection counting logic works.
629 Otherwise Concurrency clients will be accepted, and then no more. The
631 server will never know when clients have disconnected.
632 set_concurrency
634 "set_concurrency" set the number of simultaneous connections the server
636 will be willing to accept. See "Concurrency" for more details.
637 "set_concurrency" must have one parameter: the new maximum connection
638 count.
639 $kernel->call("my_server_alias", "set_concurrency", $max_count);
641 shutdown
643 The "shutdown" event starts a graceful server shutdown. No new
645 connections will be accepted. Existing connections will be allowed to
646 finish. The server will be destroyed after the last connection ends.
647 Per-Connection Commands
649 These commands affect each client connection session.
650 shutdown
652 Sending "shutdown" to an individual client session instructs the server
654 to gracefully shut down that connection. No new input will be
655 received, and any buffered output will be sent before the session ends.
656 Client sessions usually yield("shutdown") when they wish to disconnect
658 the client.
659 ClientInput => sub {
661 if ($_[ARG0] eq "quit") {
662 $_[HEAP]{client}->put("B'bye!");
663 $_[KERNEL]->yield("shutdown");
664 return;
665 }
666 # Handle other input here.
668 },
669
671 Unlike most POE modules, POE::Component::Server::TCP stores data in the
672 client sessions' HEAPs. These values are provided as conveniences for
673 application developers.
674 HEAP Members for Master Listening Sessions
676 The master listening session holds different data than client
677 connections.
678 alias
680 $_[HEAP]{alias} contains the server's Alias.
682 concurrency
684 $_[HEAP]{concurrency} remembers the server's "Concurrency" parameter.
686 connections
688 $_[HEAP]{connections} is used to track the current number of concurrent
690 client connections. It's incremented whenever a new connection is
691 accepted, and it's decremented whenever a client disconnects.
692 listener
694 $_[HEAP]{listener} contains the POE::Wheel::SocketFactory object used
696 to listen for connections and accept them.
697 HEAP Members for Connection Sessions
699 These data members exist within the individual connections' sessions.
700 client
702 $_[HEAP]{client} contains a POE::Wheel::ReadWrite object used to
704 interact with the client. All POE::Wheel::ReadWrite methods work.
705 got_an_error
707 $_[HEAP]{got_an_error} remembers whether the client connection has
709 already encountered an error. It is part of the shutdown-on-error
710 procedure.
711 remote_ip
713 $_[HEAP]{remote_ip} contains the remote client's numeric address in
715 human-readable form.
716 remote_port
718 $_[HEAP]{remote_port} contains the remote client's numeric socket port
720 in human-readable form.
721 remote_addr
723 $_[HEAP]{remote_addr} contains the remote client's packed socket
725 address in computer-readable form.
726 shutdown
728 $_[HEAP]{shutdown} is true if the client is in the process of shutting
730 down. The component uses it to ignore client input during shutdown,
731 and to close the connection after pending output has been flushed.
732 shutdown_on_error
734 $_[HEAP]{shutdown_on_error} remembers whether the client connection
736 should automatically shut down if an error occurs.
737
739 The SEE ALSO section in POE contains a table of contents covering the
740 entire POE distribution.
741 POE::Component::Client::TCP is the client-side counterpart to this
743 module.
744 This component uses and exposes features from POE::Filter,
746 POE::Wheel::SocketFactory, and POE::Wheel::ReadWrite.
747
749 This looks nothing like what Ann envisioned.
750 This component currently does not accept many of the options that
752 POE::Wheel::SocketFactory does.
753 This component will not bind to several addresses at once. This may be
755 a limitation in SocketFactory, but it's not by design.
756 This component needs better error handling.
758 Some use cases require different session classes for the listener and
760 the connection handlers. This isn't currently supported. Please send
761 patches. :)
762
764 POE::Component::Server::TCP is Copyright 2000-2013 by Rocco Caputo.
765 All rights are reserved. POE::Component::Server::TCP is free software,
766 and it may be redistributed and/or modified under the same terms as
767 Perl itself.
768 POE::Component::Server::TCP is based on code, used with permission,
770 from Ann Barcomb <kudra@domaintje.com>.
771 POE::Component::Server::TCP is based on code, used with permission,
773 from Jos Boumans <kane@cpan.org>.
774perl v5.32.0 2020-07-28 POE::Component::Server::TCP(3)