Come installare Taiga Project Management Tool su Ubuntu 16.04

• Prerequisiti
• Installa PostgreSQL
• Installa Python
• Installa RabbitMQ
• Installa Nodejs
• Installa Taiga Backend
• Installa Frontend
• Installa Taiga Events
• Configura Circo
• Installa Nginx come proxy inverso
• Conclusione

Taiga è un'applicazione gratuita e open source per la gestione dei progetti. A differenza di altri strumenti di gestione del progetto, Taiga utilizza un approccio agile incrementale per gestire lo sviluppo del progetto. Taiga è un'applicazione molto potente e completamente personalizzabile. Il backend di Taiga è scritto in Python usando il framework Django. Il frontend è scritto in JavaScript usando i framework CoffeeScript e AngularJS. Taiga include funzionalità come collaborazione di progetto, Kanban board, tracciamento dei bug, reportistica, tracciamento dei tempi, backlog, wiki e altro.

Prerequisiti

• Un'istanza del server Vultr Ubuntu 16.04 con almeno 1 GB di RAM.
• Un utente sudo .

In questo tutorial, useremo taiga.example.comcome nome di dominio puntato al server. Sostituisci tutte le occorrenze di taiga.example.comcon il tuo vero nome di dominio.

Aggiorna il tuo sistema di base usando la guida Come aggiornare Ubuntu 16.04 . Dopo aver aggiornato il sistema, procedere con l'installazione di PostgreSQL.

Installa PostgreSQL

PostgreSQL è un sistema di database relazionale ad oggetti e noto per la sua stabilità e velocità. Taiga utilizza PostgreSQL per memorizzare il suo database. Aggiungi il repository PostgreSQL nel sistema.

echo "deb http://apt.postgresql.org/pub/repos/apt/ xenial-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list

Importa la chiave di firma GPG e aggiorna gli elenchi dei pacchetti.

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
sudo apt update

Installa il server di database PostgreSQL.

sudo apt -y install postgresql

Avviare il server PostgreSQL e abilitarlo ad avviarsi automaticamente all'avvio.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Cambia la password per l'utente PostgreSQL predefinito.

sudo passwd postgres

Accedi come utente PostgreSQL.

sudo su - postgres

Crea un nuovo utente PostgreSQL per Taiga.

createuser taiga 

PostgreSQL fornisce la psqlshell per eseguire query sul database. Passa alla shell PostgreSQL.

psql

Imposta una password per l'utente appena creato per il database Taiga.

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Sostituisci DBPasswordcon una password sicura. Crea un nuovo database per l'installazione di Taiga.

CREATE DATABASE taiga OWNER taiga;

Esci dalla psqlshell.

\q

Passa sudoall'utente.

exit

Installa Python

Taiga richiede Python versione 3.4 o successive e Python 3.5 viene preinstallato nella distribuzione Ubuntu 16.04. Installa alcuni altri pacchetti richiesti.

sudo apt -y install python3 python3-pip python3-dev python3-dev virtualenvwrapper

L'ambiente virtuale Python viene utilizzato per creare un ambiente virtuale isolato per un progetto Python. Un ambiente virtuale contiene le proprie directory di installazione e non condivide le librerie con ambienti globali e altri ambienti virtuali. Una volta che Python 3 è stato installato correttamente, dovresti essere in grado di controllarne la versione.

python3 -V

Vedrai quanto segue.

user@vultr:~$ python3 -V
Python 3.5.2

Aggiornamento pip, che è un'applicazione di gestione dipendenze.

sudo pip3 install --upgrade setuptools pip 

Inoltre, installa alcuni strumenti di compilazione che saranno necessari in seguito per compilare le dipendenze.

sudo apt -y install build-essential binutils-doc autoconf flex bison libjpeg-dev libfreetype6-dev zlib1g-dev libzmq3-dev libgdbm-dev libncurses5-dev automake libtool libffi-dev curl git tmux gettext

Installa RabbitMQ

Taiga utilizza RabbitMQ per elaborare la coda dei messaggi. RabbitMQ richiede che le librerie Erlang funzionino. Installa Erlang.

sudo apt -y install erlang

Aggiungi il repository RabbitMQ.

echo 'deb http://www.rabbitmq.com/debian/ stable main' | sudo tee /etc/apt/sources.list.d/rabbitmq.list

Importare la chiave di firma GPG RabbitMQ.

wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | sudo apt-key add -

Aggiorna le informazioni sul repository.

sudo apt update

Installa RabbitMQ.

sudo apt -y install rabbitmq-server

