Install TaskServer (taskd) On CentOS 7

Using a Different System?

  • Install TaskServer (taskd) on Debian 9

  • Install TaskServer (taskd) on Fedora 26

  • Install TaskServer (taskd) on FreeBSD 11

Are we missing a guide for your target system? Request one, or submit your own!


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.
  • A sudo user.
  • Domain name pointed to a Vultr 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 -ysudo 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:           taskdVersion:        1.1.0Release:        1%{?dist}Summary:        Secure server providing multi-user, multi-client access to task dataGroup:          Applications/ProductivityLicense:        MITURL:            http://tasktools.org/projects/taskd.htmlSource0:        http://taskwarrior.org/download/%{name}-%{version}.tar.gzSource1:        taskd.serviceSource2:        taskd-configSource3:        taskd.xmlBuildRequires:  cmakeBuildRequires:  libuuid-develBuildRequires:  gnutls-develBuildRequires:  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%elseBuildRequires:  systemd%endif# For certificate generation        Requires:       gnutls-utils# Systemd requiresRequires(post):    systemdRequires(preun):   systemdRequires(postun):  systemd%descriptionThe TaskServer is a lightweight, secure server providing multi-user,multi-client access to task data.  This allows true syncing between desktop andmobile clients.Users want task list access from multiple devices running software of differingsophistication levels to synchronize data seamlessly.  Synchronization requiresthe ability to exchange transactions between devices that may not havecontinuous connectivity, and may not have feature parity.The TaskServer provides this and builds a framework to go several steps beyondmerely synchronizing data.%prep%setup -q %{name}-%{version}%build%cmakemake %{?_smp_mflags}%installmake 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%elsemkdir -p %{buildroot}%{_unitdir}/cp -a %{SOURCE1} %{buildroot}%{_unitdir}/taskd.servicemkdir -p %{buildroot}%{_prefix}/lib/firewalld/servicescp -a %{SOURCE3} %{buildroot}%{_prefix}/lib/firewalld/services/taskd.xml%endifmkdir -p %{buildroot}%{_sharedstatedir}/taskd/orgs/cp -a %{SOURCE2} %{buildroot}%{_sharedstatedir}/taskd/configrm -r %{buildroot}%{_datadir}/doc/taskd/%pregetent group taskd >/dev/null || groupadd -r taskdgetent passwd taskd >/dev/null || /    useradd -r -g taskd -d %{_sharedstatedir}/taskd/ -s /usr/bin/sh /    -c "Task Server system user" taskdexit 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 fileconfirmation=1verbose=1ip.log=onextensions=/usr/libexec/taskdqueue.size=10request.limit=1048576server=0.0.0.0:53589root=/var/lib/taskdlog=/var/log/taskd/taskd.logpid.file=/var/run/taskd.pidca.cert=/etc/pki/taskd/ca.cert.pemserver.cert=/etc/pki/taskd/server.cert.pemserver.key=/etc/pki/taskd/server.key.pemserver.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 dataAfter=network.targetDocumentation=https://tasktools.org/projects/taskd.html[Service]ExecStart=/usr/bin/taskd server --data /var/lib/taskdType=simpleUser=taskdGroup=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 Vultr 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.

    cdsudo 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=4096EXPIRATION_DAYS=365ORGANIZATION="Vultr.com Inc."CN=taskd.example.comCOUNTRY=USSTATE="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.pemchmod 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 taskdsystemctl start taskd
  5. Open the port in the firewall TaskServer (taskd) runs on.

    firewall-cmd --permanent --zone=public --add-port=53589/tcpfirewall-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/*.pemchmod 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 versionyes
  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 -ycp /mnt/c/User/WINDOWSUSER/Desktop/certificates.zip .cd .taskunzip ../certificates.zipcd
  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.pemtask config taskd.certificate -- ~/.task/**NAME**.cert.pemtask config taskd.key -- ~/.task/**NAME**.key.pemtask config taskd.server -- taskd.example.com:53589task 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.pemtaskd.certificate=/storage/emulate/0/Certs/NAME.cert.pemtaskd.credentials=GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXtaskd.key=/storage/emulate/0/Certs/NAME.key.pemtaskd.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 versionyes
  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 .taskunzip ../certificates.zipcd
  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.pemtask config taskd.certificate -- ~/.task/**NAME**.cert.pemtask config taskd.key -- ~/.task/**NAME**.key.pemtask config taskd.server -- taskd.example.com:53589task 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.

Want to contribute?

You could earn up to $300 by adding new articles

Submit your article
Suggest an update
Request an article

No comments

Powered by Blogger.