C++博客-to myself 的分类学习日志-随笔分类-c++ network library

libev_lite: test table anfds and table pendings

kongkongzi — Wed, 08 Jul 2015 08:53:00 GMT

/*
* ev.h
*/

#ifndef EV_H_
#define EV_H_

#define EV_FEATURES 0x7f

#define EV_FEATURE_CONFIG   ((EV_FEATURES) &  4)

#define EV_MINPRI (EV_FEATURE_CONFIG ? -2 : 0)
#define EV_MAXPRI (EV_FEATURE_CONFIG ? +2 : 0)

#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)

#define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
#define EV_CB_INVOKE(watcher, revents) (watcher)->cb ((watcher), (revents))

#define EMPTY2(a,b) /* used to suppress some warnings */

/************* watcher related ***********************/
typedef struct ev_watcher
{
    int active;
    int pending;
    int priority;
    void *data;
    void (*cb)(struct ev_watcher *w, int revents);
    struct ev_watcher *next;
} ev_watcher;

typedef ev_watcher *W;

typedef struct ev_watcher_list
{
    int active;
    int pending;
    int priority;
    void *data;
    void (*cb)(struct ev_watcher_list *w, int revents);
    struct ev_watcher_list *next;
} ev_watcher_list;

typedef ev_watcher_list *WL;

/* invoked when fd is either EV_READable or EV_WRITEable */
/* revent EV_READ, EV_WRITE */
typedef struct ev_io
{
    int active;
    int pending;
    int priority;
    void *data;
    void (*cb)(struct ev_io *w, int revents);
    struct ev_io *next;

    int fd; /* ro */
    int events; /* ro */
} ev_io;

/* stores the pending event set for a given watcher */
typedef struct
{
  W w;
  int events; /* the pending event set for the given watcher */
} ANPENDING;

int pendingpri;
int pendingcnt[NUMPRI];
ANPENDING *pendings [NUMPRI]; // save pending events
int pendingmax [NUMPRI];

/**************** ANFD related ****************************/
/* set in reify when reification needed */
#define EV_ANFD_REIFY 1

/* file descriptor info structure */
typedef struct
{
  WL head;
  unsigned char events; /* the events watched for */
  unsigned char reify;  /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
  unsigned char emask;  /* the epoll backend stores the actual kernel mask in here */
  unsigned char unused;
  unsigned int egen;    /* generation counter to counter epoll bugs */
} ANFD;

ANFD * anfds; // save all events
int anfdmax;

int * fdchanges;
int fdchangemax;
int fdchangecnt;

/***************** function interface *****************************/
void fd_event(int fd, int revents);
void ev_invoke_pending();

void ev_io_start (ev_io *w);
void ev_io_stop (ev_io *w);

#endif /* EV_H_ */

#include "ev.h"
#include
#include

/*****************************************************************************/
void * ev_realloc (void *ptr, long size)
{
    ptr = realloc(ptr, size);

    if (!ptr && size)
    {
        abort();
    }

    return ptr;
}

#define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */

/* find a suitable new size for the given array, */
/* hopefully by rounding to a nice-to-malloc size */
int array_nextsize (int elem, int cur, int cnt)
{
  int ncur = cur + 1;

  do
    ncur <<= 1;
  while (cnt > ncur);

  /* if size is large, round to MALLOC_ROUND - 4 * longs to accommodate malloc overhead */
  if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
    {
      ncur *= elem;
      ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
      ncur = ncur - sizeof (void *) * 4;
      ncur /= elem;
    }

  return ncur;
}

static void * array_realloc (int elem, void *base, int *cur, int cnt)
{
  *cur = array_nextsize (elem, *cur, cnt);
  return ev_realloc (base, elem * *cur);
}

#define array_init_zero(base,count)    \
  memset ((void *)(base), 0, sizeof (*(base)) * (count))

#define array_needsize(type,base,cur,cnt,init)            \
  if (0 != ((cnt) > (cur)))                \
    {                                \
      int ocur_ = (cur);                    \
      (base) = (type *)array_realloc                \
         (sizeof (type), (base), &(cur), (cnt));        \
      init ((base) + (ocur_), (cur) - ocur_);            \
    }

#define array_free(stem, idx) \
  ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0

/*****************************************************************************/
void ev_invoke_pending()
{
    pendingpri = NUMPRI;

    while (pendingpri) /* pendingpri possibly gets modified in the inner loop */
    {
        --pendingpri;

        while (pendingcnt[pendingpri])
        {
            ANPENDING *p = pendings[pendingpri] + --pendingcnt[pendingpri];

            p->w->pending = 0;
            EV_CB_INVOKE(p->w, p->events);
        }
    }
}

void ev_feed_event(void *w, int revents)
{
    W w_ = (W) w;
    int pri = ABSPRI(w_);

    if (0 != (w_->pending))
    {
        pendings[pri][w_->pending - 1].events |= revents;
    }
    else
    {
        w_->pending = ++pendingcnt[pri];
        array_needsize(ANPENDING, pendings[pri], pendingmax[pri],
                w_->pending, EMPTY2);
        pendings[pri][w_->pending - 1].w = w_;
        pendings[pri][w_->pending - 1].events = revents;
    }

    pendingpri = NUMPRI - 1;
}

void fd_event_nocheck(int fd, int revents)
{
    ANFD *anfd = anfds + fd;
    ev_io *w;

    for (w = (ev_io *) anfd->head; w; w = (ev_io *) ((WL) w)->next)
    {
        int ev = w->events & revents;

        if (ev)
            ev_feed_event((W) w, ev);
    }
}

/* do not submit kernel events for fds that have reify set */
/* because that means they changed while we were polling for new events */
void fd_event(int fd, int revents)
{
  ANFD *anfd = anfds + fd;

  if (!anfd->reify)
    fd_event_nocheck(fd, revents);
}

void wlist_add (WL *head, WL elem)
{
  elem->next = *head;
  *head = elem;
}

void wlist_del (WL *head, WL elem)
{
  while (*head)
    {
      if (*head == elem)
        {
          *head = elem->next;
          break;
        }

      head = &(*head)->next;
    }
}

void ev_io_start (ev_io *w)
{
  int fd = w->fd;

  array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
  wlist_add (&anfds[fd].head, (WL)w);
}

void ev_io_stop (ev_io *w)
{
  wlist_del (&anfds[w->fd].head, (WL)w);
}

/*
* test.c
*
*/
#include "ev.h"
#include

void test_cb(struct ev_watcher *w, int revents)
{
    printf("test_cb\n");
}

// 1 fd -> multi events(or event watcher)
// epoll_poll -> fd_event -> fd_event_nocheck -> ev_feed_event -> ev_invoke_pending
int main(int aargc, char *argv[])
{
    ev_io w_io;
    w_io.active = 1;
    w_io.pending = 0;
    w_io.priority = 2;
    w_io.data = 0;
    w_io.cb = test_cb;
    w_io.next = 0;
    w_io.fd = 10;
    w_io.events = 2;
    ev_io_start(&w_io); // register event

    int fd = 10;
    int revents = 2;
    fd_event(fd, revents); // discover event

    ev_invoke_pending(); // raise event

    return 0;
}

kongkongzi 2015-07-08 16:53 发表评论

使用thrift实现订阅服务和发布服务

kongkongzi — Tue, 07 Jul 2015 09:57:00 GMT

服务：订阅服务 market_subscriber 和发布服务 market_publisher
功能：market_subscriber 能够向 market_publisher 请求订阅某些类型的消息，当 market_publisher 有该类型的消息时，需要把它推送给订阅服务。
流程：1. market_publisher 服务启动，监听端口，注册事件处理函数，处理订阅请求消息。
2. market_subscriber 服务启动，监听端口，注册事件处理函数，处理接收推动来的消息。
3. market_subscriber 向 market_publisher 发起订阅请求，market_publisher 根据订阅请求参数，长连接 market_subscriber 提供的消息接收端口。
4. market_publisher 通过长连接向 market_subscriber 推送消息。
注意：1. market_publisher 到 market_subscriber 的长连接的维护：
（1）market_subscriber 一定时间内未收到 market_publisher 的推送消息，尝试重新发起订阅请求。
（2）market_publisher 推送订阅消息时，发现连接断开，尝试重连。考虑 market_publisher 有重启的情况，收到的订阅请求参数需要做持久化。 ==> TODO：增加一个 market_subscriber 到 market_publisher 的取消订阅的请求。

实现：
1. market_subscriber.thrift -- market_subscriber 实现的服务接口

namespace cpp market_subscriber
namespace java market_subscriber
namespace perl market_subscriber
namespace php market_subscriber

