Zainstaluj TaskServer (taskd) na CentOS 7

TaskWarrior to narzędzie do zarządzania czasem typu open source, które stanowi ulepszenie aplikacji Todo.txt i jej klonów. Ze względu na fakt, że przeciętny człowiek korzysta z wielu urządzeń / platform w swoim codziennym harmonogramie, niezwykle ważne jest posiadanie scentralizowanego repozytorium, w którym można uzyskać dostęp i aktualizować dane z dowolnego urządzenia. W tym samouczku skoncentrujemy się na skonfigurowaniu zarówno serwera o nazwie TaskServer (taskd), jak i klienta o nazwie TaskWarrior (zadanie), umożliwiającego wielu urządzeniom klienckim bezpieczny dostęp i wymianę danych.

Ma następujące funkcje:

• Nieograniczone zadania
• Priorytetyzacja zadań
• Filtrowanie wyszukiwania
• Tagowanie
• Automatyczna synchronizacja
• Automatyczne tworzenie kopii zapasowych
• Pełna kontrola i prywatność
• Szyfrowana komunikacja

Wymagania wstępne

• Instancja serwera CentOS 7 x64.
• Użytkownik sudo .
• Nazwa domeny wskazywała na instancję Vultr (taskd.example.com)

Krok 1: Zaktualizuj system

Zaloguj się jako użytkownik sudo, aby zainstalować repozytorium EPEL i zaktualizuj system w następujący sposób:

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

Krok 2: Zainstaluj RPM Build i narzędzia do budowania

Repozytorium EPEL nie zawiera RPM dla TaskServer (taskd), więc sami musimy zbudować go ze źródła do pakietu RPM.

1. Zainstaluj narzędzia GCC, Make, RPM Build, narzędzia do programowania i podpisywania.

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

2. Utwórz katalog GnuPG, w którym będą przechowywane pliki GPG niezbędne do podpisania naszego RPM.

   mkdir .gnupg
   

3. Podczas tworzenia klucza potrzebujemy entropii w systemie, aby poprawnie go losowo losować. rngdDemon generuje entropia niezbędne z /dev/urandom. Zainstalujmy to teraz.

   yum install rngd -y
   

4. Uruchom rngddemona, aby wygenerować entropię. Opcja -r wskazuje na /dev/urandomzamiast domyślnej /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Wygeneruj klucz. Opcja --gen-key każe gpg wygenerować nową parę kluczy.

   gpg --gen-key
   

6. Aby wybrać opcję „ Wybierz typ klucza: ” wybierz „ (1) RSA i RSA (domyślnie) ” jako typ klucza, wprowadzając 1 i naciskając klawisz Return / Enter .

7. W przypadku opcji „ Jaki rozmiar klucza chcesz? (2048) ” wybierz domyślną, naciskając klawisz Return / Enter .

8. W przypadku opcji „ Określ, jak długo klucz powinien być ważny. ”, Wybierz wartość domyślną, naciskając klawisz Return / Enter .

9. W przypadku opcji „ Czy to jest poprawne? (T / N) ” wpisz y i naciśnij klawisz Return / Enter .

10. W obszarze „ Prawdziwe imię: ” wprowadź wybraną nazwę i naciśnij klawisz Return / Enter .

11. W obszarze „ Adres e-mail: ” wprowadź wybrany adres e-mail i naciśnij klawisz Return / Enter .

12. Komentarz: sekcja może być pusta, jeśli tak zdecydujesz.

13. Wprowadź niezbędne zmiany, jeśli nie wprowadziłeś poprawnie swoich informacji. Jeśli jesteś zadowolony z wyświetlonej informacji o ID UŻYTKOWNIKA , wpisz O (duża litera O, a nie zero) i naciśnij klawisz Return / Enter .

14. GnuPG wyświetli teraz monit o utworzenie i zweryfikowanie hasła dla pary kluczy.

15. Po wprowadzeniu hasła twoja para kluczy GnuPG zostanie utworzona w .gnupgkatalogu w katalogu użytkownika.

16. Uruchom to polecenie, aby wyświetlić zawartość .gnupgkatalogu. Powinien on zawierać następujące katalogu private-keys-v1.di plików pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Wyeksportuj utworzoną parę kluczy. Opcja --export instruuje GnuPG, aby wyeksportował parę kluczy. Opcja -a instruuje GnuPG, aby wyprowadził parę kluczy w formacie zbroi ascii . Zamień „ Joe Q. Public ” na nazwę podaną podczas tworzenia pary kluczy w kroku nr 10 powyżej. Zamień „ jqpublic ” na dowolny wybrany tekst.

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

18. Zaimportuj parę kluczy do magazynu kluczy RPM. Zamień „ jqpublic ” na tekst wybrany w kroku # 17.

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

