Namestite TaskServer (taskd) na CentOS 7

TaskWarrior je odprtokodno orodje za upravljanje časa, ki je izboljšava aplikacije Todo.txt in njenih klonov. Zaradi dejstva, da povprečna oseba v svojem dnevnem urniku uporablja več naprav/platform, je ključnega pomena, da ima možnost centraliziranega skladišča, kjer je mogoče dostopati do podatkov in jih posodabljati iz katere koli naprave. Ta vadnica se bo osredotočila na nastavitev strežnika, imenovanega TaskServer (taskd), in odjemalca, imenovanega TaskWarrior (opravilo), ki omogoča večim odjemalskim napravam varen dostop in izmenjavo podatkov.

Ima naslednje lastnosti:

• Neomejeno število opravil
• Prednostna naloga
• Filtriranje iskanja
• Označevanje
• Samodejna sinhronizacija
• Samodejno varnostno kopiranje
• Popoln nadzor in zasebnost
• Šifrirana komunikacija

Predpogoji

• Primerek strežnika CentOS 7 x64.
• Uporabnik sudo .
• Ime domene kaže na primerek Vultr ( taskd.example.com )

1. korak: Posodobite sistem

Prijavite se kot uporabnik sudo, da namestite EPEL Repository in posodobite sistem na naslednji način:

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

2. korak: Namestite RPM Build in orodja za gradnjo

Repozitorij EPEL ne vsebuje RPM za TaskServer (taskd), zato ga moramo sami zgraditi iz vira v paket RPM.

1. Namestite orodja GCC, Make, RPM Build, razvoj in podpisovanje.

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

2. Ustvarite imenik GnuPG, ki bo vseboval datoteke GPG, potrebne za podpis našega RPM.

   mkdir .gnupg
   

3. Ko ustvarjamo ključ, potrebujemo entropijo v sistemu, da ga pravilno naključno razporedimo. rngdDemon ustvarja entropija potrebno iz /dev/urandom. Torej, namestimo ga zdaj.

   yum install rngd -y
   

4. Zaženite rngddemon za ustvarjanje entropije. Možnost -r kaže na /dev/urandomnamesto na privzeto /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Ustvari ključ. Možnost --gen-key pove gpg, da ustvari nov par ključev.

   gpg --gen-key
   

6. Za možnost " Prosimo, izberite vrsto ključa, ki ga želite: " izberite " (1) RSA in RSA (privzeto) " za vrsto ključa, tako da vnesete 1 in pritisnete tipko za povratek/vnos .

7. Za možnost " Kakšno velikost tipke želite? (2048) " izberite privzeto s pritiskom na tipko Return/Enter .

8. Za možnost » Prosimo, navedite, kako dolgo naj bo ključ veljaven. « izberite privzeto s pritiskom na tipko Return/Enter .

9. Za možnost " Ali je to pravilno? (y/N) " vnesite y in pritisnite tipko Return/Enter .

10. Pod " Pravo ime: " vnesite ime po vaši izbiri in pritisnite tipko za vrnitev/vnos .

11. Pod " E-poštni naslov: " vnesite e-poštni naslov, ki ga izberete, in pritisnite tipko Return/Enter .

12. Komentar: oddelek se lahko pusti prazno, če se tako odločijo.

13. Izvedite potrebne spremembe, če niste pravilno vnesli svojih podatkov. Če ste zadovoljni s prikazanimi informacijami USER-ID , vnesite O (velika črka O, ne nič) in pritisnite tipko Return/Enter .

14. GnuPG vas bo zdaj pozval, da ustvarite in preverite geslo za vaš par ključev.

15. Ko vnesete svoja gesla, bo vaš par ključev GnuPG ustvarjen v .gnupgimeniku v vašem uporabniškem imeniku.

16. Zaženite ta ukaz za prikaz vsebine .gnupgimenika. Vsebovati mora naslednji imenik private-keys-v1.din datoteke pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Izvozite ustvarjen par ključev. Možnost --export naroči GnuPG, da izvozi par ključev. Možnost -a naroči GnuPG, da izpiše par ključev v formatu oklepa ascii . Zamenjajte " Joe Q. Public " z imenom, ki ste ga vnesli pri ustvarjanju para ključev v koraku #10 zgoraj. Zamenjajte " jqpublic " s poljubnim besedilom, ki ga izberete.

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

18. Uvozite par ključev v shrambo ključev RPM. Zamenjajte " jqpublic " z besedilom, ki ste ga izbrali v koraku #17.

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

