Instalați TaskServer (taskd) pe CentOS 7

TaskWarrior este un instrument de gestionare a timpului open source care este o îmbunătățire a aplicației Todo.txt și a clonelor sale. Datorită faptului că persoana obișnuită folosește mai multe dispozitive / platforme în programul său zilnic, este esențial să aibă capacitatea de a avea un depozit centralizat unde datele pot fi accesate și actualizate de pe orice dispozitiv. Acest tutorial se va concentra pe configurarea atât a serverului, numit TaskServer (taskd), cât și a clientului, numit TaskWarrior (task), permițând mai multor dispozitive client să acceseze și să schimbe datele în siguranță.

Are următoarele caracteristici:

• Sarcini nelimitate
• Prioritizarea sarcinii
• Filtrare de căutare
• tagging
• Sincronizare automată
• Copie de rezervă automată
• Control deplin și confidențialitate
• Comunicare criptată

Cerințe preliminare

• O instanță de server CentOS 7 x64.
• Un utilizator sudo .
• Numele de domeniu a indicat o instanță Vultr (taskd.example.com)

Pasul 1: Actualizați sistemul

Conectați-vă ca utilizator sudo pentru a instala Depozitul EPEL și actualizați sistemul astfel:

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

Pasul 2: Instalați RPM Build și instrumente pentru construcție

Depozitul EPEL nu conține un RPM pentru TaskServer (taskd), de aceea trebuie să-l construim din sursă într-un pachet RPM.

1. Instalați instrumente GCC, Make, RPM Build, dezvoltare și semnare.

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

2. Creați un director GnuPG care va conține fișierele GPG necesare pentru semnarea RPM-ului nostru.

   mkdir .gnupg
   

3. Când creăm o cheie, avem nevoie de entropie în sistem pentru a o randomiza corect. rngdGenerează entropia necesară din daemonul /dev/urandom. Deci, hai să instalăm asta acum.

   yum install rngd -y
   

4. Porniți rngddemonul pentru a genera entropie. Opțiunea -r punctează în /dev/urandomloc de cea implicită /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Generați o cheie. Opțiunea --gen-cheie spune gpg să genereze o nouă pereche de chei.

   gpg --gen-key
   

6. Pentru opțiunea „ Vă rugăm să selectați ce tip de cheie doriți: „ opțiune, selectați „ (1) RSA și RSA (implicit) ” pentru tipul de cheie, introducând 1 și apăsând tasta Return / Enter .

7. Pentru opțiunea „ Ce tastatură doriți? (2048) ”, alegeți valoarea implicită apăsând tasta Return / Enter .

8. Pentru opțiunea „ Vă rugăm să specificați cât timp trebuie să fie valabilă cheia. ”, Alegeți valoarea implicită apăsând tasta Return / Enter .

9. Pentru opțiunea „ Este corectă (y / N) ”, introduceți y și apăsați tasta Return / Enter .

10. În „ Numele real: ”, introduceți un nume ales și apăsați tasta Returnare / Introducere .

11. În „ Adresa de e-mail: ”, introduceți o adresă de e-mail la alegere și apăsați tasta Returnare / Introducere .

12. Secțiunea Comentariu: poate fi lăsată goală dacă alegeți acest lucru.

13. Faceți modificările necesare dacă nu ați introdus corect informațiile. Dacă sunteți mulțumit de informațiile US-ID afișate, introduceți O (majusculă O, nu zero) și apăsați tasta Return / Enter .

14. GnuPG vă va solicita acum să creați și să verificați o parolă pentru perechea de chei.

15. După ce ați introdus parolele, perechea dvs. de chei GnuPG va fi creată în .gnupgdirectorul din directorul dvs. de utilizator.

16. Rulați această comandă pentru a afișa conținutul .gnupgdirectorului. Acesta ar trebui să conțină următorul director private-keys-v1.dși fișiere pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exportați perechea de chei creată. Opțiunea --export recomandă GnuPG să exporte perechea de chei. Opțiunea -a indică GnuPG să emită perechea de chei în format de armură ascii . Înlocuiți „ Joe Q. Public ” cu numele introdus la crearea perechii de chei la pasul 10 de mai sus. Înlocuiți „ jqpublic ” cu orice text alegeți.

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

18. Importați perechea de chei în magazinul de taste RPM. Înlocuiți „ jqpublic ” cu textul ales de dvs. la pasul # 17.

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

