vendredi 24 avril 2015

Connaître la taille d'un dossier

Pour trouver la taille qu'occupe un répertoire sur votre disque, vous pensiez qu'il suffisait d'un simple ls -l ?

disk usage : du

Première solution, la commande du :

$ du -sh nom_du_dossier
Quelques explications :
  • du signifie "disk usage"
  • L'option h (pour "human readable") permet d'afficher la taille du dossier dans un format facilement lisible avec l'unité (K pour Kilo-octets, M pour Mega-octets, ...)
  • L'option s n'affiche la taille que pour le dossier spécifié. Sans cette option, la commande afficherait la taille de la totalité des sous-répertoires et fichiers contenus dans le dossier.
Pour avoir une liste des dossiers (ou fichiers) classés par taille du plus grand au plus petit :

$ du -smx * | sort -nr
  • L'option m affiche la taille en Mo. Pour le tri, nous avons besoin que tous les répertoires (ou fichiers) soient affichés dans la même unité.
  • L'option x permet de ne scanner que le répertoire demandé
Pour la commande sort, les options sont :
  • n trie par taille
  • r ordonne les résultats du plus grand au plus petit

ncdu

Sinon, vous avez une autre solution beaucoup plus pratique quand vous devez arpenter toute l'arborescence d'un serveur à la recherche d'un dossier trop gros à nettoyer. Il s'agit du programme ncdu. Vous l'installez à l'aide d'un simple sudo apt-get install ncdu puis vous le lancez à l'aide de la commande :

$ ncdu -x nom_du_dossier
Après l'initialisation du programme qui va parcourir en récursif tous les sous-dossiers, vous n'avez plus qu'à naviguer dans l'arborescence avec les flèches du clavier et la touche d pour supprimer un fichier/dossier. Il y a bien sûr d'autres racourcis dans l'application que vous pourrez consulter en tapant ?.

Mis à jour le 24/04/2015

jeudi 10 juillet 2014

Validation formulaire : Champ obligatoire en fonction de la valeur d'un autre champ (Symfony 2)

Vous avez un formulaire Symfony 2 et vous voulez qu'un champ soit obligatoire que si un autre champ a une valeur spécifique ? La solution est simple, mais il fallait y penser : utiliser les groupes de validation.

Prenons un exemple :
Vous avez l'entité suivante avec ses contraintes de validation :

use Symfony\Component\Validator\Constraints as Assert;

class Content
{
    private $id;

    /*
     * Type : Application / Vidéo / Texte
     *
     * @var integer
     * @Assert\NotBlank(message="Le type est obligatoire")
     */
    private $type;

    /*
     * Support : Mobile / Tablette
     *
     * @var integer
     * @Assert\NotBlank(message="Le support est obligatoire") 
     */
    private $support;

    /* ... */
}

Vous voulez que le champ support ne soit obligatoire dans votre formulaire que si le type sélectionné est "Application".

Commencez par créer une contrainte de validation de type Callback sur votre entité en ajoutant la méthode isTypeApplication. Attention, elle prend en paramètre un ExecutionContext, donc n'oubliez pas le use qui va avec :

use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\ExecutionContext;

/**
 * @Assert\Callback(methods={"isTypeApplication"})
 */
class Content
{
    private $id;

    /*
     * Type : Application / Vidéo / Texte
     *
     * @var integer
     * @Assert\NotBlank(message="Le type est obligatoire")
     */
    private $type;

    /*
     * Support : Mobile / Tablette
     *
     * @var integer
     * @Assert\NotBlank(message="Le support est obligatoire") 
     */
    private $support;

    /* ... */

    /**
     * Vérifie si le contenu est de type "Application"
     *
     * @param ExecutionContext $context
     */
    public function isTypeApplication(ExecutionContext $context) {
        if ($this->type == 'Application) {
            $context->validate($this, '', 'type_application_group', true);
        }
    }
}

La méthode isTypeApplication qu'on vient d'ajouter, permet de re-valider le formulaire mais en utilisant cette fois le groupe de validation type_application_group lorsque le contenu est de type "Application".

Il n'y a donc plus qu'à utiliser ce groupe de validation pour la contrainte NotBlank sur la propriété support de notre entité pour obtenir au final :

use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\ExecutionContext;

/**
 * @Assert\Callback(methods={"isTypeApplication"})
 */
class Content
{
    private $id;