19. Preverite, ali je bil par ključev dodan v shrambo ključev RPM. Možnost --q gpg-pubkey povprašuje po shrambi ključev RPM GnuPG. % {Name} -% {različica} -% {sprostitev} ->% {povzetek} \ n prikaže rezultat v berljivi obliki ljudi.

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

20. Z ustvarjanjem .rpmmacros file, lahko RPM prilagodite za izvajanje dodeljenih vedenj (primer: olajša samodejno podpisovanje RPM-jev). nanoZa ustvarjanje datoteke uporabite program.

    nano .rpmmacros
    

21. Nato v .rpmmacrosdatoteko dodajte naslednje besedilo spodaj .

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

22. Shranite dokument tako, da vnesete naslednje kombinacije tipkovnic. V CTRL + X Keys. Nato tipka S. Končno, tipka za povratek/vnos .

23. Ta spodnji ukaz bo nastavil vaše okolje za gradnjo RPM. To bo dodalo dodatne makre .rpmmacrosdatoteki, ki ste jo ustvarili v koraku #20, in ustvarilo potrebne imenike za gradnjo in shranjevanje RPM-jev.

    rpmdev-setuptree
    

24. Zaženite ta ukaz, da prikažete vsebino imenika rpmbuild. Vsebovati mora naslednje imenike SOURCES , RPMS , BUILD , SRPMS in SPECS .

    find rpmbuild
    

25. Prenesite izvorno kodo TaskServerja (taskd) v rpmbuild/SOURCESimenik.

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

26. Zaustavite tekoči rgndproces.

    sudo kill -9 rngd
    

3. korak: Zgradite TaskServer (taskd) RPM iz vira

1. Če želite zgraditi nov RPM iz vira, je treba ustvariti datoteko SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. V taskd.specdatoteko dodajte naslednje besedilo spodaj .

   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. Da bo TaskServer (taskd) komuniciral in sinhroniziral z odjemalci TaskWarrior (opravilo), boste morali uporabiti skripte generiranja, ki jih najdete pod, /etc/pki/taskd/za ustvarjanje potrdil/ključev strežnika in odjemalca. Povzdignite se do korenskega uporabnika s spodnjim ukazom in spremenite imenik v /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. S nanoprogramom ustvarite varsdatoteko, da ustvarite samopodpisani korenski CA.

   nano vars
   

   Dodajte naslednje besedilo spodaj v datoteko vars. Spremenite ORGANIZACIJO , CN , DRŽAVO , DRŽAVO in KRAJ v svoje zadovoljstvo.

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

3. Ustvarite samopodpisani korenski CA, potrdilo, ključ strežnika in seznam preklicanih strežnikov (izbirno).

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

   Ti ukazi bodo ustvarili naslednje datoteke ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemin server.crl.pem) znotraj /etc/pki/taskd/imenika. Da se TaskServer (taskd) zažene, je treba spremeniti lastništvo in dovoljenja za potrdila in ključe, ustvarjene v koraku #37, da bo TaskServer (taskd) omogočil dostop do njih. Zaženite spodnje ukaze, da jih spremenite.

   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. Omogočite in zaženite demon TaskServer (taskd).

   systemctl enable taskd
   systemctl start taskd
   

5. Odprite vrata v požarnem zidu, na katerem teče TaskServer (taskd).

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

   TaskServer (taskd) je zdaj nameščen in nastavljen na vašem primerku CentOS 7.

5. korak: Konfigurirajte potrdilo in ključ odjemalca TaskWarrior

1. Ustvariti morate odjemalska potrdila in ključ za šifriranje komunikacije med TaskServer (taskd) in TaskWarrior (opravilo). Zaženite spodnji ukaz, da ustvarite potrdilo in ključ odjemalca. Zamenjajte NAMEz imenom, ki ga zlahka prepoznate za svojo stranko.

   generate.client NAME
   

   Ta ukaz bo ustvaril naslednje datoteke ( NAME.cert.pem, NAME.key.pem) znotraj /etc/pki/taskd/imenika.

2. Kopirajte naslednje datoteke v svoj uporabniški imenik, spremenite lastništvo in dovoljenja. Spodaj joeqpublic nadomestite s svojim dejanskim imenikom uporabniškega imena.

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

3. Ustvarite zip arhiv potrdil in ključa.

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

