1 시작하며

2 소스의 개괄적 구조

3 Reactor?

4 메인 루프

5 acceptor?

6 logging handler 객체

7 끝내며

// $Id: ACE_c6_a9_c5_e4_b8_ae_be_f3001_2fACE_c5_f8_c5_b6_c0_bb_bb_e7_bf_eb_c7_cf_b1_e2_c0_a7_c7_d1_c3_ca_ba_b8_c0_da_b0_a1_c0_cc_b5_e5,v 1.7 2005/09/28 06:48:30 redpixel Exp redpixel $

/* reactor가 정의되어있는 헤더화일을 Include한다. */
#include "ace/Reactor.h"

/* 간단하게, 우리는 reactor를 전역변수로 생성한다. 
   튜토리얼 후반에 우리는 더 확실하게 이 작업을 할 것이다. 
   어쨌거나 이 튜토리얼의 목적은 접속을 accept시키고 처리하는 것을
   안내하고자 하는 것이지, reactor의 전체 기능을 설명하고자하는
   것이 아니다. */
ACE_Reactor *g_reactor;

/* 우리의 accept 객체를 정의한 헤더화일을 Include한다.
  acceptor는 클라이언트로부터 접속을 서버가 "받아들이는"
  것을 위한 객체를 말한다. */
#include "acceptor.h"

/* TCP/IP 서버는 접속 요청을 위한 단지 하나의 포트만을 listen 할 수 있다. 
   다음은 포트 번호를 나타낸다.*/
static const u_short PORT = ACE_DEFAULT_SERVER_PORT;

int
main (int, char *[])
{
  /* reactor 인스턴스를 생성한다. 다시말하면, 전역 포인터는 실제로 
     이것을 다루는 가장 좋은 방법은 아니지만 여기서는 간단한 예를 들기
     위해 사용했다. 나중에 이것을 논하도록 하자. ACE_NEW_RETURN 매크로
     를 사용하는 법에 주목하자. 만약 new 연산이 실패하면 1이 리턴된다. */
  ACE_NEW_RETURN (g_reactor,
                  ACE_Reactor,
                  1);

  /* reactor와 마찬가지로, 주소(ADDR)객체에 대해서는 일단 자세히 설명하지
     않기로 한다. 이 객체가 제공하는 것은 네트워크상의 주소 서비스에 대한
     추상화이다. 이 시점에서 우리가 알아야한 모든 것은 우리는 주소객체를
     생성한다는 것이다. 이것은 신규 접속요청을 listen할 TCP/IP 포트를 
     지정한다. */
  ACE_INET_Addr addr (PORT);

  Logging_Acceptor *peer_acceptor;

  /* 우리는 이제 acceptor 객체를 생성했다. 이 시점에서는 
    객체가 "작동중"으로 open된 상태가 아니므로 어떤 접속도 
    아직 구축되지 않는다.*/
  ACE_NEW_RETURN (peer_acceptor,
                  Logging_Acceptor,
                  1);

/* acceptor가 이제 open되는 부분이다. 여러분은 대부분의 ACE 객체들이 
    사용되기 전에 open()이 실행되어야만 한다는 것을 발견할 수 있을 것이다.
    여기에서의 open()이 호출되려면 우리는 '주소'객체를 통해서 접속을 
    listen 하는 곳을 알려주어야만 한다. 또한 그것이 "g_reactor"
    인스턴스에 등록되도록 인자에 적어준다. */
  if (peer_acceptor->open (addr, g_reactor) == -1 )
    ACE_ERROR_RETURN ((LM_ERROR,
                       "Opening Acceptor\n"),
                      -1);

  ACE_DEBUG ((LM_DEBUG,
              "(%P|%t) starting up server logging daemon\n"));

  /* reactor의 handle_events 맴버 함수는 모든 등록된 객체들을 검색하고 
    관심있는 이벤트가 발생했을 경우 알맞은 맴버함수를 실행시키는 의무를
    가지고 있다. 이벤트가 실행되면 handle_events 함수는 return한다. 모든
    이벤트를 얻을 목적으로, 우리는 이것을 무한 루프에 넣도록 한다.
    현재 실행화일이 무한루프에 빠져있는 까닭에 프로그램을 종료하려면
    CTRL-C를 누를 필요가 있다. */
  for (;;)
    g_reactor->handle_events ();

  return 0;
}