    /*
     * Type : Application / Vidéo / Texte
     *
     * @var integer
     * @Assert\NotBlank(message="Le type est obligatoire")
     */
    private $type;

    /*
     * Support : Mobile / Tablette
     *
     * @var integer
     * @Assert\NotBlank(message="Le support est obligatoire", groups={"type_application_group"}) 
     */
    private $support;

    /* ... */

    /**
     * Vérifie si le contenu est de type "Application"
     *
     * @param ExecutionContext $context
     */
    public function isTypeApplication(ExecutionContext $context) {
        if ($this->type == 'Application) {
            $context->validate($this, '', 'type_application_group', true);
        }
    }
}

vendredi 14 février 2014

Nombre de lignes/de mots d'un fichier

Aujourd'hui, étude d'une petite commande à la fois simple et pratique : wc (word cound).
Elle est souvent utilisée lorsqu'on a besoin de connaître le nombre de lignes d'un fichier ou encore, mais c'est moins fréquent, le nombre de mots. Si on la lance simplement sans argument, on aura :

$ wc nom_fichier
240 569 8980 nom_fichier

Les 3 nombres retournés sont respectivement
  • Le nombre de lignes
  • Le nombre de mots
  • Le nombre d'octets
En ajoutant un argument, on peut avoir seulement l'un de ces nombres :
-l : nombre de lignes
-w : nombre de mots
-c : nombre d'octets

Un autre argument, -m, nous permet d'obtenir un 4° nombre, le nombre de caractères :

$ wc -m nom_fichier

Et voilà, c'est déjà fini

vendredi 11 octobre 2013

jsWarrior : apprendre à programmer en s'amusant

JSWarrior
Aujourd'hui, petit moment de détente !
J'ai trouvé ce petit jeu qui permet de s'entraîner à programmer en javascript en s'amusant.

Le but du jeu est simple et bien expliqué

Il y a 7 niveaux à passer pour finir le jeu. A vous de jouer à JSWarrior!

Même si les premiers niveaux sont très faciles, ce n'est qu'un début, ça se complique rapidement.

Pour les feignants ou ceux qui sont vraiment bloqués . Voici la soluce de JSWarrior.

jeudi 10 octobre 2013

2 astuces GIT pour ignorer des fichiers

1. Ignorer des fichiers déjà versionnés

Permet de ne plus commiter un fichier déjà versionné. Pratique si vous avez un fichier de configuration versionné dans lequel vous avez mis votre configuration locale que vous ne devez pas commiter.
Il suffit d'exécuter la commande suivante :

git update-index --assume-unchanged path/to/file.txt

2. Ignorer localement des fichiers

Permet de ne pas avoir les fichiers ajoutés par votre IDE committés sans pour autant les ajouter dans le .gitignore du projet. (le projet n'a pas de raison d'avoir des fichiers spécifiques à un IDE dans son .gitignore)

Dans votre repo, ajouter vos règles locales spécifiques au repository dans le fichier .git/info/exclude

Ces règles ne sont pas commitées et ne sont donc pas partagées avec les autres développeurs.

lundi 19 août 2013

Terminal : Garder un programme en tâche de fond

Aujourd'hui, petite astuce avec le terminal. Vous avez lancé un programme en ligne de commande, par exemple gedit comme ceci :

$ gedit

Le terminal a bien lancé le logiciel mais ne vous a pas rendu la main.

Pas de panique! Il suffit de faire Ctrl+Z puis de taper :

$ bg

Et voilà, le programme reste ouvert en tâche de fond et le terminal vous a rendu la main !

lundi 20 mai 2013

Installer et configurer Apache/PHP/MySQL pour Symfony2 en 10 étapes

Vous venez tout juste d'installer la dernière version d'Ubuntu (13.04 à l'heure où j'écris), et souhaitez installer tout l'environnement nécessaire pour faire fonctionner Symfony 2 (version 2.2.1 à ce jour) et commencer votre première application ?
Voici la marche à suivre !
Mais tout d'abord, quelques petites précisions avant de commencer :
  • Ce tutoriel est un guide concis qui récapitule l'ensemble des étapes à suivre pour préparer votre serveur de développement et faire fonctionner l'installation de Symfony 2. Je n'explique pas en détail tout ce qu'on va faire..
  • Je pars du principe que vous voulez créer un site qui sera accessible à l'URL http://symfony et que le contenu du site sera placé dans le répertoire /home/nom_user/www/symfony/. A vous d'adapter si vous voulez modifier ceci.
