Instaloni TaskServer (detyrë) në CentOS 7

TaskWarrior është një mjet i menaxhimit të kohës me burim të hapur që është një përmirësim në aplikacionin Todo.txt dhe klonet e tij. Për shkak të faktit se një person mesatar përdor pajisje/platforma të shumta në orarin e tij ditor, është thelbësore që të ketë aftësinë për të pasur një depo të centralizuar ku të dhënat mund të aksesohen dhe përditësohen nga çdo pajisje. Ky tutorial do të fokusohet në konfigurimin e serverit, të quajtur TaskServer (detyrë), dhe klientit, të quajtur TaskWarrior (detyrë), duke lejuar pajisje të shumta klientësh të aksesojnë dhe shkëmbejnë të dhëna në mënyrë të sigurt.

Ajo ka karakteristikat e mëposhtme:

• Detyra të pakufizuara
• Prioritetizimi i detyrave
• Kërko filtrim
• Etiketimi
• Sinkronizimi automatik
• Rezervimi automatik
• Kontroll i plotë dhe privatësi
• Komunikimi i koduar

Parakushtet

• Një shembull i serverit CentOS 7 x64.
• Një përdorues sudo .
• Emri i domenit tregoi për një shembull Vultr (taskd.example.com)

Hapi 1: Përditësoni sistemin

Identifikohu si përdoruesi juaj sudo për të instaluar depo EPEL dhe përditësoni sistemin si më poshtë:

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

Hapi 2: Instaloni RPM Build dhe mjetet për ndërtimin

Depoja EPEL nuk përmban një RPM për TaskServer (detyrë), kështu që ne duhet ta ndërtojmë vetë nga burimi në një paketë RPM.

1. Instaloni mjetet GCC, Make, RPM Build, zhvillimin dhe nënshkrimin.

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

2. Krijo një direktori GnuPG e cila do të mbajë skedarët GPG të nevojshëm për nënshkrimin e RPM-së tonë.

   mkdir .gnupg
   

3. Kur krijojmë një çelës, ne kërkojmë entropinë në sistem për ta randomizuar siç duhet. rngdDaemon gjeneron entropia e nevojshme nga /dev/urandom. Pra, le ta instalojmë atë tani.

   yum install rngd -y
   

4. Nisni rngddemonin për të gjeneruar entropi. Opsioni -r tregon në /dev/urandomvend të parazgjedhjes /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Gjeneroni një çelës. Opsioni --gen-key i thotë gpg të gjenerojë një çift të ri çelësash.

   gpg --gen-key
   

6. Për opsionin " Ju lutemi zgjidhni llojin e çelësit që dëshironi: ", zgjidhni " (1) RSA dhe RSA (parazgjedhur) " për llojin e tastit duke futur 1 dhe duke shtypur tastin Return/Enter .

7. Për opsionin " Çfarë madhësie tasti dëshironi? (2048) ", zgjidhni të paracaktuarin duke shtypur tastin Return/Enter .

8. Për opsionin " Ju lutemi specifikoni se sa kohë duhet të jetë i vlefshëm çelësi. " zgjidhni opsionin e paracaktuar duke shtypur tastin Return/Enter .

9. Për opsionin " A është e saktë? (y/N) ", futni y dhe shtypni tastin Return/Enter .

10. Nën " Emri i vërtetë: ", vendosni një emër që zgjidhni dhe shtypni tastin Kthim/Enter .

11. Në " Adresa e emailit: ", vendosni një adresë emaili që zgjidhni dhe shtypni tastin Kthim/Enter .

12. Seksioni Koment: mund të lihet i zbrazët nëse ju dëshironi.

13. Bëni çdo ndryshim të nevojshëm nëse nuk i keni futur saktë të dhënat tuaja. Nëse jeni të kënaqur me shfaqjen e informacionit të ID-së së USER-it , futni O (shkronja e madhe O, jo zero) dhe shtypni tastin Kthim/Enter .

14. GnuPG tani do t'ju kërkojë të krijoni dhe verifikoni një fjalëkalim për çiftin tuaj të çelësave.

15. Pasi të keni futur fjalëkalimet tuaja, çifti juaj i çelësave GnuPG do të krijohet nën .gnupgdrejtorinë në drejtorinë tuaj të përdoruesit.

16. Ekzekutoni këtë komandë për të shfaqur përmbajtjen e .gnupgdrejtorisë. Ai duhet të përmbajë direktoriumin private-keys-v1.ddhe skedarët e mëposhtëm pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Eksportoni çiftin e krijuar të çelësave. Opsioni --export udhëzon GnuPG të eksportojë çiftin e çelësave. Opsioni -a udhëzon GnuPG-në të nxjerrë çiftin e çelësave në formatin e armaturës ascii . Zëvendësoni " Joe Q. Public " me emrin që keni futur kur krijoni çiftin e çelësave në hapin #10 më sipër. Zëvendësoni " jqpublic " me çfarëdo teksti që zgjidhni.

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

18. Importoni çiftin e çelësave në dyqanin e çelësave RPM. Zëvendësoni " jqpublic " me tekstin që keni zgjedhur në hapin #17.

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

