Ligne de commande

Composant en ligne de commande Webman

Installation

composer require webman/console

Note
Les commandes suivantes concernent webman/console v2.2 et supérieur. Si certaines fonctionnalités manquent, veuillez mettre à jour.

Table des matières

Génération de code

• make:controller - Générer une classe contrôleur
• make:model - Générer une classe modèle à partir d'une table de base de données
• make:crud - Générer un CRUD complet (modèle + contrôleur + validateur)
• make:middleware - Générer une classe middleware
• make:command - Générer une classe de commande console
• make:bootstrap - Générer une classe d'initialisation bootstrap
• make:process - Générer une classe de processus personnalisé

Construction et déploiement

• build:phar - Emballer le projet en archive PHAR
• build:bin - Emballer le projet en binaire autonome
• install - Exécuter le script d'installation Webman

Commandes utilitaires

• version - Afficher la version du framework Webman
• fix-disable-functions - Corriger les fonctions désactivées dans php.ini
• route:list - Afficher toutes les routes enregistrées

Gestion des plugins d'application (app-plugin:*)

• app-plugin:create - Créer un nouveau plugin d'application
• app-plugin:install - Installer un plugin d'application
• app-plugin:uninstall - Désinstaller un plugin d'application
• app-plugin:update - Mettre à jour un plugin d'application
• app-plugin:zip - Emballer un plugin d'application en ZIP

Gestion des plugins (plugin:*)

• plugin:create - Créer un nouveau plugin Webman
• plugin:install - Installer un plugin Webman
• plugin:uninstall - Désinstaller un plugin Webman
• plugin:enable - Activer un plugin Webman
• plugin:disable - Désactiver un plugin Webman
• plugin:export - Exporter le code source d'un plugin

Gestion des services

• start - Démarrer les processus worker Webman
• stop - Arrêter les processus worker Webman
• restart - Redémarrer les processus worker Webman
• reload - Recharger le code sans interruption
• status - Consulter l'état des processus worker
• connections - Obtenir les informations de connexion des processus worker

Génération de code

make:controller

Générer une classe contrôleur.

Utilisation :

php webman make:controller <name>

Arguments :

Options :

Exemples :

# Créer UserController dans app/controller
php webman make:controller User

# Créer dans un plugin
php webman make:controller AdminUser -p admin

# Chemin personnalisé
php webman make:controller User -P app/api/controller

# Écraser le fichier existant
php webman make:controller User -f

# Créer sans suffixe « Controller »
php webman make:controller UserHandler --no-suffix

Structure du fichier généré :

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function index(Request $request)
    {
        return response('hello user');
    }
}

Notes :

• Les contrôleurs sont placés par défaut dans app/controller/
• Le suffixe du contrôleur défini dans la configuration est ajouté automatiquement
• Demande une confirmation d'écrasement si le fichier existe (idem pour les autres commandes)

make:model

Générer une classe modèle à partir d'une table de base de données. Prend en charge Laravel ORM et ThinkORM.

Utilisation :

php webman make:model [name]

Arguments :

Options :

Notes sur les chemins :

• Par défaut : app/model/ (application principale) ou plugin/<plugin>/app/model/ (plugin)
• --path est relatif à la racine du projet, ex. plugin/admin/app/model
• Lors de l'utilisation simultanée de --plugin et --path, ils doivent pointer vers le même répertoire

Exemples :

# Créer le modèle User dans app/model
php webman make:model User

# Spécifier le nom de table et l'ORM
php webman make:model User -t wa_users -o laravel

# Créer dans un plugin
php webman make:model AdminUser -p admin

# Chemin personnalisé
php webman make:model User -P plugin/admin/app/model

Mode interactif : Lorsque le nom est omis, entre dans un flux interactif : sélection de la table → saisie du nom du modèle → saisie du chemin. Prise en charge : Entrée pour voir plus, 0 pour créer un modèle vide, /mot-clé pour filtrer les tables.

Structure du fichier généré :

<?php
namespace app\model;

