Instalirajte TaskServer (taskd) na CentOS 7

TaskWarrior je alat za upravljanje vremenom otvorenog koda koji je poboljšanje aplikacije Todo.txt i njezinih klonova. Zbog činjenice da prosječna osoba koristi više uređaja/platforma u svom dnevnom rasporedu, ključno je imati mogućnost centraliziranog spremišta gdje se podacima može pristupiti i ažurirati s bilo kojeg uređaja. Ovaj vodič će se usredotočiti na postavljanje poslužitelja, nazvanog TaskServer (taskd), i klijenta nazvanog TaskWarrior (zadatak), dopuštajući višestrukim klijentskim uređajima sigurnu pristup i razmjenu podataka.

Ima sljedeće značajke:

• Neograničeni zadaci
• Određivanje prioriteta zadataka
• Filtriranje pretraživanja
• Označavanje
• Automatska sinkronizacija
• Automatsko sigurnosno kopiranje
• Potpuna kontrola i privatnost
• Šifrirana komunikacija

Preduvjeti

• Instanca poslužitelja CentOS 7 x64.
• Korisnik sudoa .
• Naziv domene usmjeren na Vultr instancu ( taskd.example.com )

Korak 1: Ažurirajte sustav

Prijavite se kao vaš sudo korisnik da instalirate EPEL Repository i ažurirate sustav na sljedeći način:

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

Korak 2: Instalirajte RPM Build i alate za izgradnju

EPEL spremište ne sadrži RPM za TaskServer (taskd), tako da ga sami moramo izgraditi iz izvora u RPM paket.

1. Instalirajte alate za GCC, Make, RPM Build, razvoj i potpisivanje.

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

2. Napravite GnuPG direktorij koji će sadržavati GPG datoteke potrebne za potpisivanje našeg RPM-a.

   mkdir .gnupg
   

3. Prilikom izrade ključa, potrebna nam je entropija u sustavu da bismo ga pravilno nasumično rasporedili. rngdDaemon generira entropija potrebi s /dev/urandom. Pa hajde da to sada instaliramo.

   yum install rngd -y
   

4. Pokrenite rngddemon za generiranje entropije. Opcija -r ukazuje na /dev/urandomumjesto zadanog /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Generirajte ključ. Opcija --gen-key govori gpg-u da generira novi par ključeva.

   gpg --gen-key
   

6. Za opciju " Molimo odaberite koju vrstu ključa želite: " odaberite " (1) RSA i RSA (zadano) " za tip ključa tako da unesete 1 i pritisnete tipku za povratak/unos .

7. Za opciju " Koju veličinu tipke želite? (2048) " odaberite zadanu pritiskom na tipku Return/Enter .

8. Za opciju " Molimo navedite koliko dugo ključ treba biti valjan. " odaberite zadanu vrijednost pritiskom na tipku Return/Enter .

9. Za opciju " Je li to točno? (y/N) " unesite y i pritisnite tipku Return/Enter .

10. Pod " Pravo ime: ", unesite ime po svom izboru i pritisnite tipku za povratak/unos .

11. Pod " Adresa e-pošte: ", unesite adresu e-pošte po svom izboru i pritisnite tipku za povratak/unos .

12. Odjeljak Komentar: može ostati prazan ako tako odlučite.

13. Učinite sve potrebne izmjene ako niste ispravno unijeli svoje podatke. Ako ste zadovoljni prikazanim informacijama o USER-ID-u , unesite O (veliko slovo O, a ne nula) i pritisnite tipku za povratak/unos .

14. GnuPG će vas sada tražiti da kreirate i potvrdite lozinku za vaš par ključeva.

15. Nakon što unesete svoje lozinke, vaš par ključeva GnuPG bit će kreiran u .gnupgimeniku u vašem korisničkom imeniku.

