Perles de Mongueurs - Conversion de dates

Magazine
Marque
GNU/Linux Magazine
Numéro
123
Mois de parution
janvier 2010


Résumé
Depuis le numéro 59, les Mongueurs de Perl vous proposent tous les mois de découvrir les scripts jetables qu’ils ont pu coder ou découvrir dans leur utilisation quotidienne de Perl. Bref, des choses trop courtes pour en faire un article, mais suffisamment intéressantes pour mériter d’être publiées. Ce sont les perles de Mongueurs.

Body

1. Conversion de dates

Le système des shadow passwords (cf shadow(5)) permet de renforcer la sécurité d'un système Unix en séparant les informations sensibles des comptes utilisateurs, c'est-à-dire les mots de passe, des informations publiques telles que les identifiants numériques (UID) ou les répertoires personnels (home directory). Ce système permet également de gérer le renouvellement du mot de passe, ainsi que son expiration, entraînant de fait l'invalidation du compte associé. Ceci permet de mettre facilement en place une politique d'attribution de comptes informatiques pour une durée limitée, par exemple celui du séjour d'un étudiant au sein d'un laboratoire de recherche.

Néanmoins, et aussi bizarre que cela paraisse, tout le monde ne compte pas couramment les dates à partir du premier janvier 1970, et les demandes d'ouverture de compte expriment assez rarement cette durée de validité sous cette forme, qui est pourtant celle attendue par la spécification des shadow passwords... Il s'ensuit donc des besoins de conversion assez récurrents, qui m'ont poussé à écrire un script dédié.

1.1 Le choix du module

Comme pour d'autres domaines, il existe de multiples modules dédiés à la gestion des dates et des durées dans le monde Perl :

- Date::Calc ;

- Date::Manip ;

- Class::Date ;

- etc.

Trop même, puisque cette floraison ne facilite ni la maintenance, ni le choix de l'utilisateur. Le projet DateTime vise donc à réunifier l'ensemble des fonctionnalités au sein d'un nombre réduit de modules à l'interface cohérente. C'est donc l'approche recommandée aujourd'hui pour ce type de besoins.

1.2 L'idée originale...

À l'énoncé de la spécification, la première idée consiste à vouloir considérer ce nombre de jours comme une durée, et donc d'utiliser la classe DateTime::Format::Duration pour la représenter. C'est très simple à faire, effectivement. Malheureusement, le bât blesse au moment de la conversion de cette durée, exprimée dans une unité quelconque, en nombre de jours. En effet, si le nombre d'heures dans une journée est constant, ceci n'est pas vrai pour le nombre de jours dans un mois. Il n'est donc pas possible de convertir une durée comme « un an » en un nombre de jours. Il faut donc faire autrement, et passer par l'approche bas niveau classique : toute date dans le monde Unix est un nombre de secondes écoulées depuis le 1er janvier 1970.

1.3 Et le programme qui marche

On commence par la documentation, ce qui permet d'une part de ne pas l'oublier, d'autre part de spécifier l'interface de l'outil.

    #!/usr/bin/perl

    =head1 NAME

    compute-expiration

    =head1 SYNOPSIS

compute-expiration <format> <date>

    format can be either:

    =over

    =item B<duration>: account duration from now (days/months/years)

    =item B<date>: account expiration date (day/month/year)

    =item B<count>: account expiration date (days count since epoch)

=back

    =cut

On passe ensuite au chargement des modules nécessaires, ainsi que par la définition d'une constante correspondant au nombre de secondes dans une journée.

    use strict;

    use constant SECONDS_BY_DAY => 60 * 60 * 24;

    use feature 'switch';

    use DateTime;

    use DateTime::Format::Duration;

    use DateTime::Format::Strptime;

    use Pod::Usage;

use 5.010;

L'analyse des arguments est triviale, et renvoie à la documentation si ceux-ci sont manquants, grâce à Pod::Usage. On passe ensuite à la partie principale du programme, sous la forme d'une directive given, une des nouveautés de Perl 5.10, permettant de traiter chacun des formats d'entrée.

    my $format = $ARGV[0] || pod2usage("No format given, aborting");

    my $date   = $ARGV[1] || pod2usage("No date given, aborting");

    my ($future, $count);

