Reflexive::Role::TCPServer - Provides a consumable Reflex-based multiplexing TCP server behavior
version 1.110100
{ package MyTCPServer; use Moose; use MooseX::Types::Moose(':all'); use MooseX::Types::Structured(':all'); use MooseX::Params::Validate; extends 'Reflex::Base'; sub on_socket_data { my ($self, $args) = pos_validated_list ( \@_, { isa => 'MyTCPServer' }, { isa => Dict [ data => Any, _sender => Object ] }, ); my $data = $args->{data}; my $socket = $args->{_sender}->get_first_emitter(); warn "Received data ($data) from socket ($socket)"; chomp($data); # look at Reflex::Role::Streaming for what methods are available $socket->put(reverse($data)."\n"); } with 'Reflexive::Role::TCPServer'; } my $server = MyTCPServer->new(); $server->run_all();
Reflexive::Role::TCPServer provides a multiplexing TCP server behavior for consuming classes. It does this by being an amalgamation of other Reflex and Reflexive roles such as Reflex::Role::Accepting and Reflexive::Role::Collective. The only required method to be implemented by the consumer is "on_socket_data" which is called when sockets receive data.
See the eg directory in the shipped distribution for an example that is more detailed than the synopsis.
This is the name of the class to use when constructing an input filter for each socket that is accepted. It defaults to POE::Filter::Stream.
Please see Reflexive::Stream::Filtering for more information on how filtering occurs on data.
If the input filter class takes any arguments during construction, put them here as a HashRef
This is the name of the class to use when constructing an output filter for each socket that is accepted. It defaults to POE::Filter::Stream.
If the output filter class takes any arguments during construction, put them here as a HashRef
Dict[data => Any, _sender => Object]
This role requires the method on_socket_data to be implemented in the consuming class prior to application. The inbound, filtered data will be available in the HashRef under the key 'data'. The socket that generated the event will be available via "get_first_emitter" in Reflex::Sender on the _sender object.
is: ro, isa: Int, default: 5000, writer: _set_port
port holds the particular TCP port number to use when listening for connections. It defaults to 5000 for no real particular reason, other than to make it easier to use this role in the PSGI space.
is: ro, isa: Str, default: '0.0.0.0', writer: _set_host
host holds the address to use when setting up the listening socket. It defaults to 0.0.0.0 (which means all available interfaces/addresses).
is: ro, isa: FileHandle, lazy: 1 clearer: clear_listener predicate: has_listener builder: _build_listener
listener holds the listening socket from which to accept connections. Ideally, this attribute shouldn't be touched in consuming classes
is: ro, isa: HashRef, traits: Hash clearer: _clear_sockets handles: '_set_socket' => 'set', '_delete_socket' => 'delete', '_count_sockets' => 'count', '_all_sockets' => 'values',
sockets stores the complete, accepted connections from clients.
sockets is really only for low-level access and the facilities from the consumed Reflexive::Role::Collective should be used to store/remove clients.
try_listener_build is the method called when the object is first instantiated to attempt to bind a listening socket. It wraps construction of the "listener" attribute inside a try/catch block. If it fails the "on_listener_error" callback is fired to allow for retrying the binding.
shutdown will stop the listening socket forcibly stop all active sockets.
This will allow the event loop to terminate.
_build_listener takes the "host" and "port" attributes and builds a listening socket using IO::Socket::INET. If it is unable to bind to the host/port combination, it will confess.
(FileHandle)
_build_socket is called when the listener_accept event fires. The raw socket, and the filters constructed from the "input_filter_class" and "output_filter_class" parameters are passed to the constructor for Reflexive::Stream::Filtering and returned.
BUILD is advised in a couple of different ways to ensure proper operation:
1) before BUILD is used to attempt to build the listener socket prior to Reflex::Role::Readable attempts to use the socket. This allows for the capture of exceptions on binding if they occur.
2) after BUILD is used to watch the events that this role emits.
(Dict[peer => Str, socket => FileHandle])
on_listener_accept is the callback method called when a socket connection has been accepted. It calls "_build_socket" and stores the result using "remember" in Reflexive::Role::Collective which is named "store_socket" in this role.
(Dict[errnum => Num, errstr => Str, errfun => Str])
on_listener_error is the callback called when there is an error on the listening socket.
(Dict[_sender => Object])
on_socket_stop is the callback method fired when sockets close. It calls "forget" in Reflexive::Role::Collective, which is named "remove_socket" in this role, to no longer store the socket. The socket that sent the event will be the first emitter.
(Dict[_sender => Object, errnum => Num, errstr => Str, errfun => Str])
on_socket_error is the callback fired when a socket encounters an error. The socket that sent the event will be the first emitter. This method merely unstores the socket.
Nicholas R. Perez <nperez@cpan.org>
This software is copyright (c) 2010 by Nicholas R. Perez <nperez@cpan.org>.
This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.
To install Reflexive::Role::TCPServer, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Reflexive::Role::TCPServer
CPAN shell
perl -MCPAN -e shell install Reflexive::Role::TCPServer
For more information on module installation, please visit the detailed CPAN module installation guide.