19. Verifikoni që çifti i çelësave është shtuar në ruajtjen e çelësave RPM. Opsioni --q gpg-pubkey kërkon në dyqanin e çelësave RPM GnuPG. % {Name} -% {version} -% {release} ->% {Përmbledhje} \ n tregon rezultati në një format të lexueshëm njerëzore.

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

20. Duke krijuar një .rpmmacros file, RPM mund të personalizohet për të kryer sjelljet e caktuara (shembull: lehtësimi i nënshkrimit automatik të RPM-ve). Përdorni nanoprogramin për të krijuar skedarin.

    nano .rpmmacros
    

21. Më pas, shtoni tekstin e mëposhtëm në .rpmmacrosskedar.

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

22. Ruani dokumentin duke futur kombinimet e mëposhtme të tastierës. Të Ctrl + X Keys. Pastaj, çelësi S. Më në fund, çelësi i Kthimit/Enter .

23. Kjo komandë më poshtë do të konfigurojë mjedisin tuaj të ndërtimit të RPM. Kjo do të shtojë makro shtesë në .rpmmacrosskedarin që keni krijuar në hapin #20 dhe do të krijojë drejtoritë e nevojshme për të ndërtuar dhe ruajtur RPM.

    rpmdev-setuptree
    

24. Ekzekutoni këtë komandë për të shfaqur përmbajtjen e drejtorisë rpmbuild. Ajo duhet të përmbajë në vijim directories BURIMET , rpms , Ndërtuar , SRPMS dhe syze .

    find rpmbuild
    

25. Shkarkoni kodin burimor të TaskServer (taskd) në rpmbuild/SOURCESdrejtori.

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

26. Vrasni rgndprocesin e ekzekutimit .

    sudo kill -9 rngd
    

Hapi 3: Ndërtoni TaskServer (detyrë) RPM nga burimi

1. Për të ndërtuar një RPM të re nga burimi, duhet të krijohet një skedar SPEC i TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Shtoni tekstin e mëposhtëm në taskd.specskedar.

   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. Drop root privileges and perform the rest of your commands as your regular user.

   exit
   

   TaskServer (taskd) is now setup and ready for TaskWarrior (task) clients to connect.

Step 6: Create your first TaskWarrior group and user

1. In order to create, delete, modify and sync your tasks, you will need a user account. However, before you can add users, you will first need to create an organizational group. Run the command below to create your first group. Replace GROUP with an easily recognizable name.

2. IMPORTANT! The taskd command to create groups/users must be ran as the taskd user. Running as the root user will create directories and files owned by the root user under /var/lib/taskd/orgs which will prevent TaskWarrior (task) clients from being able to access or modify anything in the group to which they have been assigned. Access will be denied.

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

3. Now, that you've created your first group, let's create your first user. Run the command below to create a user assigned to the group created in step #1. Copy and paste the generated user key, user and group in a text file. Repeat the process to add additional users.

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

Step 7: Install TaskWarrior clients

Windows 10 (Build later than 1607+)

To use TaskWarrior (task) on Windows 10, you need to install the Windows Subsystem For Linux from the Windows Store.

1. To install WSL, an elevated Powershell prompt is required. Press the Window Key and type powershell. Right click on Windows Powershell at the top of the results and select "Run as administrator". At the User Account Control prompt, click Yes. Copy and paste the text found below in the Powershell windows. When WSL finishes installing, press the Y Key to restart Windows.

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

2. Pas rindezjes, hapni një komandë dhe shkruani komandën e mëposhtme bash . Kjo do të instalojë Ubuntu në Windows. Shtypni Key Y . Tani do të shkarkohet dhe nxirret. Zgjidhni një emër përdoruesi dhe fjalëkalim.

   bash
   

3. Tani është koha për të instaluar TaskWarrior (detyrë). Shkruani komandën e mëposhtme brenda konsolës.

   sudo apt-get install task -y
   

4. Shkruani exit dy herë për të dalë nga terminali bash dhe linja e komandës së Windows.

5. Klikoni butonin Start Menu. Shkruani ubuntu . Klikoni me të djathtën në Bash në Ubuntu në Windows . Zgjidhni Pin në shiritin e detyrave . Kjo ofron lehtësi për të hyrë shpejt në bash për të hyrë në TaskWarrior (detyrë).

6. Klikoni në ikonën e Ubuntu që sapo keni krijuar në shiritin e detyrave. Kjo do të hapë një dritare terminali që ekzekuton Bash. Shkruani komandën e mëposhtme më poshtë për të krijuar drejtorinë e të dhënave TaskWarrior (detyrë) ( ~/.task/) dhe skedarin e konfigurimit ( .taskrc).

   task version
   yes
   

7. Ju duhet ta zhvendosni certificates.zipskedarin që keni ruajtur më herët gjatë konfigurimit të TaskServer në ~/.taskd/drejtorinë brenda direktorisë suaj të përdoruesit. Për të nxjerrë skedarët nga skedari zip, së unzippari instaloni programin. Kopjoni dhe ngjitni komandat e mëposhtme më poshtë duke zëvendësuar vendndodhjen aktuale të kopjes suaj të certificates.zip.

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