19. Sprawdź, czy para kluczy została dodana do magazynu kluczy RPM. Opcja --q gpg-pubkey wysyła zapytanie do magazynu kluczy RPM GnuPG. % {Name} -% {version} -% {release} ->% {Podsumowanie} \ n wyświetla wynik w czytelnej formie.

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

20. Tworząc .rpmmacros file, RPM można dostosować do wykonywania przypisanych zachowań (na przykład: łatwość automatycznego podpisywania RPM). Użyj nanoprogramu do utworzenia pliku.

    nano .rpmmacros
    

21. Następnie dodaj poniższy tekst do .rpmmacrospliku.

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

22. Zapisz dokument, wprowadzając następujące kombinacje klawiszy. W CTRL + X Keys. Następnie klawisz S. Na koniec klawisz Return / Enter .

23. To polecenie poniżej skonfiguruje środowisko kompilacji RPM. Spowoduje to dodanie dodatkowych makr do .rpmmacrospliku utworzonego w kroku # 20 i utworzenie katalogów wymaganych do zbudowania i przechowywania RPM.

    rpmdev-setuptree
    

24. Uruchom to polecenie, aby wyświetlić zawartość katalogu rpmbuild. Powinien zawierać następujące katalogi SOURCES , RPMS , BUILD , SRPMS i SPECS .

    find rpmbuild
    

25. Pobierz kod źródłowy TaskServer (taskd) do rpmbuild/SOURCESkatalogu.

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

26. Zabij trwający rgndproces.

    sudo kill -9 rngd
    

Krok 3: Zbuduj RPM TaskServer (taskd) ze źródła

1. Aby zbudować nowy RPM ze źródła, należy utworzyć plik SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Dodaj następujący tekst do taskd.specpliku.

   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. RPM wymaga również trzech dodatkowych plików, które należy utworzyć w rpmbuild/SOURCESkatalogu. Użyj nanoprogramu do utworzenia taskd-configpliku.

   nano rpmbuild/SOURCES/taskd-config
   

4. Dodaj następujący tekst do taskd-configpliku.

   # 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. Użyj nanoprogramu do utworzenia taskd.servicepliku.

   nano rpmbuild/SOURCES/taskd.service
   

6. Dodaj następujący tekst do taskd.servicepliku.

   [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. Użyj nanoprogramu do utworzenia taskd.xmlpliku.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Dodaj następujący tekst do taskd.xmlpliku.

   <?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. Aby zbudować RPM TaskServer (taskd), do zbudowania potrzebne są trzy pakiety. Uruchom poniższe polecenie, aby zainstalować te pakiety.

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

10. Teraz nadszedł czas na kompilację ze źródła i utworzenie RPM dla TaskServer (taskd). Uruchom poniższe polecenia, aby rozpocząć. Kompilacja RPM powinna zająć mniej niż minutę na instancji 1x CPU Vultr. Wprowadź hasło GnuPG utworzone w kroku # 14, aby podpisać RPM po wyświetleniu monitu.

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

11. Zainstaluj RPM TaskServer (taskd).

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

Krok 4: Skonfiguruj serwer zadań (zadanie)

1. Aby TaskServer (taskd) komunikował się i synchronizował z klientami TaskWarrior (task), będziesz musiał użyć skryptów generowania znalezionych w /etc/pki/taskd/celu wygenerowania certyfikatów / kluczy serwera i klienta. Podejdź do użytkownika root za pomocą poniższej komendy i zmień katalog na /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Za pomocą nanoprogramu utwórz varsplik, aby wygenerować samopodpisany główny urząd certyfikacji.

   nano vars
   

   Dodaj następujący tekst poniżej do pliku vars. Zmień ORGANIZACJĘ , CN , PAŃSTWO , PAŃSTWO i LOKALNOŚĆ według własnego uznania .

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

3. Wygeneruj samopodpisany główny urząd certyfikacji, certyfikat, klucz serwera i listę odwołania serwera (opcjonalnie).

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

   Polecenia te będą tworzyć następujące pliki ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemi server.crl.pem) wewnątrz /etc/pki/taskd/katalogu. Aby uruchomić TaskServer (taskd), należy zmodyfikować własność i uprawnienia do certyfikatów i kluczy wygenerowanych w kroku # 37, aby umożliwić TaskServer (taskd) dostęp do nich. Uruchom poniższe polecenia, aby je zmienić.

   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. Włącz i uruchom demona TaskServer (taskd).

   systemctl enable taskd
   systemctl start taskd
   

5. Otwórz port w zaporze, na której działa TaskServer (taskd).

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

   TaskServer (taskd) jest teraz zainstalowany i skonfigurowany w twojej instancji CentOS 7.

Krok 5: Skonfiguruj certyfikat i klucz klienta TaskWarrior