19. Verificați dacă perechea de chei a fost adăugată la magazinul de taste RPM. Opțiunea --q gpg-pubkey interogă magazinul de chei RPM GnuPG. % {Name} - {%} versiune -% {eliberare} -> {% rezumat} \ n afișează rezultatul într - un format care poate fi citit uman.

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

20. Prin crearea unui .rpmmacros file, RPM poate fi personalizat pentru a efectua comportamente alocate (exemplu: ușor semnarea automată a RPM). Utilizați nanoprogramul pentru a crea fișierul.

    nano .rpmmacros
    

21. Apoi, adăugați următorul text în .rpmmacrosfișier.

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

22. Salvați documentul introducând următoarele combinații de tastaturi. La CTRL + X Keys. Apoi, cheia S. În cele din urmă, tasta Return / Enter .

23. Această comandă de mai jos vă va configura mediul de construire RPM. Aceasta va adăuga macrocomenzi suplimentare la .rpmmacrosfișierul pe care l-ați creat la pasul # 20 și va crea directoarele necesare pentru a construi și stoca RPM.

    rpmdev-setuptree
    

24. Rulați această comandă pentru a afișa conținutul directorului rpmbuild. Acesta trebuie să conțină următoarele directoare SURSE , RPMS , BUILD , SRPMS și SPECS .

    find rpmbuild
    

25. Descărcați codul sursă TaskServer (taskd) din rpmbuild/SOURCESdirector.

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

26. Ucideți rgndprocesul de rulare .

    sudo kill -9 rngd
    

Pasul 3: Construiți RPM TaskServer (taskd) din sursă

1. Pentru a construi un nou RPM de la sursă, trebuie creat un fișier SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Adăugați următorul text în taskd.specfișier.

   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. De asemenea, RPM necesită trei fișiere suplimentare care trebuie create în rpmbuild/SOURCESdirector. Utilizați nanoprogramul pentru a crea taskd-configfișierul.

   nano rpmbuild/SOURCES/taskd-config
   

4. Adăugați următorul text în taskd-configfișier.

   # 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. Utilizați nanoprogramul pentru a crea taskd.servicefișierul.

   nano rpmbuild/SOURCES/taskd.service
   

6. Adăugați următorul text în taskd.servicefișier.

   [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. Utilizați nanoprogramul pentru a crea taskd.xmlfișierul.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Adăugați următorul text în taskd.xmlfișier.

   <?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. Pentru a construi TPMServer (taskd) RPM, sunt necesare trei pachete pentru construire. Rulați comanda de mai jos pentru a instala acele pachete.

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

10. Acum este timpul să construiți din sursă și să creați un RPM pentru TaskServer (taskd). Rulați comenzile de mai jos pentru a începe. Pentru a construi RPM ar trebui să dureze mai puțin de un minut pe o instanță 1x CPU Vultr. Introduceți parola GnuPG pe care ați creat-o la pasul 14 pentru a semna RPM când vi se solicită.

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

11. Instalați RPM TaskServer (taskd).

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

Pasul 4: Configurare TaskServer (sarcină)

1. Pentru ca TaskServer (taskd) să comunice și să sincronizeze cu clienții TaskWarrior (task), va trebui să utilizați scripturile de generare găsite în secțiunea /etc/pki/taskd/pentru a genera certificate și chei de server și de client. Elevate pentru utilizatorul root folosind comanda de mai jos și schimbați directorul /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Utilizați nanoprogramul pentru a crea un varsfișier pentru a genera o Root CA semnată cu sine.

   nano vars
   

   Adăugați următorul text de mai jos în fișierul vars. Schimbați ORGANIZAȚIA , CN , ȚARA , STATUL și LOCALITATEA, pentru a vă satisface.

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

3. Generați CA-ul rămas semnat, certificat, cheie de server și listă de revocare a serverului (opțional).

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

   Aceste comenzi vor crea următoarele fișiere ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemși server.crl.pem) în interiorul /etc/pki/taskd/directorului. Pentru ca TaskServer (taskd) să înceapă, proprietatea și permisiunile de pe certificatele și cheile generate la pasul # 37 trebuie modificate pentru a permite TaskServer (taskd) să le acceseze. Rulați comenzile de mai jos pentru a le schimba.

   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. Activați și porniți demonul TaskServer (taskd).

   systemctl enable taskd
   systemctl start taskd
   

5. Deschideți portul în firewall-ul TaskServer (taskd) rulează.

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

   TaskServer (taskd) este acum instalat și instalat pe instanța dvs. CentOS 7.

Pasul 5: Configurați certificatul și cheia de client TaskWarrior

