RCF框架详解与应用指南

需积分: 46 35 浏览量更新于2024-07-22 1 收藏 683KB PDF 举报

"RCF（Remote Call Framework）是一款现代的跨平台通信框架，设计用于替代传统的COM（Component Object Model）框架。RCF提供了一种高效、灵活且易于使用的远程调用解决方案，支持多种协议和序列化机制，适用于分布式系统开发。" RCF框架的核心特性包括： 1. **跨平台性**：RCF支持多种操作系统，如Windows、Linux和macOS，允许开发者构建可在不同平台上运行的分布式应用。 2. **用户友好**：RCF的调用方式与本地函数调用相似，降低了学习曲线，符合开发人员的编程习惯。 3. **错误处理**：提供了内置的错误处理机制，包括客户端存根和服务器会话的错误报告。 4. **客户端存根**：客户端存根是自动生成的，用于模拟远程接口，使客户端代码可以像调用本地函数一样调用远程方法。 5. **服务器会话**：服务器会话管理远程调用的上下文，支持多线程和异步调用。 6. **传输层**：RCF支持多种传输协议，如TCP/IP、UDP、HTTP/HTTPS隧道等，可进行透明的网络通信。 7. **协议协商**：RCF支持NTLM、Kerberos、Negotiate等身份验证协议，以及SSL/TLS加密，确保通信安全。 8. **压缩**：可以开启数据压缩，提高网络传输效率。 9. **传输配置**：允许开发者自定义传输层的配置，以适应不同的网络环境。 10. **序列化**：RCF支持标准C++类型、用户自定义类型以及二进制数据的序列化。此外，还支持Protocol Buffers和JSON-RPC这两种流行的序列化格式，提高了与其他系统的互操作性。 11. **文件传输**：内建文件传输功能，方便在客户端和服务器之间交换大文件。 12. **回调连接**：允许设置回调函数，实现在远程调用过程中的事件通知。 13. **发布/订阅模式**：支持发布者和订阅者模式，实现一对多的消息广播。教程部分介绍了如何开始使用RCF，包括创建接口、实现服务、配置服务器、处理错误和调用远程方法等步骤。对于开发人员来说，这些内容提供了快速入门RCF的基础。 RCF框架提供了一个强大而全面的工具集，使得开发人员能够更高效地构建分布式系统，同时保持代码的简洁性和可维护性。其丰富的特性和广泛的兼容性使其成为替代COM框架的理想选择。通过深入理解和实践RCF，开发者可以更好地应对现代企业级应用中的复杂网络通信挑战。

// Server-side.

HelloWorldImpl helloWorldImpl;

RCF::RcfServer server( RCF::HttpsEndpoint("0.0.0.0", 443) );

server.bind<I_HelloWorld>(helloWorldImpl);