1. Należy utworzyć certyfikaty klienta i klucz do szyfrowania komunikacji między TaskServer (taskd) a TaskWarrior (zadanie). Uruchom poniższe polecenie, aby wygenerować certyfikat i klucz klienta. Zamień NAMEna nazwę, którą możesz łatwo rozpoznać dla swojego klienta.

   generate.client NAME
   

   To polecenie utworzy następujące pliki ( NAME.cert.pem, NAME.key.pem) w /etc/pki/taskd/katalogu.

2. Skopiuj następujące pliki do katalogu użytkownika, zmień własność i uprawnienia. Zastąp joeqpublic poniżej faktycznym katalogiem nazw użytkowników.

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

3. Utwórz archiwum zip certyfikatów i klucza.

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

4. Użyj scp(wiersz poleceń) lub WinSCP (nakładka GUI dla SCP), aby pobrać certificates.zipplik z instancji CentOS na urządzenie klienckie (komputer / laptop / smartfon).

5. Porzuć uprawnienia roota i wykonaj resztę poleceń jako zwykły użytkownik.

   exit
   

   TaskServer (taskd) jest teraz skonfigurowany i gotowy do połączenia klientów TaskWarrior (zadania).

Krok 6: Utwórz pierwszą grupę i użytkownika TaskWarrior

1. Aby tworzyć, usuwać, modyfikować i synchronizować zadania, potrzebujesz konta użytkownika. Zanim jednak będziesz mógł dodawać użytkowników, musisz najpierw utworzyć grupę organizacyjną. Uruchom poniższe polecenie, aby utworzyć pierwszą grupę. Zamień GROUP na łatwo rozpoznawalną nazwę.

2. WAŻNY! taskdPolecenia do tworzenia grup / użytkowników muszą być ran jako taskdużytkownik. Uruchomiony jako użytkownik root utworzy katalogi i pliki należące do użytkownika root, w ramach /var/lib/taskd/orgsktórych klienci TaskWarrior (zadania) nie będą mogli uzyskać dostępu ani modyfikować niczego w grupie, do której zostali przypisani. Odmowa dostępu.

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

3. Teraz, gdy masz już pierwszą grupę, utwórzmy pierwszego użytkownika. Uruchom poniższe polecenie, aby utworzyć użytkownika przypisanego do grupy utworzonej w kroku 1. Skopiuj i wklej wygenerowany klucz użytkownika, użytkownika i grupę do pliku tekstowego. Powtórz ten proces, aby dodać kolejnych użytkowników.

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

Krok 7: Zainstaluj klientów TaskWarrior

Windows 10 (kompilacja późniejsza niż 1607+)

Aby użyć TaskWarrior (zadania) w systemie Windows 10, musisz zainstalować podsystem Windows dla systemu Linux ze Sklepu Windows.

1. Aby zainstalować WSL, wymagany jest podniesiony monit Powershell. Naciśnij klawisz Windows i wpisz PowerShell . Kliknij prawym przyciskiem myszy Windows Powershell u góry wyników i wybierz „ Uruchom jako administrator ”. W oknie Kontrola konta użytkownika kliknij przycisk Tak . Skopiuj i wklej tekst znajdujący się poniżej w oknach PowerShell. Po zakończeniu instalacji WSL naciśnij klawisz Y, aby ponownie uruchomić system Windows.

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

2. Po ponownym uruchomieniu komputera, otwórz wiersz polecenia i wpisz następujące polecenia bash . Spowoduje to zainstalowanie Ubuntu w systemie Windows. Naciśnij klawisz Y . Zostanie teraz pobrany i wyodrębniony. Wybierz nazwę użytkownika i hasło.

   bash
   

3. Teraz nadszedł czas, aby zainstalować TaskWarrior (zadanie). Wpisz następujące polecenie w konsoli.

   sudo apt-get install task -y
   

4. Wpisz dwukrotnie exit, aby wyjść z terminala bash i wiersza polecenia systemu Windows.

5. Kliknij przycisk Menu Start. Wpisz ubuntu . Kliknij prawym przyciskiem myszy Bash na Ubuntu w systemie Windows . Wybierz Przypnij do paska zadań . Zapewnia to wygodę szybkiego dostępu do bash, aby uzyskać dostęp do TaskWarrior (zadanie).

6. Kliknij ikonę Ubuntu, którą właśnie utworzyłeś na pasku zadań. Spowoduje to otwarcie okna terminala z uruchomionym Bash. Wpisz następujące polecenie poniżej, aby utworzyć katalog danych TaskWarrior (zadanie) ( ~/.task/) i plik konfiguracyjny ( .taskrc).

   task version
   yes
   