Allons-y maintenant !

1. Installer Apache

sudo apt-get install apache2

2. Installer MySQL

sudo apt-get install mysql-server mysql-client

3. Installer PHP 5

sudo apt-get install php5

4. Installer PHPMyAdmin

sudo apt-get install phpmyadmin
Lors de l'installation, vous aurez droit à 2 questions :
1°) Quel serveur web reconfigurer pour exécuter phpMyAdmin ? Choissiez apache2
2°) Faut-il configurer la base de données de phpmyadmin avec dbconfig-common ? Choisissez Non

5. Installer les modules Apache nécessaires/utiles pour Symfony 2

D'abord le mod_rewrite qui permettra l'utilisation de la réécriture d'URL :
sudo a2enmod rewrite

6. Installer les modules PHP nécessaires/utiles pour Symfony 2

sudo apt-get install php5-intl
sudo apt-get install php-apc
sudo apt-get install php-pear
sudo apt-get install php5-dev sudo pecl install xdebug

7. Configurer PHP

Modifier les paramètres de PHP en éditant les lignes suivantes du fichier /etc/php5/apache2/php.ini :
short_open_tag = Off
date.timezone = Europe/Paris
Il faut ensuite configurer les modules nouvellement installés :
APC
Editer le fichier /etc/php5/conf.d/20-apc.ini, et ajouter les lignes suivantes :
apc.shm_size = 128M
XDebug
Créer le fichier /etc/php5/conf.d/20-xdebug.ini :
zend_extension = /usr/lib/php5/20100525/xdebug.so
xdebug.max_nesting_level = 250

8. Configurer votre site local

8.1 Fichier hosts

sudo nano /etc/hosts
Ajouter la ligne :
127.0.0.1 symfony

8.2 Virtual Host

On crée un nouveau VirtualHost pour notre site : sudo nano /etc/apache2/sites-available/symfony.conf
Dans l'éditeur coller cette configuration en remplaçant /home/mon_nom/www/symfony/web/ par le répertoire où vous voulez placer votre site :
<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    ServerName symfony

    DocumentRoot /home/mon_nom/www/symfony/web/
    <Directory /home/mon_nom/www/symfony/web/>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Order allow,deny
        allow from all
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/error-symfony.log

    LogLevel warn

    CustomLog ${APACHE_LOG_DIR}/access-symfony.log combined
</VirtualHost>

Attention ! Si vous utilisez Apache 2.4 (intégré dans les dernières versions d'Ubuntu), il faut remplacer les lignes :
    AllowOverride All
    Order allow,deny
    allow from all

par :
    Require all granted

On active le VirtualHost que nous venons de créer :
sudo a2ensite symfony
On prépare le répertoire où l'on placera notre site Symfony :
cd ~
mkdir www

Il ne reste plus qu'à redémarrer apache :
sudo service apache2 reload

9. Installer Composer

Installer d'abord le module curl pour nous permettra d'installer facilement Composer :
sudo apt-get install curl
Puis installer Composer :
cd ~
curl -sS https://getcomposer.org/installer | php

Pour simplifier son utilisation, nous allons le rendre exécutable n'importe où sur le système :
sudo mv composer.phar /usr/local/bin/composer
Désormais, pour utiliser composer, il suffira de saisir directement n'importe où :
composer

10. Enfin, installer et configurer Symfony2

cd ~/www
composer create-project symfony/framework-standard-edition symfony/ 2.2.1

Mettre à jour les vendors :
composer update
Définir les droits sur les répertoires cache et logs :
$ sudo setfacl -R -m u:www-data:rwX -m u:`whoami`:rwX app/cache app/logs
$ sudo setfacl -dR -m u:www-data:rwx -m u:`whoami`:rwx app/cache app/logs

Il ne vous reste plus qu'à vérifier que tout s'est bien passé et que Symfony 2 est prêt à fonctionner en vous rendant à l'URL suivante dans votre navigateur :
http://symfony/config.php
Vous devriez avoir un joli message sur fond vert :
Your configuration looks good to run Symfony
Il ne vous reste plus qu'à cliquer sur le lien "Configure your Symfony Application online" pour terminer votre configuration de Symfony 2.

Conclusion

Et voilà ! Si tout s'est bien passé, vous êtes en mesure de créer un site avec Symfony 2 sur le serveur de développement que vous venez juste d'installer et de configurer.