| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
Pipes.Network.TCP.Safe
Description
This module exports facilities allowing you to safely obtain, use and
release Socket resources within a Pipes pipeline, by relying on
pipes-safe.
This module is meant to be used as a replacement of Pipes.Network.TCP,
and as such it overrides some functions from Network.Simple.TCP so that
they use MonadSafe instead of IO as their base monad. Additionally,
It also exports pipes that establish a TCP connection and interact with
it in a streaming fashion at once.
If you just want to use Socket obtained outside the Pipes pipeline,
then you can just ignore this module and use the simpler module
Pipes.Network.TCP instead.
- connect :: MonadSafe m => HostName -> ServiceName -> ((Socket, SockAddr) -> m r) -> m r
- serve :: MonadSafe m => HostPreference -> ServiceName -> ((Socket, SockAddr) -> IO ()) -> m r
- listen :: MonadSafe m => HostPreference -> ServiceName -> ((Socket, SockAddr) -> m r) -> m r
- accept :: MonadSafe m => Socket -> ((Socket, SockAddr) -> m r) -> m r
- fromConnect :: MonadSafe m => Int -> HostName -> ServiceName -> Producer' ByteString m ()
- toConnect :: MonadSafe m => HostName -> ServiceName -> Consumer' ByteString m r
- toConnectLazy :: MonadSafe m => HostName -> ServiceName -> Consumer' ByteString m r
- toConnectMany :: MonadSafe m => HostName -> ServiceName -> Consumer' [ByteString] m r
- fromServe :: MonadSafe m => Int -> HostPreference -> ServiceName -> Producer' ByteString m ()
- toServe :: MonadSafe m => HostPreference -> ServiceName -> Consumer' ByteString m r
- toServeLazy :: MonadSafe m => HostPreference -> ServiceName -> Consumer' ByteString m r
- toServeMany :: MonadSafe m => HostPreference -> ServiceName -> Consumer' [ByteString] m r
- module Pipes.Network.TCP
- module Network.Simple.TCP
- module Pipes.Safe
MonadSafe-compatible upgrades
The following functions are analogous versions of those exported by
Network.Simple.TCP, but compatible with MonadSafe.
connect :: MonadSafe m => HostName -> ServiceName -> ((Socket, SockAddr) -> m r) -> m r #
Like connect from Network.Simple.TCP, but compatible
with MonadSafe.
serve :: MonadSafe m => HostPreference -> ServiceName -> ((Socket, SockAddr) -> IO ()) -> m r #
Like serve from Network.Simple.TCP, but compatible
with MonadSafe.
listen :: MonadSafe m => HostPreference -> ServiceName -> ((Socket, SockAddr) -> m r) -> m r #
Like listen from Network.Simple.TCP, but compatible
with MonadSafe.
accept :: MonadSafe m => Socket -> ((Socket, SockAddr) -> m r) -> m r #
Like accept from Network.Simple.TCP, but compatible
with MonadSafe.
Streaming
Client side
The following pipes allow you to easily connect to a TCP server and immediately interact with it in a streaming fashion, all at once, instead of having to perform the individual steps separately. However, keep in mind that you'll be able to interact with the remote end in only one direction, that is, you'll either send or receive data, but not both.
Arguments
| :: MonadSafe m | |
| => Int | Maximum number of bytes to receive and send
dowstream at once. Any positive value is fine, the
optimal value depends on how you deal with the
received data. Try using |
| -> HostName | Server host name. |
| -> ServiceName | Server service port. |
| -> Producer' ByteString m () |
Connect to a TCP server and send downstream the bytes received from the remote end.
The connection socket is closed when done or in case of exceptions.
Using this Producer' you can write straightforward code like the following,
which prints whatever is received from a single TCP connection to a given
server listening locally on port 9000, in chunks of up to 4096 bytes:
>>>runSafeT . runEffect $ fromConnect 4096 "127.0.0.1" "9000" >-> P.print
Arguments
| :: MonadSafe m | |
| => HostName | Server host name. |
| -> ServiceName | Server service port. |
| -> Consumer' ByteString m r |
Connects to a TCP server, sends to the remote end the bytes received from upstream.
The connection socket is closed in case of exceptions.
Using this Consumer' you can write straightforward code like the following,
which greets a TCP client listening locally at port 9000:
>>>:set -XOverloadedStrings>>>runSafeT . runEffect $ each ["He","llo\r\n"] >-> toConnect "127.0.0.1" "9000"
Arguments
| :: MonadSafe m | |
| => HostName | Server host name. |
| -> ServiceName | Server service port. |
| -> Consumer' ByteString m r |
Like toConnect, but works more efficiently on lazy ByteStrings
(compared to converting them to a strict ByteString and sending it)
Arguments
| :: MonadSafe m | |
| => HostName | Server host name. |
| -> ServiceName | Server service port. |
| -> Consumer' [ByteString] m r |
Like toConnect, but works more efficiently on [
(compared to converting them to a strict ByteString]ByteString and sending it)
Server side
The following pipes allow you to easily run a TCP server and immediately interact with incoming connections in a streaming fashion, all at once, instead of having to perform the individual steps separately. However, keep in mind that you'll be able to interact with the remote end in only one direction, that is, you'll either send or receive data, but not both.
Arguments
| :: MonadSafe m | |
| => Int | Maximum number of bytes to receive and send
dowstream at once. Any positive value is fine, the
optimal value depends on how you deal with the
received data. Try using |
| -> HostPreference | Preferred host to bind. |
| -> ServiceName | Service port to bind. |
| -> Producer' ByteString m () |
Binds a listening socket, accepts a single connection and sends downstream any bytes received from the remote end.
Less than the specified maximum number of bytes might be received at once.
This Producer' returns if the remote peer closes its side of the connection
or EOF is received.
Both the listening and connection sockets are closed when done or in case of exceptions.
Using this Producer' you can write straightforward code like the following,
which prints whatever is received from a single TCP connection to port 9000,
in chunks of up to 4096 bytes.
>>>:set -XOverloadedStrings>>>runSafeT . runEffect $ fromServe 4096 "127.0.0.1" "9000" >-> P.print
Arguments
| :: MonadSafe m | |
| => HostPreference | Preferred host to bind. |
| -> ServiceName | Service port to bind. |
| -> Consumer' ByteString m r |
Binds a listening socket, accepts a single connection, sends to the remote end the bytes received from upstream.
Both the listening and connection sockets are closed when done or in case of exceptions.
Using this Consumer' you can write straightforward code like the following,
which greets a TCP client connecting to port 9000:
>>>:set -XOverloadedStrings>>>runSafeT . runEffect $ each ["He","llo\r\n"] >-> toServe "127.0.0.1" "9000"
Arguments
| :: MonadSafe m | |
| => HostPreference | Preferred host to bind. |
| -> ServiceName | Service port to bind. |
| -> Consumer' ByteString m r |
Like toServe, but works more efficiently on lazy ByteStrings
(compared to converting them to a strict ByteString and sending it)
Arguments
| :: MonadSafe m | |
| => HostPreference | Preferred host to bind. |
| -> ServiceName | Service port to bind. |
| -> Consumer' [ByteString] m r |
Like toServe, but works more efficiently on [
(compared to converting them to a strict ByteString]ByteString and sending it)
Exports
- From Pipes.Network.TCP
fromSocket,fromSocketN,fromSocketTimeout,fromSocketTimeoutN,toSocket,toSocketLazy,toSocketMany,toSocketTimeout,toSocketTimeoutLazy,toSocketTimeoutMany.- From Network.Simple.TCP
acceptFork,bindSock,connectSock,closeSock,HostPreference(HostAny,HostIPv4,HostIPv6,Host),recv,send,sendLazy,sendMany.- From Network.Socket
HostName,ServiceName,SockAddr,Socket,withSocketsDo.- From Pipes.Safe
runSafeT.
module Pipes.Network.TCP
module Network.Simple.TCP
module Pipes.Safe