Avviare e abilitare il server RabbitMQ.

sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server

Aggiungi un utente RabbitMQ e vhost. Inoltre, fornire l'autorizzazione all'utente tramite l'host.

sudo rabbitmqctl add_user taiga StrongMQPassword
sudo rabbitmqctl add_vhost taiga
sudo rabbitmqctl set_permissions -p taiga taiga ".*" ".*" ".*"

Assicurati di sostituire StrongMQPasswordcon una password sicura.

Installa Nodejs

Node.js versione 7 o successive è necessario per compilare il frontend di Taiga. Aggiungi il repository versione 8 di Node.js.

curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -

Installa Node.js e l' pwgenutilità.

sudo apt install -y nodejs pwgen npm

pwgenverrà utilizzato in seguito per generare una stringa segreta avanzata. Installa CoffeeScript, poiché verrà utilizzato per compilare i file Taiga scritti nel framework CoffeeScript.

sudo npm install -g coffee-script gulp

Installa Taiga Backend

Aggiungi un nuovo utente di sistema per Taiga per garantire che i processi Taiga siano in esecuzione come utente senza privilegi.

sudo adduser taiga
sudo su - taiga

Nota : d' ora in poi, tutti i comandi devono essere eseguiti come utente non privilegiato taigafino a quando non viene richiesto di tornare sudoall'utente.

Creare una nuova directory per archiviare i file di registro.

mkdir -p ~/logs

Clona il repository backend Taiga da GitHub e controlla l'ultimo ramo stabile.

git clone https://github.com/taigaio/taiga-back.git taiga-back
cd taiga-back
git checkout stable

Ora crea un nuovo ambiente virtuale per Taiga usando Python 3.

mkvirtualenv -p /usr/bin/python3 taiga
pip3 install --upgrade setuptools

Installa le dipendenze Python richieste usando pip.

pip3 install -r requirements.txt

Popolare il database con i dati iniziali necessari.

python3 manage.py migrate --noinput
python3 manage.py loaddata initial_user
python3 manage.py loaddata initial_project_templates
python3 manage.py compilemessages
python3 manage.py collectstatic --noinput

I comandi precedenti scriveranno i dati nel database PostgreSQL. Taiga inoltre fornisce alcuni dati dimostrativi o di esempio che possono essere utili per la valutazione del prodotto. Se si desidera installare i dati di esempio, eseguire quanto segue.

python3 manage.py sample_data

Nota : l' installazione dei dati di esempio è facoltativa e ha il solo scopo di valutare il prodotto.

Prima di procedere con la creazione del file di configurazione per il backend Taiga, è necessario generare una stringa segreta. Questa stringa verrà utilizzata per crittografare i dati della sessione.

Genera una stringa casuale di 64 caratteri.

pwgen -s -1 64

Dovresti vedere l'output come una stringa casuale.

(taiga) taiga@vultr:~/taiga-back$ pwgen -s -1 64
fhDfyYVJ4EH3tvAyUzmfWSeCXuf5sy5EEWrMQPaf9t3JSFrpiL6yvUEOWsFOTscP

Crea un nuovo file di configurazione per il backend Taiga.

nano ~/taiga-back/settings/local.py

Popolare il file con il seguente codice.

from .common import *

MEDIA_URL = "https://taiga.example.com/media/"
STATIC_URL = "https://taiga.example.com/static/"
SITES["front"]["scheme"] = "https"
SITES["front"]["domain"] = "taiga.example.com"

SECRET_KEY = "Generated_Secret_Key"

DEBUG = False
PUBLIC_REGISTER_ENABLED = True

DEFAULT_FROM_EMAIL = "mail@example.com"
SERVER_EMAIL = DEFAULT_FROM_EMAIL

#CELERY_ENABLED = True

EVENTS_PUSH_BACKEND = "taiga.events.backends.rabbitmq.EventsPushBackend"
EVENTS_PUSH_BACKEND_OPTIONS = {"url": "amqp://taiga:StrongMQPassword@localhost:5672/taiga"}

# Uncomment and populate with proper connection parameters
# for enable email sending. EMAIL_HOST_USER should end by @domain.tld
#EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
#EMAIL_USE_TLS = False
#EMAIL_HOST = "mail.example.com"
#EMAIL_HOST_USER = "mail@example.com"
#EMAIL_HOST_PASSWORD = "SMTPPassword"
#EMAIL_PORT = 25

# Uncomment and populate with proper connection parameters
# for enable github login/singin.
#GITHUB_API_CLIENT_ID = "yourgithubclientid"
#GITHUB_API_CLIENT_SECRET = "yourgithubclientsecret"