16. Pokrenite ovu naredbu za prikaz sadržaja .gnupgdirektorija. Trebao bi sadržavati sljedeći direktorij private-keys-v1.di datoteke pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Izvezite kreirani par ključeva. Opcija --export daje upute GnuPG-u da izveze par ključeva. Opcija -a daje upute GnuPG-u da ispiše par ključeva u ascii formatu oklopa . Zamijenite " Joe Q. Public " imenom koje ste unijeli prilikom stvaranja para ključeva u koraku #10 iznad. Zamijenite " jqpublic " bilo kojim tekstom koji odaberete.

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

18. Uvezite par ključeva u RPM spremište ključeva. Zamijenite " jqpublic " tekstom koji ste odabrali u koraku #17.

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

19. Provjerite je li par ključeva dodan u RPM spremište ključeva. Opcija --q gpg-pubkey ispituje RPM GnuPG spremište ključeva. % {Name} -% {inačica} -% {oslobađanje} ->% {sažetak} \ N prikazuje rezultat u ljudskom čitljivom formatu.

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

20. Izradom .rpmmacros file, RPM se može prilagoditi za izvođenje dodijeljenih ponašanja (primjer: olakšati automatsko potpisivanje RPM-ova). Koristite nanoprogram za stvaranje datoteke.

    nano .rpmmacros
    

21. Zatim dodajte sljedeći tekst ispod u .rpmmacrosdatoteku.

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

22. Spremite dokument unosom sljedećih kombinacija tipkovnice. U CTRL + X tipke. Zatim, ključ S. Konačno, tipka za povratak/unos .

23. Ova naredba u nastavku će postaviti vaše okruženje RPM izgradnje. Ovo će dodati dodatne makronaredbe .rpmmacrosdatoteci koju ste kreirali u koraku #20 i stvoriti potrebne direktorije za izgradnju i pohranu RPM-ova.

    rpmdev-setuptree
    

24. Pokrenite ovu naredbu za prikaz sadržaja rpmbuild direktorija. To bi trebao sadržavati sljedeće direktorije IZVORA , RPM , graditi , SRPMS i naočale .

    find rpmbuild
    

25. Preuzmite izvorni kod TaskServera (taskd) u rpmbuild/SOURCESdirektorij.

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

26. Ubijte tekući rgndproces.

    sudo kill -9 rngd
    

Korak 3: Izgradite TaskServer (taskd) RPM iz izvora