struct Snapshot
{
    1: i32 nSecurityID;              ///< 证券ID
    2: i32 nTime;                    ///< 序号/时间/日期 HHMMSSmmm
    3: i32 nTradingPhaseCode;        ///< 0:开市前  1:开盘集合竞价 2:连续竞价 3:临时停盘 4:收盘集合竞价 5:集中竞价闭市  6:协议转让结束  7:闭市
    4: i32 nPreClosePx;              ///< 昨收价 * 10000
    5: i32 nOpenPx;                  ///< 开盘价 ..
    6: i32 nHighPx;                  ///< 最高价 ..
    7: i32 nLowPx;                   ///< 最低价 ..
    8: i32 nLastPx;                  ///< 最新价 ..
    9: i64 llTradeNum;               ///< 成交笔数
    10: i64 llVolume;                 ///< 成交量
    11: i64 llValue;                  ///< 成交额(*10000)
}

service SubscriberService
{
    // 推送消息
    // Oneway means the client only makes request and does not listen for any response at all. Oneway methods must be void.
    oneway void sendSnapshot(1:list lstSnapshot);
}

2. market_publisher.thrift -- market_publisher 实现的服务接口

namespace cpp market_publisher
namespace java market_publisher
namespace perl market_publisher
namespace php market_publisher

struct SubscribeMarketParam
{
    1: string user_name;
    2: string password;
    3: i32 type; // 订阅类型
    4: string ip; // 接收推送数据的ip
    5: i16 port; // 接收推送数据的port
}

struct SubscribeMarketAck
{
    1: required i32 error_code; // 0，成功；其它，失败
    2: optional string error_info;
}

struct GetStockBaseInfoParam
{
    1: required i32 stock_code;
}

struct GetStockBaseInfoAck
{
    1: required i32 error_code;
    2: optional string error_info;
    3: optional string stock_name;
}

service PublisherService
{
    // 订阅请求：订阅行情信息
    SubscribeMarketAck subscribeMarket(1:SubscribeMarketParam param);

    GetStockBaseInfoAck getStockBaseInfo(1:GetStockBaseInfoParam param);
}

3. subscriber_server.cpp

/*
* Main.cpp
*/

#include "../gen-cpp/SubscriberService.h"
#include "../gen-cpp/PublisherService.h"
#include
#include
#include
#include
#include
#include

using namespace ::apache::thrift;
using namespace ::apache::thrift::protocol;
using namespace ::apache::thrift::transport;
using namespace ::apache::thrift::server;

using boost::shared_ptr;

using namespace  ::market_subscriber;
using namespace  ::market_publisher;

class SubscriberServiceHandler : virtual public SubscriberServiceIf {
public:
  SubscriberServiceHandler() {
    // Your initialization goes here
  }

  void sendSnapshot(const std::vector & lstSnapshot) {
    // Your implementation goes here
    printf("sendSnapshot\n");
    std::cout << "Received snapshots' number: " << lstSnapshot.size() << std::endl;
    for (std::vector::const_iterator iter = lstSnapshot.begin();
            iter != lstSnapshot.end(); iter++)
    {
        std::cout << "nSecurityID: " << iter->nSecurityID << "\t";
        std::cout << "nTime: " << iter->nTime << "\t";
        std::cout << std::endl;
    }
    sleep(10);
  }

};

const char* CLIENT_LISTNE_IP = "127.0.0.1";
const short CLIENT_LISTNE_PORT = 9060;

void subscriberServiceThread()
{
    shared_ptr handler(new SubscriberServiceHandler());
    shared_ptr processor(new SubscriberServiceProcessor(handler));
    shared_ptr serverTransport(new TServerSocket(CLIENT_LISTNE_PORT));
    shared_ptr transportFactory(new TBufferedTransportFactory());
    shared_ptr protocolFactory(new TBinaryProtocolFactory());

    TSimpleServer server(processor, serverTransport, transportFactory,
            protocolFactory);
    server.serve();
}

int main(int argc, char **argv)
{
    boost::thread thrd(&subscriberServiceThread);
    // wait for subscriberServiceThread ready
    sleep(3);

    boost::shared_ptr socket(new TSocket("127.0.0.1", 9090));
    boost::shared_ptr transport(new TBufferedTransport(socket));
    boost::shared_ptr protocol(new TBinaryProtocol(transport));
    PublisherServiceClient client(protocol);

    try
    {
        transport->open();

        SubscribeMarketAck ack;
        SubscribeMarketParam param;
        param.__set_user_name("mazhan");
        param.__set_password("123456");
        param.__set_type(0);
        param.__set_ip(CLIENT_LISTNE_IP);
        param.__set_port(CLIENT_LISTNE_PORT);

        client.subscribeMarket(ack, param);
        std::cout << "subscribeMarket(), error code: " << ack.error_code << std::endl;

        transport->close();
    }
    catch (TException& tx)
    {
        std::cout << "ERROR: " << tx.what() << std::endl;
    }

    thrd.join();
    return 0;
}

4. pubsher_server.cpp

/*
* Main.cpp
*/

#include "../gen-cpp/SubscriberService.h"
#include "../gen-cpp/PublisherService.h"
#include
#include
#include
#include
#include
#include
#include

using namespace ::apache::thrift;
using namespace ::apache::thrift::protocol;
using namespace ::apache::thrift::transport;
using namespace ::apache::thrift::server;
using namespace ::apache::thrift::concurrency;

using boost::shared_ptr;
using namespace  ::market_publisher;
using namespace  ::market_subscriber;

std::list > g_lstSubscriberServiceClient;
boost::mutex g_mutexSubscriberServiceClient;

class PublisherServiceHandler : virtual public PublisherServiceIf {
public:
  PublisherServiceHandler() {
    // Your initialization goes here
  }

  void subscribeMarket(SubscribeMarketAck& _return, const SubscribeMarketParam& param) {
    // Your implementation goes here
    std::cout << "subscribeMarket, ip=" << param.ip << ", port=" << param.port << "." << std::endl;

    boost::shared_ptr socket(new TSocket(param.ip, param.port));
    boost::shared_ptr transport(new TBufferedTransport(socket));
    boost::shared_ptr protocol(new TBinaryProtocol(transport));
    boost::shared_ptr client(new SubscriberServiceClient(protocol));

    int error_code = 1; // fail to open
    try
    {
        transport->open();
        error_code = 0;

        { // add to subscribes list
            boost::mutex::scoped_lock lock(g_mutexSubscriberServiceClient);
            g_lstSubscriberServiceClient.push_back(client);
        }
    }
    catch (TException& e)
    {
        std::cout << "Exception: " << e.what() << std::endl;
        _return.__set_error_info(e.what());
    }
    catch (std::exception& e)
    {
        std::cout << "Exception: " << e.what() << std::endl;
        _return.__set_error_info(e.what());
    }
    catch ()
    {
        char buff[100];
        snprintf(buff, 99, "fail to open %s:%d.", param.ip.c_str(), param.port);
        std::cout << "Exception: " << buff << std::endl;
        _return.__set_error_info(buff);
    }
    _return.__set_error_code(error_code);
  }

  void getStockBaseInfo(GetStockBaseInfoAck& _return, const GetStockBaseInfoParam& param) {
    // Your implementation goes here
    printf("getStockBaseInfo\n");
  }

};

int32_t getCurTime()
{
    time_t t = time(0);
    char tmp[64];
    strftime(tmp, sizeof(tmp), "%H%M%S", localtime(&t));
    return atoi(tmp);
}

// send markets to subscribers.
void publisherServiceThread()
{
    while (1)
    {
        std::vector lstSnapshot;
        Snapshot snapshot;
        snapshot.nSecurityID = 100000001;
        snapshot.nTime = getCurTime() * 1000 + rand() % 1000;
        snapshot.nTradingPhaseCode = 2;
        snapshot.nPreClosePx = 240500;
        snapshot.nOpenPx = 250500;
        snapshot.nHighPx = 250800;
        snapshot.nLowPx = 240800;
        snapshot.nLastPx = 250300;
        snapshot.llTradeNum = 15000;
        snapshot.llVolume = 6000000;
        snapshot.llValue = 15030000000;
        lstSnapshot.push_back(snapshot);

        boost::mutex::scoped_lock lock(g_mutexSubscriberServiceClient);
        std::list >::iterator iter = g_lstSubscriberServiceClient.begin();
        while (iter != g_lstSubscriberServiceClient.end())
        {
            try
            {
                (*iter)->sendSnapshot(lstSnapshot);
                iter++;
            }
            catch (TException& e)
            {
                std::cout << "Exception: " << e.what() << std::endl;
                iter = g_lstSubscriberServiceClient.erase(iter);
            }
            catch (std::exception& e)
            {
                std::cout << "Exception: " << e.what() << std::endl;
                iter = g_lstSubscriberServiceClient.erase(iter);
            }
            catch ()
            {
                std::cout << "Exception: fail to call sendSnapshot()." << std::endl;
                iter = g_lstSubscriberServiceClient.erase(iter);
            }
        }

        sleep(3);
    }
}

