Instalējiet TaskServer (taskd) operētājsistēmā CentOS 7

TaskWarrior ir atvērtā koda laika pārvaldības rīks, kas ir lietojumprogrammas Todo.txt un tās klonu uzlabojums. Sakarā ar to, ka vidusmēra cilvēks savā ikdienas grafikā izmanto vairākas ierīces/platformas, ir ļoti svarīgi nodrošināt centralizētu repozitoriju, kurā datiem var piekļūt un tos atjaunināt no jebkuras ierīces. Šajā apmācībā galvenā uzmanība tiks pievērsta gan servera, ko sauc par TaskServer (taskd), gan klienta, ko sauc par TaskWarrior (uzdevumu), iestatīšanai, ļaujot vairākām klientu ierīcēm droši piekļūt un apmainīties ar datiem.

Tam ir šādas funkcijas:

• Neierobežoti uzdevumi
• Uzdevumu prioritāšu noteikšana
• Meklēšanas filtrēšana
• Atzīmēšana
• Automātiskā sinhronizācija
• Automātiska dublēšana
• Pilnīga kontrole un privātums
• Šifrēta komunikācija

Priekšnoteikumi

• CentOS 7 x64 servera gadījums.
• Sudo lietotāju.
• Domēna nosaukums norādīja uz Vultr gadījumu ( taskd.example.com )

1. darbība: atjauniniet sistēmu

Piesakieties kā sudo lietotājs, lai instalētu EPEL repozitoriju un atjauninātu sistēmu šādi:

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

2. darbība. Instalējiet RPM Build un veidošanas rīkus

EPEL repozitorijs nesatur RPM TaskServer (taskd), tāpēc mums pašiem ir jāveido tas no avota RPM pakotnē.

1. Instalējiet GCC, Make, RPM Build, izstrādes un parakstīšanas rīkus.

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

2. Izveidojiet GnuPG direktoriju, kurā būs GPG faili, kas nepieciešami mūsu RPM parakstīšanai.

   mkdir .gnupg
   

3. Veidojot atslēgu, mums ir nepieciešama entropija sistēmā, lai to pareizi randomizētu. rngdDēmons ģenerē entropija nepieciešams no /dev/urandom. Tāpēc instalēsim to tūlīt.

   yum install rngd -y
   

4. Palaidiet rngddēmonu, lai ģenerētu entropiju. Par -R opcija norāda /dev/urandomnevis noklusējuma /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Ģenerējiet atslēgu. --Gen atslēgas variants stāsta gpg lai ģenerētu jaunu atslēgu pāri.

   gpg --gen-key
   

6. Opcijai “ Lūdzu, izvēlieties, kāda veida atslēgu vēlaties: ” atslēgas veidam atlasiet “ (1) RSA un RSA (noklusējums) ”, ievadot 1 un nospiežot taustiņu Return/Enter .

7. Opcijai " Kādu atslēgas izmēru vēlaties? (2048) " izvēlieties noklusējumu, nospiežot taustiņu Return/Enter .

8. Opcijai " Lūdzu, norādiet, cik ilgi atslēgai jābūt derīgai. " izvēlieties noklusējumu, nospiežot taustiņu Return/Enter .

9. Opcijai " Vai tas ir pareizi? (y/N) " ievadiet y un nospiediet taustiņu Return/Enter .

10. Sadaļā Īstais vārds: ievadiet izvēlēto vārdu un nospiediet atgriešanas/ievadīšanas taustiņu.

11. Sadaļā " E-pasta adrese: " ievadiet izvēlēto e-pasta adresi un nospiediet atgriešanas/ievadīšanas taustiņu.

12. Komentārs: sadaļa var atstāt tukšu, ja jums tā izvēlēties.

13. Ja neesat pareizi ievadījis informāciju, veiciet nepieciešamās izmaiņas. Ja esat apmierināts ar parādīto USER-ID informāciju, ievadiet O (lielais burts O, nevis nulle) un nospiediet atgriešanas/ievadīšanas taustiņu.

14. GnuPG tagad liks jums izveidot un pārbaudīt atslēgu pāra paroli.

15. Kad esat ievadījis paroles, jūsu GnuPG atslēgu pāris tiks izveidots .gnupgjūsu lietotāja direktorija direktorijā.