1. Da biste izgradili novi RPM iz izvora, mora se kreirati SPEC datoteka TaskServera (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Dodajte sljedeći tekst ispod u taskd.specdatoteku.

   Name:           taskd
   Version:        1.1.0
   Release:        1%{?dist}
   Summary:        Secure server providing multi-user, multi-client access to task data
   Group:          Applications/Productivity
   License:        MIT
   URL:            http://tasktools.org/projects/taskd.html
   Source0:        http://taskwarrior.org/download/%{name}-%{version}.tar.gz
   Source1:        taskd.service
   Source2:        taskd-config
   Source3:        taskd.xml
   
   BuildRequires:  cmake
   BuildRequires:  libuuid-devel
   BuildRequires:  gnutls-devel
   BuildRequires:  shadow-utils
   
   
   %if 0%{?rhel} && 0%{?rhel} <= 6
   # On rhel, we don't need systemd to build.  but we do on centos.        
   # ...just to define some macros
   %else
   BuildRequires:  systemd
   %endif
   
   # For certificate generation        
   Requires:       gnutls-utils
   
   # Systemd requires
   Requires(post):    systemd
   Requires(preun):   systemd
   Requires(postun):  systemd
   
   %description
   The TaskServer is a lightweight, secure server providing multi-user,
   multi-client access to task data.  This allows true syncing between desktop and
   mobile clients.
   
   Users want task list access from multiple devices running software of differing
   sophistication levels to synchronize data seamlessly.  Synchronization requires
   the ability to exchange transactions between devices that may not have
   continuous connectivity, and may not have feature parity.
   
   The TaskServer provides this and builds a framework to go several steps beyond
   merely synchronizing data.
   
   %prep
   %setup -q %{name}-%{version}
   
   %build
   %cmake
   make %{?_smp_mflags}
   
   %install
   make install DESTDIR=%{buildroot}
   
   mkdir -p %{buildroot}%{_sharedstatedir}/taskd/
   
   # Users will keep their keys here, but we copy some helpful scripts too.
   mkdir -p %{buildroot}%{_sysconfdir}/pki/taskd/
   cp -a pki/generate* %{buildroot}%{_sysconfdir}/pki/taskd/.
   
   mkdir -p %{buildroot}%{_localstatedir}/log/taskd/
   
   %if 0%{?rhel} && 0%{?rhel} <= 6
   # EL6 and earlier needs a sysvinit script
   # Also, no firewalld on old EL
   %else
   mkdir -p %{buildroot}%{_unitdir}/
   cp -a %{SOURCE1} %{buildroot}%{_unitdir}/taskd.service
   
   mkdir -p %{buildroot}%{_prefix}/lib/firewalld/services
   cp -a %{SOURCE3} %{buildroot}%{_prefix}/lib/firewalld/services/taskd.xml
   %endif
   
   mkdir -p %{buildroot}%{_sharedstatedir}/taskd/orgs/
   cp -a %{SOURCE2} %{buildroot}%{_sharedstatedir}/taskd/config
   
   rm -r %{buildroot}%{_datadir}/doc/taskd/
   
   %pre
   getent group taskd >/dev/null || groupadd -r taskd
   getent passwd taskd >/dev/null || \
       useradd -r -g taskd -d %{_sharedstatedir}/taskd/ -s /usr/bin/sh \
       -c "Task Server system user" taskd
   exit 0
   
   # Systemd scriptlets
   %if 0%{?rhel} && 0%{?rhel} <= 6
   # No systemd for el6
   %else
   
   %post
   %systemd_post taskd.service
   
   %preun
   %systemd_preun taskd.service
   
   %postun
   %systemd_postun_with_restart taskd.service
   
   %endif
   
   
   %files
   %doc AUTHORS COPYING ChangeLog NEWS README
   %{_bindir}/taskd
   %{_bindir}/taskdctl
   %{_mandir}/man1/taskd.1.*
   %{_mandir}/man1/taskdctl.1.*
   %{_mandir}/man5/taskdrc.5.*
   
   %{_sysconfdir}/pki/taskd/generate*
   
   %dir %attr(0750, taskd, taskd) %{_sysconfdir}/pki/taskd/
   %dir %attr(0750, taskd, taskd) %{_localstatedir}/log/taskd/
   
   %dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/
   %config(noreplace) %attr(0644, taskd, taskd) %{_sharedstatedir}/taskd/config
   %dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/orgs/
   
   %if 0%{?rhel} && 0%{?rhel} <= 6
   # No sysvinit files for el6
   %else
   %{_unitdir}/taskd.service
   %{_prefix}/lib/firewalld/services/taskd.xml
   %endif
   
   %changelog
   * Thu Aug 17 2017 Jarrett Graham <[email protected]> - 1.1.0
   - Initial packaging.
   

3. The RPM also requires three additional files that must be created in the rpmbuild/SOURCES directory. Use the nano program to create the taskd-config file.

   nano rpmbuild/SOURCES/taskd-config
   

4. Add the following text below into the taskd-config file.

   # taskd configuration file
   confirmation=1
   verbose=1
   ip.log=on
   extensions=/usr/libexec/taskd
   queue.size=10
   request.limit=1048576
   server=0.0.0.0:53589
   root=/var/lib/taskd
   log=/var/log/taskd/taskd.log
   pid.file=/var/run/taskd.pid
   ca.cert=/etc/pki/taskd/ca.cert.pem
   server.cert=/etc/pki/taskd/server.cert.pem
   server.key=/etc/pki/taskd/server.key.pem
   server.crl=/etc/pki/taskd/server.crl.pem
   

5. Use the nano program to create the taskd.service file.

   nano rpmbuild/SOURCES/taskd.service
   

6. Add the following text below into the taskd.service file.

   [Unit]
   Description=Secure server providing multi-user, multi-client access to task data
   After=network.target
   Documentation=https://tasktools.org/projects/taskd.html
   
   [Service]
   ExecStart=/usr/bin/taskd server --data /var/lib/taskd
   Type=simple
   User=taskd
   Group=taskd
   
   [Install]
   WantedBy=multi-user.target
   

7. Use the nano program to create the taskd.xml file.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Add the following text below into the taskd.xml file.

   <?xml version="1.0" encoding="utf-8"?>
   <service>
     <short>Task-warrior server</short>
     <description>This option allows you to connect to the task warrior server.</description>
     <port protocol="tcp" port="53589"/>
   </service>
   

9. In order to build the TaskServer (taskd) RPM, three packages are required for building. Run the command below to install those packages.

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

10. Now it is time to build from source and create an RPM for TaskServer (taskd). Run the commands below to get started. It should take less than a minute on a 1x CPU Vultr instance to build the RPMs. Enter the GnuPG password you created in step #14 to sign the RPM when prompted.

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

11. Install the TaskServer (taskd) RPM.

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

Step 4: Configure TaskServer (task)

1. In order for TaskServer (taskd) to communicate and sync with TaskWarrior (task) clients, you will need to use the generation scripts found under /etc/pki/taskd/ to generate server and client certificates/keys. Elevate to the root user using the command below and change directory to /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Use the nano program to create a vars file in order to generate a self-signed Root CA.

   nano vars
   

   Add the following text below into the vars file. Change ORGANIZATION, CN, COUNTRY, STATE and LOCALITY to your satisfaction.

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

3. Generate the self-signed Root CA, certificate, server key and server revocation list (optional).

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

   These commands will create the following files (ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pem and server.crl.pem) inside the /etc/pki/taskd/ directory. In order for TaskServer (taskd) to start, the ownership and permissions on the certificates and keys generated in step #37 must be modified to allow TaskServer (taskd) to access them. Run the commands below to change them.

   chown taskd.taskd ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem
   chmod 400 ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem
   

4. Enable and start the TaskServer (taskd) daemon.

   systemctl enable taskd
   systemctl start taskd
   

5. Open the port in the firewall TaskServer (taskd) runs on.

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

   TaskServer (taskd) is now installed and setup on your CentOS 7 instance.

Step 5: Configure TaskWarrior client certificate and key

1. You must create client certificates and key to encrypt communications between TaskServer (taskd) and TaskWarrior (task). Run the command below to generate a client certificate and key. Replace NAME with a name you can easily recognize for your client.

   generate.client NAME
   

   This command will create the following files (NAME.cert.pem, NAME.key.pem) inside of the /etc/pki/taskd/ directory.

2. Copy the following files to your user directory, change the ownership and permissions. Substitute joeqpublic below with your actual username directory.

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

3. Create a zip archive of the certificates and key.

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

4. Use scp (command line) or WinSCP (GUI frontend for SCP) to download the certificates.zip file from your CentOS instance to your client device (computer/laptop/smartphone).

5. Odbacite root privilegije i izvršite ostale naredbe kao obični korisnik.

   exit
   

   TaskServer (taskd) je sada postavljen i spreman za povezivanje klijenata TaskWarrior (task).

Korak 6: Napravite svoju prvu TaskWarrior grupu i korisnika

1. Za izradu, brisanje, izmjenu i sinkronizaciju zadataka trebat će vam korisnički račun. Međutim, prije nego što možete dodati korisnike, prvo ćete morati stvoriti organizacijsku grupu. Pokrenite naredbu u nastavku da biste stvorili svoju prvu grupu. Zamijenite GROUP lako prepoznatljivim imenom.

2. VAŽNO! taskdNaredba za stvaranje grupe / korisnici moraju biti ran kao taskdkorisnika. Pokretanje kao root korisnik će stvoriti direktorije i datoteke u vlasništvu root korisnika pod /var/lib/taskd/orgskojima će spriječiti TaskWarrior (zadatak) klijente da mogu pristupiti ili mijenjati bilo što u grupi kojoj su dodijeljeni. Pristup će biti odbijen.

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

3. Sada, kada ste stvorili svoju prvu grupu, napravimo svog prvog korisnika. Pokrenite naredbu u nastavku da biste stvorili korisnika dodijeljenog grupi stvorenoj u koraku #1. Kopirajte i zalijepite generirani korisnički ključ, korisnika i grupu u tekstualnu datoteku. Ponovite postupak za dodavanje dodatnih korisnika.

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

Korak 7: Instalirajte TaskWarrior klijente

Windows 10 (izrada kasnije od 1607+)

Da biste koristili TaskWarrior (zadatak) u sustavu Windows 10, morate instalirati podsustav Windows za Linux iz Windows trgovine.

1. Za instaliranje WSL-a potreban je povišeni Powershell prompt. Pritisnite tipku prozora i upišite powershell . Desnom tipkom miša kliknite Windows Powershell na vrhu rezultata i odaberite " Pokreni kao administrator ". U prompt Kontrola korisničkog računa kliknite Da . Kopirajte i zalijepite tekst koji se nalazi ispod u prozore Powershell. Kada WSL završi instalaciju, pritisnite tipku Y za ponovno pokretanje Windowsa.

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

2. Nakon ponovnog pokretanja, otvorite naredbeni redak i upišite sljedeću naredbu bash . Ovo će instalirati Ubuntu na Windows. Pritisnite Y ključ . Sada će se preuzeti i ekstrahirati. Odaberite korisničko ime i lozinku.

   bash
   

3. Sada je vrijeme da instalirate TaskWarrior (zadatak). Upišite sljedeću naredbu unutar konzole.

   sudo apt-get install task -y
   

4. Dvaput upišite exit za izlaz iz bash terminala i naredbenog retka sustava Windows.

5. Kliknite gumb izbornika Start. Upišite ubuntu . Desni klik na Bash na Ubuntu u Windowsima . Odaberite Prikvači na programsku traku . To pruža pogodnost za brzi pristup bash-u za pristup TaskWarrior-u (zadatku).

6. Kliknite na Ubuntu ikonu koju ste upravo stvorili na programskoj traci. Ovo će otvoriti prozor terminala koji pokreće Bash. Upišite sljedeću naredbu u nastavku da biste stvorili TaskWarrior (zadatak) direktorij podataka ( ~/.task/) i konfiguracijsku datoteku ( .taskrc).

   task version
   yes
   

7. Morate premjestiti certificates.zipdatoteku koju ste ranije spremili tijekom postavljanja TaskServera u ~/.taskd/direktorij unutar vašeg korisničkog imenika. Da biste izdvojili datoteke iz zip datoteke, unzipprvo instalirajte program. Kopirajte i zalijepite sljedeće naredbe u nastavku zamjenjujući stvarnu lokaciju vaše kopije certificates.zip.

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

8. Upišite sljedeće naredbe da postavite TaskWarrior (zadatak) da se poveže s TaskServerom (taskd). Zamijenite NAME s onim što ste nazvali svom certifikatu i ključu, GROUP s grupom koju ste stvorili, Joe Q. Public s korisničkim imenom koje ste kreirali i XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX s ključem koji je dodijeljen kada vaš korisnik je kreiran na poslužitelju 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. Sada je vrijeme da sinkronizirate TaskWarrior (zadatak) s TaskServerom (taskd). Pokrenite naredbu u nastavku da inicijalizirate bazu podataka.

   task sync init
   

   Sinkronizacija između vašeg klijenta TaskWarrior (zadatak) i TaskServera (taskd) sada je postavljena na platformi Windows 10.

Android

Da biste koristili TaskWarrior (zadatak) na Androidu, morate instalirati TaskWarrior za Android iz trgovine Google Play.

1. Instalirajte aplikaciju TaskWarrior (task) For Android na Google Play Store.

2. Otvorite aplikaciju TaskWarrior (zadatak) za Android.

3. Aplikacija će vas zatražiti da stvorite račun sa željenim imenom računa . Unesite ime koje ste odabrali kada ste kreirali korisničko ime za korisnika TaskServera (taskd).

4. Ostavite mapu podataka na zadanu postavku <<Create new>> i dodirnite gumb OK . Upotrijebite aplikaciju za upravljanje datotekama da biste stvorili mapu u korijenu za pohranu (na primjer: /storage/emulate/0/Certs). Pošaljite aplikaciju u pozadinu.

5. Kopirajte certificates.zipdatoteku koju ste ranije stvorili i izvucite njezin sadržaj u svoj direktorij kreiran u koraku #4.

6. U prvi plan postavite aplikaciju "TaskWarrior (zadatak) za Android" i dodirnite izbornik u gornjem lijevom kutu aplikacije da biste je otvorili.

7. Pomaknite se prema dolje do dna izbornika i dodirnite opciju Postavke .

8. Ovo će otvoriti jednostavan ugrađeni uređivač teksta aplikacije TaskWarrior For Android.

9. Unesite sljedeće opcije za postavljanje sinkronizacije sa svojim TaskServerom (taskd). Zamijenite varijable taskd.ca/ taskd.certificate/taskd.key` sa stvarnim putevima direktorija ca/certificate/key, NAME s onim što ste nazvali svom certifikatu i ključu, GROUP s grupom koju ste kreirali, Joe Q. Public s korisničkim imenom koje ste kreirali i XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX s ključem dodijeljenim kada ste kreirali svog korisnika na TaskWarrior (taskd) poslužitelju.

   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. Dodirnite ikonu diskete da biste spremili svoje postavke.

Sinkronizacija između vašeg klijenta TaskWarrior (task) i TaskServera (taskd) sada je postavljena na platformi Android.

Linux

1. Pogledajte odjeljak distribucije TaskWarrior (zadatak) za instalaciju za vašu konkretnu distribuciju Linuxa .

2. Otvorite prozor terminala. Upišite sljedeću naredbu u nastavku da biste stvorili TaskWarrior (zadatak) direktorij podataka ( ~/.task/) i konfiguracijsku datoteku ( .taskrc).

   task version
   yes
   

3. Morate premjestiti certificates.zipdatoteku koju ste ranije spremili u postavci TaskServera u ~/.taskd/direktorij unutar vašeg korisničkog imenika. Da biste izdvojili datoteke iz zip datoteke, unzipprvo instalirajte program za svoju distribuciju. Kopirajte i zalijepite sljedeće naredbe u nastavku, zamjenjujući stvarnu lokaciju svoje kopije certificates.zip.

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

4. Upišite sljedeće naredbe da postavite TaskWarrior (zadatak) da se poveže s TaskServerom (taskd). Zamijenite NAME s onim što ste nazvali svom certifikatu i ključu, GROUP s grupom koju ste stvorili, Joe Q. Public s korisničkim imenom koje ste kreirali i XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX s ključem koji je dodijeljen kada vaš korisnik je kreiran na TaskWarrior (taskd) poslužitelju.

   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. Sada je vrijeme da sinkronizirate TaskWarrior (zadatak) s TaskServerom (taskd). Pokrenite naredbu u nastavku da inicijalizirate bazu podataka.

   task sync init
   

Dodatak: Ako pokrenete Gnome Shell, postoji proširenje pod nazivom TaskWhisper koje se integrira s TaskWarrior-om (zadatak).

Sinkronizacija između vašeg klijenta TaskWarrior (task) i TaskServera (taskd) sada je postavljena na vašoj omiljenoj distribuciji Linuxa.