int main(int argc, char **argv)
{
    int port = 9090;
    shared_ptr handler(new PublisherServiceHandler());
    shared_ptr processor(new PublisherServiceProcessor(handler));
    shared_ptr serverTransport(new TServerSocket(port));
    shared_ptr transportFactory(
            new TBufferedTransportFactory());
    shared_ptr protocolFactory(new TBinaryProtocolFactory());

    TSimpleServer server(processor, serverTransport, transportFactory,
            protocolFactory);

    boost::thread thrd(&publisherServiceThread);

    printf("Starting the server\n");
    server.serve();
    printf("done.\n");
    return 0;
}

kongkongzi 2015-07-07 17:57 发表评论

libev simple server and client

kongkongzi — Fri, 03 Jul 2015 11:14:00 GMT

实现功能：client从标准输入读取输入，发送到server；server收到client的消息后，原样发给client。

libev simple server

/*
* example_server.c
*/

#include
#include
#include
#include
#include
#include in.h>
#include
#include "ev.h"

#define PORT 8333
#define BUFFER_SIZE 1024
#define MAX_ALLOWED_CLIENT 10240

struct ev_io *libevlist[MAX_ALLOWED_CLIENT] = { NULL };

// gcc example_server.c ev.o -lm
void accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents);
void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents);
int freelibev(struct ev_loop *loop, int fd);

int main()
{
    struct ev_loop *loop = ev_default_loop(0);
    int sd;
    struct sockaddr_in addr;
    int addr_len = sizeof(addr);
    struct ev_io socket_watcher;
    ev_timer timeout_watcher;

    if ((sd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("socket error. errno:%d\n", errno);
        return -1;
    }

    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(sd, (struct sockaddr*) &addr, sizeof(addr)) != 0)
    {
        printf("bind error.errno:%d\n", errno);
    }

    if (listen(sd, 2) < 0)
    {
        printf("listen error\n");
        return -1;
    }

    printf("ev_loop beg\n");

    ev_io_init(&socket_watcher, accept_cb, sd, EV_READ);
    ev_io_start(loop, &socket_watcher);

    printf("ev_loop start\n");
    ev_loop(loop, 0);
    printf("ev_loop end\n");

    return 0;
}

void accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
{
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    int client_sd;
    struct ev_io *w_client = (struct ev_io*) malloc(sizeof(struct ev_io));

    if (EV_ERROR & revents)
    {
        printf("error event in accept\n");
        return;
    }

    client_sd = accept(watcher->fd, (struct sockaddr *) &client_addr,
            &client_len);
    if (client_sd < 0)
    {
        printf("accept error\n");
        return;
    }

    //如果连接数超出指定范围，则关闭连接
    if (client_sd > MAX_ALLOWED_CLIENT)
    {
        printf("fd too large[%d]\n", client_sd);
        close(client_sd);
        return;
    }

    if (libevlist[client_sd] != NULL)
    {
        printf("client_sd not NULL fd is [%d]\n", client_sd);
        return;
    }

    printf("someone connected.\n");
    ev_io_init(w_client, read_cb, client_sd, EV_READ);
    ev_io_start(loop, w_client);

    libevlist[client_sd] = w_client;
}

void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
{
    char buffer[BUFFER_SIZE];
    ssize_t read;
    if (EV_ERROR & revents)
    {
        printf("error event in read");
        return;
    }

    read = recv(watcher->fd, buffer, BUFFER_SIZE, 0);
    if (read < 0)
    {
        printf("read error,errno:%d\n", errno);
        return;
    }

    if (read == 0)
    {
        printf("someone disconnected, errno:%d\n", errno);
        freelibev(loop, watcher->fd);
        return;
    }
    else
    {
        printf("get the message:%s\n", buffer);
    }

    send(watcher->fd, buffer, read, 0);
    bzero(buffer, read);
}

int freelibev(struct ev_loop *loop, int fd)
{
    if(libevlist[fd] == NULL)
    {
        printf("the fd already freed[%d]\n", fd);
        return -1;
    }

    close(fd);
    ev_io_stop(loop, libevlist[fd]);
    free(libevlist[fd]);
    libevlist[fd] = NULL;
    return 1;
}

libev simple client

/*
* example_client.c
*
*/

#include
#include
#include
#include
#include
#include <string.h>
#include
#include
#include
#include in.h>
#include
#include in.h>
#include "ev.h"

#define PORT 8333
#define BUFFER_SIZE 1024

// gcc example_client.c ev.o -lm
void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents);
void stdin_cb(EV_P_ ev_io *w, int revents);

int g_server_sockfd;