16. Palaidiet šo komandu, lai parādītu .gnupgdirektorijas saturu . Tajā jāietver šāds direktorijs private-keys-v1.dun faili pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Eksportējiet izveidoto atslēgu pāri. --Export opcija uzdod GnuPG eksportēt atslēgu pāri. -A opcija uzdod GnuPG izvadei atslēgu pāri ASCII bruņas formātā . Aizstājiet " Joe Q. Public " ar nosaukumu, ko ievadījāt, veidojot atslēgu pāri 10. darbībā iepriekš. Aizstājiet “ jqpublic ” ar jebkuru izvēlēto tekstu.

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

18. Importējiet atslēgu pāri RPM atslēgu krātuvē. Aizstājiet " jqpublic " ar tekstu, ko izvēlējāties 17. darbībā.

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

19. Pārbaudiet, vai atslēgu pāris ir pievienots RPM atslēgu krātuvei. --Q gpg-pubkey variants vaicājumi RPM GnuPG krātuvi. % {Name} -% {version} -% {atbrīvošanas} ->% {kopsavilkums} \ n parāda rezultāts cilvēkam lasāmā formātā.

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

20. Izveidojot .rpmmacros file, RPM var pielāgot, lai veiktu piešķirtās darbības (piemērs: atvieglotu RPM automātisko parakstīšanu). Izmantojiet nanoprogrammu, lai izveidotu failu.

    nano .rpmmacros
    

21. Pēc tam .rpmmacrosfailam pievienojiet tālāk norādīto tekstu .

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

22. Saglabājiet dokumentu, ievadot šādas tastatūras kombinācijas. Ar CTRL + X taustiņus. Pēc tam S taustiņš. Visbeidzot, atgriešanas/ievadīšanas atslēga.

23. Šī tālāk norādītā komanda iestatīs jūsu RPM veidošanas vidi. Tādējādi .rpmmacrosfailam, ko izveidojāt 20. darbībā, tiks pievienoti papildu makro un izveidoti nepieciešamie direktoriji, lai izveidotu un saglabātu RPM.

    rpmdev-setuptree
    

24. Palaidiet šo komandu, lai parādītu direktorijas rpmbuild saturu. Tajā jābūt šādām katalogi AVOTI , IPT , BUILD , SRPMS un SPECS .

    find rpmbuild
    

25. Lejupielādējiet direktorijā TaskServer (taskd) pirmkodu rpmbuild/SOURCES.

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

26. Nogaliniet darbības rgndprocesu.

    sudo kill -9 rngd
    

3. darbība. Veidojiet TaskServer (taskd) RPM no avota

1. Lai izveidotu jaunu RPM no avota, ir jāizveido TaskServer (taskd) SPEC fails.

   nano rpmbuild/SPECS/taskd.spec
   

2. Pievienojiet tālāk norādīto tekstu taskd.specfailam.

   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 ir nepieciešami arī trīs papildu faili, kas jāizveido rpmbuild/SOURCESdirektorijā. Izmantojiet nanoprogrammu, lai izveidotu taskd-configfailu.

   nano rpmbuild/SOURCES/taskd-config
   

4. Pievienojiet tālāk norādīto tekstu taskd-configfailam.

   # 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. Izmantojiet nanoprogrammu, lai izveidotu taskd.servicefailu.

   nano rpmbuild/SOURCES/taskd.service
   

