Learn How To Install TaskServer (taskd) On CentOS 7

February 22, 2019

Table of Contents

    If you are using a different system, please check our other tutorials.

    TaskWarrior is an open source time management tool that is an improvement on the Todo.txt application and its clones. Due to the fact that the average person uses multiple devices/platforms in their daily schedule, it is critical to have the ability to have a centralized repository where the data can be accessed and updated from any device. This tutorial will focus on setting up both the server, called TaskServer (taskd), and the client, called TaskWarrior (task), allowing multiple client devices to access and exchange data securely.

    It has the following features:

    • Unlimited tasks
    • Task prioritizing
    • Search filtering
    • Tagging
    • Automatic syncing
    • Automatic backup
    • Full control and privacy
    • Encrypted communication

    Prerequisites

    • A CentOS 7 x64 server instance.
    • https://www.itweb.services/tutorials/linux-guides/how-to-use-sudo-on-debian-centos-and-freebsd”>sudo user.

    • Domain name pointed to An ITWeb.Services instance ( taskd.example.com )

    Step 1: Update the system

    Log in as your sudo user to install the EPEL Repository and update the system as follows:

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

    Step 2: Install RPM Build and tools for building

    The EPEL repository doesn’t contain an RPM for the TaskServer (taskd), so we have to build it from source into an RPM package ourselves.

    1. Install GCC, Make, RPM Build, development and signing tools.

      sudo yum install gcc gcc-c++ make rpmdevtools rpm-sign rpm-build -y
      
    2. Create a GnuPG directory which will hold the GPG files necessary for signing our RPM.

      mkdir .gnupg
      
    3. When creating a key, we require entropy in the system to properly randomize it. The rngd daemon generates the entropy necessary from /dev/urandom. So let’s install that now.

      yum install rngd -y
      
    4. Start up the rngd daemon to generate entropy. The -r option points to /dev/urandom instead of the default /dev/hwrng.

      sudo rngd -r /dev/urandom
      
    5. Generate a key. The –gen-key option tells gpg to generate a new key pair.

      gpg --gen-key
      
    6. For the “Please select what kind of key you want:” option, select “(1) RSA and RSA (default)” for the key type by entering 1 and pressing the Return/Enter key.

    7. For the “What keysize do you want? (2048)” option, choose the default by pressing the Return/Enter key.

    8. For the “Please specify how long the key should be valid.” option, choose the default by pressing the Return/Enter key.

    9. For the “Is this correct? (y/N)” option, enter y and press the Return/Enter key.

    10. Under “Real name:“, enter a name of your choosing and press the Return/Enter key.

    11. Under “Email address:“, enter an email address of your choosing and press the Return/Enter key.

    12. The Comment: section can be left blank if you so choose.

    13. Make any changes necessary if you didn’t enter your information correctly. If you are satisfied with USER-ID information displayed, enter O (capital letter O, not zero) and press the Return/Enter key.

    14. GnuPG will now prompt you to create and verify a password for your key pair.

    15. After you have entered your passwords, your GnuPG key pair will be created under the .gnupg directory in your user directory.

    16. Run this command to display the contents of the .gnupg directory. It should contain the following directory private-keys-v1.d and files pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

      ls -la .gnupg
      
    17. Export the created key pair. The –export option instructs GnuPG to export the key pair. The -a option instructs GnuPG to output the key pair in ascii armor format. Replace “Joe Q. Public” with the name you’ve entered when creating the key pair in step #10 above. Replace “jqpublic” with whatever text you choose.

      gpg --export -a 'Joe Q. Public' > RPM-GPG-KEY-jqpublic
      
    18. Import the key pair into the RPM keystore. Replace the “jqpublic” with the text you chose in step #17.

      sudo rpm --import RPM-GPG-KEY-jqpublic
      
    19. Verify that the key pair was added to the RPM keystore. The –q gpg-pubkey option queries the RPM GnuPG keystore. The %{name}-%{version}-%{release} –> %{summary}n displays the result in a human readable format.

      rpm -q gpg-pubkey --qf '%{name}-%{version}-%{release} --> %{summary}n'
      
    20. By creating a .rpmmacros file, RPM can be customized to perform assigned behaviors (example: ease automatic signing of RPMs). Use the nano program to create the file.

      nano .rpmmacros
      
    21. Then, add the following text below into the .rpmmacros file.

      %_gpg_name  Joe Q. Public
      %_query_all_fmt %%{name}-%%{version}-%%{release}.%%{arch}
      %_signature gpg
      %_topdir %(echo $HOME)/rpmbuild
      
    22. Save the document by entering the following keyboard combinations. The CTRL + X Keys. Then, the S Key. Finally, the Return/Enter Key.

    23. This command below will setup your RPM build environment. This will append additional macros to the .rpmmacros file you have created in step #20 and create the required directories to build and store RPMs.

      rpmdev-setuptree
      
    24. Run this command to display the contents of the rpmbuild directory. It should contain the following directories SOURCES, RPMS, BUILD, SRPMS and SPECS.

      find rpmbuild
      
    25. Download the TaskServer (taskd) source code to the rpmbuild/SOURCES directory.

      wget https://taskwarrior.org/download/taskd-1.1.0.tar.gz -P rpmbuild/SOURCES/
      
    26. Kill the running rgnd process.

      sudo kill -9 rngd
      

    Step 3: Build TaskServer (taskd) RPM from source

    1. In order to build a new RPM from source, a TaskServer (taskd) SPEC file must be created.

      nano rpmbuild/SPECS/taskd.spec
      
    2. Add the following text below into the taskd.spec file.

      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
      # On rhel, we don't need systemd to build.  but we do on centos.        
      # ...just to define some macros
      %else
      BuildRequires:  systemd
      %endif
      
      # For certificate generation        
      Requires:       gnutls-utils
      
      # Systemd requires
      Requires(post):    systemd
      Requires(preun):   systemd
      Requires(postun):  systemd
      
      %description
      The TaskServer is a lightweight, secure server providing multi-user,
      multi-client access to task data.  This allows true syncing between desktop and
      mobile clients.
      
      Users want task list access from multiple devices running software of differing
      sophistication levels to synchronize data seamlessly.  Synchronization requires
      the ability to exchange transactions between devices that may not have
      continuous connectivity, and may not have feature parity.
      
      The TaskServer provides this and builds a framework to go several steps beyond
      merely synchronizing data.
      
      %prep
      %setup -q %{name}-%{version}
      
      %build
      %cmake
      make %{?_smp_mflags}
      
      %install
      make install DESTDIR=%{buildroot}
      
      mkdir -p %{buildroot}%{_sharedstatedir}/taskd/
      
      # Users will keep their keys here, but we copy some helpful scripts too.
      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
      # EL6 and earlier needs a sysvinit script
      # Also, no firewalld on old EL
      %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
      
      # Systemd scriptlets
      %if 0%{?rhel} && 0%{?rhel} <= 6
      # No systemd for el6
      %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
      # No sysvinit files for el6
      %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.
      
    3. The RPM also requires three additional files that must be created in the rpmbuild/SOURCES directory. Use the nano program to create the taskd-config file.

      nano rpmbuild/SOURCES/taskd-config
      
    4. Add the following text below into the taskd-config file.

      # 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
      
    5. Use the nano program to create the taskd.service file.

      nano rpmbuild/SOURCES/taskd.service
      
    6. Add the following text below into the taskd.service file.

      [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
      
    7. Use the nano program to create the taskd.xml file.

      nano rpmbuild/SOURCES/taskd.xml
      
    8. Add the following text below into the taskd.xml file.

      <?xml version="1.0" encoding="utf-8"?>
      <service>
        <short>Task-warrior server</short>
        <description>This option allows you to connect to the task warrior server.</description>
        <port protocol="tcp" port="53589"/>
      </service>
      
    9. In order to build the TaskServer (taskd) RPM, three packages are required for building. Run the command below to install those packages.

      sudo yum install cmake libuuid-devel gnutls-devel gnutls-utils -y
      
    10. Now it is time to build from source and create an RPM for TaskServer (taskd). Run the commands below to get started. It should take less than a minute on a 1x CPU IT Web Services instance to build the RPMs. Enter the GnuPG password you created in step #14 to sign the RPM when prompted.

      cd rpmbuild/SPECS/
      rpm -ba -sign taskd.spec
      
    11. Install the TaskServer (taskd) RPM.

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

    Step 4: Configure TaskServer (task)

    1. In order for TaskServer (taskd) to communicate and sync with TaskWarrior (task) clients, you will need to use the generation scripts found under /etc/pki/taskd/ to generate server and client certificates/keys. Elevate to the root user using the command below and change directory to /etc/pki/taskd.

      sudo su -
      cd /etc/pki/taskd/
      
    2. Use the nano program to create a vars file in order to generate a self-signed Root CA.

      nano vars
      

      Add the following text below into the vars file. Change ORGANIZATION, CN, COUNTRY, STATE and LOCALITY to your satisfaction.

      BITS=4096
      EXPIRATION_DAYS=365
      ORGANIZATION="IT Web Services.com Inc."
      CN=taskd.example.com
      COUNTRY=US
      STATE="New York"
      LOCALITY="New York"
      
    3. Generate the self-signed Root CA, certificate, server key and server revocation list (optional).

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

      These commands will create the following files (ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pem and server.crl.pem) inside the /etc/pki/taskd/ directory. In order for TaskServer (taskd) to start, the ownership and permissions on the certificates and keys generated in step #37 must be modified to allow TaskServer (taskd) to access them. Run the commands below to change them.

      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
      
    4. Enable and start the TaskServer (taskd) daemon.

      systemctl enable taskd
      systemctl start taskd
      
    5. Open the port in the firewall TaskServer (taskd) runs on.

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

      TaskServer (taskd) is now installed and setup on your CentOS 7 instance.

    Step 5: Configure TaskWarrior client certificate and key

    1. You must create client certificates and key to encrypt communications between TaskServer (taskd) and TaskWarrior (task). Run the command below to generate a client certificate and key. Replace NAME with a name you can easily recognize for your client.

      generate.client NAME
      

      This command will create the following files (NAME.cert.pem, NAME.key.pem) inside of the /etc/pki/taskd/ directory.

    2. Copy the following files to your user directory, change the ownership and permissions. Substitute joeqpublic below with your actual username directory.

      cp ca.cert.pem NAME.cert.pem NAME.key.pem /home/joeqpublic/
      chown joeqpublic.joeqpublic /home/joeqpublic/*.pem
      chmod 400 /home/joeqpublic/*.pem
      
    3. Create a zip archive of the certificates and key.

      zip certficates.zip ca.cert.pem NAME.cert.pem NAME.key.pem
      
    4. Use scp (command line) or WinSCP (GUI frontend for SCP) to download the certificates.zip file from your CentOS instance to your client device (computer/laptop/smartphone).

    5. Drop root privileges and perform the rest of your commands as your regular user.

      exit
      

      TaskServer (taskd) is now setup and ready for TaskWarrior (task) clients to connect.

    Step 6: Create your first TaskWarrior group and user

    1. In order to create, delete, modify and sync your tasks, you will need a user account. However, before you can add users, you will first need to create an organizational group. Run the command below to create your first group. Replace GROUP with an easily recognizable name.

    2. IMPORTANT! The taskd command to create groups/users must be ran as the taskd user. Running as the root user will create directories and files owned by the root user under /var/lib/taskd/orgs which will prevent TaskWarrior (task) clients from being able to access or modify anything in the group to which they have been assigned. Access will be denied.

      sudo -u taskd taskd add org GROUP --data /var/lib/taskd
      
    3. Now, that you’ve created your first group, let’s create your first user. Run the command below to create a user assigned to the group created in step #1. Copy and paste the generated user key, user and group in a text file. Repeat the process to add additional users.

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

    Step 7: Install TaskWarrior clients

    Windows 10 (Build later than 1607+)

    To use TaskWarrior (task) on Windows 10, you need to install the Windows Subsystem For Linux from the Windows Store.

    1. To install WSL, an elevated Powershell prompt is required. Press the Window Key and type powershell. Right click on Windows Powershell at the top of the results and select “Run as administrator“. At the User Account Control prompt, click Yes. Copy and paste the text found below in the Powershell windows. When WSL finishes installing, press the Y Key to restart Windows.

      Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
      
    2. After rebooting, open a command prompt and type the following command bash. This will install Ubuntu on Windows. Press the Y Key. It will now be downloaded and extracted. Choose a username and password.

      bash
      
    3. Now it’s time to install TaskWarrior (task). Type the following command inside the console.

      sudo apt-get install task -y
      
    4. Type exit twice to exit out of bash terminal and the Windows command prompt.

    5. Click the Start Menu button. Type ubuntu. Right click on Bash on Ubuntu on Windows. Select Pin to taskbar. This provides convenience to quickly access bash to access TaskWarrior (task).

    6. Click on the Ubuntu icon you have just created on the taskbar. This will open a terminal window running Bash. Type the following command below to create TaskWarrior (task) data directory (~/.task/) and configuration file (.taskrc).

      task version
      yes
      
    7. You need to move the certificates.zip file you’ve saved earlier during the TaskServer setup into the ~/.taskd/ directory inside of your user directory. To extract the files from the zip file, install the unzip program first. Copy and paste the following commands below substituting the actual location of your copy of certificates.zip.

      sudo apt-get install unzip -y
      cp /mnt/c/User/WINDOWSUSER/Desktop/certificates.zip .
      cd .task
      unzip ../certificates.zip
      cd
      
    8. Type the following commands to set TaskWarrior (task) up to connect with TaskServer (taskd). Replace NAME with what you’ve named your certificate and key, GROUP with the group you’ve created, Joe Q. Public with the username you’ve created and XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX with the key assigned when your user was created on the TaskWarrior (taskd) server.

      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
      
    9. Now it’s time to sync TaskWarrior (task) with TaskServer (taskd). Run the command below to initialize the database.

      task sync init
      

      Syncing between your TaskWarrior (task) client and the TaskServer (taskd) is now setup on the Windows 10 platform.

    Android

    To use TaskWarrior (task) on Android, you need to install the TaskWarrior For Android from the Google Play Store.

    1. Install the TaskWarrior (task) For Android app on Google’s Play Store.

    2. Open the TaskWarrior (task) For Android app.

    3. You will be prompted by the app to create an account with a Desired account name. Input the name you chose when you created an username for a TaskServer (taskd) user.

    4. Leave the data folder to the default setting of <<Create new>> and tap the OK button. Use a file manager app to create a folder in your storage root (for example: /storage/emulate/0/Certs). Send the app to the background.

    5. Copy the certificates.zip file you’ve created earlier and extract its contents in your directory created in step #4.

    6. Foreground the “TaskWarrior (task) For Android” app and tap the the menu at the top left corner of the app to open it.

    7. Scroll down to the bottom of the menu and tap the Settings option.

    8. This will open a simple built-in TaskWarrior For Android app text editor.

    9. Enter the following options to set up syncing with your TaskServer (taskd). Replace the taskd.ca/taskd.certificate/taskd.key` variables with the actual ca/certificate/key directory path(s), NAME with what you named your certificate and key, GROUP with the group you created, Joe Q. Public with the username you created and XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX with the key assigned when you created your user on the TaskWarrior (taskd) server.

      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
      
    10. Tap the the floppy disk icon to save your settings.

    Syncing between your TaskWarrior (task) client and the TaskServer (taskd) is now setup on the Android platform.

    Linux

    1. Refer to the TaskWarrior (task) distribution section to install for your particular Linux distribution.

    2. Open a terminal window. Type the following command below to create TaskWarrior (task) data directory (~/.task/) and configuration file (.taskrc).

      task version
      yes
      
    3. You need to move the certificates.zip file you’ve saved earlier in the TaskServer setup to the ~/.taskd/ directory inside of your user directory. To extract the files from the zip file, install the unzip program first for your particular distribution. Copy and paste the following commands below, substituting the actual location of your copy of certificates.zip.

      cp /location/of/certificates.zip .
      cd .task
      unzip ../certificates.zip
      cd
      
    4. Type the following commands to set TaskWarrior (task) up to connect with TaskServer (taskd). Replace NAME with what you’ve named your certificate and key, GROUP with the group you’ve created, Joe Q. Public with the username you’ve created and XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX with the key assigned when your user was created on the TaskWarrior (taskd) server.

      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
      
    5. Now it’s time to sync TaskWarrior (task) with TaskServer (taskd). Run the command below to initialize the database.

      task sync init
      

    Addendum: If you run Gnome Shell, there’s an extension called TaskWhisper that integrates with TaskWarrior (task).

    Syncing between your TaskWarrior (task) client and the TaskServer (taskd) is now setup on your favorite Linux distro.

    Need help?

    Do you need help setting up this on your own service?
    Please contact us and we’ll provide you the best possible quote!