int main()
{
    struct ev_loop *loop = ev_default_loop(0);

    struct hostent *he; /*  主机信息 */
    struct sockaddr_in their_addr; /*  对方地址信息 */

    /*  get the host info */
    if ((he = gethostbyname("127.0.0.1")) == NULL)
    {
        /*  注意：获取DNS信息时，显示出错需要用herror而不是perror */
        herror("gethostbyname");
        exit(1);
    }

    if ((g_server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket");
        exit(1);
    }

    their_addr.sin_family = AF_INET;
    their_addr.sin_port = htons(PORT); /*  short, NBO */
    their_addr.sin_addr = *((struct in_addr *) he->h_addr);
    bzero(&(their_addr.sin_zero), 8); /*  其余部分设成0 */
    if (connect(g_server_sockfd, (struct sockaddr *) &their_addr,
            sizeof(struct sockaddr)) == -1)
    {
        perror("connect");
        exit(1);
    }

    ev_io w_client;
    ev_io_init(&w_client, read_cb, g_server_sockfd, EV_READ);
    ev_io_start(loop, &w_client);

    ev_io stdin_watcher;
    ev_io_init(&stdin_watcher, stdin_cb, STDIN_FILENO, EV_READ);
    ev_io_start(loop, &stdin_watcher);

    printf("ev_loop start\n");
    ev_loop(loop, 0);
    printf("ev_loop end\n");

    close(g_server_sockfd);
    return 0;
}

void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
{
    char buffer[BUFFER_SIZE];
    ssize_t len;
    if (EV_ERROR & revents)
    {
        printf("error event in read");
        return;
    }

    len = recv(watcher->fd, buffer, BUFFER_SIZE, 0);
    if (len < 0)
    {
        printf("network read error,errno:%d\n", errno);
        return;
    }

    if (len == 0)
    {
        printf("someone disconnected.errno:%d\n", errno);
        close(watcher->fd);
        ev_io_stop(loop, watcher);
        free(watcher);
        return;
    }
    else
    {
        printf("get the message:%s\n", buffer);
        if (strcmp("quit",  buffer) == 0)
        {
            ev_io_stop(EV_A_ watcher);
            // to stop network io event
            ev_break(EV_A_ EVBREAK_CANCEL);
        }
    }
}

void stdin_cb(EV_P_ ev_io *w, int revents)
{
    char buffer[BUFFER_SIZE];
    bzero(buffer, BUFFER_SIZE);
    ssize_t len;
    if (EV_ERROR & revents)
    {
        printf("error event in read");
        return;
    }

    // w->fd: STDIN_FILENO
    // len = recv(w->fd, buffer, sizeof(buffer), 0); // wrong??
    len = read(w->fd, buffer, sizeof(buffer)); // right
    if (len <= 0)
    {
        printf("stdin read error, return:%ld, errno:%d\n", len, errno);
        return;
    }

    if ('\n' == buffer[len-1])
    {
        buffer[len-1] = '\0';
        if ('\r' == buffer[len-2])
        {
            buffer[len-2] = '\0';
            len--;
        }
    }

    send(g_server_sockfd, buffer, len, 0);
    if (strcmp("quit",  buffer) == 0)
    {
        ev_io_stop(EV_A_ w);
        // to stop network io event
        ev_break(EV_A_ EVBREAK_CANCEL);
    }
    bzero(buffer, len);
}

kongkongzi 2015-07-03 19:14 发表评论

ACE的编译

kongkongzi — Fri, 15 Nov 2013 08:26:00 GMT

在Windows上编译ACE：
1. 安装ActivePerl-5.14
2. 设置环境变量ACE_ROOT
3. 创建文件 $ACE_ROOT/ace/config.h，写入如下内容
  - #include "ace/config-win32.h"
4. X:\third\ACE_wrappers>bin\mwc.pl -type vc9 ACE.mwc
5. 打开ACE.sln编译
在Linux上编译ACE：

设置环境变量
- vim ~/.bashrc
- export ACE_ROOT=/home/yourname/ACE_wrappers
- export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ACE_ROOT/ace
创建文件 $ACE_ROOT/ace/config.h，写入如下内容
- #include "ace/config-linux.h"
创建文件 $ACE_ROOT/include/makeinclude/platform_macros.GNU 写入
- include $(ACE_ROOT)/include/makeinclude/platform_linux.GNU
可以在 platform_macros.GNU 里写入 INSTALL_PREFIX=/home/yourname/ace_install_dir/ 来制定输出目录
./bin/mwc.pl -static -type make ACE.mwc
make ACE
生成：ar rv ../lib/libACE.a Local_Name_Space.o ....o

支持使用ACE_Dev_Poll_Reactor:

Dev_Poll_Reactor这个文件编译需要定义ACE_HAS_EVENT_POLL宏，否则跳过，不编译。于是在config.h里面加入了#define ACE_HAS_EVENT_POLL，重新编译库，再重新编译测试文件，全部成功，运行正常。
注意生成的libACE.a的路径和你程序连接的路径是否一致。一般通过MPC生成的库存在于$(ACE_ROOT)/lib/目录下，而通过autoconf 和 automake生成的库存在于$(ACE_ROOT)/build/ace/.libs/目录下。

参考： http://www.dre.vanderbilt.edu/~schmidt/DOC_ROOT/ACE/MPC/docs/USAGE

kongkongzi 2013-11-15 16:26 发表评论

ACE UDP Client and Server example

kongkongzi — Tue, 08 Oct 2013 07:31:00 GMT

/* UDP_Peer_Event_Handler.h
*/
#ifndef _UDP_PEER_EVENT_HANDLER_H_
#define _UDP_PEER_EVENT_HANDLER_H_

#include "ace/SOCK_Dgram.h"
#include "ace/INET_Addr.h"

class UDP_Peer_Event_Handler : public ACE_Event_Handler
{
    typedef ACE_Event_Handler super;

public:
    UDP_Peer_Event_Handler (const ACE_INET_Addr &local_addr);
    virtual ~UDP_Peer_Event_Handler();

    virtual ACE_HANDLE get_handle (void) const;
    virtual int handle_input (ACE_HANDLE handle);
    virtual int handle_timeout (const ACE_Time_Value & tv,const void *arg = 0);
    virtual int handle_close (ACE_HANDLE handle,ACE_Reactor_Mask close_mask);
    virtual int handle_signal (int signum, siginfo_t* siginfo, ucontext_t* context);
    int send (const char *buf, size_t len, const ACE_INET_Addr &addr);

private:
    ACE_SOCK_Dgram gram_;
};

#endif // _UDP_PEER_EVENT_HANDLER_H_

/* UDP_Peer_Event_Handler.cpp
*/
#include "UDP_Peer_Event_Handler.h"

UDP_Peer_Event_Handler::UDP_Peer_Event_Handler (const ACE_INET_Addr &local_addr)
: gram_(local_addr)
{
    ACE_DEBUG((LM_DEBUG, "UDP_Peer_Event_Handler constructor was called.\n"));
}

UDP_Peer_Event_Handler::~UDP_Peer_Event_Handler()
{
    ACE_DEBUG((LM_DEBUG, "UDP_Peer_Event_Handler destructor was called.\n"));

    this->gram_.close();
}

ACE_HANDLE UDP_Peer_Event_Handler::get_handle (void) const
{
    return this->gram_.get_handle();
}

int UDP_Peer_Event_Handler::handle_close (ACE_HANDLE handle, ACE_Reactor_Mask mask)
{
    ACE_DEBUG((LM_DEBUG, "************handle_close***********\n"));
    if (mask == ACE_Event_Handler::WRITE_MASK)
        return 0;

    return super::handle_close(handle, mask);
}

int UDP_Peer_Event_Handler::handle_input (ACE_HANDLE)
{
    char buf[BUFSIZ];
    ACE_INET_Addr from_addr;
    char address[32];

    //ACE_DEBUG ((LM_DEBUG,"(%P|%t) activity occurred on handle %d!/n",this->gram_.get_handle ()));
    ssize_t nbytes = this->gram_.recv (buf, sizeof(buf), from_addr);
    if (nbytes == -1)
    {
        ACE_ERROR ((LM_ERROR,"%p","handle_input error/n"));

        return -1;
    }

    ACE_DEBUG ((LM_DEBUG, "[%d]bytes from[%s] received:%s/n", nbytes, address, buf));

    return 0;
}

int UDP_Peer_Event_Handler::handle_timeout (const ACE_Time_Value &,const void *)
{
    ACE_DEBUG ((LM_DEBUG,"(%P|%t) timed out for udp/n"));
    return 0;
}

int UDP_Peer_Event_Handler::handle_signal (int signum, siginfo_t* siginfo, ucontext_t* context)
{
    return ACE_Event_Handler::handle_signal (signum, siginfo, context);
}

int UDP_Peer_Event_Handler::send (const char *buf,size_t len,const ACE_INET_Addr &addr)
{
    return this->gram_.send (buf, len, addr);
}

/* ACE_UDP_Server.cpp
*/
#include "UDP_Peer_Event_Handler.h"
#include "ace/OS_main.h"
#include "ace/Reactor.h"

static const u_short SERVER_PORT = 10101;

int ACE_TMAIN (int, ACE_TCHAR *[])
{
    ACE_INET_Addr local_addr(SERVER_PORT);
    UDP_Peer_Event_Handler *udp;

    ACE_NEW_RETURN(udp, UDP_Peer_Event_Handler(local_addr), -1);

    if (ACE_Reactor::instance()->register_handler(udp, ACE_Event_Handler::READ_MASK) == -1)
    {
        ACE_ERROR_RETURN((LM_ERROR, "ACE_Reactor::register_handler"), -1);
    }

    ACE_Reactor::instance()->run_event_loop();
    return 0;
}

/* ACE_UDP_Client.cpp
*/
#include "UDP_Peer_Event_Handler.h"
#include "ace/OS_main.h"
#include "ace/Reactor.h"

static const u_short SERVER_PORT = 10101;
static const char *SERVER_HOST_NAME = "127.0.0.1";

int ACE_TMAIN (int, ACE_TCHAR *[])
{
    ACE_INET_Addr local_addr((u_short)0);
    UDP_Peer_Event_Handler *udp;

    ACE_NEW_RETURN(udp, UDP_Peer_Event_Handler(local_addr), -1);

    ACE_INET_Addr remote_addr(SERVER_PORT, SERVER_HOST_NAME);
    int ret = udp->send("hello", 5, remote_addr);    // SEND MESSAGE
    if (ACE_Reactor::instance()->register_handler(udp, ACE_Event_Handler::WRITE_MASK) == -1)
    {
        ACE_ERROR_RETURN((LM_ERROR, "ACE_Reactor::register_handler"), -1);
    }

    ACE_Reactor::instance()->run_event_loop();
    return 0;
}

kongkongzi 2013-10-08 15:31 发表评论

ACE TCP Client and Server example

kongkongzi — Tue, 08 Oct 2013 07:06:00 GMT

/* TCP_Peer_Event_Handler.h
*/
#ifndef _TCP_PEER_EVENT_HANDLER_H_
#define _TCP_PEER_EVENT_HANDLER_H_

#include "ace/Message_Block.h"
#include "ace/SOCK_Stream.h"
#include "ace/Svc_Handler.h"

class TCP_Peer_Event_Handler :
  public ACE_Svc_Handler
{
  typedef ACE_Svc_Handler super;

public:
    TCP_Peer_Event_Handler();
    virtual ~TCP_Peer_Event_Handler();

public:
   /// Activate the client handler.  This is typically called by the
  /// ACE_Acceptor or ACE_Connector.
  virtual int open (void * = 0);

  // Called when input is available from the client.
  virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);

  // Called when output is possible.
  virtual int handle_output (ACE_HANDLE fd = ACE_INVALID_HANDLE);

  // Called when this handler is removed from the ACE_Reactor.
  virtual int handle_close (ACE_HANDLE handle,
                            ACE_Reactor_Mask close_mask);
};

#endif // _TCP_PEER_EVENT_HANDLER_H_

/* TCP_Peer_Event_Handler.cpp
*/
#include "TCP_Peer_Event_Handler.h"

#define MAXHOSTNAMELEN   255

TCP_Peer_Event_Handler::TCP_Peer_Event_Handler()
{
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) TCP_Peer_Event_Handler constructor!\n")));

    this->reactor(get_reactor());

    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%P|%t) TCP_Peer_Event_Handler() Using reactor 0x%x\n"),
                this->reactor()));
}