6. Pievienojiet tālāk norādīto tekstu taskd.servicefailam.

   [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. Izmantojiet nanoprogrammu, lai izveidotu taskd.xmlfailu.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Pievienojiet tālāk norādīto tekstu taskd.xmlfailam.

   <?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. Lai izveidotu TaskServer (taskd) RPM, izveidei ir nepieciešamas trīs pakotnes. Lai instalētu šīs pakotnes, palaidiet tālāk norādīto komandu.

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

10. Tagad ir pienācis laiks veidot no avota un izveidot RPM TaskServer (taskd). Lai sāktu, izpildiet tālāk norādītās komandas. 1x CPU Vultr instancē RPM izveidošanai vajadzētu aizņemt mazāk nekā minūti. Ievadiet GnuPG paroli, ko izveidojāt 14. darbībā, lai parakstītu RPM, kad tas tiek prasīts.

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

11. Instalējiet TaskServer (taskd) RPM.

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

4. darbība: konfigurējiet TaskServer (uzdevums)

1. Lai TaskServer (taskd) varētu sazināties un sinhronizēt ar TaskWarrior (uzdevuma) klientiem, /etc/pki/taskd/servera un klienta sertifikātu/atslēgu ģenerēšanai būs jāizmanto šeit atrodamie ģenerēšanas skripti . Paaugstiniet līdz saknes lietotājam, izmantojot tālāk norādīto komandu, un mainiet direktoriju uz /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Izmantojiet nanoprogrammu, lai izveidotu varsfailu, lai ģenerētu pašparakstītu saknes CA.

   nano vars
   

   Pievienojiet tālāk norādīto tekstu vars failam. Mainiet ORGANIZĀCIJU , KN , VALSTI , ŠTATU un ATRAŠANĀS VIETAS pēc saviem ieskatiem .

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

3. Ģenerējiet pašparakstītu saknes CA, sertifikātu, servera atslēgu un servera atsaukšanas sarakstu (neobligāti).

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

   Šīs komandas direktorijā izveidos šādus failus ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemun server.crl.pem) /etc/pki/taskd/. Lai TaskServer (taskd) startētu, ir jāmaina īpašumtiesības un atļaujas sertifikātiem un atslēgām, kas ģenerētas 37. darbībā, lai ļautu TaskServer (taskd) tiem piekļūt. Palaidiet tālāk norādītās komandas, lai tās mainītu.

   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. Iespējojiet un palaidiet TaskServer (taskd) dēmonu.

   systemctl enable taskd
   systemctl start taskd
   

5. Atveriet portu ugunsmūrī, kurā darbojas TaskServer (taskd).

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

   TaskServer (taskd) tagad ir instalēts un iestatīts jūsu CentOS 7 instancē.

5. darbība: konfigurējiet TaskWarrior klienta sertifikātu un atslēgu

1. Jums ir jāizveido klienta sertifikāti un atslēga, lai šifrētu saziņu starp TaskServer (taskd) un TaskWarrior (uzdevums). Palaidiet tālāk norādīto komandu, lai ģenerētu klienta sertifikātu un atslēgu. Aizstāt NAMEar vārdu, kuru viegli atpazīstat savam klientam.

   generate.client NAME
   

   Šī komanda direktorijā izveidos šādus failus ( NAME.cert.pem, NAME.key.pem) /etc/pki/taskd/.

2. Kopējiet tālāk norādītos failus savā lietotāja direktorijā, mainiet īpašumtiesības un atļaujas. Aizstāt joeqpublic tālāk ar savu faktisko lietotājvārdu direktorijā.

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

3. Izveidojiet sertifikātu un atslēgu zip arhīvu.

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

4. Izmantojiet scp(komandrindu) vai WinSCP (GUI priekšgals SCP), lai lejupielādētu certificates.zipfailu no CentOS instances savā klienta ierīcē (datorā/klēpjdatorā/viedtālrunī).

5. Atmetiet root tiesības un izpildiet pārējās komandas kā parastais lietotājs.

   exit
   

   TaskServer (taskd) tagad ir iestatīts un gatavs TaskWarrior (uzdevumu) klientiem izveidot savienojumu.

6. darbība. Izveidojiet savu pirmo TaskWarrior grupu un lietotāju

1. Lai izveidotu, dzēstu, modificētu un sinhronizētu savus uzdevumus, jums būs nepieciešams lietotāja konts. Tomēr, pirms varat pievienot lietotājus, vispirms ir jāizveido organizācijas grupa. Palaidiet tālāk norādīto komandu, lai izveidotu savu pirmo grupu. Aizstāt GROUP ar viegli atpazīstamu nosaukumu.

2. SVARĪGS! taskdKomandu, lai izveidotu grupas / lietotājiem jābūt skrēja kā taskdlietotājs. Darbojoties kā saknes lietotājs, tiks izveidoti direktoriji un faili, kas pieder saknes lietotājam, /var/lib/taskd/orgsun tas neļaus TaskWarrior (uzdevumu) klientiem piekļūt vai modificēt jebko grupā, kurai tie ir piešķirti. Piekļuve tiks liegta.

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