1. Trebuie să creați certificate de client și cheie pentru criptarea comunicațiilor între TaskServer (taskd) și TaskWarrior (task). Rulați comanda de mai jos pentru a genera un certificat de client și o cheie. Înlocuiți NAMEcu un nume pe care îl puteți recunoaște cu ușurință pentru clientul dvs.

   generate.client NAME
   

   Această comandă va crea următoarele fișiere ( NAME.cert.pem, NAME.key.pem) în interiorul /etc/pki/taskd/directorului.

2. Copiați următoarele fișiere în directorul dvs. de utilizator, modificați proprietatea și permisiunile. Înlocuiți joeqpublic mai jos cu directorul dvs. de utilizator real.

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

3. Creați o arhivă zip a certificatelor și a cheii.

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

4. Utilizați scp(linia de comandă) sau WinSCP (interfață GUI pentru SCP) pentru a descărca certificates.zipfișierul din instanța CentOS pe dispozitivul client (computer / laptop / smartphone).

5. Renunță la privilegiile root și execută restul comenzilor tale ca utilizator obișnuit.

   exit
   

   TaskServer (taskd) este acum configurat și gata pentru conectarea clienților TaskWarrior (task).

Pasul 6: Creați primul grup și utilizator TaskWarrior

1. Pentru a vă crea, șterge, modifica și sincroniza activitățile, veți avea nevoie de un cont de utilizator. Cu toate acestea, înainte de a putea adăuga utilizatori, va trebui mai întâi să creați un grup organizațional. Rulați comanda de mai jos pentru a crea primul grup. Înlocuiți GROUP cu un nume ușor de recunoscut.

2. IMPORTANT! taskdComandă pentru a crea grupuri / utilizatorii trebuie să fie RAN ca taskdutilizatorul. Rularea ca utilizator rădăcină va crea directoare și fișiere deținute de utilizatorul root sub /var/lib/taskd/orgscare va împiedica clienții TaskWarrior (sarcină) să poată accesa sau modifica orice lucru din grupul căruia i-au fost alocați. Accesul va fi refuzat.

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

3. Acum, că ai creat primul tău grup, hai să-ți creăm primul utilizator. Rulați comanda de mai jos pentru a crea un utilizator alocat grupului creat la pasul 1. Copiați și inserați cheia de utilizator, utilizator și grup generat într-un fișier text. Repetați procesul pentru a adăuga utilizatori suplimentari.

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

Pasul 7: Instalați clienții TaskWarrior

Windows 10 (Construiți mai târziu de 1607+)

Pentru a utiliza TaskWarrior (sarcină) pe Windows 10, trebuie să instalați Windows Subsystem For Linux din Windows Store.

1. Pentru a instala WSL, este necesar un prompt Powershell ridicat. Apăsați tasta Window și tastați powerhell . Faceți clic dreapta pe Windows Powershell în partea de sus a rezultatelor și selectați „ Rulați ca administrator ”. La promptul de control al contului de utilizator, faceți clic pe Da . Copiați și lipiți textul găsit mai jos în ferestrele Powershell. Când WSL termină instalarea, apăsați tasta Y pentru a reporni Windows.

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

2. După repornire, deschideți un prompt de comandă și introduceți următoarea comandă bash . Aceasta va instala Ubuntu pe Windows. Apăsați tasta Y . Acum va fi descărcat și extras. Alegeți un nume de utilizator și o parolă.

   bash
   

3. Acum este timpul să instalați TaskWarrior (sarcină). Introduceți următoarea comandă în consolă.

   sudo apt-get install task -y
   

4. Tastați ieșire de două ori pentru a ieși din terminalul bash și promptul de comandă Windows.

5. Faceți clic pe butonul Start Menu. Tastați ubuntu . Faceți clic dreapta pe Bash pe Ubuntu pe Windows . Selectați Pin în bara de activități . Aceasta oferă comoditate pentru a accesa rapid bashul pentru a accesa TaskWarrior (sarcină).

6. Faceți clic pe pictograma Ubuntu pe care tocmai ați creat-o în bara de activități. Aceasta va deschide o fereastră de terminal care rulează Bash. Introduceți următoarea comandă de mai jos pentru a crea directorul de date TaskWarrior (sarcină ~/.task/) și fișierul de configurare ( .taskrc).

   task version
   yes
   

7. Trebuie să mutați certificates.zipfișierul pe care l-ați salvat mai devreme în timpul instalării TaskServer în ~/.taskd/directorul din interiorul directorului dvs. de utilizator. Pentru a extrage fișierele din fișierul zip, instalați mai unzipîntâi programul. Copiați și inserați următoarele comenzi de mai jos înlocuind locația actuală a copia dvs. de certificates.zip.

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

