Travailler avec Fano CLI
Qu'est-ce que Fano CLI ?
Le Fano Framework permet de configurer ou de remplacer de nombreuses fonctionnalités de base par une implémentation différente. Cela présente un inconvénient. Vous avez besoin de nombreux codes standard pour créer un seul projet.
Le Fano CLI est une application en ligne de commande permettant de créer un projet d'application Web Fano Framework. Elle facilite les tâches fastidieuses telles que la création d'un projet d'application Web Fano, la création d'un contrôleur, d'un modèle, d'une vue, de classes middleware, la génération d'une clef aléatoire et d'un GUID, la réduction des fichiers JavaScript et la configuration du serveur Web.
Fano CLI est un outil supplémentaire. Vous pouvez utiliser Fano Framework sans installer Fano CLI. Cependant, il est recommandé d'utiliser Fano CLI car vous pouvez générer facilement un projet d'application Web en quelques secondes.
Installation
Assurez-vous que Free Pascal et git sont installés. Ensuite, exécutez :
|
git clone https://github.com/fanoframework/fano-cli.git cd fano-cli ./tools/config.setup.sh ./build.sh |
Pour une saisie plus facile, copiez le binaire exécutable bin/out/fanocli dans un emplacement accessible globalement, par exemple :
| sudo cp bin/out/fanocli /usr/local/bin/fanocli |
Si vous ne souhaitez pas copier vers /usr/local/bin, ajoutez simplement le chemin de l'exécutable fanocli à la variable d'environnement PATH.
Si vous utilisez FreeBSD, après avoir exécuté config.setup.sh mais avant d'exécuter le script build.sh, éditez build.cfg et remplacez la ligne -Tlinux par -Tfreebsd.
Afficher l'aide de Fano CLI
Pour afficher les commandes disponibles, vous pouvez exécuter :
| fanocli --help |
ou simplement :
| fanocli |
Pour afficher l'aide d'une commande unique :
| fanocli --help --task=[nom de la tâche] |
ou :
| fanocli --task=[nom de la tâche] |
Par exemple :
| fanocli --task=project-scgi |
Création d'un projet d'application Web
Le Fano CLI fournit plusieurs commandes pour créer facilement une application Web Fano Framework, telles que --project-cgi, --project-fcgi, --project-fcgid, --project-scgi, --project-uwsgi, --project-mhd, --project-indy et --project-http permettant de créer un projet d'application Web prenant en charge CGI, FastCGI, SCGI et uwsgi, le protocole http. Actuellement, l'implémentation http utilise la bibliothèque libmicrohttpd, Indy ou la classe TFpHttpServer intégrée à Free Pascal :
| fanocli --project-cgi=[nom-du-projet] |
[nom-du-projet] est le répertoire dans lequel réside le projet et sera créé par Fano CLI.
Création d'un contrôleur
Après avoir créé la structure du projet, pour créer une classe de contrôleur, exécutez les options de ligne de commande --controller. Par exemple, si [nom-du-projet] ci-dessus est égal à test-fano, vous pouvez créer un contrôleur comme suit :
|
cd test-fano fanocli --controller=Hello |
Il créera les fichiers suivants :
|
test-fano/src/App/Hello/Controllers/HelloController.pas test-fano/src/App/Hello/Controllers/Factories/HelloControllerFactory.pas test-fano/src/Routes/Hello/routes.inc |
et modifie également les fichiers suivants :
|
test-fano/src/bootstrap.pas test-fano/src/Dependencies/controllers.dependencies.inc test-fano/src/Routes/routes.inc test-fano/build.cfg test-fano/build.cfg.sample |
Par défaut, il créera une route GET vers /hello. Ainsi, après avoir exécuté le script build.sh, vous pouvez accéder à HelloController en visitant l'URL :
| wget http://[votre nom d'hôte]/hello |
Pour créer un contrôleur pour un modèle de route ou une méthode HTTP spécifique, ajoutez les paramètres --route et --method. Par exemple, pour créer un contrôleur gérant la requête POST vers /my/hello :
| fanocli --controller=Hello --route=/my/hello --method=POST |
Si vous souhaitez que le contrôleur gère plusieurs méthodes, transmettez les méthodes sous forme de valeurs séparées par des virgules. L'exemple suivant crée la classe HelloController gérant les requêtes GET et POST pour router /my/hello :
| fanocli --controller=Hello --route=/my/hello --method=GET,POST |
Si vous souhaitez créer un contrôleur et ignorer la création d'itinéraire, utilisez le paramètre --no-route :
| fanocli --controller=Hello --no-route |
Création d'une vue
Après avoir créé la structure du projet, pour structurer la classe de vue, exécutez avec les options de ligne de commande --view :
|
cd test-fano fanocli --view=Hello |
Il créera les fichiers suivants :
|
test-fano/src/App/Hello/Views/HelloView.pas test-fano/src/App/Hello/Views/Factories/HelloViewFactory.pas |
et également modifier les fichiers suivants :
|
test-fano/src/bootstrap.pas test-fano/src/Dependencies/views.dependencies.inc test-fano/build.cfg test-fano/build.cfg.sample |
Création d'un modèle
Après avoir créé la structure du projet, pour structurer la classe du modèle, exécutez l'option de ligne de commande --model :
|
cd test-fano fanocli --model=Hello |
Il créera les fichiers suivants :
|
test-fano/src/App/Hello/Models/HelloModel.pas test-fano/src/App/Hello/Models/Factories/HelloModelFactory.pas |
et également modifier les fichiers suivants :
|
test-fano/src/bootstrap.pas test-fano/src/Dependencies/models.dependencies.inc test-fano/build.cfg test-fano/build.cfg.sample |
Créer un contrôleur, une vue et un modèle en même temps
Pour simplifier la création simultanée d'un contrôleur, d'une vue et d'un modèle, vous pouvez utiliser l'option de ligne de commande --mvc.
| fanocli --mvc=Hello |
La commande ci-dessus est égale à la commande suivante :
|
fanocli --controller=Hello fanocli --model=Hello fanocli --view=Hello |
Ajout de la prise en charge du middleware
Toutes les commandes de création de projet, c'est-à-dire les commandes --project*, acceptent le paramètre supplémentaire --with-middleware. S'il est défini, lors de la création du projet, la prise en charge du middleware est ajoutée au projet généré.
| fanocli --project-cgi=Hello --with-middleware |
Création d'un middleware
Pour créer un middleware, exécutez-le avec les options de ligne de commande --middleware :
|
cd test-fano fanocli --middleware=AuthOnly |
Il créera les fichiers suivants :
|
test-fano/src/Middlewares/AuthOnly/AuthOnlyMiddleware.pas test-fano/src/Middlewares/AuthOnly/Factories/AuthOnlyMiddlewareFactory.pas |
Générer une clef aléatoire
Pour générer une clef aléatoire (par exemple, une clé secrète de chiffrement), exécutez les options de ligne de commande --key=[length] :
| fanocli --key=32 |
Si la longueur n'est pas définie, on suppose qu'elle est de 64 octets de valeur aléatoire. La sortie est une chaîne codée en Base64 d'octets aléatoires. Sous Unix ou Linux, elle lit à partir de /dev/urandom. Sous Windows, elle utilise CryptoAPI.
Générer le GUID
Pour générer le GUID, exécutez avec les options de ligne de commande --guid :
| fanocli --guid |
Minifier les fichiers JavaScript
Pour réduire la taille du fichier JavaScript, exécutez les options de ligne de commande --jsmin=[path].
Avec [path] vide, il analysera le répertoire actuel à la recherche de tous les fichiers JavaScript, les minifiera et les générera sous forme de nouveau fichier avec le nom du fichier d'origine suivi de min.js :
| fanocli --jsmin |
Si [path] n'est pas vide, s'il s'agit d'un répertoire, il analyse ce répertoire à la recherche de fichiers JavaScript, les réduit et les génère sous forme de nouveau fichier avec un nom utilisant le nom de fichier d'origine suivi de min.js. Si [path] est un fichier unique, il le réduit et crée un nouveau fichier avec le même nom suivi de min.js.
| fanocli --jsmin=/path/to/js |
Si vous spécifiez le paramètre facultatif --output=[target-path], alors [target-path] sera utilisé comme nom de fichier :
| fanocli --jsmin=/path/to/js --output=/path/to/js/scripts.min.js |
Si [target-path] est égal à stdout, la sortie minifiée est affichée sur STDOUT.
| fanocli --jsmin=/path/to/js --output=stdout |
Minifier les fichiers CSS
Pour réduire la taille du fichier CSS, exécutez les options de ligne de commande --cssmin=[path].
Avec [path] vide, il analysera le répertoire actuel à la recherche de tous les fichiers CSS, les minifiera et les sortira sous forme de nouveau fichier avec le nom du fichier d'origine suivi de min.css :
| fanocli --cssmin |
Si [path] n'est pas vide, s'il s'agit d'un répertoire, il analyse ce répertoire à la recherche de fichiers CSS, les réduit et les génère sous forme de nouveau fichier avec le nom du fichier d'origine suivi de min.css. Si [path] est un fichier unique, il le réduit et crée un nouveau fichier avec le même nom suivi de min.css.
| fanocli --cssmin=/path/to/css |
Si vous spécifiez le paramètre facultatif --output=[target-path], alors [target-path] sera utilisé comme nom de fichier.
| fanocli --cssmin=/path/to/css --output=/path/to/css/styles.min.css |
Si [target-path] est égal à stdout, la sortie minifiée est affichée sur STDOUT :
| fanocli --cssmin=/path/to/css --output=stdout |
Ajouter la prise en charge de la session
Toutes les commandes de création de projet, c'est-à-dire les commandes --project*, acceptent le paramètre supplémentaire --with-session=[entreposage de session] où la valeur d'entreposage de session peut être l'une des valeurs suivantes :
| Valeur | Description |
|---|---|
| file | Créer une session qui stocke les données de session dans un fichier. |
| cookie | Créer une session qui stocke les données de session dans un cookie crypté. |
| db | Créer une session qui stocke les données de session dans la base de données. |
Session avec fichier comme entreposage
Si [entreposage de session] n'est pas défini, il s'agit d'un fichier. Les commandes suivantes sont donc identiques
|
fanocli --project-cgi=Hello --with-session=file fanocli --project-cgi=Hello --with-session |
Session avec cookie comme entreposage
Les données de session sont stockées dans un cookie chiffré :
| fanocli --project-cgi=Hello --with-session=cookie |
Session avec base de données comme entreposage
| fanocli --project-cgi=Hello --with-session=db |
Vous pouvez définir le type de SGBDR à utiliser avec le paramètre --db. S'il n'est pas défini, il suppose qu'il s'agit de MySQL. La commande suivante est identique à celle ci-dessus :
| fanocli --project-cgi=Hello --with-session=db --db=mysql |
Utilisez postgresql, firebird et sqlite pour les bases de données PostgreSQL, Firebird et SQLite respectivement :
| fanocli --project-cgi=Hello --with-session=db --db=postgresql |
Format des données de session
Pour les fichiers, les cookies et la base de données, vous pouvez définir le format des données de session avec le paramètre --type attendant une valeur json ou ini pour le format JSON ou INI respectivement.
Par exemple, la commande suivante entraînera l'ajout de la prise en charge de session au projet et chaque donnée de session sera entreposée sous forme de fichier INI :
| fanocli --project-cgi=Hello --with-session=file --type=ini |
La session nécessite un middleware
Étant donné que dans Fano Framework, la prise en charge de session est implémentée avec une infrastructure middleware, --with-session implique l'utilisation de --with-middleware, donc les commandes suivantes sont identiques :
|
fanocli --project-cgi=Hello --with-session fanocli --project-cgi=Hello --with-session --with-middleware |
Ajouter la prise en charge CSRF
Toutes les commandes de création de projet, c'est-à-dire les commandes --project*, acceptent le paramètre supplémentaire --with-csrf. S'il est défini, lors de la création du projet, la protection contre la falsification de requêtes intersites (CSRF) est ajoutée au projet généré.
| fanocli --project-scgi=Hello --with-csrf |
--with-csrf ajoute implicitement les paramètres --config et --with-session, donc la commande suivante génère un projet similaire.
|
fanocli --project-scgi=Hello --with-csrf fanocli --project-scgi=Hello --config --with-session --with-csrf |
Ajouter des dépendances de journalisation
Toutes les commandes de création de projet, c'est-à-dire les commandes --project*, acceptent le paramètre supplémentaire --with-logger. S'il est défini, lors de la création du projet, les dépendances de journalisation sont ajoutées au projet généré.
Ajouter un journal de bord entreposant les journaux dans un fichier :
| fanocli --project-scgi=Hello --with-logger=file |
Ajouter un enregistreur qui stocke les journaux dans la base de données :
| fanocli --project-scgi=Hello --with-logger=db |
Ajouter un enregistreur entreposant les journaux dans syslog :
| fanocli --project-scgi=Hello --with-logger=syslog |
Déploiement
Le Fano CLI propose des commandes pour simplifier la configuration de l'application Web Fano avec divers serveurs Web via les commandes suivantes :
| Paramètres | Description |
|---|---|
| --deploy-cgi | Configurer l'application Web Fano CGI avec un serveur Web. |
| --deploy-fcgi | Configurer l'application Web Fano FastCGI avec un serveur Web comme proxy inverse. |
| --deploy-fcgid | Configurer l'application Web Fano FastCGI avec un serveur Web Apache et mod_fcgid. |
| --deploy-scgi | Configurer l'application Web Fano SCGI avec un serveur Web comme proxy inverse. |
| --deploy-lb-scgi | Configurer l'application Web Fano SCGI avec un serveur Web comme proxy inverse et équilibreur de charge (Load Balancer). |
| --deploy-lb-fcgi | Configurer l'application Web Fano FastCGI avec un serveur Web comme proxy inverse et équilibreur de charge (Load Balancer). |
| --deploy-uwsgi | Configurer l'application Web Fano uwsgi avec un serveur Web comme proxy inverse. |
| --deploy-lb-uwsgi | Configurer l'application Web Fano uwsgi avec un serveur Web comme proxy inverse et équilibreur de charge (Load Balancer). |
| --deploy-http | Configurer l'application Web http Fano avec un serveur Web comme proxy inverse. |
| --deploy-lb-http | Configurer l'application Web http Fano avec un serveur Web comme proxy inverse et équilibreur de charge (Load Balancer). |
Toutes les commandes ci-dessus nécessitent le privilège root, vous devez donc les exécuter avec sudo :
| sudo fanocli --deploy-cgi=myapp.com |
Le développeur est responsable de s'assurer que le déploiement correspond au type de projet. Par exemple, un projet créé avec --project-fcgi ne peut être déployé qu'avec --deploy-fcgi ou --deploy-lb-fcgi.
Configurer le service en tant que service dans systemd
Dans la distribution Linux utilisant systemd, comme les dernières versions de Fedora ou Debian, Fano CLI fournit la commande --daemon-sysd=[nom-du-service] pour simplifier l'enregistrement du service de l'application Web avec systemd :
| sudo fanocli --daemon-sysd=hello |
Après cela, vous pouvez exécuter l'application à l'aide de la commande suivante :
| sudo systemctl start hello |
ou pour l'arrêter :
| sudo systemctl stop hello |
La commande --daemon-sysd accepte un paramètre supplémentaire :
| Paramètres | Description |
|---|---|
| --user=[nom d'utilisateur] | Nom d'utilisateur sous lequel l'application est exécutée. S'il n'est pas défini, l'utilisateur non root actuel est utilisé. |
| --bin=[chemin binaire de l'application] | Chemin absolu vers le binaire exécutable de l'application. S'il n'est pas défini, il s'agit du chemin absolu de bin/app.cgi. |
| sudo fanocli --daemon-sysd=hello --user=fano --bin=/home/my.fano/bin/myapp.bin |
Convertir le contenu d'un fichier texte en déclaration de variable de chaîne de caractères Pascal
Pour permettre l'inclusion directe d'un fichier HTML en tant que fichier d'inclusion, vous pouvez le convertir en déclaration de variable de chaîne de caractères Pascal à l'aide de la commande --txt2inc.
Par exemple, si vous avez un fichier index.html avec le contenu suivant :
Pour le convertir en fichier d'inclusion, exécutez :
| fanocli --txt2inc --src=index.html --dst=index.html.inc --var=htmlTemplate |
Il créera un fichier index.html.inc avec le contenu suivant :
que vous pouvez inclure dans le code Pascal&nbps;:
Paramètres
Le paramètre --src indique le chemin du fichier source à convertir. S'il n'est pas défini ou vide, STDIN sera utilisé. S'il est défini mais que le fichier n'existe pas, une erreur est générée.
Le paramètre --dst indique le chemin du fichier de destination. S'il n'est pas défini ou vide et que --src est défini, la valeur de --src est concaténée avec l'extension de fichier .inc. S'il n'est pas défini ou vide et que --src n'est pas défini, STDOUT sera utilisé. Si --dst est défini mais que le fichier existe, une erreur est générée pour éviter d'écraser accidentellement le fichier existant. Pour forcer l'écrasement du fichier existant, ajoutez le paramètre --force.
Le paramètre --var définit le nom de la variable à utiliser pour la déclaration. S'il n'est pas défini, myStr est utilisé.
Par exemple :
|
printf "<html><head></head>\r\n<body></body></html>" | fanocli --txt2inc {-------------begin----------------} myStr : string = '<html><head></head>' + LineEnding + '<body></body></html>'; {-------------end------------------} |
Construire
Changer le répertoire actif vers le nouveau répertoire du projet après avoir créé le projet et l'avoir exécuté :
| /build.sh |
pour créer une application.