3. Tagad, kad esat izveidojis savu pirmo grupu, izveidosim savu pirmo lietotāju. Palaidiet tālāk norādīto komandu, lai izveidotu lietotāju, kas piešķirts grupai, kas izveidota 1. darbībā. Kopējiet un ielīmējiet ģenerēto lietotāja atslēgu, lietotāju un grupu teksta failā. Atkārtojiet šo procesu, lai pievienotu papildu lietotājus.

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

7. darbība. Instalējiet TaskWarrior klientus

Windows 10 (veidot vēlāk par 1607+)

Lai izmantotu TaskWarrior (uzdevumu) operētājsistēmā Windows 10, no Windows veikala jāinstalē Windows apakšsistēma operētājsistēmai Linux .

1. Lai instalētu WSL, ir nepieciešama paaugstināta Powershell uzvedne. Nospiediet loga taustiņu un ierakstiet powershell . Ar peles labo pogu noklikšķiniet uz Windows Powershell rezultātu augšpusē un atlasiet Palaist kā administratoram . Uzvednē Lietotāja konta kontrole noklikšķiniet uz Jā . Kopējiet un ielīmējiet tālāk esošo tekstu Powershell logos. Kad WSL instalēšana ir pabeigta, nospiediet taustiņu Y, lai restartētu Windows.

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

2. Pēc pārstartēšanas atveriet komandu uzvedni un ierakstiet šādu komandu bash . Tas instalēs Ubuntu operētājsistēmā Windows. Nospiediet Y taustiņu . Tagad tas tiks lejupielādēts un izvilkts. Izvēlieties lietotājvārdu un paroli.

   bash
   

3. Tagad ir pienācis laiks instalēt TaskWarrior (uzdevumu). Konsolē ierakstiet šo komandu.

   sudo apt-get install task -y
   

4. Ierakstiet izeja divreiz, lai izietu no bash termināla un Windows komandrindas.

5. Noklikšķiniet uz pogas Sākt izvēlne. Ierakstiet ubuntu . Ar peles labo pogu noklikšķiniet uz Bash uz Ubuntu operētājsistēmā Windows . Atlasiet Piespraust uzdevumjoslai . Tas nodrošina ērtības, lai ātri piekļūtu bash, lai piekļūtu TaskWarrior (uzdevumam).

6. Noklikšķiniet uz Ubuntu ikonas, kuru tikko izveidojāt uzdevumjoslā. Tiks atvērts termināļa logs, kurā darbojas Bash. Tālāk ierakstiet šo komandu, lai izveidotu TaskWarrior (uzdevumu) datu direktoriju ( ~/.task/) un konfigurācijas failu ( .taskrc).

   task version
   yes
   

7. Jums ir nepieciešams, lai pārvietotu certificates.zipfailu esat saglabājis iepriekš par TaskServer uzstādīšanas nonāk laikā ~/.taskd/direktoriju iekšpusē jūsu lietotāja direktorijā. Lai izvilktu failus no zip faila, unzipvispirms instalējiet programmu. Kopējiet un ielīmējiet tālāk norādītās komandas, aizstājot jūsu kopijas faktisko atrašanās vietu certificates.zip.

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

8. Ievadiet šādas komandas, lai iestatītu TaskWarrior (uzdevumu), lai izveidotu savienojumu ar TaskServer (taskd). Aizstājiet NAME ar to, ko nosaucāt savam sertifikātam un atslēgai, GROUP ar jūsu izveidoto grupu, Džo K. Publiski ar jūsu izveidoto lietotājvārdu un XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX ar atslēgu, kas piešķirta, kad jūsu lietotājs tika izveidots TaskWarrior (taskd) serverī.

   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. Tagad ir pienācis laiks sinhronizēt TaskWarrior (uzdevumu) ar TaskServer (taskd). Palaidiet tālāk norādīto komandu, lai inicializētu datu bāzi.

   task sync init
   

   Sinhronizācija starp jūsu TaskWarrior (uzdevumu) klientu un TaskServer (taskd) tagad ir iestatīta operētājsistēmas Windows 10 platformā.

Android