given($format) {

Dans le premier cas, la date d'expiration est définie par une durée à partir de la date actuelle. La chaîne donnée en entrée, sous la forme « jours/mois/années », est convertie en une instance de la classe DateTime::Format::Duration. La date actuelle, elle, est une instance de la classe DateTime. L'addition des deux, possible grâce à la surcharge de l'opérateur +, fournit une nouvelle instance de la classe DateTime correspondant à la date d'expiration. À défaut de méthode dédiée dans la classe, il suffit alors de convertir cette date en nombre de secondes depuis le 1er janvier 1970, puis de diviser par le nombre de secondes par jour.

En cas d'erreur d'analyse, le programme s'arrête avec un message d'erreur. Celui-ci se termine par un retour chariot, pour éviter l'ajout automatique par la fonction die() de la ligne du programme à laquelle l'erreur se produit. Autant ce genre d'information est intéressante pour un développeur, autant elle concerne peu l'utilisateur final.

        when ('duration') {

            my $now      = DateTime->now();

            my $pattern = DateTime::Format::Duration->new(pattern => '%d/%m/%Y');

            my $duration = $pattern->parse_duration($date);

            die "Unrecognized date pattern $date\n" unless $duration;

            $future = $now + $duration;

            $count = int($future->epoch() / SECONDS_BY_DAY);

}

Dans le second cas, la date d'expiration est donnée directement. Il suffit alors d'analyser la chaîne fournie, grâce à la classe DateTime::Format::Strptime, pour se retrouver dans le cas précédent.

        when ('date') {

            my $pattern = DateTime::Format::Strptime->new(pattern => '%d/%m/%Y');

            $future = $pattern->parse_datetime($date);

            die "Unrecognized date pattern $date\n" unless $future;

            $count = int($future->epoch() / SECONDS_BY_DAY);

}

Enfin, le dernier cas correspond à la traduction du nombre de jours en date. Il suffit d'appliquer l'opération inverse, c'est-à-dire de convertir ce nombre en secondes d'abord, pour obtenir la date ensuite.

        when ('count') {

            $future = DateTime->from_epoch(epoch => $date * SECONDS_BY_DAY);

$count = $date;

        }

Il reste encore à traiter le cas de l'argument incorrect, ne correspondant à aucune des valeurs précédentes, puis à afficher les valeurs calculées précédemment.

        default {

            die "Unknown format $format\n";

        }

    }

    printf "expiration date: %s\n", $future->strftime('%d/%m/%Y');

    printf "days since 1970: %s\n", $count;

Au final, 62 lignes de code (documentation comprise) permettent donc de convertir des dates, exprimées dans des formats différents, sans sacrifier la lisibilité du code, grâce à l'utilisation de modules issus du projet DateTime.

À vous !

Envoyez vos perles à perles@mongueurs.net, elles seront peut-être publiées dans un prochain numéro de Linux Magazine.




Article rédigé par

Par le(s) même(s) auteur(s)

Kerberos, le SSO universel : 3- Subtilités diverses et mise en œuvre avancée

Magazine
Marque
GNU/Linux Magazine
Numéro
143
Mois de parution
novembre 2011
Résumé

La partie précédente a montré l'utilisation de Kerberos au sein de différentes applications, à partir de cas d'école. Néanmoins, les cas réels sont généralement plus complexes et certains détails viennent parfois compliquer la donne. Cette partie présente donc certains problèmes de mise en œuvre de Kerberos et la façon d'y remédier.

Kerberos, le SSO universel : 1- Présentation et déploiement

Magazine
Marque
GNU/Linux Magazine
Numéro
143
Mois de parution
novembre 2011
Résumé

Kerberos est un protocole d'authentification réseau, qui présente la particularité d'allier à la fois sécurité et confort d'utilisation, puisqu'il s'agit d'un système d'authentification unique (SSO, Single Sign On). À l'heure où fleurissent les articles vantant les mérites des systèmes de type CAS, assurant un service similaire, mais limité aux seules applications web, il paraît intéressant de présenter cette technologie quelque peu méconnue.

Kerberos, le SSO universel : 4- Relation de confiance entre royaumes

Magazine
Marque
GNU/Linux Magazine
Numéro
143
Mois de parution
novembre 2011
Résumé

Jusqu'ici, les exemples présentés concernaient l'accès à des ressources appartenant au même royaume Kerberos que l'utilisateur. Or, ceci n'est pas toujours le cas dans la réalité, lorsqu'il existe plusieurs royaumes Kerberos différents au sein d'une même entité. Cette situation peut être volontaire, les différents royaumes jouant une fonction de cloisonnement, ou non, typiquement lorsqu'un domaine Active Directory est mis en place pour gérer un parc de machines Windows et qu'il vient avec son propre royaume Kerberos.

Les derniers articles Premiums

Les derniers articles Premium

Cryptographie : débuter par la pratique grâce à picoCTF

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

L’apprentissage de la cryptographie n’est pas toujours évident lorsqu’on souhaite le faire par la pratique. Lorsque l’on débute, il existe cependant des challenges accessibles qui permettent de découvrir ce monde passionnant sans avoir de connaissances mathématiques approfondies en la matière. C’est le cas de picoCTF, qui propose une série d’épreuves en cryptographie avec une difficulté progressive et à destination des débutants !

Game & Watch : utilisons judicieusement la mémoire

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Au terme de l'article précédent [1] concernant la transformation de la console Nintendo Game & Watch en plateforme de développement, nous nous sommes heurtés à un problème : les 128 Ko de flash intégrés au microcontrôleur STM32 sont une ressource précieuse, car en quantité réduite. Mais heureusement pour nous, le STM32H7B0 dispose d'une mémoire vive de taille conséquente (~ 1,2 Mo) et se trouve être connecté à une flash externe QSPI offrant autant d'espace. Pour pouvoir développer des codes plus étoffés, nous devons apprendre à utiliser ces deux ressources.

Raspberry Pi Pico : PIO, DMA et mémoire flash

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Le microcontrôleur RP2040 équipant la Pico est une petite merveille et malgré l'absence de connectivité wifi ou Bluetooth, l'étendue des fonctionnalités intégrées reste très impressionnante. Nous avons abordé le sujet du sous-système PIO dans un précédent article [1], mais celui-ci n'était qu'une découverte de la fonctionnalité. Il est temps à présent de pousser plus loin nos expérimentations en mêlant plusieurs ressources à notre disposition : PIO, DMA et accès à la flash QSPI.

Abonnez-vous maintenant

et profitez de tous les contenus en illimité

Je découvre les offres

Déjà abonné ? Connectez-vous