Įdiekite „TaskServer“ (taskd) „CentOS 7“.

TaskWarrior yra atvirojo kodo laiko valdymo įrankis, kuris yra Todo.txt programos ir jos klonų patobulinimas. Atsižvelgiant į tai, kad eilinis žmogus savo kasdieniniame grafike naudoja kelis įrenginius/platformas, labai svarbu turėti galimybę turėti centralizuotą saugyklą, kurioje duomenis būtų galima pasiekti ir atnaujinti iš bet kurio įrenginio. Šioje pamokoje pagrindinis dėmesys bus skiriamas serverio, vadinamo „TaskServer“ (užduotis), ir kliento, vadinamo „TaskWarrior“ (užduotis), nustatymui, kad keli kliento įrenginiai galėtų saugiai pasiekti ir keistis duomenimis.

Jis turi šias funkcijas:

• Neribotos užduotys
• Užduočių prioritetų nustatymas
• Paieškos filtravimas
• Žymėjimas
• Automatinis sinchronizavimas
• Automatinis atsarginis kopijavimas
• Visiška kontrolė ir privatumas
• Šifruotas ryšys

Būtinos sąlygos

• CentOS 7 x64 serverio egzempliorius.
• Sudo vartotojas.
• Domeno pavadinimas nurodė Vultr egzempliorių ( taskd.example.com )

1 veiksmas: atnaujinkite sistemą

Prisijunkite kaip sudo naudotojas, kad įdiegtumėte EPEL saugyklą ir atnaujintumėte sistemą taip:

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

2 veiksmas: įdiekite RPM Build ir kūrimo įrankius

EPEL saugykloje nėra TaskServer (taskd) RPM, todėl turime patys sukurti jį iš šaltinio į RPM paketą.

1. Įdiekite GCC, Make, RPM Build, kūrimo ir pasirašymo įrankius.

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

2. Sukurkite GnuPG katalogą, kuriame bus GPG failai, reikalingi mūsų RPM pasirašymui.

   mkdir .gnupg
   

3. Kurdami raktą, mes reikalaujame entropijos sistemoje, kad galėtume tinkamai jį atsitiktinai suskirstyti. rngdDemonas generuoja entropija būtina iš /dev/urandom. Taigi įdiegkime tai dabar.

   yum install rngd -y
   

4. Paleiskite rngddemoną, kad sukurtumėte entropiją. Į -R variantas nurodo /dev/urandomvietoj numatytojo /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Sugeneruokite raktą. --Gen rakto parinktis pasako gpg sukurti naują raktų porą.

   gpg --gen-key
   

6. Pasirinkę „ Prašome pasirinkti, kokio tipo rakto norite: “ pasirinkite „ (1) RSA ir RSA (numatytasis) “ kaip rakto tipą, įvesdami 1 ir paspausdami klavišą „ Return/Enter“ .

7. Parinkčiai „ Kokio klavišo dydžio norite? (2048) “ pasirinkite numatytąją reikšmę paspausdami klavišą „ Return/Enter“ .

8. Parinkčiai " Nurodykite, kiek laiko turi galioti raktas. " pasirinkite numatytąją reikšmę paspausdami klavišą Return/Enter .

9. Norėdami pasirinkti parinktį „ Ar tai teisinga? (y/N) “, įveskite y ir paspauskite klavišą „ Return/Enter“ .

10. Skiltyje „ Tikrasis vardas: “ įveskite pasirinktą pavadinimą ir paspauskite klavišą „ Return/Enter“ .

11. Skiltyje „ El. pašto adresas: “ įveskite pasirinktą el. pašto adresą ir paspauskite klavišą „ Return/Enter“ .

12. Komentaras: skyrius gali būti paliktas tuščias, jei to pageidautų.

13. Jei neteisingai įvedėte informaciją, atlikite reikiamus pakeitimus. Jei jus tenkina rodoma USER-ID informacija, įveskite O (didžiąją raidę O, o ne nulį) ir paspauskite grįžimo/įvesties klavišą.

