Discussion :

[skeud]

Bonjour à tous,

Je suis ammené à développer sous visual studio une solution de deux logiciel qui doivent communiquer ensemble:
Un premier (nommé "service") qui est lancé en service windows et qui fait tout un tas de truc.
Un deuxieme (nommé "application") en application qui fait aussi tout un tas de chose.

Je dois instauré une communication entre ces deux processus sachant que l'utilisateur ne garanti pas la longévité des deux solutions (elles peuvent s’arrêter et redémarrer n'importe quand).
La communication se fait que dans un sens: l'application envois des demandes au service pour effectué une tache sans attendre de retour.

J'ai commencé par implémenter une solution de NamedPipe mais je me rend compte que ce n'est pas adapté:
Le pipe se retrouve détruit si une application cesse.
Le pipe serait créer par l'application et le service se connecte dessus pour recevoir des données sauf que si l'application redémarre, le pipe se retrouve cassé et donc ne fonctionne plus.
Je ne peux pas non plus utiliser les socket car cela implique une connexion constante entre les deux solutions.

Je me demande donc quelle serait la meilleur solution, j'ai vu que l'on pouvait utiliser le fileMapping, est-ce une bonne solution? le problème que je vois avec cette solution est la file d'attente, il ne faut pas que le service exécute les actions en attente dans le fichier.

Je comptais d'abord utiliser un système de signaux sauf que je ne connais pas le pid du service, donc impossible d'envoyer un signal.

N'éxiste-t-il pas sous windows une solution toute simple pour envoyer un signal à un service windows afin qu'il effectue une tache périodique?

Toute aide est la bienvenue .

[Médinoc]

Normalement, c'est bien le Named Pipe (ou à la rigueur socket) qu'il faut, créé par le service, et l'appli s'y connecte.
Ensuite, rien ne dit que l'appli doit maintenir une connexion permanente, plutôt que se connecter au service à chaque requête...

[r0d]

Bonjour,

as-tu regardé du côté de boost interprocess?
Il y a plusieurs solutions envisageables (mémoire partagé, fichiers partagés, avec différents types de locks, mutexes, etc.).

[skeud]

J'ai trouvé une meilleur solution en utilisant le ControlHandler des service windows, le test fonctionne bien par contre mon handler intercepte aussi les demande d'arret et de pause du service, sauriez-vous par hasard comment faire pour qu'il n'intercepte que les control user? (128 à 256). Ou sinon comment appeler le handler par défault du service?

[Médinoc]

Ce que tu dis signifie que tu as implémenté ton service en utilisant un framework qui contient le vrai ControlHandler; la réponse dépend du framework utilisé...

[skeud]

J'ai finalement trouvé une solution en mettant ma fonction longue du service dans un thread et en implémentant les différent signaux possible dans mon handler, voici le code utilisé pour ceux que ça interesse:

utilitaire pour envoyer un signal 129 à un service nommé :

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
std::string GetLastErrorStdStr(DWORD error)
{
  if (error)
  {
    LPVOID lpMsgBuf = 0;
    DWORD bufLen = FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        error,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );
    if (bufLen)
    {
      LPCSTR lpMsgStr = (LPCSTR)lpMsgBuf;
      std::string result(lpMsgStr, lpMsgStr+bufLen);
 
      LocalFree(lpMsgBuf);
 
      return result;
    }
  }
  return std::string("?????");
}
 
int _tmain(int argc, _TCHAR* argv[])
{
	SERVICE_STATUS ssStatus;
	LPTSTR app_name_long = _T("nomduservice");
	SC_HANDLE schManager;
	SC_HANDLE schService;
	if ((schManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT)) != NULL)
		if ((schService = OpenService(schManager, app_name_long, SERVICE_USER_DEFINED_CONTROL)) != NULL)
		{
			std::cout << "sending control" << std::endl;
			if (ControlService(schService, 129, &ssStatus))
				std::cout << "succes" << std::endl;
			else
				std::cout << "ControlService failed" << std::endl;
		}
		else
			std::cout << "openservice failed" << std::endl;
	else
		std::cout << "openscmanager failed" << std::endl;
	DWORD numError = GetLastError();
	std::cout << "last error = " << numError << std::endl;
	std::string error = GetLastErrorStdStr(numError);
	std::cout << error.c_str() << std::endl;
	CloseServiceHandle(schService);
	CloseServiceHandle(schManager);
	system("PAUSE");
	return (0);
}

et le code coté service :
dans le main du service :

Code :

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

RegisterServiceCtrlHandlerEx(app_name_long, ServiceControlHandler, lpContext);

la fonction de reception:

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
DWORD WINAPI ServiceControlHandler(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData, LPVOID lpContext)
{
	if (dwControl == 129)
	{
		CreateThread( 
            NULL,                   // default security attributes
            0,                      // use default stack size  
            TraitementThread,       // thread function name (correspond au thread effectuant la tache)
            lpContext,          // argument to thread function 
            0,                      // use default creation flags 
            0); 
		return (0);
	}
	else if (dwControl == SERVICE_CONTROL_STOP)
		StopService();
	else if (dwControl == SERVICE_CONTROL_INTERROGATE)
		return (0);
	else
		// log d'un code ne correspondant à rien de ce qu'on gère
	return (0);
}

Je passe le sujet en résolu étant donné que j'ai une solution fonctionnelle .

Merci de votre aide .