use support\Model;

/**
 * @property integer $id (primary key)
 * @property string $name
 */
class User extends Model
{
    protected $connection = 'mysql';
    protected $table = 'users';
    protected $primaryKey = 'id';
    public $timestamps = true;
}

Les annotations @property sont générées automatiquement à partir de la structure de la table. Prend en charge MySQL et PostgreSQL.

make:crud

Générer en une fois le modèle, le contrôleur et le validateur à partir d'une table de base de données, pour une capacité CRUD complète.

Utilisation :

php webman make:crud

Options :

Flux d'exécution : Lorsque --table n'est pas spécifié, entre dans la sélection interactive des tables ; le nom du modèle est déduit par défaut du nom de la table ; le nom du contrôleur par défaut est nom du modèle + suffixe contrôleur ; le nom du validateur par défaut est nom du contrôleur sans suffixe + Validator. Chemins par défaut : modèle app/model/, contrôleur app/controller/, validateur app/validation/ ; pour les plugins : sous-répertoires correspondants sous plugin/<plugin>/app/.

Exemples :

# Génération interactive (confirmation étape par étape après la sélection de la table)
php webman make:crud

# Spécifier le nom de la table
php webman make:crud --table=users

# Spécifier le nom de la table et le plugin
php webman make:crud --table=users --plugin=admin

# Spécifier les chemins
php webman make:crud --table=users --model-path=app/model --controller-path=app/controller

# Ne pas générer le validateur
php webman make:crud --table=users --no-validator

# Non interactif + écrasement
php webman make:crud --table=users --no-interaction --force

Structure des fichiers générés :

Modèle (app/model/User.php) :

<?php

namespace app\model;

use support\Model;

class User extends Model
{
    protected $connection = 'mysql';
    protected $table = 'users';
    protected $primaryKey = 'id';
}

Contrôleur (app/controller/UserController.php) :

<?php

namespace app\controller;

use support\Request;
use support\Response;
use app\model\User;
use app\validation\UserValidator;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(validator: UserValidator::class, scene: 'create', in: ['body'])]
    public function create(Request $request): Response
    {
        $data = $request->post();
        $model = new User();
        foreach ($data as $key => $value) {
            $model->setAttribute($key, $value);
        }
        $model->save();
        return json(['code' => 0, 'msg' => 'ok', 'data' => $model]);
    }

    #[Validate(validator: UserValidator::class, scene: 'update', in: ['body'])]
    public function update(Request $request): Response
    {
        if (!$model = User::find($request->post('id'))) {
            return json(['code' => 1, 'msg' => 'not found']);
        }
        $data = $request->post();
        unset($data['id']);
        foreach ($data as $key => $value) {
            $model->setAttribute($key, $value);
        }
        $model->save();
        return json(['code' => 0, 'msg' => 'ok', 'data' => $model]);
    }

    #[Validate(validator: UserValidator::class, scene: 'delete', in: ['body'])]
    public function delete(Request $request): Response
    {
        if (!$model = User::find($request->post('id'))) {
            return json(['code' => 1, 'msg' => 'not found']);
        }
        $model->delete();
        return json(['code' => 0, 'msg' => 'ok']);
    }

    #[Validate(validator: UserValidator::class, scene: 'detail')]
    public function detail(Request $request): Response
    {
        if (!$model = User::find($request->input('id'))) {
            return json(['code' => 1, 'msg' => 'not found']);
        }
        return json(['code' => 0, 'msg' => 'ok', 'data' => $model]);
    }
}

Validateur (app/validation/UserValidator.php) :

<?php
declare(strict_types=1);

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:0',
        'username' => 'required|string|max:32'
    ];

    protected array $messages = [];

    protected array $attributes = [
        'id' => 'Clé primaire',
        'username' => 'Nom d\'utilisateur'
    ];

    protected array $scenes = [
        'create' => ['username', 'nickname'],
        'update' => ['id', 'username'],
        'delete' => ['id'],
        'detail' => ['id'],
    ];
}