8. Tastați următoarele comenzi pentru a seta TaskWarrior (sarcină) pentru a vă conecta la TaskServer (taskd). Înlocuiți NAME cu ceea ce ați numit certificatul și cheia dvs., GROUP cu grupul pe care l-ați creat, Joe Q. Public cu numele de utilizator pe care l-ați creat și XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX cu cheia atribuită când utilizatorul dvs. a fost creat pe serverul 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. Acum este timpul să sincronizăm TaskWarrior (task) cu TaskServer (taskd). Rulați comanda de mai jos pentru a inițializa baza de date.

   task sync init
   

   Sincronizarea între clientul TaskWarrior (task) și TaskServer (taskd) este acum configurată pe platforma Windows 10.

Android

Pentru a utiliza TaskWarrior (sarcină) pe Android, trebuie să instalați TaskWarrior For Android din Magazinul Google Play.

1. Instalați aplicația TaskWarrior (task) pentru Android pe Google Play Store.

2. Deschideți aplicația TaskWarrior (sarcină) pentru Android.

3. Aplicația vi se va solicita să vă creeze un cont cu un nume de cont dorit . Introduceți numele pe care l-ați ales când ați creat un nume de utilizator pentru un utilizator TaskServer (taskd).

4. Lăsați folderul de date la setarea implicită din << Creare nouă >> și atingeți butonul OK . Utilizați o aplicație manager de fișiere pentru a crea un folder în rădăcina de stocare (de exemplu /storage/emulate/0/Certs:). Trimiteți aplicația în fundal.

5. Copiați certificates.zipfișierul pe care l-ați creat anterior și extrageți conținutul acestuia în directorul creat în pasul 4.

6. Puneți în prim-plan aplicația „TaskWarrior (task) For Android” și atingeți meniul din colțul din stânga sus al aplicației pentru ao deschide.

7. Derulați în jos în partea de jos a meniului și atingeți opțiunea Setări .

8. Aceasta va deschide un simplu editor de text pentru aplicații TaskWarrior For Android.

9. Introduceți următoarele opțiuni pentru a configura sincronizarea cu TaskServer (taskd). Înlocuiți variabilele taskd.ca/ taskd.certificate/ taskd.key` cu calea / căile directoare ca / ​​certificat / cheie, NUME cu ceea ce ați numit certificatul și cheia dvs., GRUP cu grupul pe care l-ați creat, Joe Q. Public cu numele de utilizator pe care l-ați creat și XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX cu cheia atribuită la crearea utilizatorului pe serverul 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. Atingeți pictograma de dischetă pentru a salva setările.

Sincronizarea între clientul TaskWarrior (task) și TaskServer (taskd) este acum configurată pe platforma Android.

Linux

1. Consultați secțiunea de distribuție TaskWarrior (task) pentru a instala pentru distribuția dvs. Linux specifică .

2. Deschideți o fereastră de terminal. Introduceți următoarea comandă de mai jos pentru a crea directorul de date TaskWarrior (sarcină ~/.task/) și fișierul de configurare ( .taskrc).

   task version
   yes
   

3. Trebuie să mutați certificates.zipfișierul pe care l-ați salvat mai devreme în configurarea TaskServer în ~/.taskd/directorul din directorul dvs. de utilizator. Pentru a extrage fișierele din fișierul zip, instalați mai unzipîntâi programul pentru distribuția dvs. particulară. Copiați și lipiți următoarele comenzi de mai jos, înlocuind locația actuală a copia dvs. de certificates.zip.

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

4. Tastați următoarele comenzi pentru a seta TaskWarrior (sarcină) pentru a vă conecta la TaskServer (taskd). Înlocuiți NAME cu ceea ce ați numit certificatul și cheia dvs., GROUP cu grupul pe care l-ați creat, Joe Q. Public cu numele de utilizator pe care l-ați creat și XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX cu cheia atribuită când utilizatorul dvs. a fost creat pe serverul 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. Acum este timpul să sincronizăm TaskWarrior (task) cu TaskServer (taskd). Rulați comanda de mai jos pentru a inițializa baza de date.

   task sync init
   

Addendum: Dacă executați Gnome Shell, există o extensie numită TaskWhisper care se integrează cu TaskWarrior (sarcină).

Sincronizarea între clientul TaskWarrior (task) și TaskServer (taskd) este acum configurată pe distro Linux-ul tău preferat.