How do you build your own Tarantool application without overcomplicating things unnecessarily? This second tutorial in the three-part Tarantool series will cover networking as well as installing and using third-party Tarantool packages.

Interaction with external services

As an example, let’s take a look at how OAuth2 authorization via Facebook is implemented in the tarantool-authman application. With OAuth2 authorization, a user clicks a link that takes them to the Facebook login page. After the user enters their authorization credentials and grants necessary permissions, the social network redirects them back to the site with an authorization code embedded into the redirection URI as a GET parameter. The server then exchanges this code for a token (or a pair of tokens — access and refresh): it allows obtaining information about this user directly from Facebook. To learn more about how OAuth2 authorization works, check this article.

The Tarantool application handles the code-for-token exchange and uses the token to get information about the user from the social network; in our case, the user’s email and first and last name. To exchange an authorization code for a token, it’s necessary to send Facebook an HTTP request containing the code itself, alongside the application’s Facebook parameters, client_id and client_secret.

Tarantool 1.7.4–151 has a built-in http.client package that is based on libcurl. This package allows receiving and sending HTTP requests, so let’s use it to implement OAuth2 authorization. We’ll begin by creating a helper function for sending HTTP requests in the authman/utils/http.lua package:

In-app OAuth2 authorization

Let’s create a social model and implement a get_token(provider, code) method for obtaining a token by an authorization code, and a get_profile_info(provider, token, user_tuple) method for getting and updating information about a given user. Below is the corresponding code:

Now, let’s design an API method for creating a new user or for logging in via Facebook with an existing one. This method should return a user and session data. To learn more about how sessions are created and validated, look at the source code here.

-- Getting information about a user social_id = social.get_profile_info(provider, token, user_tuple) if not validator.not_empty_string(social_id) then return response.error(error.SOCIAL_AUTH_ERROR) end

Facebook will then ask you to confirm you’re granting it the listed permissions and, following your confirmation, redirect you with an authorization code embedded into the redirection URL as a GET parameter. This is the very same authorization code that is passed to the api.social_auth() method. Before we check if our code works as expected, let’s create authman/config/config.lua, a configuration file holding the application’s Facebook parameters.

Installing additional packages

It’s always nice to have readily available solutions when dealing with various problems. For example, in Tarantool versions older than 1.7.4–151, it was impossible to send an HTTP request out of the box — you needed a tarantool-curl package for it. But it is deprecated now and therefore not recommended for use. There are many other useful packages out there, though, and one of them is tarantool-queue that implements a FIFO queue.

There exist several ways to install this package, but the simplest one has appeared only recently, in Tarantool 1.7.4–294:

$ tarantoolctl rocks install queue

Other Tarantool packages can also be installed via a package manager. The complete list of Tarantool packages is available on the Rocks page.

Another way of installing tarantool-queue is via a package manager that comes with your OS. You need to add the Tarantool repository to the list of available repositories, if you haven’t done so already during the installation, and make sure that the package you need is indeed in the repository. For example, if you’re on Ubuntu, say this:

$ sudo apt-get install tarantool-queue

A third installation method is somewhat more complicated, but it allows using not only Tarantool applications, but also Lua packages, both of which are easy to install with a LuaRocks package manager. You can refer to the documentation to learn more about LuaRocks and available packages. Let’s install LuaRocks and configure it to work with the Tarantool repository:

$ sudo apt-get install luarocks

Now, we need to configure LuaRocks so that we can install not only Lua packages, but Tarantool packages as well. To do that, we create a ~/.luarocks/config.lua file with the following settings:

So, now we’re able to create complex applications that interact with external services. In the next tutorial, we’ll talk about testing your applications, properly configuring them and deploying them to production. Thanks for reading and stay tuned!