14. GnuPG dabar paragins jus sukurti ir patvirtinti raktų poros slaptažodį.

15. Įvedus slaptažodžius, jūsų GnuPG raktų pora bus sukurta .gnupgjūsų vartotojo katalogo kataloge.

16. Paleiskite šią komandą, kad būtų rodomas .gnupgkatalogo turinys . Jame turėtų būti šis katalogas private-keys-v1.dir failai pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Eksportuokite sukurtą raktų porą. --Export variantas paveda GnuPG eksportuoti raktų porą. -A variantas nurodo GnuPG išvesties pagrindinį porą ASCII šarvai formatu . Pakeiskite „ Joe Q. Public “ pavadinimu, kurį įvedėte kurdami raktų porą atlikdami 10 veiksmą aukščiau. Pakeiskite „ jqpublic “ bet kokiu pasirinktu tekstu.

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

18. Importuokite raktų porą į RPM raktų saugyklą. Pakeiskite „ jqpublic “ tekstu, kurį pasirinkote atlikdami 17 veiksmą.

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

19. Patikrinkite, ar raktų pora buvo įtraukta į RPM raktų saugyklą. --Q ar gpg-pubkey variantas užklausų RPM GnuPG KeyStore. % {Name} -% {versija} -% {spaudai} -> {% santrauka} \ N Rodo į žmogaus skaitomais ženklais, rezultatas.

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

20. Sukūrus .rpmmacros file, RPM galima tinkinti, kad būtų atlikta priskirta veikla (pavyzdys: palengvinti automatinį RPM pasirašymą). Norėdami nanosukurti failą, naudokite programą.

    nano .rpmmacros
    

21. Tada į .rpmmacrosfailą pridėkite toliau pateiktą tekstą .

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

22. Išsaugokite dokumentą įvesdami šias klaviatūros kombinacijas. Į CTRL + X raktus. Tada S klavišas. Galiausiai, grįžimo / įvesties klavišas.

23. Ši komanda nustatys jūsų RPM kūrimo aplinką. Taip prie .rpmmacrosfailo, kurį sukūrėte atlikdami 20 veiksmą, bus pridėtos papildomos makrokomandos ir sukurti reikalingi katalogai, skirti kurti ir saugoti RPM.

    rpmdev-setuptree
    

24. Vykdykite šią komandą, kad būtų rodomas rpmbuild katalogo turinys. Jame turėtų būti šie katalogai SOURCES , RPMS , BUILD , SRPMS ir SPECS .

    find rpmbuild
    

25. Atsisiųskite TaskServer (taskd) šaltinio kodą į rpmbuild/SOURCESkatalogą.

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

26. Užmuškite vykstantį rgndprocesą.

    sudo kill -9 rngd
    

3 veiksmas: sukurkite TaskServer (taskd) RPM iš šaltinio

1. Norint sukurti naują RPM iš šaltinio, turi būti sukurtas TaskServer (taskd) SPEC failas.

   nano rpmbuild/SPECS/taskd.spec
   

2. Pridėkite toliau pateiktą tekstą į taskd.specfailą.

   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. Kad TaskServer (taskd) galėtų bendrauti ir sinchronizuoti su TaskWarrior (užduočių) klientais, /etc/pki/taskd/serverio ir kliento sertifikatams / raktams generuoti turėsite naudoti generavimo scenarijus, esančius žemiau . Perkelkite į pagrindinį vartotoją naudodami toliau pateiktą komandą ir pakeiskite katalogą į /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Naudokite nanoprogramą, kad sukurtumėte varsfailą, kad sukurtumėte savarankiškai pasirašytą Root CA.

   nano vars
   

   Pridėkite toliau pateiktą tekstą į vars failą. Pakeiskite ORGANIZACIJĄ , KN , ŠALĮ , VALSTYBĘ ir VIETOVĘ taip, kaip jums patinka .

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