TCP_Peer_Event_Handler::~TCP_Peer_Event_Handler()
{
    ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) TCP_Peer_Event_Handler destructor!\n")));
}

int TCP_Peer_Event_Handler::open(void *p)
{
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%P|%t) open() Using reactor 0x%x\n"),
                this->reactor()));

  if (super::open (p) == -1)
    return -1;

  ACE_TCHAR peer_name[MAXHOSTNAMELEN];
  ACE_INET_Addr peer_addr;
  if (this->peer ().get_remote_addr (peer_addr) == 0 &&
      peer_addr.addr_to_string (peer_name, MAXHOSTNAMELEN) == 0)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%P|%t) Connection from %s\n"),
                peer_name));
  return 0;
}

int TCP_Peer_Event_Handler::handle_input(ACE_HANDLE)
{
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%P|%t) handle_input() Using reactor 0x%x\n"),
                this->reactor()));

  const size_t INPUT_SIZE = 4096;
  char buffer[INPUT_SIZE];
  ssize_t recv_cnt, send_cnt;

  recv_cnt = this->peer ().recv (buffer, sizeof(buffer));
  if (recv_cnt <= 0)
    {
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("(%P|%t) Connection closed\n")));
      return -1;
    }
  else
  {
    buffer[recv_cnt] = '\0';
    ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("(%P|%t) Recv %s\n"), buffer));
  }

  send_cnt =
    this->peer ().send (buffer,
                        ACE_static_cast (size_t, recv_cnt));
  if (send_cnt == recv_cnt)
    return 0;
  if (send_cnt == -1 && ACE_OS::last_error () != EWOULDBLOCK)
    ACE_ERROR_RETURN ((LM_ERROR,
                       ACE_TEXT ("(%P|%t) %p\n"),
                       ACE_TEXT ("send")),
                      0);
  if (send_cnt == -1)
    send_cnt = 0;
  ACE_Message_Block *mb;
  size_t remaining =
    ACE_static_cast (size_t, (recv_cnt - send_cnt));
  ACE_NEW_RETURN
    (mb, ACE_Message_Block (&buffer[send_cnt], remaining), -1);
  int output_off = this->msg_queue ()->is_empty ();
  ACE_Time_Value nowait (ACE_OS::gettimeofday ());
  if (this->putq (mb, &nowait) == -1)
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("(%P|%t) %p; discarding data\n"),
                  ACE_TEXT ("enqueue failed")));
      mb->release ();
      return 0;
    }
  if (output_off)
    return this->reactor ()->register_handler
      (this, ACE_Event_Handler::WRITE_MASK);
  return 0;
}

int TCP_Peer_Event_Handler::handle_output(ACE_HANDLE)
{
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%P|%t) handle_output() Using reactor 0x%x\n"),
                this->reactor()));

  ACE_Message_Block *mb;
  ACE_Time_Value nowait (ACE_OS::gettimeofday ());
  while (-1 != this->getq (mb, &nowait))
    {
      ssize_t send_cnt =
        this->peer ().send (mb->rd_ptr (), mb->length ());
      if (send_cnt == -1)
        ACE_ERROR ((LM_ERROR,
                    ACE_TEXT ("(%P|%t) %p\n"),
                    ACE_TEXT ("send")));
      else
        mb->rd_ptr (ACE_static_cast (size_t, send_cnt));
      if (mb->length () > 0)
        {
          this->ungetq (mb);
          break;
        }
      mb->release ();
    }
  return (this->msg_queue ()->is_empty ()) ? -1 : 0;
}

int TCP_Peer_Event_Handler::handle_close (ACE_HANDLE h, ACE_Reactor_Mask mask)
{
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("(%P|%t) handle_close() Using reactor 0x%x\n"),
                this->reactor()));

  if (mask == ACE_Event_Handler::WRITE_MASK)
    return 0;
  return super::handle_close (h, mask);
}

/* ACE_TCP_Server.cpp
*/
#include "TCP_Peer_Event_Handler.h"
#include "ace/Log_Msg.h"
#include "ace/INET_Addr.h"
#include "ace/SOCK_Acceptor.h"
#include "ace/Reactor.h"
#include "ace/Acceptor.h"
#include
#include

typedef ACE_Acceptor
TCP_Client_Acceptor;

int ACE_TMAIN (int, ACE_TCHAR *[])
{
  ACE_INET_Addr port_to_listen("8112");
  TCP_Client_Acceptor acceptor;
  if (acceptor.open (port_to_listen) == -1)
    return 1;

  ACE_Reactor::instance ()->run_reactor_event_loop ();

  return (0);
}

/* ACE_TCP_Client.cpp
*/
#include "TCP_Peer_Event_Handler.h"

typedef ACE_Connector
  TCP_Client_Connector;

int ACE_TMAIN (int, ACE_TCHAR *[])
{
  ACE_INET_Addr port_to_connect ("8112", ACE_LOCALHOST);
  TCP_Client_Connector connector;
  TCP_Peer_Event_Handler client;
  if (connector.connect (&client, port_to_connect) == -1)
    ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
                       ACE_TEXT ("connect")), 1);

  ACE_Reactor::instance ()->run_reactor_event_loop ();
  return (0);
}

kongkongzi 2013-10-08 15:06 发表评论

The Use of ACE

kongkongzi — Tue, 17 Sep 2013 07:58:00 GMT

Using the Acceptor-Connector Framework
1. http://edc.tversu.ru/elib/inf/0027/0201699710_ch07lev1sec6.html
  When it accepts a new connection, an ACE_Acceptor creates a new sevice handler instance—in our case, a ClientService object. After creating it, ACE_Acceptor calls the new service handler's open() hook method;
ACE_Message_Block
1. http://www.dre.vanderbilt.edu/Doxygen/5.6/html/ace/classACE__Message__Block.html

kongkongzi 2013-09-17 15:58 发表评论

ACE读书笔记

kongkongzi — Tue, 03 Sep 2013 05:38:00 GMT

目录
1. 整体说明
2. ACE C++ Wrapper Facade
3. ACE框架
4. 参考
附1. 单播、多播和广播
附2. 深入C++丛书

1. 整体说明

应用环境下的面向对象中间件层次（4层）：

1）主机基础设施中间件：封装OS API；

2）分布式中间件：在1）的基础上提供更高级的服务，例如连接管理和内存管理、同步、多线程等。CORBA、ACE ORB（TAO）？

3）公共中间件服务：为各种具体应用抽取出公共的服务，例如事件通知、日志记录、持久性、安全且可恢复的事务等。

4）特定领域中间件服务：为特定的领域（例如电信、电子商务等）提供特定的服务。

分析过程、领域分析（domain analysis）

问题空间（problem space）：面对的是“软件体系及设计”方面的问题。

方案空间（solution space）：涉及的是“实现应用程序的软件工具和技术”。

设计空间（design dimension），属于问题空间（？），了解领域内的抽象概念，达成共识。

ACE的层次化体系结构：

1） ACE OS Adaptation层（10%）：由一个名为ACE_OS的类构成，包含500多个C++静态方法，这些方法封装了原始的、基于C的OS API。

2） ACE C++ Wrapper Façade层（50%）：在以面向对象的方法将1）中的方法封装成C++类。

分类：通信服务、连接/通信角色、通信领域。

3） ACE framework层（40%）：加强类间的关联，提供更大粒度上的软件复用。（参考《c++网络编程卷2》）

2. ACE C++ Wrapper Façade

Network <-->Socket related <--> Message Block related <--> I/O CDR related

其中Socket related包括：Address 、Connector、Acceptor和Stream。

服务器的并发设计: I/O操作是否频繁、计算任务是否繁重（“计算密集”型服务）。

在整个ACE中使用统一的返回约定，即0表示成功，-1表示失败，失败的原因保存在errno中。

3. ACE框架

4. 参考

《Advanced CORBA Programming with C++》

http://ace.ece.uci.edu/

http://www.riverace.com

http://www.cs.wustl.edu/~schmidt/ACE.html

Douglas C.Schmidt

美国Vanderbilt大学电子工程与计算机科学系的教授。除了学术研究而外,Schmidt教授在面向对象通信系统构建方面已经拥有超过十年的经验。他是面向对象框架Adaptive Communication Environment(ACE)的首席架构者和开发者,该框架可自由获取、并得到了广泛使用,其中含有一组丰富的组件,实现了用于高性能和实时通信系统的各种设计模式。

附1. 单播、多播和广播