// $Id: ACE_c6_a9_c5_e4_b8_ae_be_f3001_2fACE_c5_f8_c5_b6_c0_bb_bb_e7_bf_eb_c7_cf_b1_e2_c0_a7_c7_d1_c3_ca_ba_b8_c0_da_b0_a1_c0_cc_b5_e5,v 1.7 2005/09/28 06:48:30 redpixel Exp redpixel $

#ifndef _CLIENT_ACCEPTOR_H
#define _CLIENT_ACCEPTOR_H

/* SOCK_Acceptor는 소켓 접속을 accept하는 법을 가지고 있다. 
  우리는 이들중 하나를 Logging_Acceptor의 핵심부에서 사용할 
  것이다. */
#include "ace/SOCK_Acceptor.h"

#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

/* Event_Handler는 ACE_Reactor에 등록되어지는 객체이다. 이벤트가 
  일어나면, reactor는 Event_Handler로 callback한다. */
#include "ace/Event_Handler.h"

/* 클라이언트가 접속할 때, 접속을 관리할 Logging_Handler를 생성한다.
  여기 그 선언을 include 한다. */
#include "logger.h"

/* Logging_Acceptor는 ACE_Event_Handler로부터 상속받는다. 이것은
  reactor가 acceptor를 모든 다른 핸들러와 같이 취급하도록 만든다.*/
class Logging_Acceptor : public ACE_Event_Handler
{
public:

  /* 이런 간단한 경우에서는 우리는 생성자와 소멸자로 지루해지기 싫다.
    실제 어플리케이션이라면 특별하게 관리해야할 수도 있다. */

  /* 이것은 main()에서 호출했던 open() 메소드이다. 이것을 구현하려면 
    두가지를 실행해야한다 : (1) acceptor를 open한다. 이렇게 해서 
    클라이언트의 요청을 받아들일 수 있다. (2) 자기자신을 reactor에
    등록하여 클라이언트의 요구에 응답할 수 있도록 만든다. */
  int open (const ACE_INET_Addr &addr,
            ACE_Reactor *reactor)
  {
    /* acceptor의 open()을 실행한다. 우리는 main()에서 우리가 listen
      하기를 원하는 주소를 넘겨준다. 두번째 인자는 주소를 재사용해도
      "좋다"고 알려준다. 이것은 때때로 타임아웃되지 않은 닫힌 연결을
      고려하기 위해 필요하다. */
    if (this->peer_acceptor_.open (addr, 1) == -1)
      return -1;

    /* 우리가 사용할 reactor 인스턴스를 기억해둔다. 이것은 나중에 
      클라이언트 접속용 핸들러를 생성하는데 필요하다. */
    reactor_ = reactor;

    /* 이제 우리는 주어진 reactor를 등록할 수 있다. reactor의 포인터가 
      전역으로 선언되어있기 때문에 우리는 이것을 단지 사용만 하면 된다.
      ACE_Event_Handler로 부터 상속받았기 때문에 'this'을 직접 넘길 수 
      있다는 것에 주목하라. ACCEPT_MASK를 사용하는 것은 reactor에게 
      클라이언트로부터의 접속요구에 대해서 알아차리도록 설정하는 것이다. */
    return reactor->register_handler (this,
                                      ACE_Event_Handler::ACCEPT_MASK);
  }

private:

  /* 멀티 플랫폼 추상화를 제공하기 위해서, ACE는 접속 종단점(connection 
    endpoint)을 위해 "핸들"의 개념을 사용한다. UNIX에서는 이것은 전통적인
    화일 지시자(file descriptor) 또는 정수이다. 다른 운영체계에서는 또다른
    무엇이 될 수도 있다. reactor는 자신의 내부적 필요성에 의해서 핸들을 
    얻을 필요가 있다. 여기서 적절한 핸들은 acceptor 객체의 핸들이다.*/
  ACE_HANDLE get_handle (void) const
  {
    return this->peer_acceptor_.get_handle ();
  }

