to myself 的分类学习日志

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<Snapshot> lstSnapshot);
}

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);
}

/*
 * Main.cpp
 */

#include "../gen-cpp/SubscriberService.h"
#include "../gen-cpp/PublisherService.h"
#include <thrift/protocol/TBinaryProtocol.h>
#include <thrift/server/TSimpleServer.h>
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TServerSocket.h>
#include <thrift/transport/TBufferTransports.h>
#include <boost/thread/thread.hpp>

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<Snapshot> & lstSnapshot) {
    // Your implementation goes here
    printf("sendSnapshot\n");
    std::cout << "Received snapshots' number: " << lstSnapshot.size() << std::endl;
    for (std::vector<Snapshot>::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<SubscriberServiceHandler> handler(new SubscriberServiceHandler());
    shared_ptr<TProcessor> processor(new SubscriberServiceProcessor(handler));
    shared_ptr<TServerTransport> serverTransport(new TServerSocket(CLIENT_LISTNE_PORT));
    shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
    shared_ptr<TProtocolFactory> 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<TSocket> socket(new TSocket("127.0.0.1", 9090));
    boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
    boost::shared_ptr<TProtocol> 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;
}

/*
 * Main.cpp
 */


#include "../gen-cpp/SubscriberService.h"
#include "../gen-cpp/PublisherService.h"
#include <thrift/protocol/TBinaryProtocol.h>
#include <thrift/server/TSimpleServer.h>
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TServerSocket.h>
#include <thrift/transport/TBufferTransports.h>
#include <thrift/concurrency/ThreadManager.h>
#include <boost/thread/thread.hpp>

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<boost::shared_ptr<SubscriberServiceClient> > 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<TSocket> socket(new TSocket(param.ip, param.port));
    boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
    boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
    boost::shared_ptr<SubscriberServiceClient> 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<Snapshot> 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<boost::shared_ptr<SubscriberServiceClient> >::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<PublisherServiceHandler> handler(new PublisherServiceHandler());
    shared_ptr<TProcessor> processor(new PublisherServiceProcessor(handler));
    shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
    shared_ptr<TTransportFactory> transportFactory(
            new TBufferedTransportFactory());
    shared_ptr<TProtocolFactory> 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;
}