I recently wanted to run duplicity (a wonderful tool which allows rsync-style backups to a remote location with gpg encryption) on my oWRT router. Unfortunately, the tool was not included in the default oWRT packages. The only thing I could find was a 5-year-old feature request which was rejected as “Won’t fix”. So I gave it a shot and tried to cross-compile it by myself. This post will first show the general procedure how to cross-compile packages and will then deal with cross-compiling duplicity.
Deprecation notice
This article contains outdated information:
- refers to oWRT Barrierer Breaker and not to Chaos Calmer release
- davfs2 instructions are deprecated, see new article for updated procedure
General procedure for cross-compiling
To be sincere, I have had no clue how cross-compiling worked – and my first attempts just confirmed what was evident from so many postings on the web: cross-compiling software for embedded devices is a nightmare. But once you did it, it’s not that difficult.
Step 1: Get a build environment
If you don’t have a build environment create a directory under your home directory and download the openwrt sources into that directory. I am going to call mine ~/myowrt. We are going to work with the Barrier Breaker release.
|
1 2 3 |
mkdir ~/myowrt cd ~/myowrt git clone git://git.openwrt.org/14.07/openwrt.git |
git will now shuffle a dozen of mega bytes into your build directory. On top of that, you will need the packages which are already officially endorsed by the oWRT community:
|
1 2 |
cd openwrt/ ./scripts/feeds update -a |
This step will download another dozen of mega bytes into your feeds subdirectory. After this operation, your download directory should look like this:
|
1 2 3 4 5 6 |
ilek@i7:~/myowrt/openwrt$ cd feeds/ ilek@i7:~/myowrt/openwrt/feeds$ ls luci management.index oldpackages.tmp routing telephony.index luci.index management.tmp packages routing.index telephony.tmp luci.tmp oldpackages packages.index routing.tmp management oldpackages.index packages.tmp telephony |
This step has just downloaded the sources from the package feeds defined in the openwrt/feeds.conf.default file. If you issue the make menuconfig command in the openwrt root directory and navigate through the installation options, you will see, that the additional packages do not yet appear in menuconfig.
In order to make the packages available to menuconfig, we would have to issue the ./scripts/feeds/install -a commmand. But we will first add our own packages.
Step 2: Create a directory for your custom packages
Under your ~/myowrt working directory, create an additional directory for your custom packages:
|
1 |
mkdir ~/myowrt/custpacks |
In order to tell oWRT that this directory also contains packages, you have got to edit the feeds.conf.default file. Just uncomment and adapt the last line in that file as follows:
|
1 |
src-link custom /home/ilek/myowrt/custpacks |
For the sake of example, we would like to install the davfs2 package. It comes in handily that there is already a package under development on the oWRT github page. We can download the package folder with the following command (strangely the most convenient way to download a specific folder from a git repo is to use svn):
|
1 2 |
cd ~/myowrt/custpacks svn checkout https://github.com/openwrt/packages/trunk/net/davfs2 |
Another example – also relating to the webdav file system – is cadaver which is a very useful command line webdav client. Although it is not included in the trunk, I have found an oWRT Makefile provided by a Russian developer / blogger at erinome.net. All you have to do is click on the Get full directory link which will give you a tar file that you can download to your n~/myoowrt/custpacks directory where you hold your own package sources.
Step 3: Prepare the build
We can now issue the ./scripts/feeds install -a command.
|
1 2 3 |
cd ~/myowrt/openwrt ./scripts/feeds update -a ./scripts/feeds install -a |
Now run make menuconfig from the build root directory, navigate to Network / Filesystem. Select the davfs2 package to be built as a module (M).
Step 4: Build and enjoy
If this is the first time, you start to build something from the system sources, it is advisable to start with running a full build of the image because this will ensure that all necessary components from the toolchain which does the cross-compiling are built.
|
1 2 |
cd ~/myowrt/openwrt make -j 5 |
We should cd to the build root and run the make command to compile the package.
|
1 2 |
cd ~/myowrt/openwrt make package/davfs2/compile |
If the compile fails, make will tell you to re-run the compile with the V=s option to check what is going on. In the case of davfs2, make produces a couple of error messages concerning autoreconf. As autoreconf (a tool which best guesses the configuration for compiling) is not even needed here, we just delete the following line from ~/myowrt/custpacks/davfs2/Makefile (should be line 18 in the file):
|
1 |
PKG_FIXUP:=gettext-version autoreconf |
We can then run the make package/davfs2/compile again. If the compile works fine, the binary can be found in ~/myowrt/openwrt/bin/<your_target_arch>/packages/custom. You can copy that file to any oWRT device which has the specified target architecture and install it by running opkg install davfs2_1.5.2-1_mpc85xx.ipk.
Cross-compiling duplicity
Compiling duplicity is a bit more complicated, because duplicity is written in Python. That means that we do not only have to run the compile but during the process, the compiler must then internally run the setup.py, produce the relevant duplicity files and finally repackage them into an ipk file for installation.
There is another complication: While in our davfs example, we were lucky enough to find already an oWRT package source with patches and an oWRT Makefile which (almost) ran out of the box, we have to produce these ourselves.
One handy alternative would be to install python-setuptools or python-pip, which are also available as oWRT sources from github and then just issue a command like pip install duplicity and let pip do the rest. Unfortunately, this never worked for me, so we have to go the hard way and build our duplicity package with our own Makefile and
Step 1: Inspect the package sources
Normally, it is not even necessary to have the package sources on your local compiling machine. Instead, the oWRT Makefile only contains information from where it should be downloaded. This can be seen from the first lines of the Makefile in the previous davfs2 example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# # Copyright (C) 2006-2015 OpenWrt.org # # This is free software, licensed under the GNU General Public License v2. # See /LICENSE for more information. # include $(TOPDIR)/rules.mk PKG_NAME:=davfs2 PKG_VERSION:=1.5.2 PKG_RELEASE:=1 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz PKG_SOURCE_URL:=http://download.savannah.gnu.org/releases/davfs2/ PKG_MD5SUM:=376bc9346454135cba78afacbcb23f86 |
If any kind of oWRT specific adaptions of the sources are needed, this is done by patchfiles which internally modify the downloaded sources before they are compiled.
If we have to set up a Makefile and maybe some patches ourselves, the first thing we should look at are the package sources. So we just download and untar them in a temp directory to see what they include.
Step 2: Patch the setup.py file
The setup.py file is the probably most interesting one among the sources, as it would normally constitute the point of entry in a regular installation on a fully loaded Debian machine. We will create a copy of that file as setup.new and see what we can adapt.
Replace setuptools
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
#!/usr/bin/env python2 # -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*- # # Copyright 2002 Ben Escoto <ben@emerose.org> # Copyright 2007 Kenneth Loafman <kenneth@loafman.com> # # This file is part of duplicity. # # Duplicity is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by the # Free Software Foundation; either version 2 of the License, or (at your # option) any later version. # # Duplicity is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with duplicity; if not, write to the Free Software Foundation, # Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import sys import os from setuptools import setup, Extension from setuptools.command.test import test from setuptools.command.install import install from setuptools.command.sdist import sdist version_string = "0.7.02" if sys.version_info[:2] < (2, 6): print("Sorry, duplicity requires version 2.6 or later of python") sys.exit(1) incdir_list = libdir_list = None if os.name == 'posix': LIBRSYNC_DIR = os.environ.get('LIBRSYNC_DIR', '') args = sys.argv[:] for arg in args: if arg.startswith('--librsync-dir='): LIBRSYNC_DIR = arg.split('=')[1] sys.argv.remove(arg) if LIBRSYNC_DIR: incdir_list = [os.path.join(LIBRSYNC_DIR, 'include')] libdir_list = [os.path.join(LIBRSYNC_DIR, 'lib')] data_files = [('share/man/man1', ['bin/duplicity.1', 'bin/rdiffdir.1']), ('share/doc/duplicity-%s' % version_string, ['COPYING', 'README', 'README-REPO', 'README-LOG', 'CHANGELOG']), ] top_dir = os.path.dirname(os.path.abspath(__file__)) assert os.path.exists(os.path.join(top_dir, "po")), "Missing 'po' directory." for root, dirs, files in os.walk(os.path.join(top_dir, "po")): for file in files: path = os.path.join(root, file) if path.endswith("duplicity.mo"): lang = os.path.split(root)[-1] data_files.append( ('share/locale/%s/LC_MESSAGES' % lang, ["po/%s/duplicity.mo" % lang])) class TestCommand(test): def run(self): # Make sure all modules are ready build_cmd = self.get_finalized_command("build_py") build_cmd.run() # And make sure our scripts are ready build_scripts_cmd = self.get_finalized_command("build_scripts") build_scripts_cmd.run() # make symlinks for test data if build_cmd.build_lib != top_dir: for path in ['testfiles.tar.gz', 'gnupg']: src = os.path.join(top_dir, 'testing', path) target = os.path.join(build_cmd.build_lib, 'testing', path) try: os.symlink(src, target) except Exception: pass os.environ['PATH'] = "%s:%s" % ( os.path.abspath(build_scripts_cmd.build_dir), os.environ.get('PATH')) test.run(self) class InstallCommand(install): def run(self): # Normally, install will call build(). But we want to delete the # testing dir between building and installing. So we manually build # and mark ourselves to skip building when we run() for real. self.run_command('build') self.skip_build = True # This should always be true, but just to make sure! if self.build_lib != top_dir: testing_dir = os.path.join(self.build_lib, 'testing') os.system("rm -rf %s" % testing_dir) install.run(self) # TODO: move logic from dist/makedist inline class SDistCommand(sdist): def run(self): version = version_string if version[0] == '$': version = "0" os.system(os.path.join(top_dir, "dist", "makedist") + " " + version) os.system("rm -f duplicity.spec") os.system("mkdir -p " + self.dist_dir) os.system("mv duplicity-" + version + ".tar.gz " + self.dist_dir) setup(name="duplicity", version=version_string, description="Encrypted backup using rsync algorithm", author="Ben Escoto <ben@emerose.org>", author_email="bescoto@stanford.edu", maintainer="Kenneth Loafman <kenneth@loafman.com>", maintainer_email="kenneth@loafman.com", url="http://duplicity.nongnu.org/index.html", packages=['duplicity', 'duplicity.backends', 'duplicity.backends.pyrax_identity', 'testing', 'testing.functional', 'testing.overrides', 'testing.unit'], package_dir={"duplicity": "duplicity", "duplicity.backends": "duplicity/backends", }, ext_modules=[Extension("duplicity._librsync", ["duplicity/_librsyncmodule.c"], include_dirs=incdir_list, library_dirs=libdir_list, libraries=["rsync"])], scripts=['bin/rdiffdir', 'bin/duplicity'], data_files=data_files, tests_require=['lockfile', 'mock', 'pexpect'], test_suite='testing', cmdclass={'test': TestCommand, 'install': InstallCommand, 'sdist': SDistCommand}, ) |
The first thing which is going to cause trouble when cross-compiling is the import of the setuptools module in lines 25-28. The python environment which the cross-compiler offers only has the setuptools predecessor which is called distutils. Fortunately both modules have identical APIs so that we can simply replace all occurences of setuptools against distutils in these lines.
The only line in which this is not going to work is line 26, because distutils did not have any test submodule. We will therefore delete line 26 completely from the original file. After we are done with that section, it should look as follows:
|
1 2 3 4 5 6 7 8 9 10 11 |
# You should have received a copy of the GNU General Public License # along with duplicity; if not, write to the Free Software Foundation, # Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import sys import os from distutils import setup, Extension from distutils.command.install import install from distutils.command.sdist import sdist version_string = "0.7.02" |
Remove any references to setuptools.command.test
Given that we have completely removed the line which imported setuptools.command.test, we also have to remove any code which relies on that import. We therefore delete the whole TestCommand class in lines 72-97 (line numbers in the original file).
Additionally the packages list in lines 137-140 (line numbers in original file) contains some references to the testing class which we also delete. We will also delete any reference to the test module in lines 150-152 (line numbers in original file). After the cleanup, the final part of the setup.new file should look like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
setup(name="duplicity", version=version_string, description="Encrypted backup using rsync algorithm", author="Ben Escoto <ben@emerose.org>", author_email="bescoto@stanford.edu", maintainer="Kenneth Loafman <kenneth@loafman.com>", maintainer_email="kenneth@loafman.com", url="http://duplicity.nongnu.org/index.html", packages=['duplicity', 'duplicity.backends', 'duplicity.backends.pyrax_identity'], package_dir={"duplicity": "duplicity", "duplicity.backends": "duplicity/backends", }, ext_modules=[Extension("duplicity._librsync", ["duplicity/_librsyncmodule.c"], include_dirs=incdir_list, library_dirs=libdir_list, libraries=["rsync"])], scripts=['bin/rdiffdir', 'bin/duplicity'], data_files=data_files, cmdclass={'install': InstallCommand, 'sdist': SDistCommand}, ) |
We can now save our modified setup.new file and run diff to produce a patch file:
|
1 |
diff -u setup.py setup.new > 000-duplicity-setup-patch |
The only thing we still have to change in the patch file is the header. Change the first lines so that they look as follows:
|
1 2 |
--- a/setup.py 2015-03-11 13:33:38.000000000 +0100 +++ b/setup.py 2015-06-10 17:31:57.656533070 +0200 |
We can now create a patch directory under our duplicity custom package directory and copy that file there:
|
1 2 |
mkdir -p ~/myowrt/custpacks/duplicity/patches cp 000-duplicity-setup-patch ~/myowrt/custpacks/duplicity/patches |
Step 3: Write an oWRT Makefile
Now comes the tricky part – at least for me as I do not have any in-depth experience with oWRT Makefiles. What I did was trying some Makefiles from the python modules which already ship with the oWRT packages. Adapting the Makefile from pysqlite worked best (though it’s not yet perfect, as we will see later). Your final Makefile should look like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
include $(TOPDIR)/rules.mk PKG_NAME:=duplicity PKG_VERSION:=0.7.05 PKG_RELEASE:=1 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz PKG_SOURCE_URL:=https://code.launchpad.net/duplicity/0.7-series/0.7.05/+download/ PKG_MD5SUM:=b2f28a48aa392e81c740ac30d28e9250 PKG_BUILD_DEPENDS:=python include $(INCLUDE_DIR)/package.mk $(call include_mk, python-package.mk) define Package/duplicity SUBMENU:=Python SECTION:=lang CATEGORY:=Languages TITLE:=Intelligent backup with encryption (Custom package) URL:=http://duplicity.nongnu.org/ DEPENDS:=+python +librsync +python-expat +lockfile +gnupg endef define Package/duplicity/description Duplicity allows rsync-style incremental backups with GPG encryption. This package does not ship with the official oWRT distro. endef define PyPackage/duplicity/filespec +|$(PYTHON_PKG_DIR)/duplicity -|$(PYTHON_PKG_DIR)/duplicity/test endef define Build/Configure cp ./files/setup.cfg.in $(PKG_BUILD_DIR)/setup.cfg $(SED) \ 's,@INCLUDE_DIRS@,$(STAGING_DIR)/usr/include,g' \ -e 's,@INCLUDE_DIRS@,$(STAGING_DIR)/usr/include,g' \ $(PKG_BUILD_DIR)/setup.cfg endef define Build/Compile $(if $(Build/Compile/PyMod),,@echo Python packaging code not found.; false) $(call Build/Compile/PyMod,., \ install --prefix="$(PKG_INSTALL_DIR)/usr", \ ) endef $(eval $(call PyPackage,duplicity)) $(eval $(call BuildPackage,duplicity)) |
The pysqlite package which I used as the boiler plate for creating my Makefile also contained a files subdirectory with a setup.cfg.in file. Im am not sure if we really need this file and was too lazy to read the python reference. Instead, I left it in the files subdirectory after adapting it as follows:
|
1 2 3 4 5 |
[build_ext] define= include_dirs=@INCLUDE_DIRS@ library_dirs=@LIBRARY_DIRS@ libraries=rsync |
Step 4: Prepare the target device
As duplicity’s Python code imports the Python lockfile module, we have to make sure that this module is installed on the target device. Unfortunately, the lockfile module is – again – not included in the oWRT package repositories and we have to find a way to get them onto our oWRT device.
I also tried to compile those from source as presented above. Make will compile the lockfile sources but the resulting ipk package has a size of less then 1 kB – so something must be wrong in my configuration and I cannot find out what.
Fortunately, we can get the lockfile package on the target device the easy way this time. Simply issuing easy_install lockfile on the target device will install the package directly from the net.
Step 5: Compile and adapt the result
We are now ready to compile the package:
|
1 2 |
cd ~/myowrt/openwrt make package/duplicity/compile |
We can then copy the resulting ipk file from the bin/<your-arch>/packages/custom directory to the target oWRT device and install it with the opkg install command.
After the package is installed locally, there are two minor problems remaining. Firstly, the main duplicity front end file is missing in the /usr/bin directory of the target device. As the duplicity file is nothing more than an executable Python file, we can just copy that file into the /usr/bin directory from any running installation.
The second problem is that the duplicity file in this version throws an error on the target device when launched:
|
1 2 3 4 5 6 7 8 9 |
root@TESTING:~# duplicity Traceback (most recent call last): File "/usr/bin/duplicity", line 1509, in <module> with_tempdir(main) File "/usr/bin/duplicity", line 1503, in with_tempdir fn() File "/usr/bin/duplicity", line 1333, in main """), log.WarningCode.deprecate_0_6) AttributeError: class WarningCode has no attribute 'deprecate_0_6' |
There is an easy solution to get rid of that Error – just delete the lines 1328-1334 from the duplicity file as suggested in this post. For those keen on a short-cut, just download the patched duplicity file from here and copy it to the /usr/bin directory on your oWRT device.