Lua in RPM

A fairly unknown feature of RPM is that it comes with an embedded Lua interpreter. This page attempts to document the possibilities of the embedded Lua. Note that Lua-support is a compile-time option, the following assumes that your RPM is was built using --with-lua option.

  1. Lua scriptlets
  2. Including scripts
  3. Lua macros
  4. Available Lua extensions in RPM
    1. rpm extension
    2. posix extension
    3. rex extension
  5. Extending and customizing

Lua scriptlets

The internal Lua can be used as the interpreter of rpm any scriptlets (%pre, %post etc):

%pre -p <lua>
print("Hello from Lua")

The point? Remember, Lua is embedded in rpm. This means the Lua scriptlets run in the rpm process context, instead of forking a new process to execute something. This has a number of advantages over, say, using /bin/sh as scriptlet interpreter:

  • No forking involved means it runs faster. Lua itself is fairly fast as an interpreter too.
  • No external dependencies introduced to packages.
  • The internal interpreter can run when there's nothing at all installed yet, because it doesn't need to be forked. Consider the initial install phase: before even /bin/sh is available to execute the simplest shell built-in commands, the shell's dependencies will have to be installed. What if some of those need scriptlets?
  • Internal Lua is the only thing that can reliably run in %pretrans. On initial system installation, there's absolutely nothing in the environment where %pretrans scriptlets execute. This is a condition you cannot even detect with any other means: testing for existence of a file or directory would otherwise require a shell, which is not there.
  • Syntax errors in <lua> scripts are detected at package build time.
  • As it runs in within the rpm process context, it can do things that external process cannot do, such as define new macros.

Scriptlet arguments are accessible from a global 'arg' table. Note: due to an error in the original implementation, the arg indexes are off by one from general expectation and this cannot be easily fixed due to backwards compatibility requirements. The argument containing number of installed package instances is arg[2] and the similar argument for trigger targets is arg[3], whereas traditionally they are 1 and 2 (eg $1 and $2 in shell scripts).

While scriptlets shouldn't be allowed to fail normally, you can signal scriptlet failure status by using Lua's error(msg, [level]) function if you need to. As <lua> scriptlets run within the rpm process itself, care needs to be taken within the scripts - eg os.exit() must not be called (see ticket #167). In newer rpm versions (>= 4.9.0) this is not an issue as rpm protects itself by returning errors on unsafe os.exit() and posix.exec().

Including scripts

Parts of the lua scripts can be included from files. E.g.

%post -p <lua>
%include %{_sourcedir}/myfunctions.lua


Lua macros

The internal Lua interpreter can be used for dynamic macro content creation:

%{lua: print("Requires: foo >= 1.2")}

The above is a silly example and doesn't even begin to show how powerful a feature this is. For a slightly more complex example, RPM itself uses this to implement %patches and %sources macros (new in RPM 4.6.0):

%patches %{lua: for i, p in ipairs(patches) do print(p.." ") end}
%sources %{lua: for i, s in ipairs(sources) do print(s.." ") end}

Available Lua extensions in RPM

In addition to all Lua standard libraries (subject to the Lua version rpm is linked to), a few custom extensions are available in the RPM internal Lua interpreter. These can be used in all contexts where the internal Lua can be used.

rpm extension

The following RPM specific functions are available:

Function Explanation Example
define(arg) Define a global macro. rpm.define("foo 1")
expand(arg) Perform macro expansion. rpm.expand("%{_libdir}")
register() Register an RPM hook
unregister() Unregister an RPM hook
call() Call an RPM hook
interactive() Launch interactive session (only for testing + debugging) rpm --eval "%{lua: rpm.interactive()}"
vercmp() Perform RPM version comparison (rpm >= 4.7.0) rpm.vercmp("1.2-1", "2.0-1")
b64encode() Perform base64 encoding (rpm >= 4.8.0)
b64decode() Perform base64 decoding (rpm >= 4.8.0)  

posix extension

Lua standard library offers fairly limited set of io operations. The posix extension greatly enhances what can be done from Lua. The following functions are available in "posix" namespace, ie to call them use posix.function().

Function Explanation Example
access(path, [mode]) Test file/directory accessibility if posix.access("/bin/rpm", "x") then ... end
chdir(path) Change directory posix.chdir("/tmp")
chmod(path, modestring) Change file/directory mode  
chown(path, uid, gid) Change file/directory owner/group  
dir([path]) Get directory contents - like readdir() for i,p in pairs(posix.dir("/tmp")) do print(p.."\n") end
errno() Get errno value and message print(posix.errno())
exec(path, [args...]) Exec a program
files([path]) Iterate over directory contents for f in posix.files("/tmp") do print(f..'\n') end
fork() Fork a new process
getcwd() Get current directory
getenv(name) Get environment variable
getgroup(gid) Get group members (gid is number or string)
getlogin() Get login name
getpasswd(uid, selector) Get passwd information (username, uid, gid, shell, gecos...) posix.getpasswd(posix.getlogin(), "shell")
getprocessid(selector) Get process ID information (gid, uid, pid, ppid...) posix.getprocessid("pid")
kill(pid, signal) Send a signal to a process
link(oldpath, newpath) Create a hard link
mkdir(path) Create a new directory
mkfifo(path) Create a FIFO
pathconf() Get pathconf values
putenv() Change or add an environment variable
readlink(path) Read symlink value
rmdir(path) Remove a directory posix.rmdir("/tmp")
redirect2null(fd) change a file descriptor to point to /dev/null (only after fork(), since version 4.14) posix.redirect2null(1)
setgid(gid) Set group identity
setuid(uid) Set user identity
sleep(seconds) Sleep for specified number of seconds posix.sleep(5)
stat(path, selector) Perform stat() on a file/directory (mode, ino, dev, nlink, uid, gid...) posix.stat("/tmp", "mode")
symlink(oldpath, newpath) Create a symlink
sysconf(name) Access sysconf values posix.sysconf("open_max")
times() Get process times
ttyname() Get current tty name
umask() Get current umask
uname([format]) Get information about current kernel posix.uname("%r")
utime() Change access/modification time of an inode
wait() Wait for a child process
setenv() Change or add an environment variable
unsetenv() Remove a variable from environment

rex extension

This extension adds regular expression matching to Lua.

A simple example:

expr =<regex>)
if expr:match(<arg>) then
    ... do stuff ...

TODO: fully document

Extending and customizing

On initialization, RPM executes a global init.lua Lua initialization script, typically located in /usr/lib/rpm/init.lua. This can be used for performing custom runtime configuration of RPM and adding global functions and variables to the RPM Lua environment without recompiling rpm.