ACE之Proactor模式使用实例

// ACE_Proactor_Client.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "ace/Message_Queue.h"
#include "ace/Asynch_IO.h"
#include "ace/OS.h"
#include "ace/Proactor.h"
#include "ace/Asynch_Connector.h"
#include "ace/SOCK_SEQPACK_Association.h"

#pragma comment(lib,"ACEd.lib")

class Service_Handler : public ACE_Service_Handler
{
public:
  Service_Handler()
  {
    //ACE_OS::printf("Service_Handler constructed for connector \n");
  }
  ~Service_Handler ()
  {
    if (this->handle () != ACE_INVALID_HANDLE)
      ACE_OS::closesocket (this->handle ());
    //ACE_OS::printf("one Service_Handler for connecter destructed");
  }

  void post_send(void)
  {
    do 
    {
      time_t now = ACE_OS::gettimeofday().sec();
      ACE_Message_Block *mb = new ACE_Message_Block(128);
      
      char buff[64];
      ACE_INET_Addr addr;
      ACE_SOCK_SEQPACK_Association ass=ACE_SOCK_SEQPACK_Association(this->handle());
      size_t addr_size=sizeof ACE_INET_Addr;
      ass.get_local_addrs(&addr,addr_size);
      //ACE_OS::printf("fd:%d ip:%d port:%d\n",(int)this->handle(), addr.get_ip_address(), addr.get_port_number());
      sprintf(buff,"%d",addr.get_port_number());
      mb->copy(buff/*ctime(now)*/);

      if (this->writer_.write(*mb,mb->length()) !=0)
      {
        ACE_OS::printf("Begin write fail in open\n");
        delete this;
        break;
      }
      else
      {
        ACE_OS::printf("sended:%s\n",mb->rd_ptr());
      }
    } while (0);
  }

  void post_recv(void)
  {
    do 
    {
      ACE_Message_Block *mb = new ACE_Message_Block(buffer,128);
      if (this->reader_.read (*mb, mb->space ()) != 0)
      {
        ACE_OS::printf("Begin read fail\n");
        delete this;
        break;
      }
    } while (0);
  }

  virtual void open (ACE_HANDLE h, ACE_Message_Block&)
  {
    do 
    {
      this->handle (h);
      if (this->writer_.open (*this) != 0 )
      {
        ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),ACE_TEXT ("Service_Handler open")));
        delete this;
        break;
      }
      post_send();

      if (this->reader_.open (*this) != 0 )
      {
        ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),ACE_TEXT ("Service_Handler open")));
        delete this;
        break;
      }
      post_recv();

    } while (0);
  }

  virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
  {
    result.message_block ().release();
    //ACE_OS::sleep(1);
    post_send();
  }

  virtual void handle_read_stream(const ACE_Asynch_Read_Stream::Result &result)
  {
    do 
    {
      ACE_Message_Block &mb = result.message_block ();
      if (!result.success () || result.bytes_transferred () == 0)
      {
        mb.release ();
        delete this;
        break;
      }
      ACE_OS::printf("received:%s\n",mb.rd_ptr());
      mb.release();

      post_recv();
    } while (0);
  }
private:
  ACE_Asynch_Write_Stream writer_;
  ACE_Asynch_Read_Stream reader_;
  char buffer[128];
};

#include <ace/OS.h>
#include <ace/Task.h>

class TTcpNetThread : public ACE_Task_Base
{
public:
  /// 运行
  int open();

  /// 停止运行
  int close();
protected:
  /// 线程函数
  virtual int svc();
};

int TTcpNetThread::open() { return this->activate(); }

int TTcpNetThread::close()
{
  ACE_Proactor::instance()->proactor_end_event_loop(); // 终止ACE_Proactor循环

  this->wait(); // 等待清理现场

  return 0;
}

