Suggestions de la bibliothèque C ++ RPC

Je suis à la recherche de suggestions concernant le RPC bibliothèques implémenté en C++, pour les développeurs C++.

Certaines exigences en termes de contraintes:

Devrait fonctionner sur linux/unix et win32 systèmes
Être en mesure d'exécuter la fonction libre et les méthodes de la classe
Espérons-le, écrit en C++ moderne pas 90/java-esque C++
Être en mesure de fonctionner sur les réseaux et hetrogenous architectures
Pas trop lente ou inefficace
Nous espérons que les interfaces pour TR1 style std::function et coll.

Mon exemple d'utilisation consiste à appeler la fonction foo sur une machine distante.

---snip---
//foo translation unit
int foo(int i, int j)
{
   return i + j;
}
---snip---


---snip---
//client side main
int main()
{
   //register foo on client and server
   //setup necassary connections and states

   int result;

   if (RPCmechanism.invoke("foo",4,9,result))
      std::cout << "foo(4,9) = " result << std::endl;
   else
      std::cout << "failed to invoke foo(4,9)!" << std::endl;

   return 0;
}
---snip---

Quelque chose qui peut atteindre au-dessus ou similaires.

Remarque: je ne suis PAS intéressé par d'autres liaisons de langage. S'il vous plaît ne pas apporter une solution, car il a d'autres liaisons de langage. Je suis seulement intéressé dans bien conçu RPC cadres écrit en C++ le langage C++, qui sont efficaces et appropriés pour les scénarios HPC.

source d'informationauteur

c++rmi rpc

8

C'est tout un ensemble d'exigences...

Tout en ne répondant pas à tous d'entre eux (comme je ne suis pas sûr qu'une telle bête existe - je recommande à votre attention GLACE de ZeroC. Développé en partie par Michi Henning de CORBA fame (et demandez à vos amis dans les télécoms, qui n'est vraiment pas un gros mot), la GLACE est ce que CORBA aurait ressemblé s'il a commencé plus tard et n'a pas été développé par un comité.

Leur C++ cartographie est tout ce que CORBA n'est pas, il utilise des types STL, et est généralement plus récent sentiment.

Il échoue au libre-fonction et std::tests de la fonction, mais compte tenu de l'improbabilité de la recherche d'un produit pour l'ensemble de la liste, ce qui fait un bon travail de nombreuses le reste.

Bonne Chance
7

Je suis également intéressé par viables C++ RPC implémentations. Après quelques recherches, j'ai trouvé que etch, l'économie et le protocol buffers sont les solutions les plus prometteuses, cependant, aucun d'entre eux répond à tous mes besoins. Mes critères de recherche sont:
1. multi-langue, avec le C++ et PHP comme un must (C#, Java, Python, Perl ne sont pas si importantes pour le moment)
2. le serveur peut compiler/exécuter uniquement sur Linux (avec Windows comme un objectif à long terme)
3. le client doit fonctionner sur Windows et Linux (et, éventuellement, Mac)
4. open source et commerciales sympathique (qui est, sans aucun GPL)
5. il doit prendre en charge le chiffrement de la boîte
Et les candidats sont:
1. Apache Etch
  
  Pour:
  - le C de liaison est basée sur la AVR
  - prend en charge le chiffrement
  - fonctionne sur les deux plates-formes
  Contre
  - développement lent
  - manque un PHP de liaison
2. Apache Épargne
  
  Pour:
  - petit
  - plusieurs liaisons de langage
  Contre:
  - actuellement, il ne prend pas en charge le chiffrement (en cours de développement, au moins pour le C++ liaison)
  - sur Windows, il nécessite Cygwin
3. Protocole de Tampons avec un développé en interne RPC solution
  
  Pour:
  - petit
  - plusieurs liaisons de langage
  Contre:
  - pas intégré dans le RPC
Actuellement, je suis d'évaluer la possibilité de développer la couche RPC pour Protobuf à l'aide de AVR.

Cependant, la recherche continue...

EDIT: j'ai réussi à travailler à travers certaines de ces questions à l'aide de Apache Qpid (version C++) avec protobuf pour la sérialisation, bien qu'il manque actuellement de certaines fonctionnalités dont j'ai besoin.
5

anciens comme DCE-RPC, CORBA,

ou Protocol Buffersou Aubaines Etch

ou web, comme le SAVON, ou de REPOS.

Lequel vous souhaitez dépend de ce que vous voulez faire. par exemple. rapide et efficace RPC pour un réseau local aurait besoin d'un léger, binaire RPC comme Protocole de Tampons, mais un RPC pour hétérogène services web nécessitent beaucoup plus de commentaires de SAVON.

Google utilise des PB pour l'ensemble de ses internes Rpc donc c'est un bon choix. Facebook utilise l'Épargne de sorte que son à peine un petit joueur, et MME aime SAVON.
3

Avez-vous essayé d'aubaines, http://thrift.apache.org/ ?
2

Découvrez FastRPC, http://fastrpc.sourceforge.net/ .
2

RCF semble être ce que vous voulez: http://www.deltavsoft.com/index.html
1

vous pouvez utiliser protobuf mettre en œuvre un par vous-même, et ajouter tout ce que vous vouliez featrue. Il n'est pas trop dur, et vous pouvez obtenir de nombreux avantages.

Le code suivant, tiré à partir d'un exemple TAO CORBA client, montre que 3 lignes de code sont nécessaires pour se connecter à un serveur, et une seule ligne de code pour appeler une fonction. Notez que l'appel de la fonction ressemble à un natif local de l'appel de fonction. Cela peut être soit une fonction ou une fonction de membre.

//Bring in the IOR
Object_var factory_object =  orb->string_to_object (argv[1]);

//Now downcast the object reference 
My_Factory_var factory = My_Factory::_narrow (factory_object.in ());

//Now get the full name and price of the other arguments:
Widget_var widget = factory->get_widget (argv[i]);

//Get its name, put it on a _var so it is automatically
//released!
String_var full_name = widget->full_name ();

//Now get the price
Double price = widget->price ();

cout << "The price of a widget in \""
  << full_name.in () << "\" is $"
  << price << endl;

Le code du serveur est un peu plus complexe à montrer, mais dans CORBA, pour ce que vous êtes à la recherche pour le faire, surtout, créer un IDL interface, le lancer à travers le compilateur, puis remplissez-les dans votre logique d'application dans l'emplacement approprié dans le stub. Donc, votre code principal se présente comme suit:

//First initialize the ORB, that will remove some arguments...
ORB_var orb = ORB_init(argc, argv, "ORB" /* the ORB name, it can be anything! */);
Object_var poa_object = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(poa_object.in());
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();

//Create the servant
My_Factory_i my_factory_i;

//Activate it to obtain the object reference
My_Factory_var my_factory = my_factory_i._this();

//Put the object reference as an IOR string
String_var ior = orb->object_to_string (my_factory.in());
orb->run();

    //Now in your stub file generated by the idl compiler, 
    char * Widget_i::full_name (

  )
  ACE_THROW_SPEC ((
    ::CORBA::SystemException
  ))
{
  return "Some widget name";
}

::CORBA::Double Widget_i::price (

  )
  ACE_THROW_SPEC ((
    ::CORBA::SystemException
  ))
{
  return 1.25;
}

Ont un coup d'oeil à Ce WikiBook pour plus de références et d'exemples

Vous devez vous connecter pour publier un commentaire.