Installa TaskServer (taskd) su CentOS 7

TaskWarrior è uno strumento di gestione del tempo open source che è un miglioramento dell'applicazione Todo.txt e dei suoi cloni. A causa del fatto che la persona media utilizza più dispositivi / piattaforme nel loro programma giornaliero, è fondamentale avere la possibilità di avere un repository centralizzato in cui è possibile accedere e aggiornare i dati da qualsiasi dispositivo. Questo tutorial si concentrerà sull'impostazione sia del server, chiamato TaskServer (taskd), sia del client, chiamato TaskWarrior (task), che consente a più dispositivi client di accedere e scambiare dati in modo sicuro.

Ha le seguenti caratteristiche:

• Compiti illimitati
• Assegnazione delle priorità alle attività
• Filtro di ricerca
• Tagging
• Sincronizzazione automatica
• Backup automatico
• Pieno controllo e privacy
• Comunicazione criptata

Prerequisiti

• Un'istanza del server CentOS 7 x64.
• Un utente sudo .
• Nome dominio puntato a un'istanza Vultr (taskd.example.com)

Passaggio 1: aggiornare il sistema

Accedi come utente sudo per installare il repository EPEL e aggiornare il sistema come segue:

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

Passaggio 2: installare RPM Build e strumenti per la creazione

Il repository EPEL non contiene un RPM per TaskServer (taskd), quindi dobbiamo costruirlo da noi stessi in un pacchetto RPM.

1. Installa GCC, Make, RPM Build, strumenti di sviluppo e firma.

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

2. Crea una directory GnuPG che conterrà i file GPG necessari per firmare il nostro RPM.

   mkdir .gnupg
   

3. Quando creiamo una chiave, abbiamo bisogno dell'entropia nel sistema per randomizzarla correttamente. Il rngddemone genera l'entropia necessaria da /dev/urandom. Quindi installiamolo ora.

   yum install rngd -y
   

4. Avvia il rngddemone per generare entropia. L' opzione -r punta /dev/urandominvece al valore predefinito /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Genera una chiave. L' opzione --gen-key dice a gpg di generare una nuova coppia di chiavi.

   gpg --gen-key
   

6. Per l' opzione " Seleziona il tipo di chiave che desideri: ", seleziona " (1) RSA e RSA (impostazione predefinita) " per il tipo di chiave immettendo 1 e premendo il tasto Invio / Invio .

7. Per l' opzione " Quale dimensione del tasto vuoi? (2048) ", scegli il valore predefinito premendo il tasto Invio / Invio .

8. Per l' opzione " Specifica per quanto tempo deve essere valida la chiave. ", Seleziona l'impostazione predefinita premendo il tasto Invio / Invio .

9. Per l' opzione " È corretto? (Y / N) ", immettere y e premere il tasto Invio / Invio .

10. In " Nome reale: ", inserisci un nome a tua scelta e premi il tasto Invio / Invio .

11. In " Indirizzo email: ", inserisci un indirizzo email di tua scelta e premi il tasto Invio / Invio .

12. La sezione Commento: può essere lasciata vuota se lo desideri.

13. Apporta le modifiche necessarie se non hai inserito correttamente le tue informazioni. Se sei soddisfatto delle informazioni sull'ID UTENTE visualizzate, inserisci O (lettera maiuscola O, non zero) e premi il tasto Invio / Invio .

14. GnuPG ora ti chiederà di creare e verificare una password per la tua coppia di chiavi.

15. Dopo aver inserito le password, la coppia di chiavi GnuPG verrà creata nella .gnupgdirectory nella directory dell'utente.

16. Esegui questo comando per visualizzare il contenuto della .gnupgdirectory. Esso dovrebbe contenere le seguenti directory private-keys-v1.de file pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Esporta la coppia di chiavi creata. L' opzione --export indica a GnuPG di esportare la coppia di chiavi. L' opzione -a indica a GnuPG di produrre la coppia di chiavi in formato armatura ASCII . Sostituisci " Joe Q. Pubblico " con il nome che hai inserito durante la creazione della coppia di chiavi nel passaggio # 10 sopra. Sostituisci " jqpublic " con qualsiasi testo tu scelga.

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

18. Importa la coppia di chiavi nel keystore RPM. Sostituisci " jqpublic " con il testo che hai scelto nel passaggio 17.

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

