ACE入门教程：适应性通信环境解析

4星 · 超过85%的资源需积分: 3 175 浏览量更新于2024-08-01 收藏 648KB PDF 举报

"这篇教程是面向ACE框架的入门指南，非常适合初学者学习。教程通过理论与实践相结合的方式，深入浅出地介绍了ACE的核心概念和组件。作者Umar Syyid在Hughes Network Systems (HNS)的支持下为整个ACE社区创作了这份教程。" 在本教程中，读者将接触到以下关键知识点： 1. **ADAPTIVE COMMUNICATION ENVIRONMENT (ACE)**：ACE是一个开源的、跨平台的C++库，专门设计用于构建高性能、适应性强的网络应用。它提供了一套全面的工具和服务，帮助开发者处理并发性、网络通信、错误恢复等复杂问题。 2. **ACE架构**：ACE架构由三个主要层次组成。首先是操作系统适应层，它封装了不同操作系统的底层接口，使代码具有可移植性。其次是C++包装器层，它提供了面向对象的接口，使得开发更加高效。最后是ACE框架组件，这些组件提供了如线程管理、内存管理、事件处理等功能。 3. **IPC SAP (Interprocess Communication Service Access Point)**：这部分讲解了如何在ACE中进行进程间通信。SAP是通信服务的接入点，涵盖了不同类型的通信类，如套接字、管道、信号等，以及它们的分类。 4. **内存管理**：ACE提供了高级的内存管理工具，包括动态内存分配策略，以优化内存使用和提高性能。这部分可能涉及智能指针、内存池等概念。 5. **线程管理**：线程是并发执行的基本单元，ACE提供了线程创建、同步和调度的接口，帮助开发者有效地利用多核处理器资源。 6. **任务和主动对象**：任务是并发执行的实体，而主动对象是具有状态和行为的对象，能够异步执行。ACE支持这些概念，允许创建复杂的并发模式。 7. **反应器模式(The Reactor)**：这是ACE中一个重要的设计模式，用于处理多个I/O事件。反应器通过事件驱动机制，统一响应来自多个源的事件。 8. **接受者和连接器(The Acceptor and Connector)**：这两个组件是网络通信的核心，负责建立和管理客户端与服务器之间的连接。 9. **服务配置器(The Service Configurator)**：它提供了一种机制，允许在运行时动态添加、删除或修改服务，增强了系统的灵活性和可扩展性。 10. **消息队列(Message Queues)**：ACE支持消息队列，这是一种线程安全的数据结构，用于在并发组件之间传递信息，实现异步通信。 11. **附录：实用类**：教程的附录部分可能包含了各种辅助类，这些类提供了通用的功能，可以帮助开发者更便捷地完成特定任务。通过这个教程，读者不仅可以学习到ACE的基本用法，还能掌握到分布式系统设计、并发编程和网络通信的关键概念。每个主题都伴随着代码示例，有助于理论知识的实践应用。对于希望深入了解ACE并使用它来构建复杂网络应用的开发者来说，这是一个极好的起点。

{

// Initiate blocking connection with server.

ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting connect to %s:%d\n",

remote_addr_.get_host_name(),remote_addr_.get_port_number()));

if (connector_.connect (client_stream_, remote_addr_) == -1)

ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","connection failed"),-1);

else

ACE_DEBUG ((LM_DEBUG,"(%P|%t) connected to %s\n",

remote_addr_.get_host_name ()));

return 0;

}

//Uses a stream component to send data to the remote host.

int send_to_server()

{

// Send data to server

for(int i=0;i<NO_ITERATIONS; i++){

if (client_stream_.send_n (data_buf_, ACE_OS::strlen(data_buf_)+1, 0) == -1){

ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","send_n"),0);

break;

}

//Close down the connection

close();

}

//Close down the connection properly.

int close()

{

if (client_stream_.close () == -1)

ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","close"),-1);

else

return 0;

}

private:

ACE_SOCK_Stream client_stream_;

ACE_INET_Addr remote_addr_;

ACE_SOCK_Connector connector_;

char *data_buf_;

};

int main (int argc, char *argv[])

{

if(argc<3){

ACE_DEBUG((LM_DEBUG,”Usage %s <hostname> <port_number>\n”, argv[0]));

ACE_OS::exit(1);

}

Client client(argv[1],ACE_OS::atoi(argv[2]));

client.connect_to_server();

client.send_to_server();

}

The above example illustrates a client that actively connects to the server which was

described in Example 1. After establishing a connection, it sends a single string of data to

the server several times and closes down the connection.

The client is represented by a single Client class. Client contains a connect_to_server()

and a send_to_server() method.

The connect_to_server() method uses a Connector,

connector_, of type