int TTcpNetThread::svc()
{
  /*
  ACE_INET_Addr listenAddr(4567); // 默认监听地址
  TTcpAcceptor tcpAcceptor; // 接收器

  // 演出开始
  if (tcpAcceptor.open(listenAddr, 0, 1, 5, 1, 0, 0) != 0)
    ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("failed to open TcpAcceptor errno=%i\n"), errno), -1);
  */
  // Proactor的事件循环开始
  ACE_Proactor::instance()->proactor_run_event_loop();

  ACE_DEBUG((LM_DEBUG, ACE_TEXT("Network fin\n")));

  return 0;
}

#define TCP_CLIENT_THREAD_SEND  0x777

const int CLIENT_CONNECTION_NUM_OF_PER_THREAD = 1; //< 客户端每个线程的连接数

#include "ace/SOCK_Connector.h"
#include "ace/SOCK_Stream.h"
/**
* @class TTcpClientThread
* @brief TCP客户端测试线程
*/
class TTcpClientThread : public ACE_Task<ACE_MT_SYNCH>
{
  ACE_SOCK_Connector connector[CLIENT_CONNECTION_NUM_OF_PER_THREAD]; //< 连接器
  ACE_SOCK_Stream peerStream[CLIENT_CONNECTION_NUM_OF_PER_THREAD]; //< 流对象

public:
  /// ctor
  ~TTcpClientThread();
  
  /// 运行
  int open();

  /// 停止运行
  int close();
private:
  /// 线程函数
  virtual int svc();
};

TTcpClientThread::~TTcpClientThread()
{
  for(int i = 0; i < CLIENT_CONNECTION_NUM_OF_PER_THREAD; i++)
    peerStream[i].close();
}

int TTcpClientThread::open() { return this->activate(); }

int TTcpClientThread::close()
{
  ACE_TRACE("TTcpClientThread::close");

  ACE_Message_Block* termBlock;

  ACE_NEW_NORETURN(termBlock, ACE_Message_Block(0, ACE_Message_Block::MB_HANGUP));

  if (!termBlock)
    ACE_DEBUG((LM_ERROR, ACE_TEXT("Allocate failed %i"), errno));
  else
  {
    putq(termBlock);

    wait();
  }

  return 0;
}

int TTcpClientThread::svc()
{
  ACE_INET_Addr srvAddr(7878, "127.0.0.1");

  for(int i = 0; i < CLIENT_CONNECTION_NUM_OF_PER_THREAD; i++)
  {
    if (connector[i].connect(peerStream[i], srvAddr) == -1)
    {
      ACE_ERROR((LM_ERROR, ACE_TEXT("%i Failed to connect server errno=%i\n"), i, errno));
    }

    Sleep(100);
  }

  struct TPack
  {
#pragma pack(push)
#pragma pack(1)
    unsigned int seq;
    unsigned short len;
    char data [128];
#pragma pack(pop)
  };

  ACE_Message_Block* msg = 0;

  ACE_INET_Addr localAddr;
  ACE_TCHAR localAddrStr[128];

  peerStream[0].get_local_addr(localAddr);

  localAddr.addr_to_string(localAddrStr, sizeof(localAddrStr) / sizeof(ACE_TCHAR));

  TPack data;
  int len = sizeof(unsigned int) + sizeof(unsigned short);

  data.seq = 0;
  data.len = strlen(localAddrStr) + 1;
  strcpy(data.data, localAddrStr);

  len += data.len;

  char tmp[sizeof(TPack)];

  char buf[256];

  memcpy(tmp, &data, len);

  while(true) // 线程循环
  {
    if (getq(msg) != -1)
    {
      switch(msg->msg_type())
      {
      case ACE_Message_Block::MB_HANGUP:
        {
          msg->release();

          return 0;
        }
        break;
      default:
        {
          for(int i = 0; i < CLIENT_CONNECTION_NUM_OF_PER_THREAD; i++)
          {
            peerStream[i].send(tmp, 5);
            Sleep(100);
            peerStream[i].send(tmp + 5, len - 5);
            Sleep(100);

            ACE_Time_Value timeout(2);

            int recvLen =  peerStream[i].recv_n(buf, sizeof(unsigned int) + sizeof(unsigned short), 0, &timeout);

            if (recvLen == sizeof(unsigned int) + sizeof(unsigned short))
            {
              short dataLen = *(short *)(buf + 4);

              if (dataLen > 256)
                dataLen = 256;

              recvLen = peerStream[i].recv_n(buf, dataLen, 0, &timeout);

              if (recvLen != dataLen)
                ACE_DEBUG((LM_INFO, ACE_TEXT("Failed to recv data, length is %i, but only get %i\n"), dataLen, recvLen));
              else
                ACE_DEBUG((LM_INFO, ACE_TEXT("Client get data: len=%i data=%s\n"), recvLen, buf));
            } // if recvLen
          } // for
        } // default
        break;
      } // switch

      msg->release();
    } // if getq
  } // while

  ACE_DEBUG((LM_INFO, ACE_TEXT("Exit client thread")));

  return 0;
}