19. Verificare che la coppia di chiavi sia stata aggiunta al keystore RPM. L' opzione --q gpg-pubkey richiede il keystore GnuPG di RPM. Il % {nome} -% {version} - {% rilascio} -> {% sintesi} \ n visualizza il risultato in un formato leggibile.

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

20. Creando un .rpmmacros fileRPM può essere personalizzato per eseguire comportamenti assegnati (esempio: facilitare la firma automatica degli RPM). Utilizzare il nanoprogramma per creare il file.

    nano .rpmmacros
    

21. Quindi, aggiungi il seguente testo nel .rpmmacrosfile.

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

22. Salvare il documento inserendo le seguenti combinazioni di tastiera. Le CTRL + X Keys. Quindi, il tasto S. Infine, il tasto Invio / Invio .

23. Questo comando di seguito imposterà il tuo ambiente di build RPM. Ciò aggiungerà ulteriori macro al .rpmmacrosfile creato nel passaggio 20 e creerà le directory necessarie per creare e archiviare gli RPM.

    rpmdev-setuptree
    

24. Esegui questo comando per visualizzare il contenuto della directory rpmbuild. Dovrebbe contenere le seguenti directory SOURCES , RPMS , BUILD , SRPMS e SPECS .

    find rpmbuild
    

25. Scarica il codice sorgente TaskServer (taskd) nella rpmbuild/SOURCESdirectory.

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

26. Termina il rgndprocesso in esecuzione .

    sudo kill -9 rngd
    

Passaggio 3: compilare RPM TaskServer (taskd) dall'origine

1. Per creare un nuovo RPM dall'origine, è necessario creare un file SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Aggiungi il seguente testo nel taskd.specfile.

   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. L'RPM richiede anche tre file aggiuntivi che devono essere creati nella rpmbuild/SOURCESdirectory. Utilizzare il nanoprogramma per creare il taskd-configfile.

   nano rpmbuild/SOURCES/taskd-config
   

4. Aggiungi il seguente testo nel taskd-configfile.

   # 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. Utilizzare il nanoprogramma per creare il taskd.servicefile.

   nano rpmbuild/SOURCES/taskd.service
   

6. Aggiungi il seguente testo nel taskd.servicefile.

   [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. Utilizzare il nanoprogramma per creare il taskd.xmlfile.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Aggiungi il seguente testo nel taskd.xmlfile.

   <?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. Per creare l'RPM TaskServer (taskd), per la compilazione sono necessari tre pacchetti. Eseguire il comando seguente per installare quei pacchetti.

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

10. Ora è il momento di compilare dal sorgente e creare un RPM per TaskServer (taskd). Esegui i comandi seguenti per iniziare. Per creare gli RPM dovrebbe essere necessario meno di un minuto su un'istanza Vultr della CPU 1x. Immettere la password GnuPG creata nel passaggio n. 14 per firmare l'RPM quando richiesto.

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

11. Installare l'RPM TaskServer (taskd).

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

Passaggio 4: Configura TaskServer (attività)

1. Per consentire a TaskServer (taskd) di comunicare e sincronizzarsi con i client TaskWarrior (task), sarà necessario utilizzare gli script di generazione presenti in /etc/pki/taskd/per generare certificati / chiavi server e client. Elevare all'utente root utilizzando il comando seguente e cambiare directory in /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Utilizzare il nanoprogramma per creare un varsfile per generare una CA principale autofirmata.

   nano vars
   

   Aggiungi il testo seguente nel file Vars. Cambia ORGANIZZAZIONE , CN , PAESE , STATO e LOCALITÀ in modo soddisfacente.

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

3. Generare la CA principale autofirmata, il certificato, la chiave del server e l'elenco di revoche del server (facoltativo).

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

   Questi comandi creare i seguenti file ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.peme server.crl.pem) all'interno /etc/pki/taskd/della directory. Per avviare TaskServer (taskd), è necessario modificare la proprietà e le autorizzazioni per i certificati e le chiavi generati nel passaggio # 37 per consentire a TaskServer (taskd) di accedervi. Esegui i comandi seguenti per modificarli.

   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. Abilitare e avviare il demone TaskServer (taskd).

   systemctl enable taskd
   systemctl start taskd
   

5. Aprire la porta su cui è in esecuzione TaskServer (taskd) del firewall.

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

   TaskServer (taskd) è ora installato e configurato sull'istanza di CentOS 7.

Passaggio 5: configurare il certificato e la chiave del client TaskWarrior

