• 30 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours est en vidéo.

Ce cours existe en livre papier.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Mis à jour le 04/09/2017

Utiliser la console directement depuis le navigateur

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

La console est un outil bien pratique de Symfony2. Mais parfois, devoir ouvrir le terminal de Linux ou l'invite de commandes de Windows n'est pas très agréable. Et je ne parle pas des hébergements mutualisés, qui n'offrent pas d'accès SSH pour utiliser la console !

Comment continuer d'utiliser la console dans ces conditions ? Ce chapitre est là pour vous expliquer cela !

Théorie : le composant Console de Symfony2

Les commandes sont en PHP

Nous l'avons déjà évoqué au long de ce cours, les commandes Symfony2 sont bien de simples codes PHP ! Effectivement on les exécute depuis une console, mais cela ne les empêche en rien d'être en PHP.

Et comme elles sont en PHP… elles peuvent tout à fait être exécutées depuis un autre script PHP. C'est en fait ce qui est déjà fait par le script PHP de la console, celui que l'on exécute à chaque fois : le fichierapp/console. Voici son contenu :

#!/usr/bin/env php
<?php

require_once __DIR__.'/bootstrap.php.cache';
require_once __DIR__.'/AppKernel.php';

use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Component\Console\Input\ArgvInput;

$input = new ArgvInput();
$env = $input->getParameterOption(array('--env', '-e'), getenv('SYMFONY_ENV') ?: 'dev');
$debug = !$input->hasParameterOption(array('--no-debug', ''));

$kernel = new AppKernel($env, $debug);
$application = new Application($kernel);
$application->run();

Comme vous pouvez le voir, ce fichier ressemble beaucoup au contrôleur frontal,app.php. Il charge également le Kernel. La seule chose qu'il fait de différent, c'est d'utiliser le composantConsolede Symfony2, en instanciant la classeApplication(ligne 15). C'est cet objet qui va ensuite exécuter les différentes commandes définies en PHP dans les bundles.

Exemple d'une commande

Chaque commande est définie dans une classe PHP distincte, que l'on place dans le répertoireCommanddes bundles. Ces classes comprennent entres autres deux méthodes :

  • configure()qui définit le nom, les arguments et la description de la commande ;

  • execute()qui exécute la commande à proprement parler.

Prenons l'exemple de la commandelist, qui liste toutes les commandes disponibles dans l'application. Elle est définie dans le fichiervendor/symfony/src/Component/Console/Command/ListCommand.php, dont voici le contenu :

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Console\Command;

use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Output\Output;
use Symfony\Component\Console\Command\Command;

/**
 * ListCommand displays the list of all available commands for the application.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 */
class ListCommand extends Command
{
  /**
   * {@inheritdoc}
   */
  protected function configure()
  {
    $this
      ->setDefinition(array(
        new InputArgument('namespace', InputArgument::OPTIONAL, 'The namespace name'),
        new InputOption('xml', null, InputOption::VALUE_NONE, 'To output help as XML'),
      ))
      ->setName('list')
      ->setDescription('Lists commands')
      ->setHelp(<<<EOF
The <info>list</info> command lists all commands:

  <info>php app/console list</info>

You can also display the commands for a specific namespace:

  <info>php app/console list test</info>

You can also output the information as XML by using the <comment>--xml</comment> option:

  <info>php app/console list --xml</info>
EOF
      );
  }

  /**
   * {@inheritdoc}
   */
  protected function execute(InputInterface $input, OutputInterface $output)
  {
    if ($input->getOption('xml')) {
      $output->writeln($this->getApplication()->asXml($input->getArgument('namespace')), OutputInterface::OUTPUT_RAW);
    } else {
      $output->writeln($this->getApplication()->asText($input->getArgument('namespace')));
    }
  }
}

Vous distinguez bien ici les deux méthodes qui composent la commandelist. En vous basant sur cet exemple, vous êtes d'ailleurs capables d'écrire votre propre commande : ce n'est vraiment pas compliqué !

Mais revenons au but de ce chapitre, qui est de pouvoir utiliser ces commandes depuis le navigateur.

Pratique : utiliser un ConsoleBundle

ConsoleBundle?

