MochiWeb Overview

MochiWeb is a lightweight, high-performance web server framework written in Erlang.

It provides a set of modules and tools for building scalable and efficient web applications. MochiWeb is known for its simplicity, speed, and robustness, making it a popular choice among developers.

In this tutorial, we will explore the history, features, and examples of MochiWeb Erlang Framework. We will dive into its key components and demonstrate how to use them effectively.

History of MochiWeb

MochiWeb was originally developed by Bob Ippolito in 2007 as part of the MochiMedia project. It was designed to handle high levels of concurrent connections and to provide a solid foundation for building web applications in Erlang. Over the years, MochiWeb has gained popularity and has been widely adopted by the Erlang community.

Features of MochiWeb

Lightweight and Fast

MochiWeb is designed to be lightweight and efficient, making it ideal for building high-performance web applications. It is built on top of the Erlang OTP (Open Telecom Platform), which provides a highly concurrent and fault-tolerant runtime environment.

Web Server

MochiWeb includes a powerful and flexible web server module that allows you to handle HTTP requests and responses. It supports both HTTP/1.0 and HTTP/1.1 protocols and provides a straightforward interface for handling requests and generating responses.

Here's an example of a simple MochiWeb web server:

-module(my_web_server).
-export([start/0, handle_request/1]).

start() ->
    {ok, _} = mochiweb_http:start([{port, 8080}], fun() -> handle_request/1 end).

handle_request(Req) ->
    Req:respond({200, [], "Hello, World!"}).

In this example, we define a module my_web_server with two exported functions start/0 and handle_request/1. The start/0 function starts the MochiWeb HTTP server on port 8080 and specifies the callback function handle_request/1 to handle incoming requests. The handle_request/1 function simply responds with a "Hello, World!" message.

WebSocket Support

MochiWeb also provides built-in support for WebSocket, a protocol that enables real-time bidirectional communication between the client and server. It allows you to build interactive web applications that can push data to clients in real-time.

Here's an example of a MochiWeb WebSocket server:

-module(my_websocket_server).
-export([start/0, handle_websocket/1]).

start() ->
    {ok, _} = mochiweb_http:start([{port, 8080}], fun() -> handle_websocket/1 end).

handle_websocket(Req) ->
    {ok, Conn} = mochiweb_http:upgrade_to_websocket(Req),
    loop(Conn).

loop(Conn) ->
    receive
        {websocket, Conn, {text, Msg}} ->
            Conn:send({text, "Received: " ++ Msg}),
            loop(Conn);
        {websocket, Conn, close} ->
            Conn:send({close, 1000, <<"Closing connection">>})
    end.

In this example, we define a module my_websocket_server with two exported functions start/0 and handle_websocket/1. The start/0 function starts the MochiWeb WebSocket server on port 8080 and specifies the callback function handle_websocket/1 to handle WebSocket connections. The handle_websocket/1 function receives text messages from the client, sends a response, and continues to listen for further messages. If a close message is received, it sends a closing message back to the client.

RESTful Routing

MochiWeb supports RESTful routing, allowing you to define routes and handle different HTTP methods (GET, POST, PUT, DELETE, etc.) for different URLs. This makes it easy to build clean and structured APIs.

Here's an example of a MochiWeb RESTful server using the mochiweb_router module:

-module(my_restful_server).
-export([start/0]).
-include_lib("mochiweb/include/mochiweb.hrl").

start() ->
    {ok, _} = mochiweb_http:start([{port, 8080}], fun() -> handle_request/1 end).

handle_request(Req) ->
    mochiweb_router:route(Req, [
        {'GET', ["users"], fun handle_get_users/1},
        {'POST', ["users"], fun handle_post_users/1}
    ]).

handle_get_users(Req) ->
    Users = get_users(),
    Req:respond({200, [], mochijson2:encode({users, Users})}).

handle_post_users(Req) ->
    Data = Req:parse_qs(),
    User = proplists:get_value("user", Data),
    save_user(User),
    Req:respond({201, [], "User created"}).

In this example, we define a module my_restful_server with a start/0 function and a handle_request/1 function. The start/0 function starts the MochiWeb HTTP server on port 8080, and the handle_request/1 function routes incoming requests based on the HTTP method and URL pattern. We define two routes: one for handling GET requests to the "/users" URL and one for handling POST requests to the "/users" URL. The handle_get_users/1 function retrieves a list of users and responds with a JSON-encoded payload, while the handle_post_users/1 function saves the user data and responds with a "User created" message.

Conclusion

MochiWeb is a powerful and efficient web server framework for building scalable and high-performance web applications in Erlang. Its lightweight nature, support for WebSocket, RESTful routing, and other features make it a popular choice among developers. With the examples provided in this tutorial, you should have a good starting point for exploring MochiWeb and building your own web applications.

For more information and detailed documentation, you can visit the official MochiWeb website.