4. Uporabite scp(ukazna vrstica) ali WinSCP (grafični vmesnik za SCP) za prenos certificates.zipdatoteke iz svojega primerka CentOS v odjemalsko napravo (računalnik/prenosni računalnik/pametni telefon).

5. Odstranite korenske pravice in izvedite preostale ukaze kot običajni uporabnik.

   exit
   

   TaskServer (taskd) je zdaj nastavljen in pripravljen za povezavo odjemalcev TaskWarrior (task).

6. korak: Ustvarite svojo prvo skupino in uporabnika TaskWarrior

1. Za ustvarjanje, brisanje, spreminjanje in sinhronizacijo nalog boste potrebovali uporabniški račun. Preden lahko dodate uporabnike, morate najprej ustvariti organizacijsko skupino. Zaženite spodnji ukaz, da ustvarite svojo prvo skupino. Zamenjajte GROUP z lahko prepoznavnim imenom.

2. POMEMBNO! taskdUkaz za ustvarjanje skupin / uporabnikov morajo biti tekel kot taskduporabnika. Zagon kot root uporabnik bo ustvaril imenike in datoteke v lasti korenskega uporabnika, /var/lib/taskd/orgski bodo preprečili odjemalcem TaskWarrior (opravilo) dostop ali spreminjanje česar koli v skupini, kateri so bili dodeljeni. Dostop bo zavrnjen.

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

3. Zdaj, ko ste ustvarili svojo prvo skupino, ustvarimo svojega prvega uporabnika. Zaženite spodnji ukaz, da ustvarite uporabnika, dodeljenega skupini, ustvarjeni v koraku #1. Kopirajte in prilepite ustvarjeni uporabniški ključ, uporabnika in skupino v besedilno datoteko. Ponovite postopek, da dodate dodatne uporabnike.

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

7. korak: Namestite odjemalce TaskWarrior

Windows 10 (zgrajena pozneje kot 1607+)

Če želite uporabljati TaskWarrior (opravilo) v sistemu Windows 10, morate namestiti podsistem Windows za Linux iz trgovine Windows.

1. Za namestitev WSL je potreben povišan poziv Powershell. Pritisnite tipko Window Key in vnesite powershell . Z desno miškino tipko kliknite Windows Powershell na vrhu rezultatov in izberite " Zaženi kot skrbnik ". V pozivu Nadzor uporabniškega računa kliknite Da . Kopirajte in prilepite spodnje besedilo v okna Powershell. Ko WSL konča namestitev, pritisnite tipko Y, da znova zaženete Windows.

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

2. Po ponovnem zagonu odprite ukazni poziv in vnesite naslednji ukaz bash . To bo namestilo Ubuntu v Windows. Pritisnite Y ključ . Zdaj bo prenesen in ekstrahiran. Izberite uporabniško ime in geslo.

   bash
   

3. Zdaj je čas, da namestite TaskWarrior (opravilo). Vnesite naslednji ukaz v konzolo.

   sudo apt-get install task -y
   

4. Dvakrat vnesite exit za izhod iz bash terminala in ukaznega poziva Windows.

5. Kliknite gumb menija Start. Vnesite ubuntu . Desni klik na Bash na Ubuntu v sistemu Windows . Izberite Pripni v opravilno vrstico . To zagotavlja udobje za hiter dostop do bash za dostop do TaskWarriorja (opravilo).

6. Kliknite ikono Ubuntu, ki ste jo pravkar ustvarili v opravilni vrstici. To bo odprlo terminalsko okno, v katerem se izvaja Bash. Vnesite spodnji ukaz, da ustvarite podatkovni imenik TaskWarrior (opravilo) ( ~/.task/) in konfiguracijsko datoteko ( .taskrc).

   task version
   yes
   

7. certificates.zipDatoteko, ki ste jo shranili prej med namestitvijo TaskServerja, morate premakniti v ~/.taskd/imenik znotraj vašega uporabniškega imenika. Če želite datoteke ekstrahirati iz zip datoteke, najprej namestite unzipprogram. Kopirajte in prilepite spodnje ukaze, tako da nadomestite dejansko lokacijo vaše kopije datoteke certificates.zip.

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

