Plusieurs services du même type

**Warnershoot** · 20/12/2012, 18h59

Bonjour,

J'ai un problème avec CORBA, je m'explique :

J'ai un serveur CORBA fournissant plusieurs services. Ces services sont de même type, mais nommés différemment. Lorsque j'ajoute le premier service, son IOR est affiché, et le service est disponible.
Cependant à l'ajout du deuxième service, le même IOR est affiché, et le programme lève une exception :

terminate called after throwing an instance of 'CosNaming::NamingContext::NotFound'

Voici le code du programme :

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
//
//  CorbaServer.cpp
//  src
//
//  Created by Ugo RENNER on 18/12/12.
//
//

#include "CorbaServer.h"


/**
 * Constructeur
 *
 * @param argc Argc du main
 * @param argv Argv du main
 */
CorbaServer::CorbaServer(int argc, char **argv) :
orb(CORBA::ORB_init(argc, argv)),
nameService("NameService") {
		
	init();
}

/**
 * Initialise le serveur
 */
void CorbaServer::init() {
	
	try {
		
		//------------------------------------------------------------------------
		// Servant must register with POA in order to be made available for client
		// Get reference to the RootPOA.
		//------------------------------------------------------------------------
		CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
		_poa = PortableServer::POA::_narrow(obj.in());
		
		//------------------------------------------------------------------------
		// Bind object to name service as defined by directive InitRef
		// and identifier "NameService" in config file omniORB.cfg.
		//------------------------------------------------------------------------
		CORBA::Object_var obj1 = orb->resolve_initial_references(nameService.c_str());
		assert(!CORBA::is_nil(obj1.in()));
		
		//------------------------------------------------------------------------
		// narrow this to the naming context
		//------------------------------------------------------------------------
		nc = CosNaming::NamingContext::_narrow(obj1.in());
		assert(!CORBA::is_nil(nc.in()));
		
	}
	catch(CORBA::SystemException &e) {
		
		std::cerr << "Caught CORBA::SystemException." <<  std::endl;
	}
	catch(CORBA::Exception&) {
		
		std::cerr << "Caught CORBA::Exception." << std::endl;
	}
	catch(omniORB::fatalException& fe) {
		
		std::cerr << "Caught omniORB::fatalException:" << std::endl;
		std::cerr << "  file: " << fe.file() << std::endl;
		std::cerr << "  line: " << fe.line() << std::endl;
		std::cerr << "  mesg: " << fe.errmsg() << std::endl;
	}
	catch(...) {
		
		std::cerr << "Caught unknown exception." << std::endl;
	}
}


/**
 * Démarre le serveur Corba
 */
Result<Void>* CorbaServer::task() {
	
	Result<Void>* res = new Result<Void>();
	
	try {
		
		//------------------------------------------------------------------------
		// Activate the POA manager
		//------------------------------------------------------------------------
		PortableServer::POAManager_var pmgr = _poa->the_POAManager();
		pmgr->activate();
		
		std::cout << "Waiting for client requests..." << std::endl;
		
		//------------------------------------------------------------------------
		// Accept requests from clients
		//------------------------------------------------------------------------
		orb->run();
		
		//------------------------------------------------------------------------
		// If orb leaves event handling loop.
		// - currently configured never to time out (??)
		//------------------------------------------------------------------------
		orb->destroy();
		
		for(int i = 0; i < int(objMap.size()); i++)
			free(name[i].id); // str_dup does a malloc internally
	
	}
	catch(CORBA::SystemException &e) {
		
		std::cerr << "Caught CORBA::SystemException." << std::endl;
	}
	catch(CORBA::Exception&) {
		
		std::cerr << "Caught CORBA::Exception." << std::endl;
	}
	catch(omniORB::fatalException& fe) {
		
		std::cerr << "Caught omniORB::fatalException:" << std::endl;
		std::cerr << "  file: " << fe.file() << std::endl;
		std::cerr << "  line: " << fe.line() << std::endl;
		std::cerr << "  mesg: " << fe.errmsg() << std::endl;
	}
	catch(...) {
		
		std::cerr << "Caught unknown exception." << std::endl;
	}
	
	return res;
}

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
//
//  CorbaServer.h
//  src
//
//  Created by Ugo RENNER on 18/12/12.
//
//

#ifndef __src__CorbaServer__
#define __src__CorbaServer__

