Maximum performance at minimal cost. Start your server in seconds now!
    Vijona

    Install and Configure TaskWarrior and TaskServer on CentOS 7

    TaskWarrior is a powerful open-source time management utility that enhances the functionality of Todo.txt and its derivatives. In today’s multi-device environment, having centralized access to your task data is crucial. This guide walks you through configuring the TaskServer (taskd) and the TaskWarrior client (task) so that several client devices can synchronize and securely share data.

    Key Features

    • Unlimited task creation
    • Task prioritization
    • Filtering with search
    • Support for tags
    • Syncing across devices automatically
    • Built-in backup functionality
    • Complete control and privacy
    • Encrypted data transmission

    System Requirements

    • A 64-bit CentOS 7 server
    • A user account with sudo privileges
    • A domain name directing to your server (e.g., taskd.example.com)

    Step 1: Perform System Update

    Begin by logging in with your sudo-enabled user account. Proceed to install the EPEL repository and update the server system using the commands below:

    Copy Code 
    

    sudo yum install epel-release -y
sudo yum clean all && sudo yum update -y

    Step 2: Install RPM Build Tools and Prepare the Build Environment

    Since the EPEL repository doesn’t offer a prebuilt RPM package for TaskServer (taskd), you’ll need to compile it from source into an RPM manually.

    First, install the essential build tools, such as GCC, Make, RPM utilities, and signing components:

    Copy Code 
    

    sudo yum install gcc gcc-c++ make rpmdevtools rpm-sign rpm-build -y

    Create a directory to store GnuPG-related files required for signing the RPM packages:

    Copy Code 
    

    mkdir .gnupg

    Key generation depends on system entropy. To ensure sufficient entropy, install the rngd daemon which utilizes /dev/urandom:

    Copy Code 
    

    yum install rngd -y

    Launch the rngd daemon using /dev/urandom as the entropy source:

    Copy Code 
    

    sudo rngd -r /dev/urandom

    Generate a new GPG key pair with the following command:

    Copy Code 
    

    gpg --gen-key

    When prompted, use these selections:

    • Select option (1) RSA and RSA (default)
    • Use default key size: 2048
    • Accept default expiration (no expiration)
    • Confirm with y when asked if the configuration is correct
    • Provide a name and email address
    • Leave the Comment field blank or enter your own text
    • Press O to confirm and create the key
    • Enter and confirm your passphrase

    To verify the GPG key pair and its files, run:

    Copy Code 
    

    ls -la .gnupg

    Export the generated GPG key to a file, replacing the placeholders with the actual name and custom identifier you provided:

    Copy Code 
    

    gpg --export -a 'Joe Q. Public' > RPM-GPG-KEY-jqpublic

    Import the exported key into RPM’s keyring:

    Copy Code 
    

    sudo rpm --import RPM-GPG-KEY-jqpublic

    Confirm the key was successfully added by running this query:

    Copy Code 
    

    rpm -q gpg-pubkey --qf '%{name}-%{version}-%{release} --> %{summary}\n'

    Now, create a file named .rpmmacros using a text editor like nano:

    Copy Code 
    

    nano .rpmmacros

    Add the following content, replacing the name with your GPG identity:

    Copy Code 
    

    %_gpg_name  Joe Q. Public
%_query_all_fmt %%{name}-%%{version}-%%{release}.%%{arch}
%_signature gpg
%_topdir %(echo $HOME)/rpmbuild

    To save the file: press CTRL + X, then press S, and hit Enter.

    Set up the RPM development directory structure and extend the macros using this command:

    Copy Code 
    

    rpmdev-setuptree

    Inspect the directory structure of rpmbuild to ensure required folders were created:

    Copy Code 
    

    find rpmbuild

    Download the source code archive of TaskServer (version 1.1.0) into the SOURCES directory:

    Copy Code 
    

    wget https://taskwarrior.org/download/taskd-1.1.0.tar.gz -P rpmbuild/SOURCES/

    Terminate the running rngd process:

    Copy Code 
    

    sudo kill -9 rngd

    Step 3: Compile the TaskServer (taskd) RPM from Source

    To create a new RPM package for TaskServer, begin by writing a SPEC file that outlines how the software will be built and packaged. This file must be placed in the rpmbuild/SPECS directory.

    Open and edit the SPEC file with the following command:

    Copy Code 
    

    nano rpmbuild/SPECS/taskd.spec

    Insert the following content into the taskd.spec file:

    Copy Code 
    

    Name:           taskd
Version:        1.1.0
Release:        1%{?dist}
Summary:        Secure server providing multi-user, multi-client access to task data
Group:          Applications/Productivity
License:        MIT
URL:            http://tasktools.org/projects/taskd.html
Source0:        http://taskwarrior.org/download/%{name}-%{version}.tar.gz
Source1:        taskd.service
Source2:        taskd-config
Source3:        taskd.xml