8. Vnesite naslednje ukaze, da nastavite TaskWarrior (opravilo) za povezavo s strežnikom TaskServer (taskd). Zamenjajte NAME s tem, kar ste poimenovali svojemu potrdilu in ključu, GROUP s skupino, ki ste jo ustvarili, Joe Q. Public z uporabniškim imenom, ki ste ga ustvarili, in XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX s ključem, dodeljenim, ko je vaš uporabnik je bil ustvarjen na strežniku 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. Zdaj je čas, da sinhronizirate TaskWarrior (opravilo) s TaskServer (taskd). Zaženite spodnji ukaz, da inicializirate bazo podatkov.

   task sync init
   

   Sinhronizacija med odjemalcem TaskWarrior (opravilo) in TaskServerjem (taskd) je zdaj nastavljena na platformi Windows 10.

Android

Če želite uporabljati TaskWarrior (opravilo) v Androidu, morate namestiti TaskWarrior za Android iz trgovine Google Play.

1. Namestite aplikacijo TaskWarrior (task) For Android v Googlovi trgovini Play.

2. Odprite aplikacijo TaskWarrior (opravilo) za Android.

3. Aplikacija vas bo pozvala, da ustvarite račun z želenim imenom računa . Vnesite ime, ki ste ga izbrali, ko ste ustvarili uporabniško ime za uporabnika TaskServerja (taskd).

4. Pustite mapo s podatki na privzeto nastavitev <<Ustvari novo>> in tapnite gumb V redu . Uporabite aplikacijo za upravljanje datotek, da ustvarite mapo v korenu za shranjevanje (na primer: /storage/emulate/0/Certs). Pošljite aplikacijo v ozadje.

5. Kopirajte certificates.zipdatoteko, ki ste jo ustvarili prej, in izvlecite njeno vsebino v imenik, ustvarjen v koraku #4.

6. V ospredju aplikacijo "TaskWarrior (opravilo) za Android" in tapnite meni v zgornjem levem kotu aplikacije, da jo odprete.

7. Pomaknite se navzdol do dna menija in tapnite možnost Nastavitve .

8. To bo odprlo preprost vgrajen urejevalnik besedil aplikacije TaskWarrior For Android.

9. Vnesite naslednje možnosti za nastavitev sinhronizacije s strežnikom TaskServer (taskd). Zamenjajte spremenljivke taskd.ca/ taskd.certificate/taskd.key` z dejansko potjo imenika ca/certificate/key, NAME s tem, kar ste poimenovali svoje potrdilo in ključ, GROUP s skupino, ki ste jo ustvarili, Joe Q. Public z uporabniškim imenom, ki ste ga ustvarili in XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX s ključem, dodeljenim, ko ste ustvarili svojega uporabnika na strežniku 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. Tapnite ikono diskete, da shranite svoje nastavitve.

Sinhronizacija med odjemalcem TaskWarrior (opravilo) in TaskServerjem (taskd) je zdaj nastavljena na platformi Android.

Linux

1. Glejte razdelek distribucije TaskWarrior (opravilo) za namestitev za vašo distribucijo Linuxa .

2. Odprite okno terminala. Vnesite spodnji ukaz, da ustvarite podatkovni imenik TaskWarrior (opravilo) ( ~/.task/) in konfiguracijsko datoteko ( .taskrc).

   task version
   yes
   

3. certificates.zipDatoteko, ki ste jo prej shranili v nastavitvah TaskServerja, morate premakniti v ~/.taskd/imenik znotraj uporabniškega imenika. Če želite datoteke ekstrahirati iz zip datoteke, najprej namestite unzipprogram za svojo distribucijo. Kopirajte in prilepite spodnje ukaze, tako da nadomestite dejansko lokacijo vaše kopije certificates.zip.

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

4. Vnesite naslednje ukaze, da nastavite TaskWarrior (opravilo) za povezavo s strežnikom TaskServer (taskd). Zamenjajte NAME s tem, kar ste poimenovali svojemu potrdilu in ključu, GROUP s skupino, ki ste jo ustvarili, Joe Q. Public z uporabniškim imenom, ki ste ga ustvarili, in XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX s ključem, dodeljenim, ko je vaš uporabnik je bil ustvarjen na strežniku 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. Zdaj je čas, da sinhronizirate TaskWarrior (opravilo) s TaskServer (taskd). Zaženite spodnji ukaz, da inicializirate bazo podatkov.

   task sync init
   

Dodatek: Če zaženete Gnome Shell, obstaja razširitev, imenovana TaskWhisper, ki se integrira z TaskWarrior (opravilo).

Sinhronizacija med vašim odjemalcem TaskWarrior (opravilo) in TaskServerjem (taskd) je zdaj nastavljena v vaši najljubši distribuciji Linuxa.