---

---

---

---

Misultin development has been discontinued.

There currently are three main webserver libraries which basically do similar things:

• Mochiweb
• Cowboy
• Misultin

Mochiweb has been around the block for a while and it's proven solid in production, I can only recommend it for all basic webserver needs you might have. Cowboy has a very interesting approach since it allows to use multiple TCP and UDP protocols on top of a common acceptor pool. It is a very modern approach, is very actively maintained and many projects are starting to be built around it.

Especially since the recent heavy development of Cowboy's HTTP server, I believe there is way too much duplication of efforts going on here. This is why Misultin's current 'state of the art' has been frozen in the latest tag, v0.9, to support all the companies currently using Misultin in their production environment. I'm here to provide help, if needed, in moving away from it. Thus, this server should be robust and stable enough to continue serving your needs for some time.

Instead of letting this library stand here without this notice, and getting developers still use this project, I have preferred to explicitly state to gradually move away from it, so that efforts can be concentrated around one server library only. It's hard enough to let one 'child' like this one go, but I believe it's best for the whole Erlang community.

Thank you to everyone that has been supporting Misultin in these years. Hopefully its code usability, which I still believe to be unmatched (well, I have developed it so how could I feel differently about this ^^_), will provide inspiration for some library interfaces.

Best to you all,

r.

---

---

---

---

MISULTIN

Misultin is an HTTP(S) library which can easily be embedded in your own application.

https://github.com/ostinelli/misultin

>-|-|-(°>

Features

• Very fast
• HTTP and HTTPS
• Supports multiple Websocket protocols (draft-hixie-68, draft-hixie-76, draft-hybi-10 and draft-hybi-17)
• Cookies
• Session Variables
• Allows for Chunked and Byte streaming responses
• Allows for streaming file upload (via Chunked Encoding)
• Can serves static files from a static directory (though in production you should consider a specific server such as nginx to do so)
• Has Many customization options (maximum allowed connections, maximum body size, ...)
• Has a callback function for your logging needs
• Supports Unicode
• Can start multiple servers on a single node
• Can be used with or without Parametrized Modules
• Can traps the client closing a browser in Comet applications
• It's very easy to use

Quick Start

The typical 'Hello World" example code is:

-module(misultin_hello_world).
-export([start/0, stop/0]).

% start misultin http server
start() ->
    misultin:start_link([{port, 8080}, {loop, fun(Req) -> handle_http(Req) end}]).

% stop misultin
stop() ->
    misultin:stop().

% callback on request received
handle_http(Req) ->
    Req:ok("Hello World.").

Issuing the start/0 command will start an HTTP server on port 8080, which will respond to every request with an "Hello World" text.

Examples

Misultin comes packed with examples.

Simple Examples

• Hello World
• Querystring Variables
• Querystring and POST Variables
• REST
• Set and Get Cookies
• Set and Get Session Variables
• Serve a Static file for download
• Serving files from a Static directory
• File Upload
• HTTPS example
• Performing a simple redirection
• Serving compressed content
• Logging Access

Websockets

• Simple Websocket
• Simple Websocket on SSL
• Websocket exposing the close event
• Websocket exposing the close event, example 2
• Access Session Variables from Websockets

Comets

• Long Polling
• iFrame Technique
• iFrame Technique using the close event

More Advanced

• Sending Chunked Content
• Sending Byte Streaming Content
• Receiving endless streaming Upload
• Unicode
• REST with UTF-8
• Starting a nameless server
• Starting multiple servers on a same node, with a custom name
• Using the HAProxy protocol

Module Exports

The complete list of module exports can be found here.

Parametrized modules

Some developers hate them, some love them. Misultin allows you to choose if you want to use them or not. The same Hello World example shown here above, but without parametrized modules, looks like this:

-module(misultin_hello_world).
-export([start/0, stop/0]).

% start misultin http server
start() ->
    misultin:start_link([{port, 8080}, {loop, fun(Req) -> handle_http(Req) end}]).

% stop misultin
stop() ->
    misultin:stop().

% callback on request received
handle_http(Req) ->
    misultin_req:ok("Hello World.", Req).

Dependencies

You will need:

• Erlang >= R14B01
• Rebar to compile

Under the hood

Misultin is built using the OTP principles. When you start it using the misultin:start_link/1 command, you are actually starting a supervisor which handles all of Misultin's servers and modules.

Therefore, in real life applications you should always embed it in your own application. An easy example on how this can be done can be found in the Application Example here.

SSL Notes

If you are running misultin behind an SSL terminator such as stunnel or stud, and are using websockets, to make the websocket handshakes work, set in the starting options:

{ws_force_ssl, true} 

If you are using stunnel to terminate, to make misultin expect a PROXY.. line as per the proxy protocol you can also set in the starting options:

{proxy_protocol, true}

Newer versions of stunnel support this with the "protocol = proxy" config option.