3. Sugeneruokite savarankiškai pasirašytą Root CA, sertifikatą, serverio raktą ir serverio atšaukimo sąrašą (neprivaloma).

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

   Šios komandos sukurs šiuos failus ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemir server.crl.pem) /etc/pki/taskd/kataloge. Kad TaskServer (taskd) įsijungtų, sertifikatų ir raktų, sugeneruotų atliekant #37 veiksmą, nuosavybės ir teisės turi būti pakeistos, kad TaskServer (taskd) galėtų juos pasiekti. Vykdykite toliau pateiktas komandas, kad jas pakeistumėte.

   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. Įjunkite ir paleiskite TaskServer (taskd) demoną.

   systemctl enable taskd
   systemctl start taskd
   

5. Atidarykite ugniasienės prievadą, kuriame veikia TaskServer (taskd).

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

   „TaskServer“ (taskd) dabar įdiegtas ir nustatytas jūsų „CentOS 7“ egzemplioriuje.

5 veiksmas: sukonfigūruokite „TaskWarrior“ kliento sertifikatą ir raktą

1. Turite sukurti kliento sertifikatus ir raktą, kad užšifruotumėte ryšį tarp TaskServer (užduotis) ir TaskWarrior (užduotis). Vykdykite toliau pateiktą komandą, kad sugeneruotumėte kliento sertifikatą ir raktą. Pakeiskite NAMEvardu, kurį lengvai atpažįstate savo klientui.

   generate.client NAME
   

   Ši komanda sukurs šiuos failus ( NAME.cert.pem, NAME.key.pem) /etc/pki/taskd/katalogo viduje .

2. Nukopijuokite šiuos failus į savo vartotojo katalogą, pakeiskite nuosavybės teises ir teises. Pavaduojantis narys joeqpublic žemiau jūsų faktinis kataloge vartotojo vardą.

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

3. Sukurkite sertifikatų ir rakto ZIP archyvą.

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

4. Norėdami atsisiųsti failą iš CentOS egzemplioriaus į kliento įrenginį (kompiuterį / nešiojamąjį kompiuterį / išmanųjį telefoną), naudokite scp(komandinę eilutę) arba WinSCP (GUI sąsaja, skirta SCP certificates.zip).

5. Atsisakykite root teisių ir atlikite likusias komandas kaip įprastas vartotojas.

   exit
   

   TaskServer (taskd) dabar nustatytas ir paruoštas prisijungti TaskWarrior (užduočių) klientams.

6 veiksmas: sukurkite pirmąją TaskWarrior grupę ir vartotoją

1. Kad galėtumėte kurti, ištrinti, keisti ir sinchronizuoti užduotis, jums reikės vartotojo abonemento. Tačiau prieš įtraukdami vartotojus pirmiausia turėsite sukurti organizacijos grupę. Vykdykite toliau pateiktą komandą, kad sukurtumėte pirmąją grupę. Pakeiskite GROUP lengvai atpažįstamu pavadinimu.

2. SVARBU! taskdKomandų sukurti grupes / vartotojai turi būti Ran kaip taskdvartotojas. Vykdant kaip root naudotojas, bus sukurti katalogai ir failai, priklausantys pagrindiniam vartotojui, /var/lib/taskd/orgso tai neleis TaskWarrior (užduočių) klientams pasiekti ar modifikuoti bet ką grupėje, kuriai jie buvo priskirti. Prieiga bus uždrausta.

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

3. Dabar, kai sukūrėte savo pirmąją grupę, sukurkime pirmąjį vartotoją. Vykdykite toliau pateiktą komandą, kad sukurtumėte vartotoją, priskirtą grupei, sukurtai atliekant 1 veiksmą. Nukopijuokite ir įklijuokite sugeneruotą vartotojo raktą, vartotoją ir grupę į tekstinį failą. Pakartokite procesą, kad pridėtumėte papildomų vartotojų.

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