Assicurati di sostituire quello example domain namecon quello attuale nel codice sopra. Inoltre, sostituiscilo Generated_Secret_Keycon la chiave segreta effettiva e StrongMQPasswordcon la password effettiva per l'utente della coda messaggi Taiga. Se hai un server SMTP pronto e desideri utilizzare immediatamente le funzionalità di invio e-mail, puoi decommentare le opzioni e-mail e impostare il valore appropriato. Se non si dispone di un server di posta pronto, è possibile saltare l'impostazione della funzione e-mail per ora e impostarla successivamente in questo file di configurazione.

Se si desidera abilitare l'accesso GitHub, creare un'applicazione in GitHub e fornire l'ID client API e il segreto client.

Per verificare immediatamente se è possibile avviare il backend Taiga, eseguire il server Django integrato.

workon taiga
python manage.py runserver

Verrà visualizzato il seguente output se il server è stato avviato correttamente.

(taiga) taiga@vultr:~/taiga-back$ workon taiga
(taiga) taiga@vultr:~/taiga-back$ python manage.py runserver
Trying import local.py settings...
Trying import local.py settings...
Performing system checks...

System check identified no issues (0 silenced).
October 28, 2017 - 10:29:38
Django version 1.10.6, using settings 'settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Per verificare se è possibile accedere all'API, aprire un'altra sessione del terminale ed eseguire quanto segue.

curl http://127.0.0.1:8000/api/v1/

Verrà visualizzato un output simile restituito dalla chiamata API.