Notes :

• La génération du validateur est ignorée si webman/validation n'est pas installé ou activé (installer avec composer require webman/validation)
• Les attributes du validateur sont générés automatiquement à partir des commentaires des champs de la base de données ; sans commentaires, pas d'attributes
• Les messages d'erreur du validateur prennent en charge l'i18n ; la langue est sélectionnée via config('translation.locale')

make:middleware

Générer une classe middleware et l'enregistrer automatiquement dans config/middleware.php (ou plugin/<plugin>/config/middleware.php pour les plugins).

Utilisation :

php webman make:middleware <name>

Arguments :

Options :

Exemples :

# Créer le middleware Auth dans app/middleware
php webman make:middleware Auth

# Créer dans un plugin
php webman make:middleware Auth -p admin

# Chemin personnalisé
php webman make:middleware Auth -P plugin/admin/app/middleware

Structure du fichier généré :

<?php
namespace app\middleware;

use Webman\MiddlewareInterface;
use Webman\Http\Response;
use Webman\Http\Request;

class Auth implements MiddlewareInterface
{
    public function process(Request $request, callable $handler) : Response
    {
        return $handler($request);
    }
}

Notes :

• Placé par défaut dans app/middleware/
• Le nom de la classe est automatiquement ajouté au fichier de configuration middleware pour activation

make:command

Générer une classe de commande console.

Utilisation :

php webman make:command <command-name>

Arguments :

Options :

Exemples :

# Créer la commande user:list dans app/command
php webman make:command user:list

# Créer dans un plugin
php webman make:command user:list -p admin

# Chemin personnalisé
php webman make:command user:list -P plugin/admin/app/command

# Écraser le fichier existant
php webman make:command user:list -f

Structure du fichier généré :

<?php

namespace app\command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand('user:list', 'user list')]
class UserList extends Command
{
    protected function configure(): void
    {
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $output->writeln('<info>Hello</info> <comment>' . $this->getName() . '</comment>');
        return self::SUCCESS;
    }
}

Notes :

• Placé par défaut dans app/command/

make:bootstrap

Générer une classe d'initialisation bootstrap. La méthode start est automatiquement appelée au démarrage du processus, généralement pour une initialisation globale.

Utilisation :

php webman make:bootstrap <name>

Arguments :

Options :

Exemples :

# Créer MyBootstrap dans app/bootstrap
php webman make:bootstrap MyBootstrap

# Créer sans activation automatique
php webman make:bootstrap MyBootstrap no

# Créer dans un plugin
php webman make:bootstrap MyBootstrap -p admin

# Chemin personnalisé
php webman make:bootstrap MyBootstrap -P plugin/admin/app/bootstrap

# Écraser le fichier existant
php webman make:bootstrap MyBootstrap -f

Structure du fichier généré :

<?php

namespace app\bootstrap;

use Webman\Bootstrap;

class MyBootstrap implements Bootstrap
{
    public static function start($worker)
    {
        $is_console = !$worker;
        if ($is_console) {
            return;
        }
        // ...
    }
}

Notes :

• Placé par défaut dans app/bootstrap/
• Lors de l'activation, la classe est ajoutée à config/bootstrap.php (ou plugin/<plugin>/config/bootstrap.php pour les plugins)

make:process

Générer une classe de processus personnalisé et l'écrire dans config/process.php pour démarrage automatique.

Utilisation :

php webman make:process <name>

Arguments :

Options :

Exemples :

# Créer dans app/process
php webman make:process MyTcp

# Créer dans un plugin
php webman make:process MyProcess -p admin

# Chemin personnalisé
php webman make:process MyProcess -P plugin/admin/app/process

# Écraser le fichier existant
php webman make:process MyProcess -f

Flux interactif : Demande dans l'ordre : écouter sur un port ? → type de protocole (websocket/http/tcp/udp/unixsocket) → adresse d'écoute (IP:port ou chemin unix socket) → nombre de processus. Le protocole HTTP demande également le mode intégré ou personnalisé.

