+ Répondre à la discussion
Affichage des résultats 1 à 2 sur 2
  1. #1
    Invité de passage
    Inscrit en
    septembre 2006
    Messages
    24
    Détails du profil
    Informations forums :
    Inscription : septembre 2006
    Messages : 24
    Points : 4
    Points
    4

    Par défaut Plusieurs services du même type

    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 :
    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 :
    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 :
    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 !

  2. #2
    Membre éclairé
    Homme Profil pro
    Architecte technique
    Inscrit en
    septembre 2006
    Messages
    219
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2006
    Messages : 219
    Points : 301
    Points
    301

    Par défaut

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

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •