Ocsigen

Eliom

Home

Doc

Blog

Eliom

Js_of_ocaml

Server

Lwt

Tyxml

Start

Module Eliom.Common

Low level functions for Eliom, exceptions and types.

module Ocsipersist : module type of Ocsipersist

Persistent key-value store interface for OCaml. This is a virtual library defining a unified frontend for a number of key-value storage implementations. Implementations of the following backends currently exist: SQLite, DBM, PostgreSQL. You can choose the backend you prefer by installing packages ocsipersist-sqlite, ocsipersist-dbm or ocsipersist-pgsql.

type scope_hierarchy = Common_base.scope_hierarchy

Scopes

type user_scope = [
  1. | `Session_group of scope_hierarchy
  2. | cookie_scope
]
type scope = [
  1. | `Site
  2. | user_scope
]
type all_scope = [
  1. | scope
  2. | `Global
  3. | `Request
]
type user_level = [
  1. | `Session_group
  2. | cookie_level
]
val level_of_user_scope : [< user_scope ] -> [> user_level ]
val scope_hierarchy_of_user_scope : [< user_scope ] -> scope_hierarchy

Eliom is using regular (browser) cookies but can also use its own browser tab cookies (only if you are using a client side Eliom application).

It is possible to define Eliom references or services for one (browser) session, for one tab, or for one group of sessions.

Using `Global scope means you want the data or service to be available to any client. `Site is limited to current sub-site (if you have several sites on the same server).

If you want to restrict the visibility of an Eliom reference or a service: * to a browser session, use ~scope:Common.default_session_scope, * to a group of sessions, use ~scope:Common.default_group_scope, * to a client process, use ~scope:Common.default_process_scope. If you have a client side Eliom program running, and you want to restrict the visibility of the service to this instance of the program, use ~scope:Common.default_process_scope.

You can create new scope hierarchies with Common.create_scope_hierarchy. Thus it is possible to have for example several sessions that can be opened or closed independently. They use different cookies.

Secure scopes are associated to secure cookies (that is, cookies sent by browsers only if the protocol is https).

type global_scope = [
  1. | `Global
]
type site_scope = [
  1. | `Site
]
type session_group_scope = [
  1. | `Session_group of scope_hierarchy
]
type session_scope = [
  1. | `Session of scope_hierarchy
]
type client_process_scope = [
  1. | `Client_process of scope_hierarchy
]
type request_scope = [
  1. | `Request
]
val global_scope : [> global_scope ]
val site_scope : [> site_scope ]
val default_group_scope : [> session_group_scope ]
val default_session_scope : [> session_scope ]
val default_process_scope : [> client_process_scope ]
val comet_client_process_scope : [> client_process_scope ]
val request_scope : [> request_scope ]
val create_scope_hierarchy : string -> scope_hierarchy
val list_scope_hierarchies : unit -> scope_hierarchy list

Exception and error handling

exception Eliom_404

Page not found

exception Eliom_Wrong_parameter

Service called with wrong parameter names

exception Eliom_Session_expired
exception Eliom_Typing_Error of (string * exn) list

The service (GET or POST) parameters do not match expected type

exception Site_information_not_available of string

That function cannot be used when the site information is not available, that is, outside a request or the initialisation phase of your Eliom module (while reading the configuration file).

In particular, you cannot use the function before the configuration file is read for example when you are using static linking. In that case you must delay the function call using Service.register_eliom_module.

exception Eliom_site_information_not_available of string

Backwards-compatible alias for Site_information_not_available. The Eliom_ prefix is redundant under the Eliom.Common namespace; new code should use Site_information_not_available directly.

exception Request_information_not_available of string

That function needs the current request, and cannot be used outside a request, for instance during the initialisation phase of your Eliom module. The argument tells where the request was needed.

This is the case of the functions that act on the session of the current user, such as registering a service with a session, session group or client process scope.

exception Cannot_call_this_function_before_app_is_linked_to_a_site

Statically linked app: You cannot call this function before App.run.

type full_state_name = {
  1. user_scope : user_scope;
  2. secure : bool;
  3. site_dir_str : string;
}
val full_state_name_of_json : Deriving_Json_lexer.lexbuf -> full_state_name
val full_state_name_to_json : Buffer.t -> full_state_name -> unit
val full_state_name_json : full_state_name Deriving_Json.t
type state_cookies = {
  1. service_cookies : string Full_state_name_table.t;
  2. data_cookies : string Full_state_name_table.t;
  3. persistent_cookies : string Full_state_name_table.t;
}

The state cookies sent by a request, for each kind of state. The keys of the tables are the full state names.

If present and true in request data, it means that the previous coservice does not exist any more

val eliom_service_session_expired : (full_state_name list * full_state_name list) Polytables.key

If present in request data, means that the service session cookies does not exist any more. The string lists are the list of names of expired sessions