7 veiksmas: įdiekite „TaskWarrior“ klientus

„Windows 10“ (sukurta vėliau nei 1607 ir naujesnė versija)

Norėdami naudoti „TaskWarrior“ (užduotis) sistemoje „Windows 10“, iš „Windows“ parduotuvės turite įdiegti „ Windows“ posistemį, skirtą „Linux“ .

1. Norint įdiegti WSL, reikalingas padidintas Powershell raginimas. Paspauskite lango klavišą ir įveskite powershell . Dešiniuoju pelės mygtuku spustelėkite „Windows Powershell“ rezultatų viršuje ir pasirinkite „ Vykdyti kaip administratorių “. Vartotojo abonemento valdymo raginime spustelėkite Taip . Nukopijuokite ir įklijuokite toliau pateiktą tekstą „Powershell“ languose. Kai WSL baigs diegti, paspauskite Y klavišą, kad paleistumėte Windows iš naujo.

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

2. Paleidę iš naujo atidarykite komandų eilutę ir įveskite šią komandą bash . Tai įdiegs „Ubuntu“ sistemoje „Windows“. Paspauskite Y klavišą . Dabar jis bus atsisiųstas ir ištrauktas. Pasirinkite vartotojo vardą ir slaptažodį.

   bash
   

3. Dabar atėjo laikas įdiegti TaskWarrior (užduotį). Įveskite šią komandą konsolės viduje.

   sudo apt-get install task -y
   

4. Du kartus įveskite exit, kad išeitumėte iš „bash“ terminalo ir „Windows“ komandų eilutės.

5. Spustelėkite mygtuką Pradėti meniu. Įveskite ubuntu . Dešiniuoju pelės mygtuku spustelėkite Bash Ubuntu sistemoje Windows . Pasirinkite Prisegti prie užduočių juostos . Tai suteikia patogumo greitai pasiekti bash ir pasiekti TaskWarrior (užduotį).

6. Spustelėkite ką tik sukurtą Ubuntu piktogramą užduočių juostoje. Bus atidarytas terminalo langas, kuriame veikia „Bash“. Toliau įveskite šią komandą, kad sukurtumėte TaskWarrior (užduočių) duomenų katalogą ( ~/.task/) ir konfigūracijos failą ( .taskrc).

   task version
   yes
   

7. certificates.zipFailą, kurį išsaugojote anksčiau vykdydami TaskServer sąranką, turite perkelti į ~/.taskd/savo vartotojo katalogo katalogą. Norėdami išskleisti failus iš ZIP failo, pirmiausia įdiekite unzipprogramą. Nukopijuokite ir įklijuokite toliau pateiktas komandas, pakeisdamos tikrąją kopijos vietą certificates.zip.

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

8. Įveskite šias komandas, kad nustatytumėte „TaskWarrior“ (užduotį), kad prisijungtų prie „TaskServer“ (taskd). Pakeiskite NAME tuo, ką pavadinote savo sertifikatu ir raktu, GROUP - savo sukurta grupe, Joe Q. Vieša su jūsų sukurtu vartotojo vardu ir XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX raktu, priskirtu jūsų naudotojui. buvo sukurtas TaskWarrior (taskd) serveryje.

   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. Dabar atėjo laikas sinchronizuoti TaskWarrior (užduotis) su TaskServer (taskd). Norėdami inicijuoti duomenų bazę, paleiskite toliau pateiktą komandą.

   task sync init
   

   Sinchronizavimas tarp jūsų TaskWarrior (užduočių) kliento ir TaskServer (taskd) dabar nustatytas Windows 10 platformoje.

Android

Norėdami naudoti „TaskWarrior“ (užduotis) „Android“, turite įdiegti „ TaskWarrior“, skirtą „Android“, iš „Google Play“ parduotuvės.

1. Įdiekite „TaskWarrior“ (užduotis) „Android“ programą „Google Play“ parduotuvėje.

