Installera TaskServer (taskd) på CentOS 7

TaskWarrior är ett tidshanteringsverktyg med öppen källkod som är en förbättring av Todo.txt-applikationen och dess kloner. På grund av det faktum att den genomsnittliga personen använder flera enheter/plattformar i sitt dagliga schema, är det viktigt att ha möjligheten att ha ett centraliserat arkiv där data kan nås och uppdateras från vilken enhet som helst. Denna handledning kommer att fokusera på att ställa in både servern, kallad TaskServer (taskd), och klienten, som kallas TaskWarrior (uppgift), vilket gör att flera klientenheter kan komma åt och utbyta data säkert.

Den har följande funktioner:

• Obegränsade uppgifter
• Uppgiftsprioritering
• Sökfiltrering
• Taggning
• Automatisk synkronisering
• Automatisk säkerhetskopiering
• Full kontroll och integritet
• Krypterad kommunikation

Förutsättningar

• En CentOS 7 x64-serverinstans.
• En sudo- användare.
• Domännamn pekade på en Vultr-instans ( taskd.example.com )

Steg 1: Uppdatera systemet

Logga in som din sudo-användare för att installera EPEL Repository och uppdatera systemet enligt följande:

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

Steg 2: Installera RPM Build och verktyg för att bygga

EPEL-förvaret innehåller ingen RPM för TaskServer (taskd), så vi måste bygga det från källan till ett RPM-paket själva.

1. Installera GCC, Make, RPM Build, utveckling och signeringsverktyg.

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

2. Skapa en GnuPG-katalog som innehåller de GPG-filer som krävs för att signera vår RPM.

   mkdir .gnupg
   

3. När vi skapar en nyckel kräver vi entropi i systemet för att korrekt randomisera den. Den rngddemonen genererar entropin nödvändig ur /dev/urandom. Så låt oss installera det nu.

   yum install rngd -y
   

4. Starta rngddemonen för att generera entropi. De -r alternativet pekar /dev/urandomi stället för standard /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Skapa en nyckel. Den --gen-key alternativet berättar gpg att generera ett nytt nyckelpar.

   gpg --gen-key
   

6. För alternativet " Vänligen välj vilken typ av nyckel du vill ha: " välj " (1) RSA och RSA (standard) " för nyckeltypen genom att ange 1 och trycka på Retur/Enter- tangenten.

7. För alternativet " Vilken tangentstorlek vill du ha? (2048) " väljer du standard genom att trycka på Retur/Enter- tangenten.

8. För alternativet " Vänligen ange hur länge nyckeln ska vara giltig " väljer du standard genom att trycka på Retur/Enter- tangenten.

9. För alternativet " Är detta korrekt? (y/N) " anger du y och trycker på Retur/Enter .

10. Under " Riktigt namn: " anger du ett namn som du väljer och trycker på Retur/Enter .

11. Under " E-postadress: " anger du en e-postadress som du väljer och trycker på Retur/Enter- tangenten.

12. I Kommentar: avsnitt kan lämnas tomt om du så önskar.

13. Gör nödvändiga ändringar om du inte har angett din information korrekt. Om du är nöjd med USER-ID- informationen som visas, skriv in O (versal O, inte noll) och tryck på Retur/Enter- tangenten.

14. GnuPG kommer nu att uppmana dig att skapa och verifiera ett lösenord för ditt nyckelpar.

15. Efter att du har angett dina lösenord kommer ditt GnuPG-nyckelpar att skapas under .gnupgkatalogen i din användarkatalog.

16. Kör det här kommandot för att visa innehållet i .gnupgkatalogen. Den bör innehålla följande katalog private-keys-v1.doch filer pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exportera det skapade nyckelparet. Den --export alternativet instruerar GnuPG att exportera nyckelpar. Den -a alternativet instruerar GnuPG att mata nyckelparet i ascii rustning format . Ersätt " Joe Q. Public " med namnet du angav när du skapade nyckelparet i steg #10 ovan. Ersätt " jqpublic " med vilken text du än väljer.

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

18. Importera nyckelparet till RPM-nyckelarkivet. Ersätt " jqpublic " med texten du valde i steg #17.

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

19. Verifiera att nyckelparet har lagts till i RPM-nyckelarkivet. Den --q gpg-pubkey alternativet frågar RPM GnuPG nyckel. Den % {name} -% {version} -% {utsläpp} ->% {sammanfattning} \ n visar resultatet i ett mänskligt läsbart format.

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

20. Genom att skapa en .rpmmacros filekan RPM anpassas för att utföra tilldelade beteenden (exempel: förenkla automatisk signering av RPM). Använd nanoprogrammet för att skapa filen.

    nano .rpmmacros
    

21. Lägg sedan till följande text nedan i .rpmmacrosfilen.

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

22. Spara dokumentet genom att ange följande tangentbordskombinationer. De CTRL + X Keys. Sedan, S- tangenten. Slutligen, Retur/Enter- tangenten.

23. Det här kommandot nedan kommer att ställa in din RPM-byggmiljö. Detta kommer att lägga till ytterligare makron till .rpmmacrosfilen du skapade i steg #20 och skapa de nödvändiga katalogerna för att bygga och lagra RPM.

    rpmdev-setuptree
    

24. Kör det här kommandot för att visa innehållet i rpmbuild-katalogen. Den bör innehålla följande kataloger SOURCES , RPMS , BUILD , SRPMS och SPECS .

    find rpmbuild
    

25. Ladda ner TaskServer (taskd) källkoden till rpmbuild/SOURCESkatalogen.

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

26. Döda den pågående rgndprocessen.

    sudo kill -9 rngd
    

Steg 3: Bygg TaskServer (taskd) RPM från källan

1. För att bygga en ny RPM från källan måste en TaskServer (taskd) SPEC-fil skapas.

   nano rpmbuild/SPECS/taskd.spec
   

2. Lägg till följande text nedan i taskd.specfilen.

   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 <[email protected]> - 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 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.

    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="Vultr.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. Efter omstart, öppna en kommandotolk och skriv följande kommando bash . Detta kommer att installera Ubuntu på Windows. Tryck på Y-tangenten . Den kommer nu att laddas ner och extraheras. Välj ett användarnamn och lösenord.

   bash
   

3. Nu är det dags att installera TaskWarrior (uppgift). Skriv följande kommando inuti konsolen.

   sudo apt-get install task -y
   

4. Skriv exit två gånger för att avsluta bash-terminalen och Windows-kommandotolken.

5. Klicka på knappen Startmeny. Skriv ubuntu . Högerklicka på Bash på Ubuntu på Windows . Välj Fäst till aktivitetsfältet . Detta ger bekvämlighet för att snabbt komma åt bash för att komma åt TaskWarrior (uppgift).

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.