7. Musisz przenieść certificates.zipplik zapisany wcześniej podczas instalacji TaskServer do ~/.taskd/katalogu wewnątrz katalogu użytkownika. Aby wyodrębnić pliki z pliku zip, unzipnajpierw zainstaluj program. Skopiuj i wklej poniższe polecenia zastępując rzeczywistą lokalizację swojej kopii certificates.zip.

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

8. Wpisz następujące polecenia, aby ustawić TaskWarrior (zadanie) tak, aby łączył się z TaskServer (taskd). Zamień NAME na nazwę, którą nazwałeś swój certyfikat i klucz, GROUP na grupę, którą utworzyłeś, Joe Q. Public na nazwę użytkownika, którą utworzyłeś, a XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX na klucz przypisany, gdy użytkownik został utworzony na serwerze 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. Czas zsynchronizować TaskWarrior (zadanie) z TaskServer (taskd). Uruchom poniższe polecenie, aby zainicjować bazę danych.

   task sync init
   

   Synchronizacja między klientem TaskWarrior (zadanie) a TaskServer (taskd) jest teraz konfigurowana na platformie Windows 10.

Android

Aby użyć TaskWarrior (zadania) na Androidzie, musisz zainstalować TaskWarrior na Androida ze sklepu Google Play.

1. Zainstaluj aplikację TaskWarrior (zadanie) na Androida w Google Play Store.

2. Otwórz aplikację TaskWarrior (zadanie) na Androida.

3. Aplikacja wyświetli monit o utworzenie konta z żądaną nazwą konta . Wprowadź nazwę, którą wybrałeś podczas tworzenia nazwy użytkownika dla użytkownika TaskServer (taskd).

4. Pozostaw folder danych z domyślnym ustawieniem << Utwórz nowy >> i dotknij przycisku OK . Użyj aplikacji do zarządzania plikami, aby utworzyć folder w katalogu głównym magazynu (na przykład /storage/emulate/0/Certs:). Wyślij aplikację w tło.

5. Skopiuj certificates.zipwcześniej utworzony plik i wypakuj jego zawartość do katalogu utworzonego w kroku 4.

6. Na pierwszym planie aplikacja „TaskWarrior (zadanie) na Androida” i dotknij menu w lewym górnym rogu aplikacji, aby ją otworzyć.

7. Przewiń w dół do dolnej części menu i dotknij opcji Ustawienia .

8. Otworzy się prosty wbudowany edytor tekstowy aplikacji TaskWarrior dla systemu Android.

9. Wprowadź następujące opcje, aby skonfigurować synchronizację z serwerem zadań (taskd). Zastąp zmienne taskd.ca/ taskd.certificate/ taskd.key` rzeczywistymi ścieżkami katalogu ca / ​​certificate / key, NAME nazwą o nazwie twojego certyfikatu i klucza, GROUP z utworzoną grupą, Joe Q. Public z utworzoną nazwą użytkownika i XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX z kluczem przypisanym podczas tworzenia użytkownika na serwerze 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. Stuknij ikonę dyskietki, aby zapisać ustawienia.

Synchronizacja między klientem TaskWarrior (zadanie) a TaskServer (taskd) jest teraz konfigurowana na platformie Android.

Linux

1. Zapoznaj się z rozdziałem dotyczącym dystrybucji TaskWarrior (zadania), aby zainstalować konkretną dystrybucję systemu Linux .

2. Otwórz okno terminala. Wpisz następujące polecenie poniżej, aby utworzyć katalog danych TaskWarrior (zadanie) ( ~/.task/) i plik konfiguracyjny ( .taskrc).

   task version
   yes
   

3. Musisz przenieść certificates.zipplik zapisany wcześniej w konfiguracji TaskServer do ~/.taskd/katalogu wewnątrz katalogu użytkownika. Aby wyodrębnić pliki z pliku zip, zainstaluj unzipnajpierw program dla określonej dystrybucji. Skopiuj i wklej następujące polecenia poniżej, zastępując rzeczywistą lokalizację swojej kopii certificates.zip.

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

4. Wpisz następujące polecenia, aby ustawić TaskWarrior (zadanie) na połączenie z TaskServer (taskd). Zamień NAME na nazwę, którą nazwałeś swój certyfikat i klucz, GROUP na grupę, którą utworzyłeś, Joe Q. Public na nazwę użytkownika, którą utworzyłeś, a XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX na klucz przypisany, gdy użytkownik został utworzony na serwerze 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. Czas zsynchronizować TaskWarrior (zadanie) z TaskServer (taskd). Uruchom poniższe polecenie, aby zainicjować bazę danych.

   task sync init
   

Dodatek: Jeśli uruchomisz Gnome Shell, istnieje rozszerzenie o nazwie TaskWhisper, które integruje się z TaskWarrior (zadanie).

Synchronizacja między klientem TaskWarrior (zadanie) a TaskServer (taskd) jest teraz skonfigurowana w ulubionej dystrybucji systemu Linux.