RCF::CertificatePtr serverCertPtr( new RCF::PfxCertificate("path/to/certificate.p12", "pass↵

word", "CertificateName") );

server.setCertificate(serverCertPtr);

server.start();

// Client-side.

// This client will connect to server1.acme.com via the HTTP proxy at proxy.acme.com:8080.

RcfClient<I_HelloWorld> client( RCF::HttpsEndpoint("server1.acme.com", 443) );

client.getClientStub().setHttpProxy("proxy.acme.com");

client.getClientStub().setHttpProxyPort(8080);

client.Print("Hello World");

Certiﬁcates and certiﬁcate validation for HTTPS are conﬁgured as for the SSL transport protocol (see Transport Protocols below).

Multiple transports can be conﬁgured for a single RcfServer. For example, to conﬁgure a server that accepts both IPv4 and IPv6

connections on port 50001:

RCF::RcfServer server;

server.addEndpoint( RCF::TcpEndpoint("0.0.0.0", 50001) );

server.addEndpoint( RCF::TcpEndpoint("::0", 50001) );

server.start();

On some platforms, the underlying network stack will allow you to specify ::0 to listen on both IPv4 and IPv6 interfaces, in which

case this would be sufﬁcient:

RCF::RcfServer server;

server.addEndpoint( RCF::TcpEndpoint("::0", 50001) );

server.start();

Here is a server accepting connections over TCP, UDP and named pipes:

RCF::RcfServer server;

server.addEndpoint( RCF::TcpEndpoint("::0", 50001) );

server.addEndpoint( RCF::UdpEndpoint("::0", 50002) );

server.addEndpoint( RCF::Win32NamedPipeEndpoint("MyPipe") );

server.start();

See Transports for more information on transports.

Transport protocols

Transport protocols are layered on top of the transport, and provide authentication and encryption.

RCF supports the following transport protocols:

• NTLM

• Kerberos

• SSL

The NTLM and Kerberos transport protocols are only supported on Windows, while the SSL transport protocol is supported on all

platforms.

RCF User Guide

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

An RcfServer can be conﬁgured to require certain transport protocols:

std::vector<RCF::TransportProtocol> protocols;

protocols.push_back(RCF::Tp_Ntlm);

protocols.push_back(RCF::Tp_Kerberos);

server.setSupportedTransportProtocols(protocols);

On the client-side, ClientStub::setTransportProtocol() is used to conﬁgure transport protocols. For instance, to use the

NTLM protocol on a client connection:

RcfClient<I_HelloWorld> client( RCF::TcpEndpoint(50001) );

client.getClientStub().setTransportProtocol(RCF::Tp_Ntlm);

client.Print("Hello World");

In this example, the client will authenticate itself to the server and encrypt its connection using the NTLM protocol, using the implicit

credentials of the logged on user.

To provide explicit credentials, use ClientStub::setUsername() and ClientStub::setPassword():

RcfClient<I_HelloWorld> client( RCF::TcpEndpoint(50001) );

client.getClientStub().setTransportProtocol(RCF::Tp_Ntlm);

client.getClientStub().setUsername("SomeDomain\\Joe");

client.getClientStub().setPassword("JoesPassword");

client.Print("Hello World");

The Kerberos protocol can be conﬁgured similarly. The Kerberos protocol requires the client to supply the Service Principal Name

(SPN) of the server. You can do this by calling ClientStub::setKerberosSpn():

RcfClient<I_HelloWorld> client( RCF::TcpEndpoint(50001) );

client.getClientStub().setTransportProtocol(RCF::Tp_Kerberos);

client.getClientStub().setKerberosSpn("SomeDomain\\ServerAccount");

client.Print("Hello World");

If a client attempts to call Print() without conﬁguring one of the transport protocols required by the server, they will get an error:

try

{

RcfClient<I_HelloWorld> client( RCF::TcpEndpoint(50001) );

client.Print("Hello World");

}

catch(const RCF::Exception & e)

{

std::cout << "Error: " << e.getErrorString() << std::endl;

}

Error: Server requires one of the following transport protocols to be used: NTLM, Kerberos.

From within the server implementation of Print(), you can retrieve the transport protocol of the current session. If the transport

protocol is NTLM or Kerberos, you can also retrieve the username of the client, as well as impersonate the client:

RCF User Guide

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

class HelloWorldImpl

{

public:

void Print(const std::string & s)

{

RCF::RcfSession & session = RCF::getCurrentRcfSession();

RCF::TransportProtocol protocol = session.getTransportProtocol();

if ( protocol == RCF::Tp_Ntlm || protocol == RCF::Tp_Kerberos )

{

std::string clientUsername = session.getClientUsername();

RCF::SspiImpersonator impersonator(session);

// Now running under Windows credentials of client.

// ...

// Impersonation ends when we exit scope.

}

std::cout << s << std::endl;

}

};

RCF also supports using SSL as the transport protocol. RCF provides two SSL implementations, one based on OpenSSL, and the

other based on the Windows Schannel security package. The Windows Schannel implementation is used automatically on Windows,

while the OpenSSL implementation is used if RCF_USE_OPENSSL is deﬁned when building RCF (see Building).

SSL-enabled servers need to conﬁgure a SSL certiﬁcate. The mechanics of certiﬁcate conﬁguration vary depending on which imple-

mentation is being used. Here is an example using the Schannel SSL implementation:

RCF::RcfServer server( RCF::TcpEndpoint(50001) );

RCF::CertificatePtr serverCertificatePtr( new RCF::PfxCertificate(

"C:\\ServerCert.p12",

"Password",

"CertificateName") );

server.setCertificate(serverCertificatePtr);

server.start();

RcfClient<I_HelloWorld> client( RCF::TcpEndpoint(50001) );

client.getClientStub().setTransportProtocol(RCF::Tp_Ssl);

client.getClientStub().setEnableSchannelCertificateValidation("localhost");

RCF::PfxCertificate is used to load PKCS #12 certiﬁcates, from .pfx and .p12 ﬁles. RCF also provides the RCF::StoreCer-

tificate class, to load certiﬁcates from a Windows certiﬁcate store.

When using the OpenSSL-based SSL implementation, the RCF::PemCertificate class is used to load PEM certiﬁcates, from

.pem ﬁles.

RCF also supports link level compression of remote calls. Compression is conﬁgured independently of transport protocols, using

ClientStub::setEnableCompression(). The compression stage is applied immediately before the transport protocol stage.

Here is an example of a client connecting to a server through an HTTP proxy, using NTLM for authentication and encryption, and

with compression enabled:

RCF User Guide

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

RcfClient<I_HelloWorld> client( RCF::HttpEndpoint("server123.com", 80) );

client.getClientStub().setHttpProxy("proxy.mycompany.com");

client.getClientStub().setHttpProxyPort(8080);

client.getClientStub().setTransportProtocol(RCF::Tp_Ntlm);

client.getClientStub().setEnableCompression(true);

client.Print("Hello World");

For more information see Transport protocols.

Server-side threading

By default a RcfServer uses a single thread to handle incoming remote calls, so remote calls are dispatched serially, one after the

other.

This can be a problem if you have multiple clients and some of them are making calls that take signiﬁcant time to complete. To improve

responsiveness in these situations, a RcfServer can be conﬁgured to run multiple threads and dispatch remote calls in parallel.

To conﬁgure a multi-threaded RcfServer, use RcfServer::setThreadPool() to assign a thread pool to the server. RCF thread

pools can be conﬁgured to use either a ﬁxed number of threads:

RCF::RcfServer server( RCF::TcpEndpoint(50001) );

// Thread pool with fixed number of threads (5).

RCF::ThreadPoolPtr tpPtr( new RCF::ThreadPool(5) );

server.setThreadPool(tpPtr);

server.start();

, or a dynamic number of threads, varying with server load:

RCF::RcfServer server( RCF::TcpEndpoint(50001) );

// Thread pool with varying number of threads (1 to 25).

RCF::ThreadPoolPtr tpPtr( new RCF::ThreadPool(1, 25) );

server.setThreadPool(tpPtr);

server.start();

Thread pools conﬁgured through RcfServer::setThreadPool() are shared across all the transports of that RcfServer. It is

also possible to use I_ServerTransport::setThreadPool() to conﬁgure thread pools for individual transports:

RCF::RcfServer server;

RCF::ServerTransport & tcpTransport = server.addEndpoint(RCF::TcpEndpoint(50001));

RCF::ServerTransport & pipeTransport = server.addEndpoint(RCF::Win32NamedPipeEndpoint("MyPipe"));

// Thread pool with up to 5 threads to serve TCP clients.

RCF::ThreadPoolPtr tcpThreadPoolPtr( new RCF::ThreadPool(1, 5) );

tcpTransport.setThreadPool(tcpThreadPoolPtr);

// Thread pool with single thread to serve named pipe clients.

RCF::ThreadPoolPtr pipeThreadPoolPtr( new RCF::ThreadPool(1) );

pipeTransport.setThreadPool(pipeThreadPoolPtr);

server.start();

RCF User Guide

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

Asynchronous remote calls

RCF supports client-side asynchronous remote call invocation, and server-side asynchronous remote call dispatching.

Asynchronous remote call invocation

On the client-side, asynchronous remote calls allow you to avoid blocking the thread that is making a remote call. Asynchronous

remote calls complete on background threads, and the calling thread is notiﬁed at a later point, when the call completes.

Asynchronous remote call invocation is implemented in RCF using the RCF::Future<> template. Here is a simple example of

waiting for an asynchronous call to complete:

HelloWorldImpl helloWorld;

RCF::RcfServer server( RCF::TcpEndpoint(50001) );

server.bind<I_HelloWorld>(helloWorld);

server.start();

RcfClient<I_HelloWorld> client( RCF::TcpEndpoint(50001) );

RCF::Future<int> fRet;

// Asynchronous remote call.

fRet = client.Print("Hello World");

// Wait for the call to complete.

while (!fRet.ready()) RCF::sleepMs(1000);

// Check for errors.

std::auto_ptr<RCF::Exception> ePtr = client.getClientStub().getAsyncException();

if (ePtr.get())

{

// Error handling.

// ...

}

else

{

int howManyCharsPrinted = *fRet;

}

A remote call is performed asynchronously, if any of the parameters, or the return value, is of type RCF::Future<>, or if

RCF::AsyncOneway or RCF::AsyncTwoway is speciﬁed as the calling semantic. Once a call is complete, RCF::Future<> instances

can be dereferenced to retrieve the return values. If the call completed with an error, the error can be retrieved by calling

RCF::ClientStub::getAsyncException() . The error will also be thrown if an attempt is made to dereference an associated

RCF::Future<> instance.

Instead of waiting for the result on the calling thread, we can assign a completion callback to the remote call:

typedef boost::shared_ptr< RcfClient<I_HelloWorld> > HelloWorldPtr;

void onPrintCompleted(

RCF::Future<int> fRet,

HelloWorldPtr clientPtr)

{

int howManyCharsPrinted = *fRet;

}

RCF User Guide

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

剩余121页未读，继续阅读

add_081

粉丝: 1
资源: 7

RCF框架详解与应用指南

Remote Call Function库

RCF 远程调用框架

RemoteCall.zip

使用RCF-UnsupVideoSeg，需要准备什么

RCF-UnsupVideoSeg，使用步骤。要保姆级别的

STM32F103CBT6外置RTC芯片RCF8563驱动

from models import RCF

RCF-UnsupVideoSeg，更多资料

利用改进的U-Net与RCF 利用改进的U-Net与RCF融合的网络模型对遥感影像目标区域高分2号遥感影像进行建筑物提取

RCF边缘检测模型优缺点

最新资源