Structure du fichier généré :

Processus sans écoute (uniquement onWorkerStart) :

<?php
namespace app\process;

use Workerman\Worker;

class MyProcess
{
    public function onWorkerStart(Worker $worker)
    {
        // TODO: Write your business logic here.
    }
}

Les processus TCP/WebSocket en écoute génèrent les modèles de rappel onConnect, onMessage, onClose correspondants.

Notes :

• Placé par défaut dans app/process/ ; la configuration du processus est écrite dans config/process.php
• La clé de configuration est le snake_case du nom de la classe ; échoue si elle existe déjà
• Le mode HTTP intégré réutilise le fichier de processus app\process\Http, ne génère pas de nouveau fichier
• Protocoles pris en charge : websocket, http, tcp, udp, unixsocket

Construction et déploiement

build:phar

Emballer le projet en archive PHAR pour distribution et déploiement.

Utilisation :

php webman build:phar

Démarrage :

Accéder au répertoire build et exécuter

php webman.phar start

Notes :

• Le projet emballé ne prend pas en charge reload ; utiliser restart pour mettre à jour le code

• Pour éviter une taille de fichier excessive et une utilisation mémoire importante, configurer exclude_pattern et exclude_files dans config/plugin/webman/console/app.php pour exclure les fichiers inutiles.

• L'exécution de webman.phar crée un répertoire runtime au même emplacement pour les journaux et fichiers temporaires.

• Si votre projet utilise un fichier .env, placer .env dans le même répertoire que webman.phar.

• webman.phar ne prend pas en charge les processus personnalisés sous Windows

• Ne jamais stocker les fichiers uploadés par l'utilisateur dans le paquet phar ; manipuler les uploads utilisateur via phar:// est dangereux (vulnérabilité de désérialisation phar). Les uploads utilisateur doivent être stockés séparément sur disque en dehors du phar. Voir ci-dessous.

• Si votre activité nécessite d'uploader des fichiers vers le répertoire public, extraire le répertoire public au même emplacement que webman.phar et configurer config/app.php :

  'public_path' => base_path(false) . DIRECTORY_SEPARATOR . 'public',

  Utiliser la fonction utilitaire public_path($relative_path) pour obtenir le chemin réel du répertoire public.

build:bin

Emballer le projet en binaire autonome avec runtime PHP intégré. Aucune installation PHP requise sur l'environnement cible.

Utilisation :

php webman build:bin [version]

Arguments :

Exemples :

# Utiliser la version PHP actuelle
php webman build:bin

# Spécifier PHP 8.2
php webman build:bin 8.2

Démarrage :

Accéder au répertoire build et exécuter

./webman.bin start

Notes :

• Fortement recommandé : la version PHP locale doit correspondre à la version de build (ex. PHP 8.1 local → build avec 8.1) pour éviter les problèmes de compatibilité
• Le build télécharge les sources PHP 8 mais ne les installe pas localement ; n'affecte pas l'environnement PHP local
• webman.bin ne fonctionne actuellement que sur Linux x86_64 ; non pris en charge sur macOS
• Le projet emballé ne prend pas en charge reload ; utiliser restart pour mettre à jour le code
• .env n'est pas emballé par défaut (contrôlé par exclude_files dans config/plugin/webman/console/app.php) ; placer .env dans le même répertoire que webman.bin au démarrage
• Un répertoire runtime est créé dans le répertoire webman.bin pour les fichiers de journal
• webman.bin ne lit pas de php.ini externe ; pour des paramètres php.ini personnalisés, utiliser custom_ini dans config/plugin/webman/console/app.php
• Exclure les fichiers inutiles via config/plugin/webman/console/app.php pour éviter une taille de paquet excessive
• Le build binaire ne prend pas en charge les coroutines Swoole
• Ne jamais stocker les fichiers uploadés par l'utilisateur dans le paquet binaire ; manipuler via phar:// est dangereux (vulnérabilité de désérialisation phar). Les uploads utilisateur doivent être stockés séparément sur disque en dehors du paquet.
• Si votre activité nécessite d'uploader des fichiers vers le répertoire public, extraire le répertoire public au même emplacement que webman.bin et configurer config/app.php comme ci-dessous, puis reconstruire :

  'public_path' => base_path(false) . DIRECTORY_SEPARATOR . 'public',

