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]

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?

[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?

[Médinoc]

Pour moi, c'est plus ou moins ceci: Automate Fini Déterministe

[Trunks]

Pour moi, c'est plus ou moins ceci: Automate Fini Déterministe

Je suis désolé, mais ça m'aide pas vraiment
C'est trop théorique et spécifique. Je ne vois pas comment je peux mettre ça en place concrètement, quelles techniques utiliser ...
J'ai compris le principe, il reste plus qu'à trouver comment le mettre en place.

[Médinoc]

Un conseil, utilise plutôt ce que Koala01 t'a indiqué.

[Trunks]

C'est ce que j'avais commencé à faire.
Voulais juste avoir d'autres conseils et idées au cas où il y aurait une meilleure

Merci à vous pour vos aides et conseils toujours aussi utiles comme à l'accoutumée

[loufoque]

C'est pas plutôt des coroutines ou des continuations qu'il te faut ?

[Trunks]

C'est pas plutôt des coroutines ou des continuations qu'il te faut ?

Qu'est ce que c'est?

[loufoque]

Wikipedia et Google sont tes amis.
(et les cours de base de programmation aussi)

[Trunks]

Finallement, je viens d'implémenter seulement maintenant. J'ai choisi la solution de koala01 qui est simple à mettre en place.
J'ai utilisé les goto (pour la 1e fois depuis que je développe !) qui me permet de gérer correctement les if. Cependant, la portée est seulement locale à une fonction, mais c'est déjà pas si mal

Voici ce que ça donne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
void main_func()
{
	CRestore restore;
 
	restore.Init();
 
	if (restore.GetRestorationPoint() == "Debut")
	{
		goto begin;
	}
	else if (restore.GetRestorationPoint() == "func01")
	{
		goto f1;
	}
	else if (restore.GetRestorationPoint() == "func02"
	{
		goto f2;
	}
	else if (restore.GetRestorationPoint() == "func03"
	{
		goto f3;
	}
	else if (restore.GetRestorationPoint() == "func04"
	{
		goto f4;
	}
	else if (restore.GetRestorationPoint() == "func05"
	{
		goto f5;
	}
	else if (restore.GetRestorationPoint() == "func06"
	{
		goto f6;
	}
	else if (restore.GetRestorationPoint() == "func07"
	{
		goto f7;
	}
 
begin:
	restore.UpdateConfigFile("Etape01");
f1:
	restore.UpdateConfigFile("Etape02");
	func1();
f2:
	restore.UpdateConfigFile("Etape03");
	func2();
f3:
	restore.UpdateConfigFile("Etape04");
	if (func3())
	{
f4:
		restore.UpdateConfigFile("Etape05");
		func4();
f5:
		restore.UpdateConfigFile("Etape06");
		func5();
	}
	else
	{
f6:
		restore.UpdateConfigFile("Etape07");
		func6();
	}
f7:
	restore.UpdateConfigFile("Etape08");
	func7();
}

La fonction UpdateConfigFile() permet la mise à jour automatique de la section [Param] du fichier de configuration.

[JulienDuSud]

Oula...

Pourquoi pas un truc comme ça, qui serait un peu plus propre, à mon sens ?:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
#include <map>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/variant.hpp>
 
void func1();
void func2();
bool func3();
void func4();
void func5();
void func6();
void func7();
 
void func1()
{
	//...
	func2();
}
 
void func2()
{
	//...
	if( func3() )
	{
		func4();
	}
	else
	{
		func6();
	}
}
 
bool func3()
{
	//...
	return false;
}
 
void func4()
{
	func5();
}
 
void func5()
{
	func7();
}
 
void func6()
{
	func7();
}
 
void func7()
{
 
}
 
int main()
{
	typedef boost::function< void() > void_func;
	typedef boost::function< bool() > bool_func;
	typedef boost::variant< void_func, bool_func > var_func;
 
	typedef std::map< std::string, var_func > FuncMap;
	FuncMap m;
 
	m.insert( std::make_pair( "Etape01", void_func(boost::bind( &func1 )) ) );	
	m.insert( std::make_pair( "Etape02", void_func(boost::bind( &func2 )) ) );
	m.insert( std::make_pair( "Etape03", bool_func(boost::bind( &func3 )) ) );
	// m.insert( ... );
	// jusqu'à toutes les fonctions.
 
	FuncMap::iterator it = m.find( restore.GetRestorationPoint() );
	if( it != m.end() )
	{
		try
		{
			boost::get< void_func >( it->second )();
			++it;
		}
		catch( boost::bad_get& e )
		{
			--it;
		}
	}
 
	return 0;
}

Après, à mon avis tu dois clairement revoir ta conception...

[bacelar]

C'est quoi, ce truc horrible.(Edit : message Trunks)

Un _try/_finally avec une routine de roolback/compensation, c'est beaucoup plus maintenable. Une classe de transaction avec un appel à un Rollback dans le destructeur pour un effet ceinture+bretelle.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Transaction t;
_try
{
.....
t.add(xxxxxxx);
.....
.....
.....
 
    t.Commit();
}
_finally
{
   if(!t.commited)
   {
      t.Rollback();
   }
}

[Trunks]

C'est quoi, ce truc horrible.(Edit : message Trunks)

Un _try/_finally avec une routine de roolback/compensation, c'est beaucoup plus maintenable. Une classe de transaction avec un appel à un Rollback dans le destructeur pour un effet ceinture+bretelle.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Transaction t;
_try
{
.....
t.add(xxxxxxx);
.....
.....
.....
 
    t.Commit();
}
_finally
{
   if(!t.commited)
   {
      t.Rollback();
   }
}

Je ne connais pas _try/_finally en C++

Par contre le principe de rollback pas mal, mais il n'y a rien dans le standard il me semble et je ne peux pas utiliser boost vu que j'utilise VC++ 6.0 (pas le choix).

[bacelar]

http://msdn.microsoft.com/en-us/libr...74(VS.60).aspx

[Médinoc]

Mais il n'a jamais été dit plus haut qu'on pouvait se permettre de se restreindre à Visual... (j'admets qu'on n'a pas explicitement dit le contraire non plus, mais pour ce genre de sujets, je l'ai supposé).