Please Note

Introduction

The officially sanctioned way of making distributed function calls between C++ programs is to use CORBA, but for many applications, this is overkill. The CORBA specifications allow distributed function calls to be made between code written in any number of languages, and to make it all work, specialized tools need to be integrated into the build process, in order to translate object definitions written in CORBA's IDL to whichever native language is being used (C++, Java, etc.).

However, if we assume that the server and client are both written in the same language, let us assume C++, since it is possible to do away with these complexities. In particular, instead of elaborate definitions of interfaces and marshalling specifications, we can simply defer to C++.

Instead of separate IDL files with object interfaces, we specify the interfaces directly in C++ source code, using the preprocessor, and to marshal arguments across process boundaries, we use the native C++ serialization framework provided in the latest release of the Boost library.

The Boost.Serialization library is used to serialize parameters and return values. It handles standard types and containers automatically, and is easily extended to user defined classes. It also allows us to serialize pointers, with proper handling of polymorphic pointers and multiple pointers to single objects.

Basic Usage

There are three basic steps to using this framework:

Use the RCF_xxx macros to define interfaces.

Use the RcfServer class to expose objects that implement the interface.

Use the RcfClient<> classes to invoke methods on the objects exposed by the server.

type is the identifier for the interface, type_id is a string giving a runtime description of the interface. The RCF_METHOD_xx macros define the member functions, and are named according to the number of arguments and whether the return value is void or not. So, for a function func accepting two strings and returning an integer, we write:

RCF_METHOD_R2(int, func, std::string, std::string);

and if the function has a void return type, we would instead write:

RCF_METHOD_V2(void, func, std::string, std::string);

Dispatch IDs for each function are generated automatically; the first member function is numbered 0, the next one 1, and so on. So, the order in which the functions appear in the definition is important, unlike in CORBA, where dispatch IDs are based on the function name. The dispatch IDs are generated using templates and not any preprocessor __LINE__ trickery, so the interface does not change if blank lines are inserted. The maximum number of member functions that can appear between RCF_BEGIN() and RCF_END() is at the moment limited to 25, but this limit is arbitrary.

The purpose of the RCF_xxx macros is to define the class RcfClient<type>. This class serves as a client stub, from the user's point of view, but also has facilities that allow the framework to use it as a server stub. These macros can be used in any namespace, not just the global namespace.

Once we have defined an interface using the RCF_xxx macros, we can start a server and bind the interface to concrete objects:

{
// create the server and tell it which port to listen on
RCF::RcfServer server(port);
// Interface is the identifer of the interface we're exporting,
// Object is a type that implements that interface
// one object for each client
server.bind<Interface, Object>();
// ... or one object shared by all clients
Object object;
server.bind<Interface>(object);
// tell the server to start listening for connections
server.start();
// ...
// the server will shut down automatically as it goes out of scope
}

The objects are statically bound to the corresponding interface; there is no need for the object to derive from an interface class as is the case for traditional dynamic polymorphism. Instead, the compiler resolves the interface at compile time, which is not only more efficient, but also allows more flexible semantics.

The server can handle multiple simultaneous clients, even in single threaded mode, and can be stopped at any time. The lifetime of objects exposed by the server is determined by the number of current connections to the given object; once there are no more live connections to the object, a timeout is set, and when it expires, the object is deleted.

To make a client call, we instantiate the corresponding RcfClient<> template and pass the server IP and port number to the constructor. When the first remote method is called, the client then attempts to connect to the server, queries for the given object, invokes the requested member function of the remote object, and then returns the remote return value.

Should any exceptions arise on the server side while invoking the requested object, an exception of type RCF::RemoteException will be propagated back to the client and thrown. Should any exceptions arise anywhere else on the server side, e.g., while serializing arguments, then the server will forcibly close the connection, and the client will throw an exception.

RCF will automatically handle a range of parameter types, including C++ primitive types (int, double, etc.), std::string, STL containers, and pointers and references to any of the previously mentioned types. Polymorphic pointers and references, and multiple pointers to single objects are correctly handled as well. Smart pointers are also supported (boost::shared_ptr, std::auto_ptr), and are the safest way of passing polymorphic parameters.

In CORBA, one can tag a parameter as in, out, or inout, depending on which direction(s) one wants the parameter to be marshaled. In RCF, the marshaling directions are deduced from the parameter type, according to the following conventions:

Value: in
Pointer: in
Const reference: in
Nonconst reference: inout
Nonconst reference to pointer: out

To use user-defined types as parameters or return values, some additional serialization code is needed. What that code is depends on which serialization protocols are being used; by default Boost.Serialization is used, and an example of passing a user-defined type would look like the following:

Details

The server and client classes use BSD-style sockets to implement the networking, over TCP, and the whole framework has been compiled and tested on Linux, Solaris (x86 and SPARC) and Win32, using Visual C++ 7.1, Codewarrior 9.0, Borland C++ 5.5, and GCC 3.2. Building RCF requires v. 1.32.0 or later of the Boost library, although the only parts of Boost that need to be built are Boost.Serialization, and, for multithreaded builds, Boost.Threads. Multithreaded builds are enabled by defining RCF_USE_BOOST_THREADS before including any RCF headers.

To use RCF in your own application, you'll need to include the src/RCF.cpp file among the sources of the application, and link to the necessary libraries from Boost, along with OS-specific socket libraries (on Windows that would be ws2_32.lib, on Linux libnsl, etc.).

I've included a demo project for Visual Studio .NET 2003, which includes everything needed to compile, link, and run a server/client pair, with the exception of the Boost library, which needs to be downloaded and unzipped, but no building is needed.

Performance, as measured in requests/second, is highly dependent on the serialization protocol, and also on the compiler being used. Before turning to Boost.Serialization, I used a serialization framework of my own, with which I could clock around 3000 minimal requests/sec. using Visual C++ 7.1, and 3300 requests/sec. with Codewarrior 9.0, on a loopback connection on a 1400Mhz, 384Mb PC running Windows XP. GCC 3.2, on the other hand, was far slower. Using Boost.Serialization, however, I've been nowhere near these numbers; on average, it's around five times slower.

Conclusion

RMI is a well known concept in Java circles, what I've done here is to do something similar in C++, without all the complications of CORBA. If you like it, please tell me, if you don't, well, please tell someone else.... Jokes aside, any and all feedback is appreciated, all I ask is that if you grade the article, and do so with a low grade, then please leave an explanatory comment!

History

8 Feb 2005 - First release.

10 Mar 2005

Now includes a custom serialization framework, so you no longer have to use Boost's. Both serialization frameworks are supported though, use the project-wide RCF_NO_BOOST_SERIALIZATION and RCF_NO_SF_SERIALIZATION defines to control which ones are used. Default behaviour is to compile both.

Default client timeout changed to 10s.

Server can be configured to only accept clients from certain IP numbers.

Server can be configured to listen only on a specific network interface, such as 127.0.0.1.

Client stubs automatically reset their connections when exceptions are thrown (eg for timeouts).

Finer-grained exception classes.

11 July 2005

Stripped CVS folders from distribution.

Added user-definable callback functions to be called when RcfServer has started.

16 Aug 2005

Added facilities for server-bound objects to query the IP address of the client that is currently invoking them. To see how it works, open the file RCF/test/Test_ClientInfo.cpp in the download. Just place a call to RCF::getCurrentSessionInfo().getClientInfo().getAddress(), and you'll receive a string containing the IP address of the client that is invoking the method.

23 Sep 2005

Initialization and deinitialization of the framework can now be done explicitly, be defining the project-wide preprocessor symbol RCF_NO_AUTO_INIT_DEINIT, and then calling RCF::init() and RCF::deinit() at appropriate times. This is mainly useful for DLL builds, so that the DLL can be loaded without automatically initializing Winsock.

19 Oct 2005

Compatible with Boost 1.33.0.

Added enum serialization to the built-in serialization engine, through the SF_SERIALIZE_ENUM macro. For an example of its use, see test/Test_Serialization.cpp.

Added a license.

30 Jan 2006

Miscellaneous bugfixes.

The built-in maximum message size limit has been changed to 50 Kb. Look in src/RCF/Connection.cpp, line 374, if you need to change this.

I'll only be making sporadic maintenance releases of this version of RCF from now on. You can find the next generation of RCF here.

License

Share

About the Author