user@vultr:~$ curl http://127.0.0.1:8000/api/v1/
{"webhooks": "http://127.0.0.1:8000/api/v1/webhooks", "invitations": "http://127.0.0.1:8000/api/v1/invitations", "severities": "http://127.0.0.1:8000/api/v1/severities", "memberships": "http://127.0.0.1:8000/api/v1/memberships", "user-storage": "http://127.0.0.1:8000/api/v1/user-storage", "epics/(?P<resource_id>\\d+)/voters": "http://127.0.0.1:8000/api/v1/epics/(?P<resource_id>\\d+)/voters", "wiki": "http://127.0.0.1:8000/api/v1/wiki", "priorities": "http://127.0.0.1:8000/api/v1/priorities", "userstories/attachments": "http://127.0.0.1:8000/api/v1/userstories/attachments", "epics/(?P<epic>[^/.]+)/related_userstories": "http://127.0.0.1:8000/api/v1/epics/(?P<epic>[^/.]+)/related_userstories", "timeline/user": "http://127.0.0.1:8000/api/v1/timeline/user", "userstories/(?P<resource_id>\\d+)/voters": "http://127.0.0.1:8000/api/v1/userstories/(?P<resource_id>\\d+)/voters", "wiki-links": "http://127.0.0.1:8000/api/v1/wiki-links", "epics/attachments": "http://127.0.0.1:8000/api/v1/epics/attachments", "issues/custom-attributes-values": "http://127.0.0.1:8000/api/v1/issues/custom-attributes-values

Arresta il server back-end Taiga premendo " ctrl + C" e disattiva l'ambiente virtuale.

deactivate

Installa Frontend

Il frontend Taiga è il componente di Taiga che serve l'interfaccia utente Web. Clona il repository frontend Taiga da Github e controlla l'ultimo ramo stabile.

cd ~
git clone https://github.com/taigaio/taiga-front-dist.git taiga-front-dist
cd taiga-front-dist
git checkout stable

Crea un nuovo file di configurazione per il frontend Taiga.

nano ~/taiga-front-dist/dist/conf.json

Popolare il file.

{
    "api": "https://taiga.example.com/api/v1/",
    "eventsUrl": "wss://taiga.example.com/events",
    "eventsMaxMissedHeartbeats": 5,
    "eventsHeartbeatIntervalTime": 60000,
    "eventsReconnectTryInterval": 10000,
    "debug": true,
    "debugInfo": false,
    "defaultLanguage": "en",
    "themes": ["taiga"],
    "defaultTheme": "taiga",
    "publicRegisterEnabled": true,
    "feedbackEnabled": true,
    "privacyPolicyUrl": null,
    "termsOfServiceUrl": null,
    "maxUploadFileSize": null,
    "contribPlugins": [],
    "tribeHost": null,
    "importers": [],
    "gravatar": true
}

Assicurati di sostituire il example domaincon il dominio effettivo. Puoi anche cambiare la lingua predefinita e altri parametri nella configurazione sopra.

Installa Taiga Events

Oltre al frontend e al backend, dobbiamo anche installare eventi Taiga. Taiga events è un server socket web e consente al frontend Taiga di mostrare le modifiche in tempo reale in moduli come backlog, Kanban e altro. Utilizza inoltre il server RabbitMQ per l'elaborazione dei messaggi.

Clona il repository di eventi Taiga da Github.

cd ~
git clone https://github.com/taigaio/taiga-events.git taiga-events
cd taiga-events

Installa le dipendenze Node.js usando npm.

npm install

Crea un nuovo file di configurazione per gli eventi Taiga.

nano ~/taiga-events/config.json

Popolare il file.

{
    "url": "amqp://taiga:StrongMQPassword@localhost:5672/taiga",
    "secret": "Generated_Secret_Key",
    "webSocketServer": {
        "port": 8888
    }
}

Sostituisci Generated_Secret_Keycon l'attuale chiave segreta lunga 64 caratteri che hai generato in precedenza. La chiave segreta dovrebbe essere esattamente uguale alla chiave fornita nel file di configurazione del backend Taiga. Inoltre, aggiorna il StrongMQPasswordcon la password effettiva per l'utente della coda messaggi Taiga.

Configura Circo

Circus è un gestore dei processi per le applicazioni Python. Useremo Circus per gestire il backend e gli eventi Taiga.

Torna sudoall'utente.

exit

Nota : da adesso dovrai eseguire i comandi usando l' sudoutente.

sudo apt -y install circus

Crea un nuovo file di configurazione Circus per eseguire il backend Taiga.

sudo nano /etc/circus/conf.d/taiga.ini

Popolare il file.

[watcher:taiga]
working_dir = /home/taiga/taiga-back
cmd = gunicorn
args = -w 3 -t 60 --pythonpath=. -b 127.0.0.1:8001 taiga.wsgi
uid = taiga
numprocesses = 1
autostart = true
send_hup = true
stdout_stream.class = FileStream
stdout_stream.filename = /home/taiga/logs/gunicorn.stdout.log
stdout_stream.max_bytes = 10485760
stdout_stream.backup_count = 4
stderr_stream.class = FileStream
stderr_stream.filename = /home/taiga/logs/gunicorn.stderr.log
stderr_stream.max_bytes = 10485760
stderr_stream.backup_count = 4

[env:taiga]
PATH = /home/taiga/.virtualenvs/taiga/bin:$PATH
TERM=rxvt-256color
SHELL=/bin/bash
USER=taiga
LANG=en_US.UTF-8
HOME=/home/taiga
PYTHONPATH=/home/taiga/.virtualenvs/taiga/lib/python3.5/site-packages

Crea una nuova configurazione Circus per l'esecuzione di Eventi Taiga.

sudo nano /etc/circus/conf.d/taiga-events.ini

Popolare il file.

[watcher:taiga-events]
working_dir = /home/taiga/taiga-events
cmd = /usr/local/bin/coffee
args = index.coffee
uid = taiga
numprocesses = 1
autostart = true
send_hup = true
stdout_stream.class = FileStream
stdout_stream.filename = /home/taiga/logs/taigaevents.stdout.log
stdout_stream.max_bytes = 10485760
stdout_stream.backup_count = 12
stderr_stream.class = FileStream
stderr_stream.filename = /home/taiga/logs/taigaevents.stderr.log
stderr_stream.max_bytes = 10485760
stderr_stream.backup_count = 12

Riavvia Circus e abilita l'avvio automatico all'avvio.

sudo systemctl restart circusd
sudo systemctl enable circusd

Controlla lo stato di Circus.

circusctl status

Se Circus ha avviato correttamente tutti i processi Taiga, verrà visualizzato il seguente output.

user@vultr:~$ circusctl status
circusd-stats: active
plugin:flapping: active
taiga: active
taiga-events: active

Se vedi uno qualsiasi dei processi non attivi, esegui sudo chmod -R 777 /home/taiga/logse riavvia Circus. Controlla di nuovo lo stato dei processi Circus, questa volta troverai sicuramente il servizio in esecuzione.

Ora abbiamo Taiga installato e funzionante con successo. Prima di poterlo utilizzare, è necessario esporre l'installazione utilizzando qualsiasi server Web di produzione.

Installa Nginx come proxy inverso

Useremo Nginx come proxy inverso per servire l'applicazione agli utenti. Otterremo e installeremo anche certificati SSL da Let's Encrypt.

Certbot è il client ufficiale per l'emissione di certificati per Let's Encrypt CA. Aggiungi il repository PPA Certbot nel sistema.

sudo add-apt-repository ppa:certbot/certbot
sudo apt update

Installa Nginx e Certbot.

sudo apt -y install nginx certbot

Nota : per ottenere certificati da Let's Encrypt CA, è necessario assicurarsi che il dominio per il quale si desidera generare i certificati sia puntato verso il server. In caso contrario, apporta le modifiche necessarie ai record DNS del tuo dominio e attendi che il DNS si propaghi prima di effettuare nuovamente la richiesta di certificato. Certbot controlla l'autorità di dominio prima di fornire i certificati.

Ora usa il web server integrato in Certbot per generare i certificati per il tuo dominio.

sudo certbot certonly --standalone -d taiga.example.com

È probabile che i certificati generati siano archiviati nella /etc/letsencrypt/live/taiga.example.com/directory. Il certificato SSL verrà conservato come fullchain.peme la chiave privata verrà salvata come privkey.pem.

Let's Encrypt certificati scadranno tra 90 giorni, quindi si consiglia di impostare il rinnovo automatico per i certificati utilizzando i processi Cron. Cron è un servizio di sistema che viene utilizzato per eseguire attività periodiche.

Apri il file di lavoro cron.

sudo crontab -e

Aggiungi la seguente riga.

0 0 * * * /usr/bin/certbot renew --quiet

Il precedente cron job verrà eseguito ogni giorno a mezzanotte. Se il certificato è in scadenza, rinnoverà automaticamente i certificati.

Genera un forte parametro Diffie-Hellman. Fornisce un ulteriore livello di sicurezza per lo scambio di dati tra host e server.

sudo openssl dhparam -out /etc/ssl/dhparam.pem 2048 

Crea un nuovo blocco server Nginx per servire il frontend Taiga.

sudo nano /etc/nginx/sites-available/taiga

Popolare il file con il seguente.

server {
    listen 80;
    server_name taiga.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name taiga.example.com;

    access_log /home/taiga/logs/nginx.access.log;
    error_log /home/taiga/logs/nginx.error.log;

    large_client_header_buffers 4 32k;
    client_max_body_size 50M;
    charset utf-8;

    index index.html;

    # Frontend
    location / {
        root /home/taiga/taiga-front-dist/dist/;
        try_files $uri $uri/ /index.html;
    }

    # Backend
    location /api {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:8001/api;
        proxy_redirect off;
    }

    location /admin {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:8001$request_uri;
        proxy_redirect off;
    }

    # Static files
    location /static {
        alias /home/taiga/taiga-back/static;
    }

    # Media files
    location /media {
        alias /home/taiga/taiga-back/media;
    }

     location /events {
        proxy_pass http://127.0.0.1:8888/events;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_connect_timeout 7d;
        proxy_send_timeout 7d;
        proxy_read_timeout 7d;
    }

    add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload";
    add_header Public-Key-Pins 'pin-sha256="klO23nT2ehFDXCfx3eHTDRESMz3asj1muO+4aIdjiuY="; pin-sha256="633lt352PKRXbOwf4xSEa1M517scpD3l5f79xMD9r9Q="; max-age=2592000; includeSubDomains';

    ssl on;
    ssl_certificate /etc/letsencrypt/live/taiga.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/taiga.example.com/privkey.pem;
    ssl_session_timeout 5m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK';
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/ssl/dhparam.pem;
    ssl_stapling on;
    ssl_stapling_verify on;

}

Assicurati di cambiare il domain namee il path to the SSL certificates. Abilita l'host virtuale.

sudo ln -s /etc/nginx/sites-available/taiga /etc/nginx/sites-enabled/taiga

Ora puoi riavviare il web server Nginx e abilitarlo ad avviarsi automaticamente all'avvio.

sudo systemctl restart nginx
sudo systemctl status nginx

Infine, correggi la proprietà e l'autorizzazione sui file Taiga.

sudo chown -R taiga:taiga /home/taiga/
sudo chmod o+x /home/taiga/

Conclusione

Ora puoi accedere all'installazione di Taiga andando su https://taiga.example.com. Accedi utilizzando l'account amministratore iniziale con nome utente " admin" e password " 123123". L'installazione è ora pronta per l'uso in produzione. Inizia creando un nuovo progetto o valutando il prodotto. Se stai già gestendo un progetto su Github, Jira o Trello, puoi importare facilmente i progetti in Taiga utilizzando gli importatori .