1，单播（unicast）：有具体目标地址的帧从源到达目标地址的过程。比如你对小月喊“小月”，那么只有小月答应你。单播是说，对特定的主机进行数据传送。例如给某一个主机发送IP数据包。这时候，数据链路层给出的数据头里面是非常具体的目的地址，对于以太网来说，就是网卡的MAC地址（不是FF-FF-FF-FF-FF-FF这样的地址）。现在的具有路由功能的主机应该可以将单播数据定向转发，而目的主机的网络接口则可以过滤掉和自己MAC地址不一致的数据。

2，多播（multicast）：也叫组播。仅应用于UDP。就是帧送往定义在一组内的地址。比如你喊：“是男人都过来一人发一百块钱”。哪么男的都会过来女的就不会过来因为没有钱发她不会理你。多播组？帧仅传送给属于多播组的多个主机。使用多播，主机可加入一个或多个多播组。这样，网卡将获悉该主机属于哪个多播组，然后仅接收主机所在多播组的那些多播帧。Internet组管理协议（IGMP）、多播路由协议（如PIM、DVMRP等）？当一台主机欲加入某个多播组时，会发出“主机成员报告”的IGMP消息通知多播路由器。当多播路由器接收到发给那个多播组的数据时，便会将其转发给所有的多播主机。多播路由器还会周期性地发出“主机成员查询”的IGMP消息，向子网查询多播主机，若发现某个多播组已没有任何成员，则停止转发该多播组的数据。此外，当支持IGMP v2的主机（如Ｗindows 98/2000计算机）退出某个多播组时，还会向路由器发送一条“离开组”的IGMP消息，以通知路由器停止转发该多播组的数据。但只有当子网上所有主机都退出某个多播组时，路由器才会停止向该子网转发该多播组的数据。IP多播应用的编程方法？

参考：http://baike.baidu.com/view/378050.htm

3，广播（broadcast）：仅应用于UDP。就是把帧发往所有能到达的地址。比如学校的广播中喊“今天放假”。哪么全校的同学都会响应，大叫爽死了。广播是主机针对某一个网络上的所有主机发送数据包。这个网络可能是网络，可能是子网，还可能是所有的子网。如果是网络，例如A类网址的广播就是 netid.255.255.255，如果是子网，则是netid.netid.subnetid.255；如果是所有的子网（B类IP）则是则是 netid.netid.255.255。广播所用的MAC地址FF-FF-FF-FF-FF-FF。网络内所有的主机都会收到这个广播数据，网卡只要把 MAC地址为FF-FF-FF-FF-FF-FF的数据交给内核就可以了。一般说来ARP，或者路由协议RIP应该是以广播的形式播发的。

附2. 深入C++丛书

kongkongzi 2013-09-03 13:38 发表评论

cpp-netlib之async_client解析

kongkongzi — Mon, 15 Jul 2013 09:19:00 GMT

cpp-netlib:
参考：
1. http://cpp-netlib.org/
2. https://github.com/cpp-netlib/
3. http://github.com/cpp-netlib/

解析版本： cpp-netlib-0.9.4
注：使用的boost版本为boost_1_53_0。若使用boost_1_46_1在Windows上编译会出现错误。

testClient.cpp：

#include
#include
#include

namespace http = boost::network::http;

using namespace boost::network;

struct body_handler {
    explicit body_handler(void* context)
    : context_(context) {}

    BOOST_NETWORK_HTTP_BODY_CALLBACK(operator(), range, error) {
        // in here, range is the Boost.Range iterator_range, and error is
        // the Boost.System error code.
        if (!error)
        {
            std::cout << "Received " << boost::distance(range) << "bytes." << std::endl;
            body_.append(boost::begin(range), boost::end(range));
            std::cout << "body: " << body_ << std::endl;
        }
        else
        {
            std::cout << "Error: " << error << std::endl;
        }

        return;
    }

private:
    void* context_;
    std::string body_;
};

int main(int argc, char *argv[]) {
    try {
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }

    if (argc != 2) {
        std::cout << "Usage: " << argv[0] << " [url]" << std::endl;
        return 1;
    }

    http::client client;
    http::client::request request(argv[1]);
    request << header("Connection", "close");
    http::client::response response = client.get(request, http::_body_handler=body_handler(NULL));
    std::cout << "status: " << http::status(response) << std::endl;

    return 0;
}

kongkongzi 2013-07-15 17:19 发表评论

cpp-netlib之三大组类

kongkongzi — Mon, 15 Jul 2013 08:59:00 GMT

1. cpp-netlib-class-server

2. cpp-netlib-class-client

3. cpp-netlib-class-message

kongkongzi 2013-07-15 16:59 发表评论

cpp-netlib之async_server解析

kongkongzi — Mon, 15 Jul 2013 08:29:00 GMT

#include "CommonPrecomp.h"
#include "RequestHandler.h"
#include "RequestHandlerFactory.h"
#include <string>
#include

struct test_handler {
    /* when there are many request at the same time, can put the request into a queue, then let another thread process it.
     * or maybe need to call http::client to connect to other server, and get response.
     */
    void operator()(const server::request &request, server::connection_ptr connection)
    {
        request_handler_ptr request_handler_ = request_handler_factory::get_mutable_instance().create();
        return request_handler_->start(request, connection);
    }
};

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " address port" << std::endl;
        return 1;
    }

    try {
        test_handler handler;
        utils::thread_pool thread_pool_(2);
        server instance(argv[1], argv[2], handler, thread_pool_);
        instance.run();
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }

    return 0;
}

CommonPrecomp.h

#ifndef _COMMON_PRECOMP_H_
#define _COMMON_PRECOMP_H_

#include
#include
#include
#include

namespace http = boost::network::http;
namespace utils = boost::network::utils;

struct test_handler;
typedef boost::network::http::async_server server;

#endif // _COMMON_PRECOMP_H_

CommonPrecomp.cpp

#include "CommonPrecomp.h"

RequestHandler.h

#ifndef _REQUEST_HANDLER_H_
#define _REQUEST_HANDLER_H_

class request_handler
{
public:
    struct is_content_length {
        template <class Header>
        bool operator()(Header const & header) {
            return boost::iequals(header.name, "content-length");
        }
    };

    request_handler();
    ~request_handler();

    void start(const server::request &request, server::connection_ptr connection);

    void read_callback(server::connection::input_range input, boost::system::error_code const & ec, std::size_t bytes_transferred, server::connection_ptr connection);

    void write_callback(boost::system::error_code const & ec);

private:
    std::string uri_;
    std::string content_;
    std::size_t content_length_;
    std::size_t read_content_length_;

private:
    static server::response_header common_headers[3];
    static std::string bad_request;
};

typedef boost::shared_ptr request_handler_ptr;

#endif // _REQUEST_HANDLER_H_

RequestHandler.cpp

#include "CommonPrecomp.h"
#include "RequestHandler.h"
#include "RequestHandlerFactory.h"

request_handler::request_handler()
: uri_()
, content_()
, content_length_(0)
, read_content_length_(0)
{
    std::cout << "request_handler constructor!" << std::endl;
}

request_handler::~request_handler()
{
    std::cout << "request_handler destructor!" << std::endl;
}

void request_handler::start(const server::request &request, server::connection_ptr connection)
{
    if (request.method == "POST")
    {
        server::request::headers_container_type::iterator found =
            boost::find_if(request.headers, is_content_length());
        if (found == request.headers.end())
        {
            connection->set_status(server::connection::bad_request);
            connection->set_headers(boost::make_iterator_range(common_headers, common_headers+3));
            connection->write(bad_request, boost::bind(&request_handler::write_callback, this, _1));
            return;
        }

        uri_ = http::destination(request);
        content_length_ = boost::lexical_cast(found->value);

        connection->read(boost::bind(&request_handler::read_callback, this, _1, _2, _3, _4));
        return;
    }
    else
    {
        connection->set_status(server::connection::bad_request);
        connection->set_headers(boost::make_iterator_range(common_headers, common_headers+3));
        connection->write(bad_request, boost::bind(&request_handler::write_callback, this, _1));
    }
}

void request_handler::read_callback(server::connection::input_range input, boost::system::error_code const & ec, std::size_t bytes_transferred, server::connection_ptr connection)
{
    if (ec)
    {
        std::cerr << "Error: " << ec << std::endl;
        // todo others.
        return;
    }

    read_content_length_ += bytes_transferred;
    content_ += std::string(input.begin(), input.end());
    if (read_content_length_ < content_length_)
    {
        connection->read(boost::bind(&request_handler::read_callback, this, _1, _2, _3, _4));
        return;
    }

    if ("/videoProcessing/start" == uri_)
    {
        // todo: decode the body(content) by creating a message of application logic layer
        std::string response_body = "";

        std::vector headers(common_headers, common_headers+3);
        headers[2].value = boost::lexical_caststring>(response_body.size());
        connection->set_status(server::connection::ok);
        connection->set_headers(boost::make_iterator_range(headers.begin(), headers.end()));
        connection->write(response_body, boost::bind(&request_handler::write_callback, this, _1));
    }
    else
    {
        connection->set_status(server::connection::bad_request);
        connection->set_headers(boost::make_iterator_range(common_headers, common_headers+3));
        connection->write(bad_request, boost::bind(&request_handler::write_callback, this, _1));
    }
}