Lai izmantotu TaskWarrior (uzdevumu) operētājsistēmā Android, no Google Play veikala jāinstalē TaskWarrior Android ierīcēm .

1. Google Play veikalā instalējiet Android lietotni TaskWarrior (task).

2. Atveriet Android lietotni TaskWarrior (task).

3. Lietotne jums liks izveidot kontu ar vēlamo konta nosaukumu . Ievadiet nosaukumu, kuru izvēlējāties, izveidojot lietotājvārdu TaskServer (taskd) lietotājam.

4. Atstājiet datu mapi uz noklusējuma iestatījumu <<Izveidot jaunu>> un pieskarieties pogai Labi . Izmantojiet failu pārvaldnieka programmu, lai krātuves saknē izveidotu mapi (piemēram: /storage/emulate/0/Certs). Nosūtiet lietotni fonā.

5. Kopējiet certificates.zipiepriekš izveidoto failu un izņemiet tā saturu savā direktorijā, kas izveidota 4. darbībā.

6. Priekšplānā lietotne “TaskWarrior (task) For Android” un pieskarieties izvēlnei lietotnes augšējā kreisajā stūrī, lai to atvērtu.

7. Ritiniet uz leju līdz izvēlnes apakšdaļai un pieskarieties opcijai Iestatījumi .

8. Tiks atvērts vienkāršs iebūvēts TaskWarrior Android lietotņu teksta redaktors.

9. Ievadiet tālāk norādītās opcijas, lai iestatītu sinhronizāciju ar savu TaskServer (taskd). Nomainiet taskd.ca/ taskd.certificate/ taskd.key` mainīgie ar faktisko ca / sertifikāta / atslēgas direktorija ceļš (-i), NAME ar to, ko jūs nosauca savu sertifikātu un taustiņu GROUP ar grupu, kuru izveidojāt, Joe Q. Sabiedrības ar lietotājvārdu esat izveidojis un XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX ar atslēgu, kas tika piešķirta, kad izveidojāt savu lietotāju TaskWarrior (taskd) serverī.

   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. Pieskarieties disketes ikonai, lai saglabātu iestatījumus.

Sinhronizācija starp jūsu TaskWarrior (uzdevumu) klientu un TaskServer (taskd) tagad ir iestatīta Android platformā.

Linux

1. Skatiet TaskWarrior (uzdevumu) izplatīšanas sadaļu, lai instalētu jūsu konkrētajam Linux izplatīšanai .

2. Atveriet termināļa logu. Tālāk ierakstiet šo komandu, lai izveidotu TaskWarrior (uzdevumu) datu direktoriju ( ~/.task/) un konfigurācijas failu ( .taskrc).

   task version
   yes
   

3. Jums ir nepieciešams, lai pārvietotu certificates.zipfailu esat saglabājis agrāk TaskServer uzstādīšanas uz ~/.taskd/direktoriju iekšpusē jūsu lietotāja direktorijā. Lai izvilktu failus no zip faila, unzipvispirms instalējiet programmu savam konkrētajam izplatīšanai. Kopējiet un ielīmējiet tālāk norādītās komandas, aizstājot savas kopijas faktisko atrašanās vietu certificates.zip.

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

4. Ievadiet šādas komandas, lai iestatītu TaskWarrior (uzdevumu), lai izveidotu savienojumu ar TaskServer (taskd). Aizstājiet NAME ar to, ko nosaucāt savam sertifikātam un atslēgai, GROUP ar jūsu izveidoto grupu, Džo K. Publiski ar jūsu izveidoto lietotājvārdu un XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX ar atslēgu, kas piešķirta, kad jūsu lietotājs tika izveidots TaskWarrior (taskd) serverī.

   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. Tagad ir pienācis laiks sinhronizēt TaskWarrior (uzdevumu) ar TaskServer (taskd). Palaidiet tālāk norādīto komandu, lai inicializētu datu bāzi.

   task sync init
   

Papildinājums: ja palaižat Gnome Shell, ir paplašinājums TaskWhisper, kas integrējas ar TaskWarrior (uzdevumu).

Sinhronizācija starp jūsu TaskWarrior (uzdevumu) klientu un TaskServer (taskd) tagad ir iestatīta jūsu iecienītākajā Linux distro.