#include <vector>
#define CLIENT_THREAD_NUM 4
int main(int argc, char *argv[]) 
{

  ACE_INET_Addr remote_addr(4567,ACE_LOCALHOST); 

  std::vector<ACE_Asynch_Connector<Service_Handler> *> vtconnector;
  for (int i=0;i<2000;i++)
  {
    ACE_INET_Addr local_addr(10000+i,ACE_LOCALHOST); 
    ACE_Asynch_Connector<Service_Handler> *connector = new ACE_Asynch_Connector<Service_Handler>;
    connector->open();
    if (connector->connect(remote_addr,local_addr) == -1)
      return -1;
    vtconnector.push_back(connector);
  }

  TTcpNetThread netThread[CLIENT_THREAD_NUM];

  for(int i = 0; i < CLIENT_THREAD_NUM; i++)
  {
    netThread[i].open();
  }
  while (getchar())
  {
    ACE_OS::sleep(1);
  }
  //ACE_Proactor::instance ()->proactor_run_event_loop();

  return 0; 
}

// ACE_Proactor_Server.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "ace/Asynch_IO.h"
#include "ace/OS_main.h"
#include "ace/Proactor.h"
#include "ace/Asynch_Acceptor.h"
#include "ace/INET_Addr.h"
#include "ace/OS.h"
#include "ace/SOCK_Connector.h"
#include "ace/SOCK_Acceptor.h"
#include "ace/SOCK_Stream.h"
#include "ace/Message_Block.h"
#include "ace/Containers.h"
#include "ace/SOCK_SEQPACK_Association.h"

ACE_DLList<ACE_Asynch_Write_Stream> wList;

class Service_Handler:public ACE_Service_Handler
{
public:
  Service_Handler()
  {

  }
  ~Service_Handler(void)
  {
    if(this->handle()!=ACE_INVALID_HANDLE)
      ACE_OS::closesocket(this->handle());
  }