1. È necessario creare certificati client e chiave per crittografare le comunicazioni tra TaskServer (taskd) e TaskWarrior (attività). Eseguire il comando seguente per generare un certificato client e una chiave. Sostituisci NAMEcon un nome che puoi riconoscere facilmente per il tuo cliente.

   generate.client NAME
   

   Questo comando creerà i seguenti file ( NAME.cert.pem, NAME.key.pem) all'interno della /etc/pki/taskd/directory.

2. Copia i seguenti file nella tua directory utente, modifica la proprietà e le autorizzazioni. Sostituisci joeqpublic di seguito con la tua directory utente attuale.

   cp ca.cert.pem NAME.cert.pem NAME.key.pem /home/joeqpublic/
   chown joeqpublic.joeqpublic /home/joeqpublic/*.pem
   chmod 400 /home/joeqpublic/*.pem
   

3. Creare un archivio zip di certificati e chiave.

   zip certficates.zip ca.cert.pem NAME.cert.pem NAME.key.pem
   

4. Utilizzare scp(riga di comando) o WinSCP (frontend GUI per SCP) per scaricare il certificates.zipfile dall'istanza CentOS sul dispositivo client (computer / laptop / smartphone).

5. Rilascia i privilegi di root ed esegui il resto dei tuoi comandi come utente normale.

   exit
   

   TaskServer (taskd) è ora configurato e pronto per la connessione dei client TaskWarrior (task).

Passaggio 6: crea il tuo primo gruppo e utente TaskWarrior

1. Per creare, eliminare, modificare e sincronizzare le attività, è necessario un account utente. Tuttavia, prima di poter aggiungere utenti, dovrai prima creare un gruppo organizzativo. Esegui il comando seguente per creare il tuo primo gruppo. Sostituisci GROUP con un nome facilmente riconoscibile.

2. IMPORTANTE! Il taskdcomando per creare gruppi / utenti deve essere eseguito come taskdutente. L'esecuzione come utente root creerà directory e file di proprietà dell'utente root in base ai /var/lib/taskd/orgsquali impedirà ai client TaskWarrior (attività) di accedere o modificare qualsiasi cosa nel gruppo a cui sono stati assegnati. L'accesso sarà negato.

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

3. Ora che hai creato il tuo primo gruppo, creiamo il tuo primo utente. Eseguire il comando seguente per creare un utente assegnato al gruppo creato nel passaggio n. 1. Copia e incolla la chiave utente, l'utente e il gruppo generati in un file di testo. Ripeti la procedura per aggiungere altri utenti.

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

Passaggio 7: installare i client TaskWarrior

Windows 10 (versione successiva a 1607+)

Per utilizzare TaskWarrior (attività) su Windows 10, è necessario installare il sottosistema Windows per Linux da Windows Store.

1. Per installare WSL, è richiesto un prompt Powershell elevato. Premi il tasto Finestra e digita powershell . Fare clic destro su Windows Powershell nella parte superiore dei risultati e selezionare " Esegui come amministratore ". Alla richiesta Controllo account utente, fare clic su Sì . Copia e incolla il testo che trovi di seguito nelle finestre di Powershell. Al termine dell'installazione di WSL, premere il tasto Y per riavviare Windows.

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

2. Dopo il riavvio, aprire un prompt dei comandi e digitare il seguente comando bash . Questo installerà Ubuntu su Windows. Premere il tasto Y . Ora verrà scaricato ed estratto. Scegli un nome utente e una password.

   bash
   

3. Ora è il momento di installare TaskWarrior (attività). Digita il seguente comando all'interno della console.

   sudo apt-get install task -y
   

4. Digitare exit due volte per uscire dal terminale bash e dal prompt dei comandi di Windows.

5. Fai clic sul pulsante del menu Start. Digita Ubuntu . Fare clic destro su Bash su Ubuntu su Windows . Seleziona Aggiungi alla barra delle applicazioni . Ciò fornisce la comodità di accedere rapidamente a bash per accedere a TaskWarrior (attività).

6. Fai clic sull'icona di Ubuntu che hai appena creato sulla barra delle applicazioni. Questo aprirà una finestra terminale che esegue Bash. Digitare il comando seguente per creare la directory dei dati TaskWarrior (task) ( ~/.task/) e il file di configurazione ( .taskrc).

   task version
   yes
   

7. È necessario spostare il certificates.zipfile salvato in precedenza durante l'installazione di TaskServer nella ~/.taskd/directory all'interno della directory dell'utente. Per estrarre i file dal file zip, installare unzipprima il programma. Copia e incolla i seguenti comandi di seguito sostituendo la posizione effettiva della tua copia di certificates.zip.

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

8. Digitare i comandi seguenti per impostare TaskWarrior (attività) su per connettersi con TaskServer (taskd). Sostituisci NAME con ciò che hai nominato il tuo certificato e la tua chiave, GROUP con il gruppo che hai creato, Joe Q. Public con il nome utente che hai creato e XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX con la chiave assegnata quando il tuo utente è stato creato sul server TaskWarrior (taskd).

   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. Ora è il momento di sincronizzare TaskWarrior (task) con TaskServer (taskd). Eseguire il comando seguente per inizializzare il database.

   task sync init
   

   La sincronizzazione tra il client TaskWarrior (task) e TaskServer (taskd) è ora configurata sulla piattaforma Windows 10.

androide

Per utilizzare TaskWarrior (attività) su Android, è necessario installare TaskWarrior per Android dal Google Play Store.

1. Installa TaskWarrior (attività) per l'app Android sul Play Store di Google.

2. Apri TaskWarrior (attività) per l'app Android.

3. L'app ti chiederà di creare un account con un nome account desiderato . Inserisci il nome che hai scelto quando hai creato un nome utente per un utente TaskServer (taskd).

4. Lascia la cartella dei dati all'impostazione predefinita di << Crea nuovo >> e tocca il pulsante OK . Utilizzare un'app di gestione file per creare una cartella nella radice di archiviazione (ad esempio:) /storage/emulate/0/Certs. Invia l'app in background.

5. Copia il certificates.zipfile che hai creato in precedenza ed estrai il suo contenuto nella directory creata nel passaggio 4.

6. Metti in primo piano l'app "TaskWarrior (attività) per Android" e tocca il menu nell'angolo in alto a sinistra dell'app per aprirla.

7. Scorri verso il basso fino alla fine del menu e tocca l' opzione Impostazioni .

8. Questo aprirà un semplice editor di testo app TaskWarrior per Android integrato.

9. Immettere le seguenti opzioni per configurare la sincronizzazione con TaskServer (taskd). Sostituisci le variabili taskd.ca/ taskd.certificate/ taskd.key` con i percorsi effettivi della directory ca / ​​certificate / key, NAME con ciò che hai nominato il certificato e la chiave, GROUP con il gruppo che hai creato, Joe Q. Public con il nome utente che hai creato e XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX con la chiave assegnata durante la creazione dell'utente sul server TaskWarrior (taskd).

   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. Tocca l'icona del dischetto per salvare le tue impostazioni.

La sincronizzazione tra il client TaskWarrior (task) e TaskServer (taskd) è ora configurata sulla piattaforma Android.

Linux

1. Fare riferimento alla sezione di distribuzione TaskWarrior (attività) da installare per la propria particolare distribuzione Linux .

2. Apri una finestra del terminale. Digitare il comando seguente per creare la directory dei dati TaskWarrior (task) ( ~/.task/) e il file di configurazione ( .taskrc).

   task version
   yes
   

3. È necessario spostare il certificates.zipfile salvato in precedenza nell'impostazione TaskServer nella ~/.taskd/directory all'interno della directory dell'utente. Per estrarre i file dal file zip, installa unzipprima il programma per la tua particolare distribuzione. Copia e incolla i seguenti comandi di seguito, sostituendo la posizione effettiva della tua copia di certificates.zip.

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

4. Digitare i comandi seguenti per impostare TaskWarrior (attività) su per connettersi con TaskServer (taskd). Sostituisci NAME con ciò che hai nominato il tuo certificato e la tua chiave, GROUP con il gruppo che hai creato, Joe Q. Public con il nome utente che hai creato e XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX con la chiave assegnata quando il tuo utente è stato creato sul server TaskWarrior (taskd).

   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. Ora è il momento di sincronizzare TaskWarrior (task) con TaskServer (taskd). Eseguire il comando seguente per inizializzare il database.

   task sync init
   

Addendum: se esegui Gnome Shell, c'è un'estensione chiamata TaskWhisper che si integra con TaskWarrior (attività).

La sincronizzazione tra il client TaskWarrior (task) e TaskServer (taskd) è ora configurata sulla tua distribuzione Linux preferita.