  /* accept 요청이 도착하면, reactor는 handle_input() 콜백을 실행시킨다.
    이곳이 접속요청을 다루어야 하는 코드 위치이다. */
  virtual int handle_input (ACE_HANDLE handle)
  {
    /* reactor에 의해 우리에게 전달된 핸들은 상위 호출(up-call)을 
      일으키는 원인이 된다. 약간 앞선 입장에서 바라본다면 실제로 다중
      접속을 처리하는데 있어서 하나의 핸들러만을 등록할 경우도 있다.
      _handle 인자는 그것들을 해결하는 방법이다. 여기서는 이 인자를
      사용하지 않기 때문에 단순히 ACE_UNUSED_ARG() 매크로를 사용해서 
      이것을 무시하기로 한다. */
    ACE_UNUSED_ARG (handle);

    Logging_Handler *svc_handler;

    /* 접속 요구에 응답하여, 우리는 새로운 Logging_Handler를 생성한다.
      이 신규 객체는 클라이언트가 접속이 끊길때 까지 상호 통신하기 위한
      목적으로 사용된다. ACE_NEW_RETURN 매크로를 사용하는 방식에 주의하자.
      new 연산이 실패하면 -1을 반환한다. */
    ACE_NEW_RETURN (svc_handler,
                    Logging_Handler,
                    -1);

    /* 연결을 완료하기 위해서 acceptor 객체의 accept() 메소드 호출을 
      실행하고, 접속 핸들러 인스턴스에 그것을 넘긴다. 이것은 접속의 
      "소유권"을 acceptor로부터 연결 핸들러로 전송한다. */
    if (this->peer_acceptor_.accept (*svc_handler) == -1)
      ACE_ERROR_RETURN ((LM_ERROR,
                         "%p",
                         "accept failed"),
                        -1);

    /* 다시 말하지만, 대부분의 객체들은 사용하기전에 open()해두는 것
      이 좋다. 우리는 핸들러에게 이벤트에 대한 등록을 할 수 있도록 
      reactor 포인터를 넘길 것이다. 만약 open()이 실패하면 close()를 
      강제로 실행한다. */
    if (svc_handler->open (reactor_) == -1)
      svc_handler->close ();

    return 0;
  }

protected:

  /* acceptor 객체 인스턴스 */
  ACE_SOCK_Acceptor peer_acceptor_;

  /* reactor 포인터를 담아둘 변수 */
  ACE_Reactor *reactor_;
};

#endif /* _CLIENT_ACCEPTOR_H */

typedef ACE_Acceptor <YourHandlerClass, ACE_SOCK_ACCEPTOR> YourAcceptorClass;

typedef ACE_Acceptor <Logging_Handler, ACE_SOCK_ACCEPTOR> Client_Acceptor;

// $Id: ACE_c6_a9_c5_e4_b8_ae_be_f3001_2fACE_c5_f8_c5_b6_c0_bb_bb_e7_bf_eb_c7_cf_b1_e2_c0_a7_c7_d1_c3_ca_ba_b8_c0_da_b0_a1_c0_cc_b5_e5,v 1.7 2005/09/28 06:48:30 redpixel Exp redpixel $

#ifndef _CLIENT_HANDLER_H
#define _CLIENT_HANDLER_H

/* 접속 핸들러도 또한 ACE_Event_Handler로부터 상속받는다. 
  그러므로 이것은 reactor에 등록할 수 있다.*/
#include "ace/Event_Handler.h"

#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

#include "ace/INET_Addr.h"

/* 우리는 TCP/IP를 사용하기 때문에, 연결처리를 위해 
  SOCK_Stream이 필요하다. */
#include "ace/SOCK_Stream.h"

class Logging_Handler : public ACE_Event_Handler
{
public:
  /* acceptor와 같이 생성자와 소멸자는 무시한다. */

  /* 클라이언트 핸들러를 open하기 위해서, 자기사진을 reactor에 
    등록해야만 한다. ACE_SOCK_Stream 맴버 변수를 "open"할 
    필요가 없다는 것에 주목해라. 왜? acceptor의 accept() 매소드를 
    호출하는 것이 우리가 원하는 바를 해주기 때문이다.*/
  int open (ACE_Reactor *reactor)
  {
    /* reactor를 기억해두자. */
    reactor_ = reactor;

    /* 여기서는 READ_MASK를 사용한다. */
    if (reactor->register_handler (this,
                                   ACE_Event_Handler::READ_MASK) == -1)
      ACE_ERROR_RETURN ((LM_ERROR,
                         "(%P|%t) can't register with reactor\n"),
                        -1);
    return 0;
  }

  /* 명시적으로 close되었다면 "화일 핸들"을 close 할 것이다. 네트워크 
    처리결과는 클라이언트의 접속을 끊고, reactor에 등록되어있다면 등록을
    해제하게 된다. */
  int close (void)
  {
    return this->handle_close (ACE_INVALID_HANDLE,
                               ACE_Event_Handler::RWE_MASK);
  }