BuildRequires:  cmake
BuildRequires:  libuuid-devel
BuildRequires:  gnutls-devel
BuildRequires:  shadow-utils

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
BuildRequires:  systemd
%endif

Requires:       gnutls-utils
Requires(post):    systemd
Requires(preun):   systemd
Requires(postun):  systemd

%description
The TaskServer provides secure, lightweight synchronization for task data across multiple clients and platforms. It enables users to maintain updated task lists from different devices and offers robust data exchange for systems without constant connectivity or identical features.

%prep
%setup -q %{name}-%{version}

%build
%cmake
make %{?_smp_mflags}

%install
make install DESTDIR=%{buildroot}

mkdir -p %{buildroot}%{_sharedstatedir}/taskd/
mkdir -p %{buildroot}%{_sysconfdir}/pki/taskd/
cp -a pki/generate* %{buildroot}%{_sysconfdir}/pki/taskd/.
mkdir -p %{buildroot}%{_localstatedir}/log/taskd/

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
mkdir -p %{buildroot}%{_unitdir}/
cp -a %{SOURCE1} %{buildroot}%{_unitdir}/taskd.service
mkdir -p %{buildroot}%{_prefix}/lib/firewalld/services
cp -a %{SOURCE3} %{buildroot}%{_prefix}/lib/firewalld/services/taskd.xml
%endif

mkdir -p %{buildroot}%{_sharedstatedir}/taskd/orgs/
cp -a %{SOURCE2} %{buildroot}%{_sharedstatedir}/taskd/config
rm -r %{buildroot}%{_datadir}/doc/taskd/

%pre
getent group taskd >/dev/null || groupadd -r taskd
getent passwd taskd >/dev/null || \
    useradd -r -g taskd -d %{_sharedstatedir}/taskd/ -s /usr/bin/sh \
    -c "Task Server system user" taskd
exit 0

%if 0%{?rhel} && 0%{?rhel} <= 6
%else

%post
%systemd_post taskd.service

%preun
%systemd_preun taskd.service

%postun
%systemd_postun_with_restart taskd.service

%endif

%files
%doc AUTHORS COPYING ChangeLog NEWS README
%{_bindir}/taskd
%{_bindir}/taskdctl
%{_mandir}/man1/taskd.1.*
%{_mandir}/man1/taskdctl.1.*
%{_mandir}/man5/taskdrc.5.*

%{_sysconfdir}/pki/taskd/generate*

%dir %attr(0750, taskd, taskd) %{_sysconfdir}/pki/taskd/
%dir %attr(0750, taskd, taskd) %{_localstatedir}/log/taskd/
%dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/
%config(noreplace) %attr(0644, taskd, taskd) %{_sharedstatedir}/taskd/config
%dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/orgs/

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
%{_unitdir}/taskd.service
%{_prefix}/lib/firewalld/services/taskd.xml
%endif

%changelog
* Thu Aug 17 2017 Jarrett Graham <jarrett+rpmbuild@jarrettgraham.com> - 1.1.0
- Initial packaging.
</jarrett+rpmbuild@jarrettgraham.com>

    The RPM build process also needs three support files. First, create the taskd-config file in rpmbuild/SOURCES:

    Copy Code 
    

    nano rpmbuild/SOURCES/taskd-config

    Insert the following configuration settings:

    Copy Code 
    

    # taskd configuration file
confirmation=1
verbose=1
ip.log=on
extensions=/usr/libexec/taskd
queue.size=10
request.limit=1048576
server=0.0.0.0:53589
root=/var/lib/taskd
log=/var/log/taskd/taskd.log
pid.file=/var/run/taskd.pid
ca.cert=/etc/pki/taskd/ca.cert.pem
server.cert=/etc/pki/taskd/server.cert.pem
server.key=/etc/pki/taskd/server.key.pem
server.crl=/etc/pki/taskd/server.crl.pem

    Next, create the systemd service unit file for TaskServer:

    Copy Code 
    

    nano rpmbuild/SOURCES/taskd.service

    Add this unit definition for systemd:

    Copy Code 
    

    [Unit]
Description=Secure server providing multi-user, multi-client access to task data
After=network.target
Documentation=https://tasktools.org/projects/taskd.html

[Service]
ExecStart=/usr/bin/taskd server --data /var/lib/taskd
Type=simple
User=taskd
Group=taskd

