RCF—用于C++的进程间通讯(3)

翻译 2008年05月18日 14:09:00

过滤器(Filters

RCF通过过滤器的概念来支持对消息的压缩和加密。过滤器需要同时应用于服务器端和客户端。也可以被应用于传输层,例如应用SSL过滤器到向TCP这样基于流的传输;或者应用于独立的消息载荷,例如压缩像UDP这样基于包传递的消息。前者称为传输过滤器,后者称为载荷过滤器。

传输过滤器

在一个服务器-客户的会话中安装一个传输过滤器是由客户端发起的。客户端查询服务器端是否支持给定的过滤器,如果服务器端支持,过滤器就会同时在两端安装,然后继续通讯。

询问服务器端和安装过滤器的过程是由客户端桩自动处理的。用户只要在远程调用之前调用ClientStub::setTransportFilters(),客户端桩会自动询问服务器端并且安装过滤器。

传输过滤器可以用two-way方式的,那样的话一个读操作或者写操作都会导致下行方向的多个读写请求。 一个典型的例子就是一个SSL加密过滤器在任何时刻都需要发起一个握手操作,这个握手操作又会包含多个下行的读写请求。

载荷过滤器

使用载荷过滤器不需要服务器端或者客户端任何特殊的步骤。如果客户端桩通过ClientStub::setPayloadFilters()函数调用设置了过滤器,消息的载荷将会用设置的过滤器来传输。载荷的前面会被加入足够的数据,以便让服务器端能够解码传输用的过滤器,从而让服务器端解码传输的载荷。如果服务器端不能解码这个过滤器,服务器端将返回一个异常到客户端。

载荷过滤器必须使用one-way方式,也就是说一个读操作只会导致在下行方向的一个或者多个读请求(译注:传输过滤器则会导致多个读写请求),写操作也是类型的。RCF本身已经提供了几个过滤器:基于Zlib的两个压缩过滤器,还有一个基于OpenSSLSSL加密过滤器。这些过滤器也可以被连接起来使用,从而提高过滤器序列。

OpenSSL的加密过滤器只能用于传输过滤器,因为SSL的加密和解密过程需要一个two-way的会话,这个前面也有提到过。另一方面,有状态和无状态的压缩过滤器可以被用于传输和载荷过滤器。在像UDP这样非面向流的传输之上,只有用无状态的压缩过滤器才是有意义的。但是,在想TCP这样的传输之上,有状态好无状态压缩过滤器都是可以使用的。

一个例子:

{
    
// compression of payload

    RcfClient
<I_X> client(endpoint);
    client.setPayloadFilters( RCF::FilterPtr(
        
new RCF::ZlibStatelessCompressionFilter() ) );

    
// encryption of transport

    std::
string certFile = "client.pem";
    std::
string certFilePwd = "client_password";
    client.setTransportFilters( RCF::FilterPtr(
    
new RCF::OpenSslEncryptionFilter(
            RCF::SslClient, certFile, certFilePwd)) ) );

    
// multiple chained transport filters

    
//       - compression followed by encryption

    std::vector
<RCF::FilterPtr> transportFilters;
    transportFilters.push_back( RCF::FilterPtr(
        
new RCF::ZlibStatefulCompressionFilter()));
    transportFilters.push_back( RCF::FilterPtr(
        
new RCF::OpenSslEncryptionFilter(
            RCF::SslClient, certFile, certFilePwd)) ) );
    client.setTransportFilters(transportFilters);

    
// multiple chained payload filters - double compression

    std::vector
<RCF::FilterPtr> payloadFilters;
    payloadFilters.push_back( RCF::FilterPtr(
        
new RCF::ZlibStatefulCompressionFilter()));
    payloadFilters.push_back( RCF::FilterPtr(
        
new RCF::ZlibStatefulCompressionFilter()));
    client.setPayloadFilters(payloadFilters);
}


{
    std::
string certFile = "server.pem";
    std::
string certFilePwd = "server_password";

    
// FilterService service enables the server to load the filters it needs

    RCF::FilterServicePtr filterServicePtr( 
new RCF::FilterService );
    filterServicePtr
->addFilterFactory( RCF::FilterFactoryPtr(
        
new RCF::ZlibStatelessCompressionFilterFactory) );
    filterServicePtr
->addFilterFactory( RCF::FilterFactoryPtr(
        
new RCF::ZlibStatefulCompressionFilterFactory) );
    filterServicePtr
->addFilterFactory( RCF::FilterFactoryPtr(
        
new RCF::OpenSslEncryptionFilterFactory(certFile, certFilePwd)) );

    RCF::RcfServer server(endpoint);
    server.addService(filterServicePtr);
    server.start();
}

远程对象创建

RcfServer类允许用户暴露(expose)一个类的单个实例给远程客户端,但也没有限制远程客户端在服务器上创建对象。远程对象创建就是ObjectFactoryService服务的职责。一旦在服务器端安装了ObjectFactoryService服务,客户端就可以通过I_ObjectFactory接口来创建对象,允许创建对象的个数是在服务中配置的。

ObjectFactoryService服务还实现了一个垃圾回收机制,借此机制那些不再使用(例如没有活动的客户端会话或者在配置的持续时间内没有客户端访问)的对象最终将会被删除。请注意:目前在此服务内还没有一个安全保证机制。一个创建了的对象可以被这个服务器的所有客户端访问。