  /* This is a bit of magic...  When we call the accept() method of
    the acceptor object, it wants to do work on an ACE_SOCK_Stream.
    We have one of those as our connection to the client but it would
    be gross to provide a method to access that object.  It's much
    cooler if the acceptor can just treat the Logging_Handler as an
    ACE_SOCK_Stream.  Providing this cast operator lets that happen
    cleanly.  */

  operator ACE_SOCK_Stream &()
  {
    return this->cli_stream_;
  }

protected:

  /* accept와 마찬가지로 reactor로의 핸들을 제공할 필요가 있다. */
  ACE_HANDLE get_handle (void) const
  {
    return this->cli_stream_.get_handle ();
  }

  /* 여기에 handle_input()이 있다. 이것이 어플리케이션의 주 작업장소이다. */
  virtual int handle_input (ACE_HANDLE)
  {
    /* 작은 버퍼를 만들고 초기화 한다. 1을 더한 것은 널로 끝나는 문자열에
      대한 배려이다. */
    char buf[BUFSIZ + 1];

    /* ACE_SOCK_Stream의 recv() 매소드를 실행한다. 에러일 경우는 -1을 
      반환한다. 정상이라면, 읽어들인 바이트 수를 반환한다. 물론, 0바이트
      를 읽어들였다면 접속이 끊긴것이다. 어떻게 그것을 알수 있는가?
      만약 "조금"이라도 움직임이 없었다면, handle_input() 함수가 
      reactor에 의해 호출되지 않을 것이고, 끊어진 연결은 reactor로 
      read 요청처럼 보일 수 있기 때문이다. 그러나 끊어진 연결로부터 read
      했을 때에는 항상 0바이트를 읽게 될 것이다.

      에러일 경우나 접속이 끊어진 경우라면 -1을 반환하는 것에 주의하라.
      그것은 reactor에게 깔끔하게 shutdown할 수 있는 handle_close()
      를 호출하도록 알려준다. 

      이들을 사용하지 않는다 할지라도, recv() 호출에서 사용할 수 있는
      몇가지 추가적인 인자들이 있다. 이들중 하나는 ACE_Time_Value 인데
      이것은 recv()가 실행되고 블럭당하는 시간을 한정한다. 데이타가
      받을 수 있는 상황인 것을 확신할 수 없을 때 이것을 사용할 수 있다.
      
      Since we only get to handle_input() when data is ready, that would be redundant.  
      On the other hand, if you use recv_n() to read *exactly* a number of bytes then
      limiting the time you wait for those bytes might be good.  
      
      The other paramter that may come in handy is an integer flags.
      This is passed directly to the underlying OS recv() call.  */
    ssize_t retval;
    switch (retval = this->cli_stream_.recv (buf, BUFSIZ))
    {
    case -1:
      ACE_ERROR_RETURN ((LM_ERROR,
                         "(%P|%t) %p bad read\n",
                         "client logger"),
                        -1);
    case 0:
      ACE_ERROR_RETURN ((LM_ERROR,
                         "(%P|%t) closing log daemon (fd = %d)\n",
                         this->get_handle ()),
                        -1);
    default:
      buf[retval] = '\0';
      ACE_DEBUG ((LM_DEBUG,
                  "(%P|%t) from client: %s",
                  buf));
    }

    return 0;
  }

  /* handle_input()이 -1을 반환할 때, 여기서 끝낸다. 몇가지 처리할 잡일이 남아있다. */
  int handle_close (ACE_HANDLE, ACE_Reactor_Mask _mask)
  {
    /* reactor로 부터 자기 자신을 제거한다. 반드시 DONT_CALL 마스크를 포함시켜야만 한다!
      이것은 handle_close()를 다시 호출하는 것을 막아준다. */
    reactor_->remove_handler (this,
                              _mask | ACE_Event_Handler::DONT_CALL);

    /* 클라이언트와 연결되어있는 소켓을 닫는다.*/
    cli_stream_.close ();

    /* acceptor에 의해 동적으로 할당된 사실을 우리는 알고 있다. 
      이제 자살할 시간이다. */
    delete this;

    return 0;
  }

protected:

  /* 우리의 피어 연결 */
  ACE_SOCK_Stream cli_stream_;

  /* reactor  */
  ACE_Reactor *reactor_;
};

#endif /* _CLIENT_HANDLER_H */