8. Shkruani komandat e mëposhtme për të vendosur TaskWarrior (detyrë) për t'u lidhur me TaskServer (taskd). Zëvendësoni NAME me atë që keni emërtuar certifikatën dhe çelësin tuaj, GROUP me grupin që keni krijuar, Joe Q. Publik me emrin e përdoruesit që keni krijuar dhe XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXXX me çelësin e caktuar kur përdoruesi juaj u krijua në serverin 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. Tani është koha për të sinkronizuar TaskWarrior (detyrë) me TaskServer (taskd). Ekzekutoni komandën më poshtë për të inicializuar bazën e të dhënave.

   task sync init
   

   Sinkronizimi midis klientit tuaj TaskWarrior (detyrë) dhe TaskServer (taskd) tani është konfiguruar në platformën Windows 10.

Android

Për të përdorur TaskWarrior (detyrë) në Android, duhet të instaloni TaskWarrior For Android nga Google Play Store.

1. Instaloni aplikacionin TaskWarrior (detyrë) Për Android në Dyqanin e Google Play.

2. Hapni aplikacionin TaskWarrior (detyrë) Për Android.

3. Do t'ju kërkohet nga aplikacioni të krijoni një llogari me një emër llogarie të dëshiruar . Futni emrin që zgjodhët kur krijuat një emër përdoruesi për një përdorues të TaskServer (taskd).

4. Lëreni dosjen e të dhënave në cilësimin e paracaktuar të <<Krijo të re>> dhe trokitni lehtë mbi butonin OK . Përdorni një aplikacion të menaxherit të skedarëve për të krijuar një dosje në rrënjën tuaj të ruajtjes (për shembull: /storage/emulate/0/Certs). Dërgo aplikacionin në sfond.

5. Kopjoni certificates.zipskedarin që keni krijuar më parë dhe nxirrni përmbajtjen e tij në drejtorinë tuaj të krijuar në hapin #4.

6. Në plan të parë aplikacionin "TaskWarrior (detyrë) Për Android" dhe trokitni lehtë mbi menunë në këndin e sipërm të majtë të aplikacionit për ta hapur atë.

7. Lëvizni poshtë në fund të menysë dhe trokitni lehtë mbi opsionin Cilësimet .

8. Kjo do të hapë një redaktues teksti të thjeshtë të integruar të aplikacionit TaskWarrior For Android.

9. Futni opsionet e mëposhtme për të konfiguruar sinkronizimin me TaskServer-in tuaj (detyrë). Zëvendësoni variablat taskd.ca/ taskd.certificate/taskd.key` me shtegun aktual të drejtorisë ca/certificate/key, EMRI me atë që keni emërtuar certifikatën dhe çelësin tuaj, GROUP me grupin që keni krijuar, Joe Q. Publik me emrin e përdoruesit që keni krijuar dhe XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX me çelësin e caktuar kur keni krijuar përdoruesin tuaj në serverin 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. Prekni ikonën e diskut të diskut për të ruajtur cilësimet tuaja.

Sinkronizimi midis klientit tuaj TaskWarrior (detyrë) dhe TaskServer (taskd) tani është konfiguruar në platformën Android.

Linux

1. Referojuni seksionit të shpërndarjes TaskWarrior (detyrë) për ta instaluar për shpërndarjen tuaj të veçantë Linux .

2. Hapni një dritare terminali. Shkruani komandën e mëposhtme më poshtë për të krijuar drejtorinë e të dhënave TaskWarrior (detyrë) ( ~/.task/) dhe skedarin e konfigurimit ( .taskrc).

   task version
   yes
   

3. Ju duhet ta zhvendosni certificates.zipskedarin që keni ruajtur më parë në konfigurimin e TaskServer në ~/.taskd/drejtorinë brenda direktorisë suaj të përdoruesit. Për të nxjerrë skedarët nga skedari zip, së unzippari instaloni programin për shpërndarjen tuaj të veçantë. Kopjoni dhe ngjitni komandat e mëposhtme më poshtë, duke zëvendësuar vendndodhjen aktuale të kopjes suaj të certificates.zip.

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

4. Shkruani komandat e mëposhtme për të vendosur TaskWarrior (detyrë) për t'u lidhur me TaskServer (taskd). Zëvendësoni NAME me atë që keni emërtuar certifikatën dhe çelësin tuaj, GROUP me grupin që keni krijuar, Joe Q. Publik me emrin e përdoruesit që keni krijuar dhe XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXXX me çelësin e caktuar kur përdoruesi juaj u krijua në serverin 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. Tani është koha për të sinkronizuar TaskWarrior (detyrë) me TaskServer (taskd). Ekzekutoni komandën më poshtë për të inicializuar bazën e të dhënave.

   task sync init
   

Shtojcë: Nëse përdorni Gnome Shell, ekziston një shtesë e quajtur TaskWhisper që integrohet me TaskWarrior (detyrë).

Sinkronizimi midis klientit tuaj TaskWarrior (detyrë) dhe TaskServer (taskd) tani është konfiguruar në shpërndarjen tuaj të preferuar Linux.