Au final, voici tous les fichiers de conf qui sont importants pour moi de près ou de loin:

├── .autoenv
├── .bashrc
├── .config
│   ├── autostart
│   ├── Code
│   ├── copyq
│   ├── fish
│   ├── gtg
│   ├── liferea
│   ├── pulse
│   ├── stremio
│   ├── sublime-text-3
│   ├── transmission
│   ├── user-dirs.dirs
│   ├── user-dirs.locale
│   ├── variety
│   ├── VeraCrypt
│   ├── Zeal
│   └── zim
├── .django-completion.bash
├── .editorconfig
├── .git-aware-prompt
├── .git-completion.bash
├── .gitconfig
├── .gitignore
├── .git-prompt.sh
├── .git.scmbrc
├── .jupyter
├── .lastpass
├── .liferea_1.8
├── .local
│   └── share
        ├── gtg
        ├── keyrings
        ├── liferea
        ├── omf
        ├── TowerFall
        ├── virtualenvs
        └── Zeal
├── .mozilla
├── .netrc
├── .oh-my-zsh
├── .openambit
├── .pypirc
├── .scmbrc
├── .scm_breeze
├── .sshplus
├── .vscode
│   └── extensions
└── .zshrc

Quand on bidouille, on les change souvent. On les backup aussi, pour pouvoir les porter d’un laptop à un autre, les synchroniser, les uploader sur un serveur ou les récup lors d’une réinstallation. Parce que quand on a tuné ses terminaux et éditeurs aux petits oignons, on a pas envie de recommencer à poil.

Pour bien faciliter les choses, ils sont éparpillés un peu partout, dans des sous-dossiers différents.

Et je sais pas quel vil individu a suggéré une fois que faire une partition séparée pour /home était la solution de Skippy à tous les soucis, mais perso, ça me cause plus de bugs qu’autre chose quand on change de versions d’OS.

Bref, laissez tomber vos vieilles croyances issues de charlatans de sectes. Moi, j’ai vu la lumière (lien de don bitcoin en bas à droite de la page), et elle s’appelle GNU stow.

Stow est un vieil utilitaire (donc sagesse millénaire des anciens, vous pouvez avoir confiance, prenez ce cristal aussi il est en promo), qui est grosso merdo un ln -s récursive. C’est-à-dire que ça fait des symlinks des fichiers et des dossiers que vous lui passez.

On peut l’utiliser pour plein de choses, mais l’usage sacré implique le sacrifice d’une vierge à Max, puis de déplacer tous les fichiers de settings qu’on souhaite gérer dans un seul dossier.

Par exemple, moi j’ai:

/home/user/church/settings/

    ├── .autoenv
    ├── .bashrc
    ├── .config
    │   ├── autostart
    │   ├── Code
    │   ├── copyq
    │   ├── fish
    │   ├── gtg
    ...

Au lieu de les avoir éparpillées partout, toutes les brebis sont maintenant regroupées dans une seule église.

Il est très important de garder l’organisation des dossiers et des sous-dossiers d’origine. Ici vous voyez que j’ai le dossier Code, qui est le dossier de settings de VSCode. Mais il est DANS un dossier .config, car avant mon regroupement il était dans /home/user/.config/.

En revanche, il n’est pas du tout nécessaire que .config contienne tous les dossiers qu’il avait précédemment. Seuls ceux qui vous intéressent. Le reste peut rester à sa place initiale, dans le /home/user/.config/.

Donc je résume:

• Listez les fichiers et dossiers de settings qui vous intéressent.
• Déplacez les tous dans un dossier commun en gardant une arborescence similaire.
• Laissez les fichiers qui ne vous intéressent pas là où ils sont.
• Priez (une bonne pratique avant toute opération informatique).

Arrive le messie, Stow.

D’abord, il faut l’installer, mais comme c’est un outil vénérable, il est dans les dépôts. Sous Ubuntu, le psaume “apt install stow” fera l’affaire.

Ensuite, on prêche. Je me perds dans mes propres paraboles, mais les voies du seigneur sont impénétrables, contrairement à celles d’Abella Anderson. Bref on demande à stow de traiter récursivement tout le contenu du dossier settings qui est dans /home/user/church afin de le linker vers /home/user/:

stow -d /home/user/church -t /home/user/ settings

Stow va prendre récursivement tous les dossiers qui sont dans /home/user/church/settings, et les comparer à ceux dans /home/user. Si ils existent, il va ne rien faire, mais si ils n’existent pas, il va créer un lien vers chacun de ceux manquants. Pour les fichiers, si ils n’existent pas, il va créer un lien, sinon il va vous afficher une erreur, afin de ne pas écraser quelque chose d’important et vous signalez qu’il y un souci.

Le but de tout ça ?

Pour votre système et tous vos logiciels, ça ne change rien. Ils vont tomber sur les liens et avoir l’impression que tous les fichiers de configs sont à leur place et vont continuer à fonctionner dans la joie et le gospel.

Et pour vous, ben vous avez un seul endroit où tous les fichiers importants sont regroupés. Plus besoin de les chercher. Facile à backuper et à restaurer. On peut même tout foutre sous Git.

Loué soit le sauveur.

Vive moi.

Générer une clé secrète:

import random
import string

def secret_key(size=50):
    pool = string.ascii_letters + string.digits + string.punctuation
    return "".join(random.SystemRandom().choice(pool) for i in range(size))

Générer une clé secrete avec une commande manage.py:

from django.core.management.base import BaseCommand, CommandError
from polls.models import Question as Poll