void request_handler::write_callback(boost::system::error_code const & ec)
{
    request_handler_factory::get_mutable_instance().destroy(this);
}

server::response_header request_handler::common_headers[3] = {
    {"Connection","close"}
    ,{"Content-Type", "text/plain"}
    ,{"Content-Length", "0"}
};

std::string request_handler::bad_request("Bad Request.");

RequestHandlerFactory.h

#ifndef _REQUEST_HANDLER_FACTORY_H_
#define _REQUEST_HANDLER_FACTORY_H_

#include "RequestHandler.h"

class request_handler_factory : public boost::serialization::singleton
{
public:
    request_handler_ptr create();
    void destroy(request_handler* handler);

    ~request_handler_factory();

private:
    std::list request_handler_lst;
};

#endif // _REQUEST_HANDLER_FACTORY_H_

RequestHandlerFactory.cpp

#include "CommonPrecomp.h"
#include "RequestHandlerFactory.h"
#include "RequestHandler.h"

request_handler_factory::~request_handler_factory()
{
}

request_handler_ptr request_handler_factory::create()
{
    request_handler_ptr request_handler_(new request_handler());
    request_handler_lst.push_back(request_handler_);
    return request_handler_;
}

void request_handler_factory::destroy(request_handler* handler)
{
    for (std::list::iterator iter = request_handler_lst.begin();
        iter != request_handler_lst.end(); iter++)
    {
        if (iter->get() == handler)
        {
            request_handler_lst.erase(iter);
            return;
        }
    }
}

图1：cppnetlib-asio-async_server.jpg

kongkongzi 2013-07-15 16:29 发表评论

cpp-netlib之network解析

kongkongzi — Thu, 04 Jul 2013 09:28:00 GMT

cpp-netlib:
参考：
1. http://cpp-netlib.org/

解析版本： cpp-netlib-0.9.4
注：使用的boost版本为boost_1_53_0。若使用boost_1_46_1在Windows上编译会出现错误。

cpp-netlib-0.9.4版本编译后：

Linux：
libcppnetlib-client-connections.a
libcppnetlib-server-parsers.a
libcppnetlib-uri.a
Windows：H:\work\boost\cpp-netlib-0.9.4\libs\network\src\Release
cppnetlib-client-connections.lib
cppnetlib-server-parsers.lib
cppnetlib-uri.lib
Windows工程配置：
1. include: H:/work/boost/boost_1_53_0;H:/work/boost/cpp-netlib-0.9.4;
2. preprocessor: _SCL_SECURE_NO_WARNINGS; _WIN32_WINNT=0x0501;

测试代码testServer.cpp：

#include
#include <string>
#include

namespace http = boost::network::http;

struct hello_world;
typedef http::server server;

struct hello_world {
    void operator() (server::request const &request,
                     server::response &response) {
        std::string ip = source(request);
        response = server::response::stock_reply(
            server::response::ok, std::string("Hello, ") + ip + "!");
    }

    void log(const char* msg)
    {
        std::cout << msg << std::endl;
    }
};

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

    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " address port" << std::endl;
        return 1;
    }

    try {
        hello_world handler;
        server server_(argv[1], argv[2], handler);
        server_.run();
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }

    return 0;
}

图1：cppnetlib-listening

图2：cppnetlib-handleAccept

图3：cppnetlib-class

说明：
1. http::server与http::async_server的区别：
（1）http::async_server使用了多线程来处理每个连接上的请求，详细分析查看《cpp-netlib之async_server解析》：http://www.cppblog.com/toMyself/archive/2013/07/15/201819.html。

thread_pool().post(boost::bind(&Handler::operator(), &handler, cref(request_), async_connection::shared_from_this()))。

kongkongzi 2013-07-04 17:28 发表评论

Boost Parameter库学习笔记

kongkongzi — Wed, 03 Jul 2013 08:41:00 GMT

The Boost Parameter Library
参考：
1. 英文文档： http://www.boost.org/doc/libs/1_54_0/libs/parameter/doc/html/index.html
2. 中文文档：http://stlchina.huhoo.net/boost/libs/parameter/doc/html/index.html
3. 中文文档下载svn： http://boost-doc-zh.googlecode.com/svn/trunk

测试代码：

#include
#include
#include
#include void.hpp>
#include
#include
#include <string>
#include
#include

namespace libnofx
{
    BOOST_PARAMETER_NAME(host)
    BOOST_PARAMETER_NAME(port)
    BOOST_PARAMETER_NAME(handler)
    BOOST_PARAMETER_NAME(io_service)

    BOOST_PARAMETER_FUNCTION(
        (bool), server_init, tag,
        (required
            (host, (std::string const &))
            (port, (std::string const &))
            (handler, *))
        (optional
            (io_service, *, 0))
    )
    {
        host_type str;

        std::cout << "host=" << host << std::endl;
        std::cout << "port=" << port << std::endl;
        std::cout << "handler=" << handler << std::endl;
        std::cout << "io_service=" << io_service << std::endl;

        return true;
    }
}

namespace libnofx
{
    BOOST_PARAMETER_NAME(arg1)
    BOOST_PARAMETER_NAME(arg2)

    struct callable2
    {
        BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
            (void), print/*operator()*/, tag,
            (required
                (arg1, (int))
                (arg2, (int)))
        )
        {
            std::cout << arg1 << ", " << arg2 << std::endl;
        }
    };
}

namespace libnofx
{
    BOOST_PARAMETER_NAME(name)
    BOOST_PARAMETER_NAME(index)

    struct myclass_impl
    {
        template <class ArgumentPack>
        myclass_impl(ArgumentPack const& args)
        {
            std::cout << "name = " << args[_name]
            << "; index = " << args[_index | 42]
            << std::endl;
        }
    };

    struct myclass : myclass_impl
    {
        BOOST_PARAMETER_CONSTRUCTOR(
            myclass, (myclass_impl), tag
            , (required (name,*)) (optional (index,*))) // no semicolon
    };
}

namespace libnofx
{
    BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
    BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
    BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
    BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)


    using namespace boost;
    using boost::mpl::_;

    #  define BOOST_PYTHON_MAX_BASES 10

    namespace detail { struct bases_base {}; }

    // A type list for specifying bases
    //template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_MAX_BASES, typename Base, mpl::void_) >
    //struct bases : detail::bases_base
    //{
    //};
    template <class A0 = void, class A1 = void, class A2 = void, class A3 = void, class A4 = void>
    struct bases : detail::bases_base
    {};

    typedef parameter::parameters<
        parameter::required >

        , parameter::optional<
        parameter::deduced
        , is_base_and_derived
        >

        , parameter::optional<
        parameter::deduced
        , mpl::not_<
        mpl::or_<
        is_base_and_derived
        , is_same
        >
        >
        >

        , parameter::optional<
        parameter::deduced
        , is_same
        >
    > class_signature;

    template <
        class A0
            , class A1 = parameter::void_
            , class A2 = parameter::void_
            , class A3 = parameter::void_
    >
    struct class_
    {
        // Create ArgumentPack
        typedef typename
            class_signature::bind::type args;

        // Extract first logical parameter.
        typedef typename parameter::binding<
            args, tag::class_type>::type class_type;

        typedef typename parameter::binding<
            args, tag::base_list, bases<> >::type base_list;

        typedef typename parameter::binding<
            args, tag::held_type, class_type>::type held_type;

        typedef typename parameter::binding<
            args, tag::copyable, void>::type copyable;
    };

    struct B { virtual ~B(); };
    struct D : B { ~D(); };

    //typedef class_, copyable > c1;
    //typedef class_ >, base_list > > c2;

    typedef class_ c1;
    typedef class_, bases > c2;
}

using namespace libnofx;

