NAME

       Eliom_comet.Channel - Basic primitives needed for server push.

Module

       Module   Eliom_comet.Channel

Documentation

       Module Channel
        : sig end

       Basic primitives needed for server push.

       type 'a t

       v t is the type of server-to-client communication channels transporting data of type v

       type comet_scope = [ `Client_process of Eliom_common.scope_hierarchy | `Site ]

       val create : ?scope:[< comet_scope ] -> ?name:string -> ?size:int -> 'a Lwt_stream.t -> 'a t

       create s returns a channel sending values from s .

       There   are   two   kind   of   channels   created   depending   on   the   given   scope   (defaults  to
       Eliom_common.comet_client_process ).

       With scope Eliom_common.site all users knowing the name of the channel can access it.  Only  one  message
       queue is created: it is what we call a stateless channel in the sense that the memory used by the channel
       does  not  depend  on  the number of users.  The channel can be reclaimed by the GC when there is no more
       reference to it.  The buffer channel has a limited buffer of size size (default:  1000).  If  the  client
       requests too old messages, exception Eliom_coment.Channel_full will be raised (on client side).

       With  a scope of level Eliom_common.client_process_scope the channel can only be accessed by the user who
       created it. It can only be created when client process data is available (that  is:  during  a  request).
       The  eliom  service  created  to communicate with the client is only available in the scope of the client
       process. To avoid memory leak when the client do not read sent data, the channel has  a  limited  size  .
       When a channel is full, no data can be read from it anymore.

       A  channel  can  be  used only once on client side. To be able to receive the same data multiple times on
       client side, use create (Lwt_stream.clone s) every time.

       To enforce the limit on the buffer size, the data is read into stream as soon as possible: If you want  a
       channel that reads data on the stream only when the client requests it, use create_unlimited instead, but
       be careful of memory leaks.

       val  create_unlimited : ?scope:Eliom_common.client_process_scope -> ?name:string -> 'a Lwt_stream.t -> 'a
       t

       create_unlimited s creates a channel which does not read immediately on the stream. It is read only  when
       the  client requests it: use it if the data you send depends on the time of the request (for instance the
       number of unread mails). Be careful, the size of this stream is not limited: if the size  of  the  stream
       increases and your clients don't read it, you may have memory leaks.

       val create_newest : ?name:string -> 'a Lwt_stream.t -> 'a t

       create_newest  s is similar to create ~scope:Eliom_common.site s but only the last message is returned to
       the client.

       val external_channel : ?history:int -> ?newest:bool -> prefix:string -> name:string -> unit -> 'a t

       external_channel ~prefix ~name () declares an external channel. The channel was created by an instance of
       Eliom serving the prefix prefix (the prefix configured in the <site> tag of the configuration file).  The
       channel was named by name . Both servers must run the exact same version of Eliom.

       The optional newest parameters tells whether the channel is a new one. If the channel is not new, history
       is the maximum number of messages retrieved at the first request. The default is 1 .

       val wait_timeout : ?scope:Eliom_common.client_process_scope -> float -> unit Lwt.t

       wait_timeout  ~scope time waits for a period of inactivity of length time in the scope . Only activity on
       stateful channels is taken into accounts.

       The default scope is Eliom_common.comet_client_process .

OCamldoc                                           2014-02-04                            Eliom_comet.Channel(3o)