install

Exécuter le script d'installation du framework Webman (appelle \Webman\Install::install()), pour l'initialisation du projet.

Utilisation :

php webman install

Commandes utilitaires

version

Afficher la version workerman/webman-framework.

Utilisation :

php webman version

Notes : Lit la version depuis vendor/composer/installed.php ; retourne un échec si impossible à lire.

fix-disable-functions

Corriger disable_functions dans php.ini, en supprimant les fonctions requises par Webman.

Utilisation :

php webman fix-disable-functions

Notes : Supprime les fonctions suivantes (et les correspondances de préfixe) de disable_functions : stream_socket_server, stream_socket_accept, stream_socket_client, pcntl_*, posix_*, proc_*, shell_exec, exec. Ignore si php.ini introuvable ou disable_functions vide. Modifie directement le fichier php.ini ; sauvegarde recommandée.

route:list

Lister toutes les routes enregistrées au format tableau.

Utilisation :

php webman route:list

Exemple de sortie :

+-------+--------+-----------------------------------------------+------------+------+
| URI   | Method | Callback                                      | Middleware | Name |
+-------+--------+-----------------------------------------------+------------+------+
| /user | GET    | ["app\\controller\\UserController","index"] | null       |      |
| /api  | POST   | Closure                                      | ["Auth"]   | api  |
+-------+--------+-----------------------------------------------+------------+------+

Colonnes de sortie : URI, Method, Callback, Middleware, Name. Les callbacks Closure s'affichent comme « Closure ».

Gestion des plugins d'application (app-plugin:*)

app-plugin:create

Créer un nouveau plugin d'application, générant la structure de répertoires complète et les fichiers de base sous plugin/<name>.

Utilisation :

php webman app-plugin:create <name>

Arguments :

Exemples :

# Créer un plugin d'application nommé foo
php webman app-plugin:create foo

# Créer un plugin avec tiret
php webman app-plugin:create my-app

Structure de répertoires générée :

plugin/<name>/
├── app/
│   ├── controller/IndexController.php
│   ├── model/
│   ├── middleware/
│   ├── view/index/index.html
│   └── functions.php
├── config/          # app.php, route.php, menu.php, etc.
├── api/Install.php  # Hooks d'installation/désinstallation/mise à jour
├── public/
└── install.sql

Notes :

• Le plugin est créé sous plugin/<name>/ ; échoue si le répertoire existe déjà

app-plugin:install

Installer un plugin d'application, exécutant plugin/<name>/api/Install::install($version).

Utilisation :

php webman app-plugin:install <name>

Arguments :

Exemples :

php webman app-plugin:install foo

app-plugin:uninstall

Désinstaller un plugin d'application, exécutant plugin/<name>/api/Install::uninstall($version).

Utilisation :

php webman app-plugin:uninstall <name>

Arguments :

Options :

Exemples :

php webman app-plugin:uninstall foo
php webman app-plugin:uninstall foo -y

app-plugin:update

Mettre à jour un plugin d'application, exécutant Install::beforeUpdate($from, $to) et Install::update($from, $to, $context) dans l'ordre.

Utilisation :

php webman app-plugin:update <name>

Arguments :

Options :

Exemples :

php webman app-plugin:update foo
php webman app-plugin:update foo --from 1.0.0 --to 1.1.0

app-plugin:zip

Emballer un plugin d'application en fichier ZIP, sortie vers plugin/<name>.zip.

Utilisation :

php webman app-plugin:zip <name>

Arguments :

Exemples :

php webman app-plugin:zip foo

Notes :

• Exclut automatiquement node_modules, .git, .idea, .vscode, __pycache__, etc.