int main(int argc, char* argv[])
{
    /* 2.1 Parameter-Enabled Functions
     */
    bool success = false;
    success = server_init("0.0.0.0", "4112", "0x12345678", 12345678);
    success = server_init(_port="4113", _host="127.0.0.1", _handler="0x87654321");

    /* 2.2 Parameter-Enabled Member
     */
    int arg1 = 1;
    int arg2 = 2;
    callable2 ca2;
    ca2.print(arg1, arg2);

    /* 2.3 Parameter-Enabled Constructors
     */
    myclass x("bob", 3); // positional
    myclass y(_index = 12, _name = "sally"); // named
    myclass z("june"); // positional/defaulted

    /* 2.4 Parameter-Enabled Class Templates
     */
    BOOST_MPL_ASSERT((boost::is_same));
    BOOST_MPL_ASSERT((boost::is_same >));
    BOOST_MPL_ASSERT((boost::is_same));
    BOOST_MPL_ASSERT((boost::is_same));

    BOOST_MPL_ASSERT((boost::is_same));
    BOOST_MPL_ASSERT((boost::is_same >));
    BOOST_MPL_ASSERT((boost::is_same >));
    BOOST_MPL_ASSERT((boost::is_samevoid>));

    return 0;
}

keyword tag type 和 Parameter-Enabled Constructors 预编译后的代码样例：
namespace libnofx
{
    namespace tag
    {
        struct name
        {
            static char const* keyword_name()
            {
                return "name";
            }

            typedef boost::parameter::value_type< boost::mpl::_2, name, boost::parameter::void_ > _;
            typedef boost::parameter::value_type< boost::mpl::_2, name, boost::parameter::void_ > _1; };
    }
    namespace
    {
        ::boost::parameter::keyword const& _name = ::boost::parameter::keyword::instance;
    }


    namespace tag
    {
        struct index
        {
            static char const* keyword_name()
            {
                return "index";
            }

            typedef boost::parameter::value_type< boost::mpl::_2, index, boost::parameter::void_ > _;
            typedef boost::parameter::value_type< boost::mpl::_2, index, boost::parameter::void_ > _1; };
    }
    namespace
    {
        ::boost::parameter::keyword const& _index = ::boost::parameter::keyword::instance;
    }

    struct myclass_impl
    {
        template <class ArgumentPack>
        myclass_impl(ArgumentPack const& args)
        {
            std::cout << "name = " << args[_name]
            << "; index = " << args[_index | 42]
            << std::endl;
        }
    };

    struct myclass : myclass_impl
    {
        template <class BoostParameterDummy>
        struct boost_param_params_79ctor  : boost::parameter::parameters<
            boost::parameter::required            , typename boost::parameter::aux::unwrap_predicate< void * >::type >
            , boost::parameter::optional            , typename boost::parameter::aux::unwrap_predicate< void * >::type >
        >
        {};

        typedef boost_param_params_79ctor <int> constructor_parameters79;

        template< class ParameterArgumentType0>
        explicit myclass(  const ParameterArgumentType0 & a0
            , typename boost::parameter::aux::match< constructor_parameters79
            ,  ParameterArgumentType0 >::type = constructor_parameters79() )
            : boost::parameter::aux::unaryfunptr_arg_type< void(*)(myclass_impl) >::type (
            constructor_parameters79()(  a0 ) )
        {}

        template< class ParameterArgumentType0 , class ParameterArgumentType1>
        myclass(  const ParameterArgumentType0 & a0 , const ParameterArgumentType1 & a1
            , typename boost::parameter::aux::match< constructor_parameters79,  ParameterArgumentType0
            , ParameterArgumentType1 >::type = constructor_parameters79() )
            : boost::parameter::aux::unaryfunptr_arg_type< void(*)(myclass_impl) >::type
            ( constructor_parameters79()(  a0 , a1 ) )
        {}
    };
}

kongkongzi 2013-07-03 16:41 发表评论

POCO之Net解析

kongkongzi — Mon, 24 Jun 2013 09:40:00 GMT
     摘要: POCO：参考：1. http://pocoproject.org/2. https://github.com/pocoproject解析版本：poco-1.4.6p1测试代码--TestServer.cpp： Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.co...  阅读全文

kongkongzi 2013-06-24 17:40 发表评论

Boost多线程编程

kongkongzi — Wed, 22 Sep 2010 09:15:00 GMT
     摘要: Boost多线程编程背景 •       今天互联网应用服务程序普遍使用多线程来提高与多客户链接时的效率；为了达到最大的吞吐量，事务服务器在单独的线程上运行服务程序；          GUI应用程序将那些费...  阅读全文

kongkongzi 2010-09-22 17:15 发表评论

zlib

kongkongzi — Mon, 02 Aug 2010 09:03:00 GMT
一个压缩库，配合boost使用
zlib 1.2.3 -> www.zlib.net

kongkongzi 2010-08-02 17:03 发表评论

boost的编译

kongkongzi — Mon, 02 Aug 2010 09:01:00 GMT

bjam --toolset=msvc-9.0 --build-type=complete
bjam --build-type=complete

首先运行boost根目录下的bootstrap.bat，然后会生成一个bjam的文件，运行这个文件，大部分的文件就都生成出来了。不过有两个文件是我们需要的(libboost_bzip2-vc90-mt.lib libboost_zlib-vc90-mt.lib)，而在windows下编译，boost默认是不编译的，因为boost用了zlib和bzip两个三方库来进行编译的。所以我们要手动把这两个文件生成出来，从上述地址把软件下来，然后解压到某地。运行下述命令：

     bjam -sZLIB_SOURCE=ZLIB_PATH -sBZIP2_SOURCE=BZIP_PATH --toolset=msvc address-model=32 --with-iostreams stage

      这里面我们要为boost制定zlib和bzip的位置，然后我们会看到生成了如下输出

libboost_iostreams-vc80-mt-s-1_38.lib和libboost_zlib-vc80-mt-s-1_38.lib
（iostreams和zlib）
bjam --toolset=msvc --with-iostreams -sZLIB_SOURCE=d:\zlib stage runtime-link=static threading=multi release

boost   http://sourceforge.net/projects/boost/files/boost/1.43.0/
bzip2   http://www.bzip.org/downloads.html
zlib      http://www.zlib.net/

kongkongzi 2010-08-02 17:01 发表评论

asio

kongkongzi — Thu, 05 Mar 2009 07:17:00 GMT

boost::asio
boost::asio::io_service // This class provides access to I/O functionality.
boost::asio::io_service::run(); // Run the io_service's event processing loop.
                                 // 在run之前已经注册了(将)要处理的Event
boost::asio::io_service::post(CompletionHandler handler); // Request the io_service to
                                 // invoke the given handler and return immediately.
boost::asio::ip::tcp::acceptor
boost::asio::strand // guarantees that, for those handlers that are dispatched through it,
   // an executing handler will be allowed to complete before the next one is started.
boost::bind // bind any argument to a specific value or route input arguments into arbitrary positions

strand_.wrap(boost::bind(&tcp_client_jade::handle_read_type, shared_from_this(),
            boost::asio::placeholders::error));
strand_.wrap(boost::bind(&tcp_client_jade::handle_read_type, shared_from_this(),
            boost::asio::placeholders::error));
strand_.wrap(boost::bind(&session::handle_write, shared_from_this(),
            boost::asio::placeholders::error));

使用io_service作为处理工作的work pool，可以看到，就是通过io_service.post投递一个Handler到io_service的队列,Handler在这个io_service.run内部得到执行，有可能你会发现，io_services.dispatch的接口也和io_service.post一样，但不同的是它是直接调用而不是经过push到队列然后在io_services.run中执行，而在这个示例当中，显然我们需要把工作交到另一个线程去完成，这样才不会影响网络接收线程池的工作以达到高效率的接收数据，这种设计与前面的netsever其实相同，这就是典型的Half Sync/Half Async。二者的区别就是netsever自己实现了工作队列，而不是直接使用io_service，这种设计实际上在win下是使用了iocp作为工作队列。
不过我更倾向于前一种设计，因为那样做，代码一切都在自己的掌握中，而io_service则是经过许多封装代码，并且本身设计只是用于处理网络完成事件的。
无论如何使用，都能感觉到使用boost.asio实现服务器，不尽是一件非常轻松的事，而且代码很漂亮，逻辑也相当清晰，这点上很不同于ACE。

我觉IO_SERVICE是一个基本性的接口，基本上通常用到的类实例都需要通过它来构造功能我们可以看似socket

学习boost的使用：
1、查看源代码。boost在源码了添加了大量的注释，对于理解某个函数的功能、使用方法等都有大量的说明。
2、查看doc文档。boost在doc里提供了比较多的应用实例，可以参考。

/// The type of the service that will be used to provide I/O operations.
typedef IoObjectService service_type;

/// The underlying implementation type of I/O object.
typedef typename service_type::implementation_type implementation_type;

// The backend service implementation.
service_type& service;

// The underlying native implementation.
implementation_type implementation;

数据与操作的分离？
io_service associated with the object.

boost::asio::detail::task_io_service<boost::asio::detail::epoll_reactor<false> >::do_one
boost/asio/detail/task_io_service.hpp:222

kongkongzi 2009-03-05 15:17 发表评论