ACE_SOCK_Connector, to actively establish a connection. The connection setup is done

by calling the connect() method on the Connector

connector_, passing it the

remote_addr_ of the machine we wish to connect to, and an empty ACE_SOCK_Stream

client_stream_ to establish the connection “into”. The remote machine is specified in the

runtime arguments of the example. Once the connect() method returns successfully, the

stream can be used to send and receive data over the newly established link. This is

accomplished by using the send() and recv() family of methods available in the

ACE_SOCK_Stream wrapper class.

In the example, once the connection has been established, the send_to_server() method is

called to send a single string to the server

NO_ITERATIONS times. As mentioned before,

this is done by using the send() methods of the stream wrapper class.

Using Datagrams in ACE

The Datagrams wrapper classes in ACE are ACE_SOCK_Dgram and

ACE_LSOCK_Dgram. These wrappers include methods to send and receive datagrams

and wrap the non-connection-oriented UDP and UNIX domain sockets protocol. Unlike

the Streams wrapper, these wrappers wrap a non-connection-oriented protocol. This

means that there are no acceptors and connectors that are used to “setup” a connection.

Instead, in this case, communication is through a series of sends and receives. Each

send() indicates the destination remote address as a parameter. The following example

illustrates how datagrams are used with ACE. The example uses the ACE_SOCK_Dgram

wrapper (i.e., the UDP wrapper). The ACE_LSOCK_Dgram, which wraps UNIX domain

datagrams, could also be used. The usage of both wrappers is very similar, the only

difference is that local datagrams use the ACE_UNIX_Addr class for addresses instead of

ACE_INET_Addr.

Example 3

//Server

#include "ace/OS.h"

#include "ace/SOCK_Dgram.h"

#include "ace/INET_Addr.h"

#define DATA_BUFFER_SIZE 1024

#define SIZE_DATA 19

class Server{

public:

Server(int local_port)

The above code is for a simple server that expects a client application to send it a

datagram on a known port. The datagram contains a fixed and pre-determined amount of

data in it. The server, on reception of this data, proceeds to send a reply back to the client

that originally sent the data.

The single class Server contains an ACE_SOCK_Dgram named local_ as a private

member which it uses both to receive and send data. The Server instantiates local_ in

its constructor, with a known ACE_INET_Addr (local host with known port) so the client

can locate it and send messages to it.

The class contains two methods: accept_data(), used to receive data from the client (uses

the wrappers recv() call) and send_data(), used to send data to the remote client (uses the

wrappers send() call). Notice that the underlying calls for both the send() and receive()of

the local_ wrapper class wrap the BSD sendto() and recvfrom() calls and have a

similar signature.

The main function just instantiates an object of type server and calls the accept_data()

method on it which waits for data from the client. When it gets the data it is expecting it

calls send_data() to send a reply message back to the client. This goes on forever until

the client is killed.

The corresponding client code is very similar:

Example 4

//Client

#include "ace/OS.h"

#include "ace/SOCK_Dgram.h"

#include "ace/INET_Addr.h"

#define DATA_BUFFER_SIZE 1024

#define SIZE_DATA 28

class Client{

public:

Client(const char * remote_host_and_port)

:remote_addr_(remote_host_and_port),

local_addr_((u_short)0),local_(local_addr_)

{

data_buf = new char[DATA_BUFFER_SIZE];

}

//Receive data from the remote host using the datgram wrapper `local_’.

//The address of the remote machine is received in `remote_addr_’

//which is of type ACE_INET_Addr. Remember that there is no established

//connection.

int accept_data()

{

if(local_.recv(data_buf,SIZE_DATA,remote_addr_)!=-1){

ACE_DEBUG((LM_DEBUG, "Data received from remote server %s was: %s \n" ,

remote_addr_.get_host_name(), data_buf));

return 0;

}

else

return -1;

剩余155页未读，继续阅读

tstc_tstc

粉丝: 0
资源: 5

ACE入门教程：适应性通信环境解析

A Tutorial Introduction to the Minimum Description Length Principle

a tutorial introduction to estimation and filtering

C语言程序设计：Chapter 1 A Tutorial Introduction.ppt

C程序设计英文课件：第一章 A Tutorial Introduction

Hands-On Python A Tutorial Introduction for Beginners Python 3.1 Version

A tutorial on adaptive MCMC

ACE tutorial

Awk - A Tutorial and Introduction - by Bruce Barnett.pdf

SLAM入门教程 A Tutorial Approach to Simultaneous Localization and Mapping

Awk入门教程 《Awk A Tutorial and Introduction - by Bruce Barnett》

最新资源

Awk入门教程《Awk A Tutorial and Introduction - by Bruce Barnett》