#include "RealTimeThread.h"
#include "BadAccessException.h"

#include <map>
#include <cstring>
#include <cstdlib>
#include <cassert>
#include <omniORB4/CORBA.h>
#include <omniORB4/Naming.hh>

#define MAXCORBASERVER 10

class CorbaServer : public RealTimeThread {
	
	typedef std::map<const std::string, PortableServer::ServantBase*> ServerObjectMap;
	
public:
	CorbaServer(int, char**);
	void init();
	
	template<typename T>
	void addServerObject(const char *, T*);
	
	virtual Result<Void>* task();
	
private:
	CORBA::ORB_var orb;
	ServerObjectMap objMap;
	std::string nameService;
	CosNaming::Name name;
	PortableServer::POA_var _poa;
	CosNaming::NamingContext_var nc;
};

#include "CorbaServer.hxx"

#endif /* defined(__src__CorbaServer__) */

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
/**
 * Ajoute un objet serveur
 *
 * @param obj Objet à ajouter à la liste des objets serveurs
 */
template<typename T>
void CorbaServer::addServerObject(const char *objName, T* obj) {
	
	//try {
		
		std::cout << "Lancement du service \"" << objName << "\"." << std::endl;
		
		// Ajout de l'objet dans la liste
		objMap.insert(objMap.end(), std::pair<const char *, T*>(objName, obj));
		
		//------------------------------------------------------------------------
		// ObjectId_var class defined in poa.h
		// typedef String_var ObjectId_var; CORBA_ORB.h
		// ???????
		
		//------------------------------------------------------------------------
		// Servant object activated in RootPOA.
		// (Object id used for various POA operations.)
		//------------------------------------------------------------------------
		
		// Récupération de l'objet activé
		PortableServer::ObjectId_var activatedObject = _poa->activate_object(obj);
		
		//------------------------------------------------------------------------
		// Obtain object reference from servant and register in naming service(??)
		//------------------------------------------------------------------------
		CORBA::Object_var SA_obj = obj->_this();
		
		//------------------------------------------------------------------------
		// Obtain a reference to the object, and print it out as string IOR.
		//------------------------------------------------------------------------
		CORBA::String_var sior(orb->object_to_string(SA_obj.in()));
		std::cerr << "'" << (char*)sior << "'" << std::endl;
		
		//------------------------------------------------------------------------
		// Bind to CORBA name service. Same name to be requested by client.
		//------------------------------------------------------------------------
	
		// Nombre de serveurs
		name.length(objMap.size());
		name[objMap.size() - 1].id = CORBA::string_dup(objName);
		nc->rebind(name, SA_obj.in());
		
		//========================================================================
		obj->_remove_ref();
		
		std::cout << "Service \"" << objName << "\" lancé." << std::endl;
		
	/*}
	catch(CORBA::SystemException &e) {
		
		std::cerr << "Caught CORBA::SystemException." << std::endl;
	}
	catch(CORBA::Exception&) {
		
		std::cerr << "Caught CORBA::Exception." << std::endl;
	}
	catch(omniORB::fatalException& fe) {
		
		std::cerr << "Caught omniORB::fatalException:" << std::endl;
		std::cerr << "  file: " << fe.file() << std::endl;
		std::cerr << "  line: " << fe.line() << std::endl;
		std::cerr << "  mesg: " << fe.errmsg() << std::endl;
	}
	catch(...) {
		
		std::cerr << "Caught unknown exception." << std::endl;
	}*/
}

Merci d'avance !

**CorbAddict** · 08/01/2013, 11h44

Bonjour,

Il y a un problème avec la stratégie de nommage dans le Naming Service:
Le 1er objet (avec par exemple objName="A") est enregistré sous le chemin "/A".
Le 2e objet (avec par exemple objName="B") devrait être enregistré sous le chemin "/A/B".
Mais cela n'est pas possible, car l'objet enregistré sous "/A" n'est pas un NamingContext! D'où l'exception NotFound qui veut dire ici: "noeud intermédiaire (NamingContext) non trouvé".

Si objName est différent pour chaque objet à enregistrer, le code suivant est plus simple:

Code :

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

1
2
3
4
5
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup(objName);
nc->rebind(name, SA_obj.in());

Plusieurs services du même type

CORBA

Discussions similaires

Partager

Partager