{
    
// allow max 50 objects to be created
    unsigned int numberOfTokens = 50;

    
// delete objects after 60 s, when no clients are connected to them
    unsigned int objectTimeoutS = 60;

    
// create object factory service
    RCF::ObjectFactoryServicePtr objectFactoryServicePtr(
        
new RCF::ObjectFactoryService(numberOfTokens, objectTimeoutS) );

    
// allow clients to create and access Echo objects, through I_Echo
    objectFactoryServicePtr->bind<I_Echo, Echo>();

    RCF::RcfServer server(endpoint);
    server.addService(objectFactoryServicePtr);
    server.start();
}


{
    RcfClient
<I_Echo> client1(endpoint);
    
bool ok = RCF::createRemoteObject<I_Echo>(client1);
    
// client can now be used to access a newly created object on the server.


    RcfClient
<I_Echo> client2(endpoint);
    client2.getClientStub().setToken( client1.getClientStub().getToken() );
    
// client1 and client2 will now be accessing the same object

}

发布订阅(Publish/Subscribe

发布订阅模式是分布式程序中众所周知的术语。一个进程扮演发布者的角色,定期地给订阅者发送消息包。订阅者呼叫发布者并且请求发布者发布的订阅数据。

对于像UDP这样面向包的传输,在已有的RCF原语上建立这个功能是相对简单的。对于像TCP这样的面向流的传输,RCF提供了额外的特征来使能发布订阅功能。订阅者呼叫的连接被逆转,然后发布者利用这个连接来发布。

PublishingServiceSubscriptionService两个服务构成了这个功能。下面的例子描述了如何使用这些服务。

RCF_BEGIN(I_Notify, "I_Notify")
    RCF_METHOD_V1(
void, func1, int)
    RCF_METHOD_V2(
void, func2, std::string, std::string)
RCF_END(I_Notify)

{
    RCF::RcfServer publishingServer(endpoint);
    RCF::PublishingServicePtr publishingServicePtr(
        
new RCF::PublishingService() );
    publishingServer.addService(publishingServicePtr);
    publishingServer.start();

    
// start accepting subscription requests for I_Notify
    publishingServicePtr->beginPublish<I_Notify>();

    
// call func1() on all subscribers
    publishingServicePtr->publish<I_Notify>().func1(1);

    
// call func2(std::string, std::string) on all subscribers
    publishingServicePtr->publish<I_Notify>().func2("one""two");

    
// stop publishing I_Notify and disconnect all subscribers
    publishingServicePtr->endPublish<I_Notify>();

    publishingServer.stop();
}


{
    RCF::RcfServer subscribingServer(endpoint);
    RCF::SubscriptionServicePtr subscriptionServicePtr(
        
new RCF::SubscriptionService() );
    subscribingServer.addService( subscriptionServicePtr );
    subscribingServer.start();

    Notify notify;
    subscriptionServicePtr
->beginSubscribe<I_Notify>(
    notify, RCF::TcpEndpoint(ip, port));

    
// notify.func1() and notify.func2()
    
// will now be remotely invoked by the publisher
    
// ...

    subscriptionServicePtr
->endSubscribe<I_Notify>(notify);
}

相关文章推荐

RCF—用于C++的进程间通讯(3)

过滤器(Filters) RCF通过过滤器的概念来支持对消息的压缩和加密。过滤器需要同时应用于服务器端和客户端。也可以被应用于传输层,例如应用SSL过滤器到向TCP这样基于流的传输;或者应用于独立的...

RCF—用于C++的进程间通讯

RCF—用于C++的进程间通讯   导言 RCF(Remote Call Framework,远程调用框架)是一个C++的框架。这个框...
  • ilvu999
  • ilvu999
  • 2012年10月20日 22:51
  • 1859

RCF—用于C++的进程间通讯(4)

可扩展性 传输 对于前一个版本的RCF,一个(应得的)批评是关于它和TCP协议过度紧密的关系。现在RCF采用了传输无关的设计,并且对于初用者,可以使用它支持的TCP和UDP协议。更重要的是,它...

RCF—用于C++的进程间通讯(1)

导言 RCF(Remote Call Framework,远程调用框架)是一个C++的框架。这个框架用来为实现C++程序进程间调用提供一个简单和一致(consistent)的方法。这个框架基于强...

Linux进程间通讯—旗语

/* * 生产者/消费者模型 * 给定仓库容积(N) * 生成者生成的产品入库 * 消费者从仓库中取出产品消费 * 仓库满了时生产者不能继续生成 * 仓库为空时消费者不能继续消费 * 对...

进程间通讯————消息队列

Linux支持system V 提供的进程间通信机制:消息队列、信号(semaphores)和共享内存。称为system V的IPC对象,可以通过系统调用(system call)对对象的创建者设置这...

Java—进程间通讯的有几种方法

进程间通信的方法主要有以下几种:   (1)管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。   (2)命名管道(named pipe):...

Windows上C++使用共享内存进行进程间通讯

共享内存 (也叫内存映射文件) 主要是通过映射机制实现的 , Windows 下进程的地址空间在逻辑上是相互隔离的 , 但在物理上却是重叠的 ; 所谓的重叠是指同一块内存区域可能被多个进程同时使用 ,...

C++:共享内存(进程间通讯)(转载)

转载来自:http://blog.csdn.net/taily_duan/article/details/51692999// ServerCom.cpp : Defines the entry po...

Linux 进程间通讯(IPC)详细总结 3信号量(Semaphore)。

3,信号量(Semaphore) 信号不能传递信息,只能用来控制时序 信号量(Semaphore),有时被称为信号灯,是在多线程环境下使用的一种设施,是可以用来保证两个或多个关键代码段不被并发调用...
  • x32sky
  • x32sky
  • 2011年12月18日 09:45
  • 669
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:RCF—用于C++的进程间通讯(3)
举报原因:
原因补充:

(最多只允许输入30个字)