Gestion des plugins (plugin:*)

plugin:create

Créer un nouveau plugin Webman (forme de paquet Composer), générant le répertoire de configuration config/plugin/<name> et le répertoire source du plugin vendor/<name>.

Utilisation :

php webman plugin:create <name>
php webman plugin:create --name <name>

Arguments :

Exemples :

php webman plugin:create foo/my-admin
php webman plugin:create --name foo/my-admin

Structure générée :

• config/plugin/<name>/app.php : Configuration du plugin (inclut le commutateur enable)
• vendor/<name>/composer.json : Définition du paquet plugin
• vendor/<name>/src/ : Répertoire source du plugin
• Ajoute automatiquement le mapping PSR-4 au composer.json racine du projet
• Exécute composer dumpautoload pour actualiser l'autoloading

Notes :

• Le nom doit être au format vendor/package : lettres minuscules, chiffres, -, _, ., et doit contenir un /
• Échoue si config/plugin/<name> ou vendor/<name> existe déjà
• Erreur si l'argument et --name sont fournis tous deux avec des valeurs différentes

plugin:install

Exécuter le script d'installation du plugin (Install::install()), copiant les ressources du plugin vers le répertoire du projet.

Utilisation :

php webman plugin:install <name>
php webman plugin:install --name <name>

Arguments :

Options :

Exemples :

php webman plugin:install foo/my-admin
php webman plugin:install --name foo/my-admin

plugin:uninstall

Exécuter le script de désinstallation du plugin (Install::uninstall()), supprimant les ressources du plugin du projet.

Utilisation :

php webman plugin:uninstall <name>
php webman plugin:uninstall --name <name>

Arguments :

Options :

Exemples :

php webman plugin:uninstall foo/my-admin

plugin:enable

Activer le plugin, définissant enable à true dans config/plugin/<name>/app.php.

Utilisation :

php webman plugin:enable <name>
php webman plugin:enable --name <name>

Arguments :

Options :

Exemples :

php webman plugin:enable foo/my-admin

plugin:disable

Désactiver le plugin, définissant enable à false dans config/plugin/<name>/app.php.

Utilisation :

php webman plugin:disable <name>
php webman plugin:disable --name <name>

Arguments :

Options :

Exemples :

php webman plugin:disable foo/my-admin

plugin:export

Exporter la configuration du plugin et les répertoires spécifiés du projet vers vendor/<name>/src/, et générer Install.php pour emballage et publication.

Utilisation :

php webman plugin:export <name> [--source=path]...
php webman plugin:export --name <name> [--source=path]...

Arguments :

Options :

Exemples :

# Exporter le plugin, inclut par défaut config/plugin/<name>
php webman plugin:export foo/my-admin

# Exporter en plus app, config, etc.
php webman plugin:export foo/my-admin --source app --source config
php webman plugin:export --name foo/my-admin -s app -s config

Notes :

• Le nom du plugin doit suivre la nomenclature des paquets Composer (vendor/package)
• Si config/plugin/<name> existe et n'est pas dans --source, il est automatiquement ajouté à la liste d'export
• Le Install.php exporté inclut pathRelation pour utilisation par plugin:install / plugin:uninstall
• plugin:install et plugin:uninstall exigent que le plugin existe dans vendor/<name>, avec la classe Install et la constante WEBMAN_PLUGIN

Gestion des services

start

Démarrer les processus worker Webman. Mode DEBUG par défaut (premier plan).

Utilisation :

php webman start

Options :

stop

Arrêter les processus worker Webman.

Utilisation :

php webman stop

Options :

restart

Redémarrer les processus worker Webman.

Utilisation :

php webman restart

Options :

reload

Recharger le code sans interruption. Pour rechargement à chaud après mise à jour du code.

Utilisation :

php webman reload

Options :

status

Consulter l'état d'exécution des processus worker.

Utilisation :

php webman status

Options :

connections

Obtenir les informations de connexion des processus worker.

Utilisation :

php webman connections