class Command(BaseCommand):
    help = 'Generate a secret key'

    def add_arguments(self, parser):
        parser.add_argument('size', default=50, type=int)

    def handle(self, *args, **options):
        self.stdout.write(secret_key(options['size']))

A mettre dans ./votreapp/management/command/generate_secret_key.py :)

Une fonction pour lire la clé depuis un fichier texte ou générer la clé si elle n’existe pas:

import io
import os

try:
    import pwd
except ImportError:
    pass

try:
    import grp
except ImportError:
    pass


def secret_key_from_file(
        file_path, 
        create=True, 
        size=50, 
        file_perms=None, # unix uniquement
        file_user=None, # unix uniquement
        file_group=None # unix uniquement
    ):
    try:
        with io.open(file_path) as f:
            return f.read().strip()
    except IOError as e:
        if e.errno == 2 and create:
            with io.open(file_path, 'w') as f:
                key = secret_key(size)
                f.write(key)

            if any((file_perms, file_user, file_group)) and not pwd:
                raise ValueError('File chmod and chown are for Unix only')

            if file_user:
                os.chown(file_path, uid=pwd.getpwnam(file_user).pw_uid)

            if file_group:
                os.chown(file_path, gid=grp.getgrnam(file_group).gr_gid)

            if file_perms:
                os.chmod(file_path, int(str(file_perms), 8))

            return key

        raise

Et une fonction pour récupérer la clé depuis une variable d’environnement ou un fichier:

def get_secret_key(
        file_path=None, 
        create=True, 
        size=50, 
        file_perms=None, 
        file_user=None, 
        file_group=None,
        env_var="DJANGO_SECRET_KEY"
    ):
    try:
        return os.environ[env_var]
    except KeyError:
        if file_path:
            return secret_key_from_file(file_path, create=create, size=size)
        raise

Le but de cette dernière est d’avoir ça dans son fichier de settings:

SECRET_KEY = get_secret_key('secret_key')

Et de foutre ‘secret_key’ dans son .gitignore.

Comme ça:

• Si on n’a pas de clé secrète, on en génère une.
• Si on a une, elle est dans un fichier qui n’est PAS dans settings.py.
• On peut commiter settings.py. Chaque env de dev et prod a sa clé secrète automatiquement.
• On peut overrider la clé avec une variable d’environnement si on le souhaite.

En attendant, j’ai proposé qu’on ajoute ça a django extensions. Et qui sait, dans le core peut être un jour ?

Mais j’aime pouvoir le mettre en veille rapidement, en appuyant juste sur le bouton power, et il n’y a plus de paramètres pour le régler dans les settings d’Ubuntu.

La solution et cette petite ligne de commande :

gsettings set org.gnome.settings-daemon.plugins.power button-power 'suspend'

Les valeurs possibles sont :

• ‘blank’ : aucune valeur.
• ‘suspend’ : mettre en veille.
• ‘shutdown’ : éteindre.
• ‘hibernate’ : hiberner.
• ‘interactive’ : afficher une fenêtre qui demande quoi faire.
• ‘nothing’ : ne rien faire.

On peut aussi le faire en graphique pour ceux qui n’aiment pas le terminal.

Rappel donc, le fichier settings.py, c’est juste du Python.

Ça veut dire qu’on peut faire ça en début de fichier:

import os
# répérer le dossier du projet
ROOT_DIR = os.path.dirname(os.path.realpath(__file__))

Et ça un peut partout dans le projet pour éviter les d'avoir des chemins absolus en dur:

STATIC_ROOT = os.path.join(ROOT_DIR, 'static')

On peut aussi faire des choses comme celle-ci, pour avoir un comportement spécial en mode debug:

if DEBUG:

    # on retire le dernier middleware
    MIDDLEWARE_CLASSES = [:-1]
    #et on en rajoute un au début
    MIDDLEWARE_CLASSES = (
        'libs.middlewares.MonMiddlewareKilebo',
    ) + MIDDLEWARE_CLASSES

Et si un settings n’existe pas, on peut l’inventer pour le réutiliser partout dans son code ailleurs:

SERVER_POOL = (
    ('8.8.8.8', "sametmax.com"),
    ('8.8.4.4', "cnd.sametmax.com"),
    ('208.67.222.222', 'staging.sametmax.com'),
    ('208.67.220.220', "dev.sametmax.com")
)

Et même se faciliter la vie:

SERVER_POOL_DICT = dict(SERVER_POOL)

Dans le même genre on peut faire des calculs:

CINQ_MINUTES = 60 * 5
...
CACHE_MIDDLEWARE_SECONDS = CINQ_MINUTES * 2

Et bien entendu, on peut splitter son fichier de settings en plusieurs fichiers. Il y a le maintenant classique fichier de settings local qui est différent sur chaque marchine, et qu’on importe en fin de fichier:

try:
    from settings_local import *
except ImportError:
    pass

Ca permet de mettre les paramètres de la base de données dans settings_local.py.

Mais on oublie souvent que peut tout à fait récupérer les paramètres depuis un fichier non Python.

Récupérer des valeurs dans un fichiers ini ? Fastoche !

import ConfigParser
config = ConfigParser.RawConfigParser()
config.readfp('/chemin/vers/fichier.ini')
locals().update(config.items('section'))

import socket

if socket.gethostname() == 'monsupersite.com':
    DEBUG = False
else:
    DEBUG = True

Pour ce faire on utilise word wrap

Allez dans les préférences > Settings User et rajoutez cette ligne:

Par exemple:

{
	"font_size": 11.0
}

donnera:

{
	"font_size": 11.0,
	"word_wrap": true
}

Relancez Sublime pour que les changements soient pris en compte.