  virtual void open(ACE_HANDLE h,ACE_Message_Block &message_block)
  {
    //handle_= h;
    //this->handle(h);
    if(rs_.open(*this,h))
    {
      ACE_ERROR ((LM_ERROR,"%p/n","ACE_Asynch_Read_Stream::open"));
      return;
    }

    if(ws_.open(*this))
    {
      ACE_ERROR ((LM_ERROR,"%p/n","ACE_Asynch_Write_Stream::open"));
      return;
    }

    if (post_recv()==-1)
      return;

    //wList.insert_tail(&ws_);
    addresses(remote_address,local_address);
    remote_address.addr_to_string(peer_name,MAXHOSTNAMELEN);

    ACE_INET_Addr addr;
    ACE_SOCK_SEQPACK_Association ass=ACE_SOCK_SEQPACK_Association(h);
    size_t addr_size=sizeof ACE_INET_Addr;
    ass.get_remote_addrs(&addr,addr_size);
    ACE_OS::printf("fd:%d ip:%d port:%d\n",(int)h, addr.get_ip_address(), addr.get_port_number());
    //ACE_DEBUG((LM_DEBUG,ACE_TEXT("peer:%s\n"),peer_name));
  }
protected:
  int post_recv(void)
  {
    ACE_Message_Block *mb=0;
    ACE_NEW_RETURN(mb,ACE_Message_Block(512),-1);

    if(rs_.read(*mb,mb->space())==-1)
    {
      ACE_ERROR_RETURN((LM_ERROR,"%p/n","ACE_Asynch_Read_Stream::read"),-1);
    }
    return 0;
  }
  virtual void handle_read_stream(const ACE_Asynch_Read_Stream::Result &result)
  {
    //ACE_HANDLE h = result.handle();
    ACE_Message_Block &mb = result.message_block ();
    if (result.success()&&result.bytes_transferred()!=0)
    {
      ACE_DEBUG((LM_DEBUG,ACE_TEXT("recv:%s\n"),mb.rd_ptr()));
      if (ws_.write(*mb.duplicate(),result.message_block().length())==-1)
      {
        ACE_ERROR ((LM_ERROR,"%p\n","ACE_Asynch_Write_Stream::write"));
      }
      /*ACE_DLList_Iterator<ACE_Asynch_Write_Stream> iter(wList);
      while(!iter.done())
      {
        if (iter.next()->write(*result.message_block().duplicate(),
          result.message_block().length())==-1)
        {
          ACE_ERROR ((LM_ERROR,"%p/n","ACE_Asynch_Write_Stream::write"));
        }
        iter++;
      }*/
      mb.release();
      post_recv();
    }
    else
    {
      mb.release();
      /*ACE_DLList_Iterator<ACE_Asynch_Write_Stream> iter(wList);
      while (!iter.done ())
      {
        if(&ws_==iter.next())
        {
          iter.remove();
          break;
        }
        iter++;
      }*/
      delete this;
    }
  }
  virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
  {
    //ACE_OS::printf("write complete:%d %d\n", result.success(),result.bytes_transferred());
    result.message_block().release();
  }
private:
  ACE_Asynch_Read_Stream rs_;
  ACE_Asynch_Write_Stream ws_;

  ACE_HANDLE handle_;

  ACE_TCHAR peer_name[MAXHOSTNAMELEN];
  ACE_INET_Addr remote_address;
  ACE_INET_Addr local_address;
};

#include <ace/OS.h>
#include <ace/Task.h>

class TTcpNetThread : public ACE_Task_Base
{
public:
  /// 运行
  int open();

  /// 停止运行
  int close();
protected:
  /// 线程函数
  virtual int svc();
};

int TTcpNetThread::open() { return this->activate(); }

int TTcpNetThread::close()
{
  ACE_Proactor::instance()->proactor_end_event_loop(); // 终止ACE_Proactor循环

  this->wait(); // 等待清理现场

  return 0;
}

int TTcpNetThread::svc()
{
  /*
  ACE_INET_Addr listenAddr(4567); // 默认监听地址
  TTcpAcceptor tcpAcceptor; // 接收器

  // 演出开始
  if (tcpAcceptor.open(listenAddr, 0, 1, 5, 1, 0, 0) != 0)
    ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("failed to open TcpAcceptor errno=%i\n"), errno), -1);
  */
  // Proactor的事件循环开始
  ACE_Proactor::instance()->proactor_run_event_loop();

  ACE_DEBUG((LM_DEBUG, ACE_TEXT("Network fin\n")));

  return 0;
}

#pragma comment(lib,"ACEd.lib")

#define CLIENT_THREAD_NUM 4

int main(int argc,char *argv[])
{
  ACE_Asynch_Acceptor<Service_Handler> acceptor;

  if(acceptor.open(ACE_INET_Addr(4567),0,1) == -1)
  {
    return -1;
  }

  TTcpNetThread netThread[CLIENT_THREAD_NUM];

  for(int i = 0; i < CLIENT_THREAD_NUM; i++)
  {
    netThread[i].open();
  }
  while (getchar())
  {
    ACE_OS::sleep(1);
  }
  //ACE_Proactor::instance()->proactor_run_event_loop();

  return 0;
};