gi-gio-2.0.18: Gio bindings

CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria (garetxe@gmail.com)
Safe HaskellNone
LanguageHaskell2010

GI.Gio.Objects.ThreadedSocketService

Contents

Description

A ThreadedSocketService is a simple subclass of SocketService that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting the ThreadedSocketService::run signal in the new thread.

The signal handler may perform blocking IO and need not return until the connection is closed.

The service is implemented using a thread pool, so there is a limited amount of threads available to serve incoming requests. The service automatically stops the SocketService from accepting new connections when all threads are busy.

As with SocketService, you may connect to ThreadedSocketService::run, or subclass and override the default handler.

Since: 2.22

Synopsis

Exported types

toThreadedSocketService :: (MonadIO m, IsThreadedSocketService o) => o -> m ThreadedSocketService Source #

Cast to ThreadedSocketService, for types for which this is known to be safe. For general casts, use castTo.

Methods

new

threadedSocketServiceNew Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Int32

maxThreads: the maximal number of threads to execute concurrently handling incoming clients, -1 means no limit

-> m ThreadedSocketService

Returns: a new SocketService.

Creates a new ThreadedSocketService with no listeners. Listeners must be added with one of the SocketListener "add" methods.

Since: 2.22

Properties

maxThreads

No description available in the introspection data.

constructThreadedSocketServiceMaxThreads :: IsThreadedSocketService o => Int32 -> IO (GValueConstruct o) Source #

Construct a GValueConstruct with valid value for the “max-threads” property. This is rarely needed directly, but it is used by new.

getThreadedSocketServiceMaxThreads :: (MonadIO m, IsThreadedSocketService o) => o -> m Int32 Source #

Get the value of the “max-threads” property. When overloading is enabled, this is equivalent to

get threadedSocketService #maxThreads

Signals

run

type C_ThreadedSocketServiceRunCallback = Ptr () -> Ptr SocketConnection -> Ptr Object -> Ptr () -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

type ThreadedSocketServiceRunCallback Source #

Arguments

 = SocketConnection

connection: a new SocketConnection object.

-> Object

sourceObject: the source_object passed to socketListenerAddAddress.

-> IO Bool

Returns: True to stop further signal handlers from being called

The ::run signal is emitted in a worker thread in response to an incoming connection. This thread is dedicated to handling connection and may perform blocking IO. The signal handler need not return until the connection is closed.

afterThreadedSocketServiceRun :: (IsThreadedSocketService a, MonadIO m) => a -> ThreadedSocketServiceRunCallback -> m SignalHandlerId Source #

Connect a signal handler for the “run” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after threadedSocketService #run callback

onThreadedSocketServiceRun :: (IsThreadedSocketService a, MonadIO m) => a -> ThreadedSocketServiceRunCallback -> m SignalHandlerId Source #

Connect a signal handler for the “run” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on threadedSocketService #run callback