Discussion :

[Trunks]

Bonjour,

J'ai un programme qui fait des traitements informatiques (sauvegardes, modifications, envois par FTP, ...).

Le programme peut comporter des erreurs critiques qui nécessite un arrêt de ce dernier et affiche le message d'erreur qui permettra de résoudre le problème et ainsi reprendre où j'en étais avant le plantage.

Pour celà, je crée des points de restauration que je stocke dans un fichier ini. Quand je lance le programme, je lis le fichier et sais à quel endroit je dois continuer mon programme.

Cependant, je ne sais pas comment le mettre en place. Pointeur de fonction?

Voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void main_func()
{
    func1();
    func2();
    if (func3())
    {
        func4();
        func5();
    }
    else
        func6();
    func7();
}

Je ne vois pas comment faire pour reprendre le traitement à func4() par exemple. Comment procéderiez vous?

Merci d'avance.

[Sylvain Togni]

Cela me parait difficile. Es-tu obligé de terminer le programme après une erreur critique ? Il serait plus simple que le programme continu de tourner, et reprenne juste au début de la fonction courante. L'idiome RAII + les exceptions doivent aider à cela.

Sinon il faudrait modéliser le traitement par un ensemble de taches. La présence de if/else implique plusieurs chemins possibles et donc une structure de graphe. Un point de restauration est alors un sommet de ce graphe qu'il suffit de sérialiser pour pouvoir reprendre l'exécution au même endroit.

[Trunks]

Tu as raison, le RAII semble la meilleure solution. Le système de graphe compliquerait énormément le code et ça risque de devenir très rapidement un véritable fouillis !

Je pense que je vais donc mettre en place ce système. Le programme sera en attente le temps que l'utilisateur règle le problème, puis relancera la partie incriminée.

Merci pour ton conseil

[koala01]

Salut,

Peut etre pourrais tu travailler sur une idée de DP "memento" mais... à l'envers...

Je m'explique:
Le memento va rajouter ce qui a été fait chaque fois que tu fais quelque chose, afin de pouvoir effectuer un "roll back" des différentes actions, dans l'ordre dans lequel elles ont été effectuées.

Tu pourrait commencer par créer une liste des actions à effectuer, et à chaque fois qu'une action est terminée, tu écrit dans le fichier quelle action vient de se finir.

De cette manière, après plantage, tu lit la dernière action correctement effectuée, et tu reprend l'exécution de ce qui reste à faire

Tu aurais donc plusieurs fichiers ini différents:

Le premier consisterait à donner l'ensemble des actions à effectuer (copier tel fichier à tel endroit, renommer tel autre, effacer un troisieme, déplacer tel répertoire, transmettre par ftp,...) à chaque fois.

Un autre servirait de "log" pour indiquer (à toi et au programme) ce qui a été fait et (éventuellement) les problèmes à résoudre.

Lorsque tu lance l'application, tu charge le "script" (l'ensemble des actions), puis tu récupère le dernier point de sauvegarde, et tu n'a "plus qu'à"...continuer à partir de ce point

[Médinoc]

Sinon, pour la "reprise" d'exécution comme ça, tu peux faire une machine à états. Ainsi, tu sauvegardes l'état dans lequel tu es, et tu peux recharger cet état ensuite...

[Trunks]

Sinon, pour la "reprise" d'exécution comme ça, tu peux faire une machine à états. Ainsi, tu sauvegardes l'état dans lequel tu es, et tu peux recharger cet état ensuite...

Comment ça marche?

[Trunks]

Salut,

Peut etre pourrais tu travailler sur une idée de DP "memento" mais... à l'envers...

Je m'explique:
Le memento va rajouter ce qui a été fait chaque fois que tu fais quelque chose, afin de pouvoir effectuer un "roll back" des différentes actions, dans l'ordre dans lequel elles ont été effectuées.

Tu pourrait commencer par créer une liste des actions à effectuer, et à chaque fois qu'une action est terminée, tu écrit dans le fichier quelle action vient de se finir.

De cette manière, après plantage, tu lit la dernière action correctement effectuée, et tu reprend l'exécution de ce qui reste à faire

Tu aurais donc plusieurs fichiers ini différents:

Le premier consisterait à donner l'ensemble des actions à effectuer (copier tel fichier à tel endroit, renommer tel autre, effacer un troisieme, déplacer tel répertoire, transmettre par ftp,...) à chaque fois.

Un autre servirait de "log" pour indiquer (à toi et au programme) ce qui a été fait et (éventuellement) les problèmes à résoudre.

Lorsque tu lance l'application, tu charge le "script" (l'ensemble des actions), puis tu récupère le dernier point de sauvegarde, et tu n'a "plus qu'à"...continuer à partir de ce point

C'est exactement ça. Finallement, je me rend compte, que c'est possible que le programme a parfois besoin de se terminer plus tard, donc reprendre où j'en étais.

Concrètement, j'ai des dizaines de fonctions que je lance les uns après les autres. Et j'ai un fichier ini qui se présente de la manière suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
[Etapes]
Etape01=Debut
Etape02=func01
Etape03=func02
Etape04=func03
Etape05=func04
Etape06=func05
Etape07=func06
Etape08=func07
 
[Param]
Etape=Etape03

Le champ param me dit où commencer l'exécution.
Ce qui reste à savoir, c'est comment commencer l'exécution à partir de la fonction en question. Mettre un système de flag (booléen) et dans chaque fonction tester si le flag correspond, si ce n'est pas le cas, skipper la fonction et aller à la suivante et une fois trouvée, poursuivre le traitement?