Vous le savez sûrement, la communauté de Symfony2 est très active, et un nombre impressionnant de bundles a vu le jour depuis la sortie de Symfony2. Vous pouvez les retrouver presque tous sur le sitehttp://knpbundles.com/qui les recense.

Il doit sûrement y avoir plusieurs bundles qui fournissent une console dans le navigateur, mais je vous propose d'en installer un en particulier :CoreSphereConsoleBundle. C'est un bundle simple qui remplit parfaitement sa tâche, et dont l'interface est très pratique, comme le montre la figure suivante.

Interface de CoreSphereConsoleBundle
Interface de CoreSphereConsoleBundle

InstallerCoreSphereConsoleBundle

L'installation d'un tel bundle est vraiment simple, attaquons-la dès maintenant.

TéléchargerCoreSphereConsoleBundle

Vous trouverez toutes les instructions sur la page du bundle : github.com/CoreSphere/ConsoleBundle. Voici comment procéder :

Pour l'installer avecComposer, rajoutez la ligne suivante dans vos dépendances :

// composer.json

"require": {
        // …
        "coresphere/console-bundle": "dev-master"
    }

Puis mettez à jour vos dépendances grâce à la commande suivante :

php ../composer.phar update
Enregistrement du bundle dans le Kernel

Puis il faut enregistrer le bundleCoreSphereConsoleBundledansapp/AppKernel.php. Je ne l'active que pour le mode "dev" car on ne s'en servira que via le contrôleur frontal de développement (app_dev.php) :

<?php
// app/AppKernel.php

use Symfony\Component\HttpKernel\Kernel;
use Symfony\Component\Config\Loader\LoaderInterface;

class AppKernel extends Kernel
{
  public function registerBundles()
  {
    $bundles = array(
      // ...
    );

    if (in_array($this->getEnvironment(), array('dev', 'test'))) {
      // ...
      $bundles[] = new CoreSphere\ConsoleBundle\CoreSphereConsoleBundle();
    }

    return $bundles;
  }
}
Enregistrement des routes

Pour paramétrer un bundle, on fait comme toujours : on lit sa documentation. La documentation se trouve soit dans lereadme, soit dans le répertoireResources/doc, cela dépend des bundles. Dans notre cas, elle se trouve dans lereadme.

Pour les routes, il faut donc enregistrer le fichier dans notrerouting_dev.yml. On ne les met pas dansrouting.yml, car la console ne doit être accessible qu'en mode dev, on a enregistré le bundle que pour ce mode. Ajoutez donc à la fin deapp/config/routing_dev.yml:

#app/config/routing_dev.yml

_console:
    resource: "@CoreSphereConsoleBundle/Resources/config/routing.yml"
    prefix: /_console
Publier les assets

L'installation touche à sa fin, il ne reste plus qu'à rendre disponibles les fichiers JS et CSS du bundle, ce qui se fait comme vous le savez grâce à la commande suivante :

php app/console assets:install web

C'est fini ! Il ne reste plus qu'à utiliser notre nouvelle console.

Utilisation de la console dans son navigateur

Par défaut, le bundle définit la route_consolepour afficher la console. Allez donc à l'adresse /_console et profitez !

Pour les utilisateurs de Windows, vous pouvez remarquer que le résultat des commandes est en couleurs. Eh oui, Symfony2 est plus fort que l'invite de commandes de Windows, il gère les couleurs !

En plus de l'adresse/_consoledédiée, il y a un petit bouton console, regardez en bas à droite dans la barre d'outils de Symfony. Cela vous permet d'accéder rapidement à la console.

Prêts pour l'hébergement mutualisé

Vous êtes prêts pour utiliser la console de votre application sur les hébergements mutualisés, qui n'offrent généralement pas d'accès SSH !

En résumé

  • Les commandes Symfony2 sont en PHP pur, il est ainsi tout à fait possible de « simuler » une console via le navigateur.

  • Vous disposez maintenant d'une console accessible depuis votre navigateur : cela va vous simplifier la vie, croyez-moi ! ;)

  • N'hésitez pas à faire vos retours sur le bundle directement via les issues sur GitHub : github.com/CoreSphere/ConsoleBundle/issues.

Exemple de certificat de réussite
Exemple de certificat de réussite