2. Atidarykite „Android“ skirtą „TaskWarrior“ (užduotis) programą.

3. Programėlė paragins susikurti paskyrą su pageidaujamu paskyros pavadinimu . Įveskite vardą, kurį pasirinkote kurdami TaskServer (taskd) vartotojo vartotojo vardą.

4. Palikite duomenų aplanko numatytąjį nustatymą <<Sukurti naują>> ir bakstelėkite mygtuką Gerai . Naudokite failų tvarkyklės programą, kad sukurtumėte aplanką saugyklos šaknyje (pavyzdžiui: /storage/emulate/0/Certs). Nusiųskite programą į foną.

5. Nukopijuokite certificates.zipfailą, kurį sukūrėte anksčiau, ir išskleiskite jo turinį į katalogą, sukurtą atliekant 4 veiksmą.

6. Programos „TaskWarrior (task) For Android“ pirmame plane ir bakstelėkite meniu viršutiniame kairiajame programos kampe, kad ją atidarytumėte.

7. Slinkite žemyn į meniu apačią ir bakstelėkite parinktį Nustatymai .

8. Tai atidarys paprastą integruotą „TaskWarrior For Android“ programos teksto rengyklę.

9. Įveskite šias parinktis, kad nustatytumėte sinchronizavimą su savo TaskServer (taskd). Pakeiskite taskd.ca/ taskd.certificate/ taskd.key` kintamuosius su faktine ca / sertifikato / Mygtukais katalogas kelyje (-ai), PAVADINIMAS su ką pavadino savo pažymėjimą ir raktas, GRUPĖ su grupe sukurtą, Džo K. Viešojo su vartotojo vardu jums sukurta ir XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX su raktu, priskirtu, kai sukūrėte savo naudotoją TaskWarrior (taskd) serveryje.

   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. Bakstelėkite diskelio piktogramą, kad išsaugotumėte nustatymus.

Sinchronizavimas tarp jūsų TaskWarrior (užduočių) kliento ir TaskServer (taskd) dabar nustatytas Android platformoje.

Linux

1. Norėdami įdiegti konkrečiam Linux platinimui, žr. TaskWarrior (užduočių) platinimo skyrių .

2. Atidarykite terminalo langą. Toliau įveskite šią komandą, kad sukurtumėte TaskWarrior (užduočių) duomenų katalogą ( ~/.task/) ir konfigūracijos failą ( .taskrc).

   task version
   yes
   

3. certificates.zipFailą, kurį išsaugojote anksčiau „TaskServer“ sąrankoje, turite perkelti į ~/.taskd/savo vartotojo katalogo katalogą. Norėdami išskleisti failus iš ZIP failo, pirmiausia įdiekite unzipkonkrečiam platinimui skirtą programą. Nukopijuokite ir įklijuokite toliau pateiktas komandas, pakeisdami tikrąją kopijos vietą certificates.zip.

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

4. Įveskite šias komandas, kad nustatytumėte „TaskWarrior“ (užduotį), kad prisijungtų prie „TaskServer“ (taskd). Pakeiskite NAME tuo, ką pavadinote savo sertifikatu ir raktu, GROUP - savo sukurta grupe, Joe Q. Vieša su jūsų sukurtu vartotojo vardu ir XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX raktu, priskirtu jūsų naudotojui. buvo sukurtas TaskWarrior (taskd) serveryje.

   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. Dabar atėjo laikas sinchronizuoti TaskWarrior (užduotis) su TaskServer (taskd). Norėdami inicijuoti duomenų bazę, paleiskite toliau pateiktą komandą.

   task sync init
   

Papildymas: jei naudojate „Gnome Shell“, yra plėtinys „ TaskWhisper“, kuris integruojamas su „TaskWarrior“ (užduotis).

Sinchronizavimas tarp jūsų „TaskWarrior“ (užduočių) kliento ir „TaskServer“ (taskd) dabar nustatytas jūsų mėgstamoje „Linux“ platinimo sistemoje.