[Install]
WantedBy=multi-user.target

    Create the taskd.xml Firewall Definition

    The final supporting file needed is the taskd.xml, which defines a custom firewall service for TaskServer. Use the command below to create the file in the rpmbuild/SOURCES directory:

    Copy Code 
    

    nano rpmbuild/SOURCES/taskd.xml

    Add the following XML content to define the custom service for firewall rules:

    Copy Code 
    

    

  Task-warrior server
  This option allows you to connect to the task warrior server.

    Install Required Build Dependencies

    Before compiling TaskServer, make sure all necessary development packages are installed. Use this command to install them:

    Copy Code 
    

    sudo yum install cmake libuuid-devel gnutls-devel gnutls-utils -y

    Build and Sign the TaskServer RPM Package

    Navigate to the rpmbuild/SPECS directory and begin the build process. When prompted, enter the GPG password that you created earlier to sign the package:

    Copy Code 
    

    cd rpmbuild/SPECS/
rpm -ba --sign taskd.spec

    Install the Generated TaskServer RPM

    After the RPM is successfully built, install it on your CentOS system using the command below. This will complete the setup of TaskServer:

    Copy Code 
    

    cd
sudo rpm -ivh rpmbuild/RPMS/x86_64/taskd-1.1.0-1.el7.centos.x86_64.rpm

    Step 4: Set Up and Configure TaskServer (taskd)

    To allow synchronization between TaskServer (taskd) and TaskWarrior (task) clients, you must generate the necessary server and client certificates using the helper scripts located in /etc/pki/taskd/.

    Switch to the root user and navigate to the certificate directory with these commands:

    Copy Code 
    

    sudo su -
cd /etc/pki/taskd/

    Next, create a configuration file named vars to define the settings for generating a self-signed Root Certificate Authority (CA):

    Copy Code 
    

    nano vars

    Add the following variables to the vars file, updating the values for organization, domain name, and location as needed:

    Copy Code 
    

    BITS=4096
EXPIRATION_DAYS=365
ORGANIZATION="centron.de."
CN=taskd.example.com
COUNTRY=US
STATE="New York"
LOCALITY="New York"

    Now, execute the following scripts to generate the Root CA, server certificate, server private key, and optionally a certificate revocation list:

    Copy Code 
    

    ./generate.ca
./generate.server
./generate.crl

    These scripts will produce the following files inside the /etc/pki/taskd/ directory:

    • ca.cert.pem
    • ca.key.pem
    • server.cert.pem
    • server.key.pem
    • server.crl.pem

    TaskServer requires specific ownership and permission settings for these files. Apply the changes with the commands below:

    Copy Code 
    

    chown taskd.taskd ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem
chmod 400 ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem

    Enable and launch the TaskServer service with the following systemd commands:

    Copy Code 
    

    systemctl enable taskd
systemctl start taskd

    Finally, open the required TCP port in the system firewall and reload the ruleset to apply changes:

    Copy Code 
    

    firewall-cmd --permanent --zone=public --add-port=53589/tcp
firewall-cmd --reload

    With this, TaskServer (taskd) is now successfully configured and running on your CentOS 7 server.

    Step 6: Set Up Your First TaskWarrior Group and User

    To begin managing tasks using TaskWarrior, a user account is required. However, you must first establish an organizational group that users will belong to. Use the following command to create this group, replacing GROUP with a meaningful name of your choice:

    Note: It’s critical to execute these commands as the taskd user. Running them as root will result in permission issues due to incorrect file ownership in /var/lib/taskd/orgs, which can block clients from accessing or syncing task data.

    Copy Code 
    

    sudo -u taskd taskd add org GROUP --data /var/lib/taskd

    After creating the group, proceed to add your first user. Replace GROUP with the group name from the previous step and enter the user’s full name in quotes. Once generated, save the user key, username, and group name in a secure text file. You can repeat this step for each new user you wish to register.

    Copy Code 
    

    sudo -u taskd taskd add user GROUP 'Joe. Q. Public' --data /var/lib/taskd

    Step 7: Install TaskWarrior on Windows 10

    To use TaskWarrior on a Windows 10 machine (Build 1607 or newer), you’ll need to install the Windows Subsystem for Linux (WSL). This enables a Linux environment that supports the TaskWarrior command-line tool.

    Begin by launching an elevated PowerShell prompt. Press the Windows key, search for PowerShell, right-click on it, and select Run as administrator. In the User Account Control prompt, click Yes. Then, run the following command to enable WSL:

    Copy Code 
    

    Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

    Once the installation finishes, press Y to reboot your computer. After restarting, open the Command Prompt and run:

    Copy Code 
    

    bash

    This installs Ubuntu on Windows. Accept the setup prompts, and choose a username and password as instructed.

    Once inside the Linux shell, install TaskWarrior by running:

    Copy Code 
    

    sudo apt-get install task -y

    Type exit twice to close the Bash shell and the Command Prompt. For quick access to Bash in the future, open the Start Menu, search for Ubuntu, right-click on Bash on Ubuntu on Windows, and choose Pin to taskbar.

    Launch Ubuntu from the taskbar and run the following command to create the TaskWarrior data directory and config file:

    Copy Code 
    

    task version