Software developer, ex-resident of Sweden and now living in Canberra, Australia, working on distributed C++ applications. Jarl enjoys programming, but prefers skiing and playing table tennis. He derives immense satisfaction from referring to himself in third person.

Comments and Discussions

A RCF::Token object is assigned to each client. When the connections limit exceeds, the number if free tokens turns into zero and further connection attempts always fail.
The question is: how is it possible to put the free token back into the pool of free token explicitly ?? or just to break down the connection in other words ?? The most wanted way, as I see, is to leave the scope of the RcfClient object or maybe it is a call to some method like client.disconnect(). Please, enlight me, in such a bottleneck.

The best thing is to set up your appllication so that you bind interfaces directly to an instance:

RcfServer server(ip, port);X x;server.bind<I_X>(x);

Then all the clients will be accessing the same object, they won't be needing individual tokens, and the token limit will no longer play a role.

If you still need separate server objects for each client, then you could increase the number of tokens, if you want. Currently its hardcoded to 100, but you can change the value of NumberOfTokens in RcfServer.hpp to something bigger.

The tokens are returned to the pool when the corresponding server object is deleted. That only happens when a server object has been inactive for 60 seconds though, so after a RcfClient goes out of scope, it will still take a minute before the server decides to delete the object and recycle the token.

Hope that helps If possible, go with the first option, with all the clients sharing an object, and then the issue won't turn up at all...

I have got one more question about the RCF connections. How can I track the connection event - I need to have an opportunity to accept or to refuse pending connection. I have found out, that your framework can filter the ip-addresses of connecting clients, but I need a little bit more sophisticated server logics. For example: I have a data storage nested in server. The server has a "reader" interface and a "writer" interface. The idea is - the server must distinguish the client's access - "writer" interface must not be allowed for "everyone", except hard-fixed "priviledged" clients. And another sub-question - how can I implement the "many readers, one writer" concept - like the boost::read_write_mutex, using the RCF facilities ??
If it is possible to handle the both problems, I will be very happy .

In test/Test_ClientInfo.cpp, there's an example of using the RCF::getCurrentSession() function, which can be called from within any server thread and gives information on the session that is currently being processed. Calling RCF::getCurrentSessionInfo().getClientInfo().getAddress()will give you a string representation of the client's IP address, and then from that you can decide whether you want to grant the client read or write access.

Yeah, it's been on my mind... I've been busy the past months rewriting and extending RCF, and when its released I'll see what the people at Boost think of it, and if they think it could eventually be accepted.

Can't say I'm looking forward to having to change the names of all my classes and functions, though, to agree with the Boost guidelines...

No, it's still supported, its just a little awkwardly configured. The original error you got was because the client wasn't configured to use one of the boost serialization protocols; it was still trying to use SF.

You have to specifically tell the client which serialization protocol to use, before making any remote calls:

Those kind of parameters should be avoided, sorry they are still mentioned in the article. I haven't found it possible to provide a safe enough way to marshal such parameters; it's hard to avoid getting memory leaks on the server.

You need to use a reference to a boost::shared_pointer instead, that works as an out parameter and is a lot safer. Ie

Thank You...
I need also to know if there is an easy way to send and recv structures.
like for instance MEASUREITEMSTRUCT which is a standart windows defined struct.
also how can I pass buffers?
Thanks You are very helpful.
Uri

Serializing the structs like that will work as long as the server and client have the same binary representation of the struct. In this case it will probably be ok, but otherwise it's a bit dangerous. The alternative is to define the following function in the global namespace:

As for the buffers, I'm not sure what you mean. If you want to serialize a sequence of bytes, specified by a void * pointer and a length, you can copy them to a std::vector<char> and then serialize that, like you did in your SF_SERIALIZE_STRUCT macro. The extra copy might not be great from an efficiency point of view, but unless you're serializing a lot of data, I doubt that you'll notice any difference.

Yeah, you can use SF::dynamicArray, but it's bit trickier than using a std::vector<char>. There's an example in Test_Serialization.cpp of how to use it, the main thing to remember is that if you read data into a dynamic array, then you are yourself responsible for eventually calling delete[] on the array.

If you can't get it working, show me the code and I'll see if I can help you.

The problem is that when reading data, SF::dynamicArray actually allocates the whole array, and then makes pch point to the array. In other words, when reading, it completely ignores what pch was already pointing to.