yes

    Now, place your certificates.zip file—downloaded earlier during the TaskServer setup—into the ~/.task/ directory. Before extraction, ensure that the unzip utility is installed:

    Copy Code 
    

    sudo apt-get install unzip -y
cp /mnt/c/User/WINDOWSUSER/Desktop/certificates.zip .
cd .task
unzip ../certificates.zip
cd

    To connect the client with the TaskServer, configure TaskWarrior using the following commands. Replace the placeholders with your actual certificate filenames, organization name, user name, and unique key:

    Copy Code 
    

    task config taskd.ca -- ~/.task/ca.cert.pem
task config taskd.certificate -- ~/.task/**NAME**.cert.pem
task config taskd.key -- ~/.task/**NAME**.key.pem
task config taskd.server -- taskd.example.com:53589
task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX

    With your client configured, initialize synchronization with the TaskServer using this command:

    Copy Code 
    

    task sync init

    TaskWarrior on your Windows 10 system is now successfully connected to the TaskServer and ready for task synchronization.

    Step 8: Install TaskWarrior on Android

    To use TaskWarrior on Android, download the official TaskWarrior For Android app from the Google Play Store.

    1. Open the Google Play Store and install TaskWarrior For Android.
    2. Launch the app after installation completes.
    3. When prompted, enter your preferred account name—the same one used when the user was created on the TaskServer.
    4. Leave the Data Folder set to <<Create new>> and tap OK.
    5. Using a file manager, create a new folder on your Android device—for example, /storage/emulate/0/Certs.
    6. Place the previously saved certificates.zip file into that folder and extract its contents.
    7. Return to the TaskWarrior app and open the menu by tapping the icon at the top left corner.
    8. Scroll down and choose Settings to launch the built-in configuration editor.

    Add the following settings into the editor to configure synchronization with the TaskServer. Update each line by replacing NAME, GROUP, Joe Q. Public, and the user key appropriately:

    Copy Code 
    

    taskd.ca=/storage/emulate/0/Certs/ca.cert.pem
taskd.certificate=/storage/emulate/0/Certs/NAME.cert.pem
taskd.credentials=GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
taskd.key=/storage/emulate/0/Certs/NAME.key.pem
taskd.server=taskd.example.com:53589

    Once all values are filled in, tap the floppy disk icon to save your configuration.

    Your TaskWarrior client on Android is now connected and synchronized with your TaskServer instance.

    Step 9: Install TaskWarrior on Linux

    To install TaskWarrior on Linux, consult your distribution’s package repository or the official TaskWarrior website for the appropriate installation method.

    Once installed, open a terminal and run the following command to create the TaskWarrior configuration file and data directory:

    Copy Code 
    

    task version
yes

    Move the certificates.zip file you generated during the TaskServer setup into your home directory. Extract its contents into the ~/.task directory. If you don’t already have the unzip utility, install it using your package manager first. Then, execute the following commands (adjusting the path to your ZIP file as needed):

    Copy Code 
    

    cp /location/of/certificates.zip .
cd .task
unzip ../certificates.zip
cd

    Next, configure TaskWarrior to connect with your TaskServer. Replace the placeholders such as NAME, GROUP, Joe Q. Public, and the user’s unique key accordingly:

    Copy Code 
    

    task config taskd.ca -- ~/.task/ca.cert.pem
task config taskd.certificate -- ~/.task/**NAME**.cert.pem
task config taskd.key -- ~/.task/**NAME**.key.pem
task config taskd.server -- taskd.example.com:53589
task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX

    Finally, initialize synchronization between TaskWarrior and your TaskServer by running the command below:

    Copy Code 
    

    task sync init

    Additional Tip: If you are using GNOME Shell, you may want to explore the “TaskWhisper” extension, which provides an interface for integrating TaskWarrior into your desktop environment.

    Your TaskWarrior client is now successfully configured to sync with your TaskServer on Linux.

    Conclusion

    TaskWarrior, combined with TaskServer, delivers a secure, synchronized, and platform-independent solution for task management. Whether you’re operating on CentOS, Windows, Linux, or Android, this setup allows you to seamlessly manage and sync your task data across multiple devices and users. By configuring TaskServer with proper certificates and securely linking each TaskWarrior client, you gain full control, privacy, and convenience—tailored for both individuals and teams. With this guide, you’ve now built a fully functional, encrypted, and flexible task management environment ready for real-world productivity.

    Source: vultr.com

    Create a Free Account

    Register now and get access to our Cloud Services.

    Try now

    Posts you might be interested in: