/*
* Class: com_wiesen_test_provider_MapDecodeJNI
* Method: decodeTileInfo
* Signature: (Ljava/lang/String;II)V
*/
void JNICALL Java_com_wiesen_test_provider_MapDecodeJNI_decodeTileInfo
(JNIEnv *env, jobject object, jstring path, jint start, jint length){
const char *j_path = env->GetStringUTFChars(path, 0);
std::ifstream file(j_path,std::ios::in|std::ios::binary);
char * tile_info = (char *) malloc(length);
if (!file){
return;
}
file.seekg(start,std::ios_base::beg);
file.read(tile_info,length);
file.close();
env->ReleaseStringUTFChars(path,j_path);
jclass clazz = env->GetObjectClass(object);
if (clazz == NULL){
MY_LOG_ERROR("clazz is null");
return;
}
jmethodID method_id = env->GetMethodID(clazz,"setTileInfo","([B)V");
if (method_id == NULL){
MY_LOG_ERROR("not found setTileInfo([B) method");
return;
}
jbyteArray bytes = env->NewByteArray(length);
env->SetByteArrayRegion(bytes, 0,length, (jbyte *) tile_info);
env->CallVoidMethod(object,method_id,bytes);
free(tile_info);
}
/*
* Class: com_wiesen_test_provider_MapDecodeJNI
* Method: getTileIndex
* Signature: (Ljava/lang/String;)V
*/
void JNICALL Java_com_wiesen_test_provider_MapDecodeJNI_getTileIndex
(JNIEnv *env, jobject object, jstring path){
const char *j_path = env->GetStringUTFChars(path, 0);
std::ifstream in(j_path,std::ios::in|std::ios::binary);
char *index = (char *) malloc(8 * 1024);
if (!in) {
MY_LOG_ERROR("file open error");
return;
}
in.seekg(0, std::ios_base::beg);
in.read(index, 8 * 1024);
in.close();
env->ReleaseStringUTFChars(path,j_path);
jclass clazz = env->GetObjectClass(object);
if (clazz == NULL){
MY_LOG_ERROR("clazz is null");
return;
}
jmethodID method_id = env->GetMethodID(clazz,"parseIndex","(Ljava/lang/String;)V");
if (method_id == NULL){
MY_LOG_ERROR("not found parseIndex(String) method");
return;
}
jstring index_str = env->NewStringUTF(index);
env->CallVoidMethod(object,method_id,index_str);
env->ReleaseStringUTFChars(index_str,index);
free(index);
}
IndexDB::IndexDB():m_mutex()
{
MY_LOG_DEBUG("IndexDB::IndexDB()");
const Conf & cf = Conf::get_instance();
m_conn = mysql_init(NULL);
if( m_conn == NULL)
{
MY_LOG_ERROR("IndexDB() mysql_init() %s", mysql_error(m_conn));
}
unsigned int port = (unsigned int)atoi( cf["sql_port"].c_str());
m_db = cf["sql_db"];
m_table = cf["sql_table"];
if( mysql_real_connect(
m_conn,
cf["sql_host"].c_str(),
cf["sql_usr"].c_str(),
cf["sql_passwd"].c_str(),
m_db.c_str(),
port,
NULL,
0 ) == NULL)
{
MY_LOG_ERROR("IndexDB() mysql_real_connect() %s ", mysql_error(m_conn));
}
std::string qstr = " select max(id) from ";
qstr += m_table;
if( mysql_real_query( m_conn, qstr.c_str(), qstr.size() ) )
{
MY_LOG_ERROR("IndexDB() mysql_real_query() %s : %s ", qstr.c_str(), mysql_error(m_conn));
}
MYSQL_RES * result = mysql_store_result( m_conn);
if( NULL == result )
{
MY_LOG_ERROR("IndexDB() mysql_store_result() %s ", mysql_error(m_conn));
}
else
{
MYSQL_ROW row;
while( (row = mysql_fetch_row( result)))
{
if( row[0] == NULL)
{
m_count =0;
}
else
{
m_count = strtoul( row[0] , NULL, 0) ;
}
}
}
mysql_free_result(result);
}
void MYCTPTradeInterface::OnRspQryInstrumentCommissionRate(CThostFtdcInstrumentCommissionRateField *pInstrumentCommissionRate,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
// 成功了
if (pRspInfo == NULL || pRspInfo->ErrorID == 0)
{
if (pInstrumentCommissionRate)
{
MY_LOG_INFO("OnRspQryInstrumentCommissionRate, InstrumentID: %s"
"; InvestorRange: %c"
"; BrokerID: %s"
"; InvestorID: %s"
"; OpenRatioByMoney: %.4f"
"; OpenRatioByVolume: %.4f"
"; CloseRatioByMoney: %.4f"
"; CloseRatioByVolume: %.4f"
"; CloseTodayRatioByMoney: %.4f"
"; CloseTodayRatioByVolume: %.4f",
pInstrumentCommissionRate->InstrumentID,
pInstrumentCommissionRate->InvestorRange,
pInstrumentCommissionRate->BrokerID,
pInstrumentCommissionRate->InvestorID,
pInstrumentCommissionRate->OpenRatioByMoney,
pInstrumentCommissionRate->OpenRatioByVolume,
pInstrumentCommissionRate->CloseRatioByMoney,
pInstrumentCommissionRate->CloseRatioByVolume,
pInstrumentCommissionRate->CloseTodayRatioByMoney,
pInstrumentCommissionRate->CloseTodayRatioByVolume
);
}
else
{
MY_LOG_ERROR("OnRspQryInstrumentCommissionRate, response info is null.");
}
}
else
{
MY_LOG_ERROR("OnRspQryInstrumentCommissionRate, ErrorID: %d; ErrorMsg: %s",
pRspInfo->ErrorID, pRspInfo->ErrorMsg);
}
// 查别的
if (bIsLast)
{
CThostFtdcQryInstrumentField instrument_struct;
memset(&instrument_struct, 0, sizeof(instrument_struct));
memcpy(instrument_struct.InstrumentID, "", strlen(""));
memcpy(instrument_struct.ExchangeID, "", strlen(""));
memcpy(instrument_struct.ExchangeInstID, "", strlen(""));
memcpy(instrument_struct.ProductID, "", strlen(""));
boost::this_thread::sleep(boost::posix_time::millisec(1000)); // 查询要间隔1s
int ret = p_trader_api_->ReqQryInstrument(&instrument_struct, ++nRequestID);
MY_LOG_INFO("ReqQryInstrument, return_code: %d", ret);
}
}
void Socket::set_nonblock()
{
int flag = fcntl( m_sockfd, F_GETFL,0);
if( flag <0 )
{
MY_LOG_ERROR("Socket::set_nonblock() error ");
}
flag |= O_NONBLOCK;
if( fcntl( m_sockfd, F_SETFL, flag) < 0)
{
MY_LOG_ERROR("Socket::set_nonblock() error ");
}
return ;
}
void Socket::bind( const InetAddress &addr)
{
if( -1 == ::bind(m_sockfd, (const struct sockaddr *)addr.get_sockaddr_in(), sizeof( addr )) )
{
MY_LOG_ERROR("Socket::bind() error ");
}
}
void MYPositionDataManager::InitPosition(
const std::string &code, char dir, VolumeType volume,int today_buy_volume,
int today_sell_volume,int yestoday_long_pos,char ex)
{
MY_LOG_DEBUG("MYPositionDataManager::InitPosition: %s, dir=%c, volume=%ld", code.c_str(), dir, volume);
if (volume != 0){
std::lock_guard < std::mutex > lock(mutex_pos_);
PositionDataOfCode::iterator it = pos_datas_.find(code);
if (it == pos_datas_.end()){
it = pos_datas_.insert(std::make_pair(code, PositionInfoInEX())).first;
}
MY_LOG_DEBUG("before InitPosition (%s): long=%d, short=%d",
code.c_str(), it->second.long_position, it->second.short_position);
it->second.exchange = ex;
if (dir == BUSSINESS_DEF::ENTRUST_BUY){
it->second.long_position += volume;
it->second.today_buy_volume += today_buy_volume;
it->second.today_sell_volume += today_sell_volume;
it->second.long_pos_yd += yestoday_long_pos;
}else if (dir == BUSSINESS_DEF::ENTRUST_SELL){
it->second.short_position += volume;
}else{
MY_LOG_ERROR("MYPositionDataManager::InitPosition goto wrong branch");
}
MY_LOG_DEBUG("after InitPosition, pos(%s): l=%d,s=%d",
code.c_str(),it->second.long_position, it->second.short_position);
}
}
bool FileMgr::add_page( const Page & page , IndexEntry & idx)
{
MY_LOG_DEBUG("FileMgr::add_page() %ld", page.m_id);
MutexGuard guard(m_mutex);
m_fileStream[m_lastFileNum].seekp(0, std::ios::end);
size_t off1 = m_fileStream[m_lastFileNum].tellp();
m_fileStream[m_lastFileNum] << page;
size_t off2 = m_fileStream[m_lastFileNum].tellp();
idx.m_offset = off1;
idx.m_length = off2 - off1;
std::string hash = page.get_hash();
memcpy( (void *) idx.m_contenthash, (const void*)hash.c_str(), hash.size());
idx.m_filenum = m_lastFileNum;
if( !m_fileStream[m_lastFileNum])
{
MY_LOG_ERROR("fstream error file num: %d ", m_lastFileNum);
return false;
}
MY_LOG_DEBUG("FileMgr::add_page() pageid=%ld hash=%s", page.m_id, idx.hash_to_hex_string().c_str());
return true;
}
void Socket::shut_down_write()
{
if( -1 == ::shutdown(m_sockfd, SHUT_WR))
{
MY_LOG_ERROR("Socket::shut_down_write() error ");
}
}
void Socket::listen()
{
if( -1 == ::listen( m_sockfd, SOMAXCONN))
{
MY_LOG_ERROR("Socket::listen() error ");
}
}
void Socket::set_keep_alive(bool on)
{
int optval = on? 1:0;
int ret = setsockopt( m_sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, static_cast<socklen_t>( sizeof(optval))) ;
if(ret == -1 )
{
MY_LOG_ERROR("Soccket::set_keep_alive() error ");
}
}
void Socket::set_reuse_port(bool on)
{
int optval = on? 1:0;
int ret = setsockopt( m_sockfd, SOL_SOCKET, SO_REUSEPORT, &optval, static_cast<socklen_t>( sizeof(optval))) ;
if(ret == -1 )
{
MY_LOG_ERROR("Socket::set_reuse_port() error ");
}
}
void Socket::set_tcp_no_delay(bool on)
{
int optval = on? 1:0;
int ret = setsockopt( m_sockfd, IPPROTO_TCP, TCP_NODELAY, &optval, static_cast< socklen_t>(sizeof( optval)));
if( ret == -1 )
{
MY_LOG_ERROR("Socket::set_tcp_no_delay() error ");
}
}
void MYCTPTradeInterface::OnRspQryBrokerTradingParams(CThostFtdcBrokerTradingParamsField *pBrokerTradingParams,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
// 成功了
if (pRspInfo == NULL || pRspInfo->ErrorID == 0)
{
if (pBrokerTradingParams)
{
MY_LOG_INFO("OnRspQryBrokerTradingParams, BrokerID: %s"
"; InvestorID: %s"
"; MarginPriceType: %c"
"; Algorithm: %c"
"; AvailIncludeCloseProfit: %c",
pBrokerTradingParams->BrokerID,
pBrokerTradingParams->InvestorID,
pBrokerTradingParams->MarginPriceType,
pBrokerTradingParams->Algorithm,
pBrokerTradingParams->AvailIncludeCloseProfit
);
}
else
{
MY_LOG_ERROR("OnRspQryBrokerTradingParams, response info is null.");
}
}
else
{
MY_LOG_ERROR("OnRspQryBrokerTradingParams, ErrorID: %d; ErrorMsg: %s",
pRspInfo->ErrorID, pRspInfo->ErrorMsg);
}
// 处理完毕，登出，节约交易连接数
CThostFtdcUserLogoutField user_logout;
memset(&user_logout, 0, sizeof(user_logout));
memcpy(user_logout.BrokerID, broker_id_, strlen(broker_id_));
memcpy(user_logout.UserID, user_, strlen(user_));
// 发出登出请求
boost::this_thread::sleep(boost::posix_time::millisec(1000)); // 间隔1s
int ret = p_trader_api_->ReqUserLogout(&user_logout, ++nRequestID);
MY_LOG_INFO("ReqUserLogout, return_code: %d", ret);
}
void QuoteInterface_TDF::InitOpenSetting(TDF_OPEN_SETTING *settings, const ConfigData &cfg)
{
if (cfg.Logon_config().quote_provider_addrs.empty())
{
MY_LOG_ERROR("TDF - quote provider's address is empty");
return;
}
// tcp://192.168.60.23:7120
const std::string &addr_cfg = cfg.Logon_config().quote_provider_addrs.front();
std::string ip_port = addr_cfg.substr(6);
std::size_t split_pos = ip_port.find(":");
if ((split_pos == std::string::npos) || (split_pos + 1 >= ip_port.length()))
{
MY_LOG_ERROR("TDF - parse quote provider's address error: %s", addr_cfg.c_str());
}
MY_LOG_DEBUG("ip_port: %s", ip_port.c_str());
std::string addr_ip = ip_port.substr(0, split_pos);
std::string addr_port = ip_port.substr(split_pos + 1);
//MY_LOG_DEBUG("ip: %s, port: %s, user: %s, pw: %s", addr_ip.c_str(), addr_port.c_str(), cfg.Logon_config().account.c_str(), cfg.Logon_config().password.c_str());
//MY_LOG_DEBUG("subscriptions: %s", DeepCopy(FormatSubscribString(cfg.Subscribe_datas()).c_str()));
memset(settings, 0, sizeof(TDF_OPEN_SETTING));
strncpy(settings->szIp, addr_ip.c_str(), sizeof(settings->szIp) - 1);
strncpy(settings->szPort, addr_port.c_str(), sizeof(settings->szPort) - 1);
strncpy(settings->szUser, cfg.Logon_config().account.c_str(), sizeof(settings->szUser) - 1);
strncpy(settings->szPwd, cfg.Logon_config().password.c_str(), sizeof(settings->szPwd) - 1);
settings->pfnMsgHandler = &QuoteInterface_TDF::QuoteDataHandler;
settings->pfnSysMsgNotify = &QuoteInterface_TDF::SystemMsgHandler;
settings->szMarkets = DeepCopy("SZ-2;SH-2;"); // subscibe two market
settings->szSubScriptions = DeepCopy(FormatSubscribString(cfg.Subscribe_datas()).c_str());
settings->nTime = 0;
settings->nTypeFlags = DATA_TYPE_TRANSACTION | DATA_TYPE_ORDER | DATA_TYPE_ORDERQUEUE;
}
FileMgr::FileMgr( const std::string & file ) : m_mutex()
{
MY_LOG_DEBUG("FileMgr() %s", file.c_str());
m_lastFileNum = 0;
m_fileStream[ m_lastFileNum ].open( file , std::ios::in | std::ios::out | std::ios::binary );
if( !m_fileStream)
{
MY_LOG_ERROR("FileMgr::FileMgr() m_fileStream error");
}
}
InetAddress::InetAddress( const std::string &ip, unsigned short port)
{
// MY_LOG_DEBUG("InetAddress::InetAddress() ip: %s, port= %d " ,ip.c_str(), port);
memset(&m_addr, 0, sizeof( m_addr));
m_addr.sin_family = AF_INET;
m_addr.sin_port = htons(port);
if( inet_aton( ip.c_str(), & m_addr.sin_addr )==0)
{
MY_LOG_ERROR(" ip invalid ");
}
}
void MYCTPTradeInterface::OnRspUserLogout(CThostFtdcUserLogoutField *pUserLogout,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
if (pRspInfo == NULL || pRspInfo->ErrorID == 0)
{
MY_LOG_INFO("CTP-Trade - OnRspUserLogout success.");
securities_get_finished = true;
}
else
{
MY_LOG_ERROR("CTP-Trade - OnRspUserLogout, ErrorID: %d; ErrorMsg: %s",
pRspInfo->ErrorID, pRspInfo->ErrorMsg);
}
}
QuoteInterface_TDF::QuoteInterface_TDF(const SubscribeContracts* subscribe_contracts, const ConfigData& cfg)
: cfg_(cfg), p_stock_md_save_(NULL), p_stock_idx_save_(NULL)
{
if (subscribe_contracts)
{
subscribe_contracts_ = *subscribe_contracts;
}
InitErrorMap();
sprintf(qtm_name_, "tdf_%s_%u", cfg.Logon_config().account.c_str(), getpid());
QuoteUpdateState(qtm_name_, QtmState::INIT);
// create save object
p_stock_md_save_ = new QuoteDataSave<TDF_MARKET_DATA_MY>(cfg_, qtm_name_, "tdf_market_data", TDF_STOCK_QUOTE_TYPE);
p_stock_idx_save_ = new QuoteDataSave<TDF_INDEX_DATA_MY>(cfg_, qtm_name_, "tdf_index_data", TDF_INDEX_QUOTE_TYPE);
p_stock_oq_save_ = new QuoteDataSave<T_OrderQueue>(cfg_, qtm_name_, "order_queue_data", KMDS_ORDER_QUEUE_TYPE);
p_stock_pe_save_ = new QuoteDataSave<T_PerEntrust>(cfg_, qtm_name_, "per_entrust_data", KMDS_PER_ENTRUST_TYPE);
p_stock_pb_save_ = new QuoteDataSave<T_PerBargain>(cfg_, qtm_name_, "per_bargain_data", KMDS_PER_BARGAIN_TYPE);
s_p_stock_md_save = p_stock_md_save_;
s_p_stock_idx_save = p_stock_idx_save_;
s_p_stock_oq_save = p_stock_oq_save_;
s_p_stock_pe_save = p_stock_pe_save_;
s_p_stock_pb_save = p_stock_pb_save_;
// environment settings
//TDF_SetEnv(TDF_ENVIRON_HEART_BEAT_INTERVAL, 10);
//TDF_SetEnv(TDF_ENVIRON_MISSED_BEART_COUNT, 2);
//TDF_SetEnv(TDF_ENVIRON_OPEN_TIME_OUT, 30);
// quote connection settings
open_settings = new TDF_OPEN_SETTING();
InitOpenSetting(open_settings, cfg);
TDF_ERR nErr = TDF_ERR_SUCCESS;
g_hTDF = TDF_Open(open_settings, &nErr);
// try till open success
while (nErr == TDF_ERR_NETWORK_ERROR || g_hTDF == NULL)
{
MY_LOG_ERROR("TDF_Open returned: %s; try again.", GetErrStr(nErr));
QuoteUpdateState(qtm_name_, QtmState::CONNECT_FAIL);
sleep(3);
g_hTDF = TDF_Open(open_settings, &nErr);
}
MY_LOG_INFO("TDF_Open success.");
QuoteUpdateState(qtm_name_, QtmState::CONNECT_SUCCESS);
QuoteUpdateState(qtm_name_, QtmState::API_READY);
}
PageDB::PageDB( const std::string & datafile, const std::string & indexfile): m_update(false), m_fileMgr( datafile)
{
MY_LOG_DEBUG("PageDB::PageDB()");
const Conf & cf = Conf::get_instance();
if( cf["pagedbidx_use_db"] == "yes")
{
m_indexer.reset(new IndexDB());
if(!m_indexer)
{
MY_LOG_ERROR( "PageDB::PageDB() new IndexDB() error ");
}
}
else
{
m_indexer.reset(new IndexFile( indexfile ));
if( !m_indexer)
{
MY_LOG_ERROR( "PageDB::PageDB() new IndexFile() error ");
}
}
}
void MYCTPTradeInterface::OnRspQryInstrumentMarginRate(CThostFtdcInstrumentMarginRateField *pInstrumentMarginRate,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
// 成功了
if (pRspInfo == NULL || pRspInfo->ErrorID == 0)
{
if (pInstrumentMarginRate)
{
MY_LOG_INFO("OnRspQryInstrumentMarginRate, InstrumentID: %s; "
"InvestorRange: %c; BrokerID: %s; InvestorID: %s; HedgeFlag: %c; "
"LongMarginRatioByMoney: %.4f; LongMarginRatioByVolume: %.4f; "
"ShortMarginRatioByMoney: %.4f; ShortMarginRatioByVolume: %.4f; IsRelative: %d",
pInstrumentMarginRate->InstrumentID,
pInstrumentMarginRate->InvestorRange,
pInstrumentMarginRate->BrokerID,
pInstrumentMarginRate->InvestorID,
pInstrumentMarginRate->HedgeFlag,
pInstrumentMarginRate->LongMarginRatioByMoney,
pInstrumentMarginRate->LongMarginRatioByVolume,
pInstrumentMarginRate->ShortMarginRatioByMoney,
pInstrumentMarginRate->ShortMarginRatioByVolume,
pInstrumentMarginRate->IsRelative
);
}
else
{
MY_LOG_INFO("OnRspQryInstrumentMarginRate, response info is null.");
}
}
else
{
MY_LOG_ERROR("OnRspQryInstrumentMarginRate, ErrorID: %d; ErrorMsg: %s",
pRspInfo->ErrorID, pRspInfo->ErrorMsg);
}
// 查别的
if (bIsLast)
{
CThostFtdcQryInstrumentCommissionRateField instrument_commission_rate;
memset(&instrument_commission_rate, 0, sizeof(instrument_commission_rate));
memcpy(instrument_commission_rate.BrokerID, broker_id_, strlen(broker_id_));
memcpy(instrument_commission_rate.InvestorID, user_, strlen(user_));
memcpy(instrument_commission_rate.InstrumentID, "", strlen(""));
boost::this_thread::sleep(boost::posix_time::millisec(1000)); // 查询要间隔1s
int ret = p_trader_api_->ReqQryInstrumentCommissionRate(&instrument_commission_rate, ++nRequestID);
MY_LOG_INFO("ReqQryInstrumentCommissionRate, return_code: %d", ret);
}
}
void MYCTPTradeInterface::OnRspQryTradingCode(CThostFtdcTradingCodeField *pTradingCode,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
// 成功了
if (pRspInfo == NULL || pRspInfo->ErrorID == 0)
{
if (pTradingCode)
{
MY_LOG_INFO("OnRspQryTradingCode, InvestorID: %s; BrokerID: %s; ExchangeID: %s; ClientID: %s; ClientIDType: %c",
pTradingCode->InvestorID,
pTradingCode->BrokerID,
pTradingCode->ExchangeID,
pTradingCode->ClientID,
pTradingCode->ClientIDType
);
}
else
{
MY_LOG_INFO("OnRspQryTradingCode, response info is null.");
}
}
else
{
MY_LOG_ERROR("OnRspQryTradingCode, ErrorID: %d; ErrorMsg: %s",
pRspInfo->ErrorID, pRspInfo->ErrorMsg);
}
// 查别的
if (bIsLast)
{
CThostFtdcQryInstrumentMarginRateField instrument_margin_rate;
memset(&instrument_margin_rate, 0, sizeof(instrument_margin_rate));
memcpy(instrument_margin_rate.BrokerID, broker_id_, strlen(broker_id_));
memcpy(instrument_margin_rate.InvestorID, user_, strlen(user_));
memcpy(instrument_margin_rate.InstrumentID, "", strlen(""));
instrument_margin_rate.HedgeFlag = THOST_FTDC_CIDT_Speculation;
boost::this_thread::sleep(boost::posix_time::millisec(1000)); // 查询要间隔1s
int ret = p_trader_api_->ReqQryInstrumentMarginRate(&instrument_margin_rate, ++nRequestID);
MY_LOG_INFO("ReqQryInstrumentMarginRate, return_code: %d", ret);
}
}
void MYCTPTradeInterface::OnRspUserLogin(CThostFtdcRspUserLoginField *pRspUserLogin,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
// 登陆了，则查查信息
if (pRspInfo == NULL || pRspInfo->ErrorID == 0)
{
MY_LOG_INFO("CTP-Trade - OnRspUserLogin success.");
}
else
{
MY_LOG_ERROR("CTP-Trade - OnRspUserLogin, ErrorID: %d; ErrorMsg: %s",
pRspInfo->ErrorID, pRspInfo->ErrorMsg);
// 登录失败，不断重试
boost::this_thread::sleep(boost::posix_time::millisec(1000)); // 查询要间隔1s
CThostFtdcReqUserLoginField user_logon;
memset(&user_logon, 0, sizeof(user_logon));
memcpy(user_logon.BrokerID, broker_id_, strlen(broker_id_));
memcpy(user_logon.UserID, user_, strlen(user_));
memcpy(user_logon.Password, password_, strlen(password_));
// 发出登陆请求
p_trader_api_->ReqUserLogin(&user_logon, 1);
}
if (bIsLast)
{
// 查询交易编码
CThostFtdcQryTradingCodeField qry_trading_code;
memset(&qry_trading_code, 0, sizeof(qry_trading_code));
memcpy(qry_trading_code.BrokerID, broker_id_, strlen(broker_id_));
memcpy(qry_trading_code.InvestorID, user_, strlen(user_));
memcpy(qry_trading_code.ExchangeID, "", strlen(""));
memcpy(qry_trading_code.ClientID, user_, strlen(user_));
qry_trading_code.ClientIDType = THOST_FTDC_CIDT_Speculation;
boost::this_thread::sleep(boost::posix_time::millisec(1000)); // 查询要间隔1s
int ret = p_trader_api_->ReqQryTradingCode(&qry_trading_code, ++nRequestID);
MY_LOG_INFO("CTP-Trade - ReqQryTradingCode, return_code: %d", ret);
}
}
bool FileMgr::get_page( const IndexEntry & idx, Page & page )
{
MY_LOG_DEBUG("FileMgr::get_page() %ld", idx.m_id);
MutexGuard guard(m_mutex);
int num = idx.m_filenum;
if( num <= m_lastFileNum && num >=0 )
{
std::unique_ptr<char> p( new char [ idx.m_length] );
if( !p )
{
MY_LOG_ERROR("unique_ptr");
}
m_fileStream[num].clear();
m_fileStream[num].seekg( idx.m_offset , std::ios::beg);
m_fileStream[num].read( p.get(), idx.m_length );
if( m_fileStream[num])
{
std::string tmp( p.get(), idx.m_length );
Page pg(tmp);
std::string hash = pg.get_hash();
if( 0 == memcmp( idx.m_contenthash, hash.c_str(), hash.size() ))
{
page = pg;
return true;
}
IndexEntry idx2;
memcpy((void *)idx.m_contenthash, (const void *)hash.c_str(), hash.size());
std::string hashstr1 = idx.hash_to_hex_string();
std::string hashstr2 = idx2.hash_to_hex_string();
MY_LOG_INFO("FileMgr::get_page() %ld hash not match {hash1:%s hash2:%s}, tmp={%s}\npage.m_content={%s}", idx.m_id, hashstr1.c_str(), hashstr2.c_str(), tmp.c_str(), page.m_content.c_str());
}
}
MY_LOG_DEBUG("FileMgr::get_page() %lu failed!", idx.m_id);
return false;
}
void MYCTPTradeInterface::OnRspQryInstrument(CThostFtdcInstrumentField *pInstrument,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
// 成功了
if (pRspInfo == NULL || pRspInfo->ErrorID == 0)
{
if (pInstrument)
{
MY_LOG_INFO("OnRspQryInstrument, InstrumentID: %s"
"; ExchangeID: %s"
"; InstrumentName: %s"
"; ExchangeInstID: %s"
"; ProductID: %s"
"; ProductClass: %c"
"; DeliveryYear: %08d"
"; DeliveryMonth: %02d"
"; MaxMarketOrderVolume: %d"
"; MinMarketOrderVolume: %d"
"; MaxLimitOrderVolume: %d"
"; MinLimitOrderVolume: %d"
"; VolumeMultiple: %d"
"; PriceTick: %0.4f"
"; CreateDate: %s"
"; OpenDate: %s"
"; ExpireDate: %s"
"; StartDelivDate: %s"
"; EndDelivDate: %s"
"; InstLifePhase: %c"
"; IsTrading: %d"
"; PositionType: %c"
"; PositionDateType: %c"
"; LongMarginRatio: %0.4f"
"; ShortMarginRatio: %.4f",
pInstrument->InstrumentID,
pInstrument->ExchangeID,
pInstrument->InstrumentName,
pInstrument->ExchangeInstID,
pInstrument->ProductID,
pInstrument->ProductClass,
pInstrument->DeliveryYear,
pInstrument->DeliveryMonth,
pInstrument->MaxMarketOrderVolume,
pInstrument->MinMarketOrderVolume,
pInstrument->MaxLimitOrderVolume,
pInstrument->MinLimitOrderVolume,
pInstrument->VolumeMultiple,
pInstrument->PriceTick,
pInstrument->CreateDate,
pInstrument->OpenDate,
pInstrument->ExpireDate,
pInstrument->StartDelivDate,
pInstrument->EndDelivDate,
pInstrument->InstLifePhase,
pInstrument->IsTrading,
pInstrument->PositionType,
pInstrument->PositionDateType,
InvalidToZeroD(pInstrument->LongMarginRatio),
InvalidToZeroD(pInstrument->ShortMarginRatio)
);
securities_exchcode.insert(std::make_pair(pInstrument->InstrumentID, ExchNameToExchCode(pInstrument->ExchangeID)));
securities_volumn_multiple.insert(std::make_pair(pInstrument->InstrumentID, pInstrument->VolumeMultiple));
securities_tickprice.insert(std::make_pair(pInstrument->InstrumentID, pInstrument->PriceTick));
}
else
{
MY_LOG_ERROR("OnRspQryInstrument, response info is null.");
}
}
else
{
MY_LOG_ERROR("OnRspQryInstrument, ErrorID: %d; ErrorMsg: %s",
pRspInfo->ErrorID, pRspInfo->ErrorMsg);
}
// 查别的
if (bIsLast)
{
MY_LOG_INFO("OnRspQryInstrument, task finished.");
CThostFtdcQryBrokerTradingParamsField broker_param;
memset(&broker_param, 0, sizeof(broker_param));
memcpy(broker_param.BrokerID, broker_id_, strlen(broker_id_));
memcpy(broker_param.InvestorID, user_, strlen(user_));
boost::this_thread::sleep(boost::posix_time::millisec(1000)); // 查询要间隔1s
int ret = p_trader_api_->ReqQryBrokerTradingParams(&broker_param, ++nRequestID);
MY_LOG_INFO("ReqQryBrokerTradingParams, return_code: %d", ret);
}
}
//系统消息回调，用于通知用户收到了网络断开事件、连接（重连）结果、代码表结果等。
//当获取系统消息时，pMsgHead->pAppHead指针为空,
//pMsgHead->pData指向相应的结构体
void QuoteInterface_TDF::SystemMsgHandler(THANDLE hTdf, TDF_MSG* pMsgHead)
{
if (!pMsgHead || !hTdf)
{
return;
}
switch (pMsgHead->nDataType)
{
case MSG_SYS_DISCONNECT_NETWORK:
{
MY_LOG_INFO("network disconnected.");
QuoteUpdateState(qtm_name_, QtmState::DISCONNECT);
}
break;
case MSG_SYS_CONNECT_RESULT:
{
TDF_CONNECT_RESULT* pConnResult = (TDF_CONNECT_RESULT*) pMsgHead->pData;
if (pConnResult && pConnResult->nConnResult)
{
MY_LOG_INFO("TDF - connect success.");
QuoteUpdateState(qtm_name_, QtmState::CONNECT_SUCCESS);
}
else
{
MY_LOG_ERROR("TDF - connect failed.");
QuoteUpdateState(qtm_name_, QtmState::CONNECT_FAIL);
}
}
break;
case MSG_SYS_LOGIN_RESULT:
{
TDF_LOGIN_RESULT* pLoginResult = (TDF_LOGIN_RESULT*) pMsgHead->pData;
if (pLoginResult && pLoginResult->nLoginResult)
{
MY_LOG_INFO("TDF - login success.");
QuoteUpdateState(qtm_name_, QtmState::LOG_ON_SUCCESS);
for (int i = 0; i < pLoginResult->nMarkets; i++)
{
MY_LOG_INFO("market: %s, dyn_date: %d", pLoginResult->szMarket[i], pLoginResult->nDynDate[i]);
}
}
else
{
MY_LOG_ERROR("TDF - login failed.");
QuoteUpdateState(qtm_name_, QtmState::LOG_ON_FAIL);
}
}
break;
case MSG_SYS_CODETABLE_RESULT:
{
TDF_CODE_RESULT* pCodeResult = (TDF_CODE_RESULT*) pMsgHead->pData;
MY_LOG_INFO("code table: %s; market count: %d", pCodeResult->szInfo, pCodeResult->nMarkets);
for (int i = 0; i < pCodeResult->nMarkets; i++)
{
MY_LOG_INFO("market: %s; items: %d; date: %d", pCodeResult->szMarket[i], pCodeResult->nCodeCount[i],
pCodeResult->nCodeDate[i]);
//获取代码表
TDF_CODE* pCodeTable;
unsigned int nItems;
TDF_GetCodeTable(hTdf, pCodeResult->szMarket[i], &pCodeTable, &nItems);
for (unsigned int i = 0; i < nItems; i++)
{
TDF_CODE& code = pCodeTable[i];
MY_LOG_INFO("code: %s; market: %s; type: %d", code.szCode, code.szMarket, code.nType);
}
TDF_FreeArr(pCodeTable);
}
}
break;
case MSG_SYS_QUOTATIONDATE_CHANGE:
{
TDF_QUOTATIONDATE_CHANGE* pChange = (TDF_QUOTATIONDATE_CHANGE*) pMsgHead->pData;
if (pChange)
{
MY_LOG_INFO("date changed, prepare reconnect.");
}
}
break;
case MSG_SYS_MARKET_CLOSE:
{
TDF_MARKET_CLOSE* pCloseInfo = (TDF_MARKET_CLOSE*) pMsgHead->pData;
if (pCloseInfo)
{
MY_LOG_INFO("close market: %s; time: %d", pCloseInfo->szMarket, pCloseInfo->nTime);
}
}
break;
case MSG_SYS_HEART_BEAT:
{
MY_LOG_INFO("TDF - heart beat.");
}
break;
default:
break;
}
}
//数据回调，用于通知用户收到了行情、逐笔成交，逐笔委托，委托队列等
//pMsgHead->pAppHead->ItemCount字段可以获知得到了多少条记录
//pMsgHead->pAppHead->pData指向第一条数据记录
void QuoteInterface_TDF::QuoteDataHandler(THANDLE hTdf, TDF_MSG* pMsgHead)
{
if (!pMsgHead || !pMsgHead->pData)
{
MY_LOG_ERROR("QuoteDataHandler receive null data.");
return;
}
unsigned int nItemCount = pMsgHead->pAppHead->nItemCount;
if (!nItemCount)
{
MY_LOG_ERROR("QuoteDataHandler receive data, count is 0.");
return;
}
//MY_LOG_DEBUG("QuoteDataHandler receive data, DataType: %d", pMsgHead->nDataType);
switch (pMsgHead->nDataType)
{
case MSG_DATA_MARKET:
{
TDF_MARKET_DATA *p = (TDF_MARKET_DATA*) pMsgHead->pData;
timeval t;
gettimeofday(&t, NULL);
for (unsigned int i = 0; i < nItemCount; ++i)
{
TDF_MARKET_DATA_MY tdf_my = Convert(*p);
if (md_data_handler_
&& (subscribe_contracts_.empty() || subscribe_contracts_.find(p->szCode) != subscribe_contracts_.end()))
{
md_data_handler_(&tdf_my);
}
// 存起来
s_p_stock_md_save->OnQuoteData(t.tv_sec * 1000000 + t.tv_usec, &tdf_my);
++p;
}
}
break;
case MSG_DATA_INDEX:
{
TDF_INDEX_DATA *p = (TDF_INDEX_DATA*) pMsgHead->pData;
timeval t;
gettimeofday(&t, NULL);
for (unsigned int i = 0; i < nItemCount; ++i)
{
TDF_INDEX_DATA_MY tdf_my = Convert(*p);
if (id_data_handler_
&& (subscribe_contracts_.empty() || subscribe_contracts_.find(p->szCode) != subscribe_contracts_.end()))
{
id_data_handler_(&tdf_my);
}
// 存起来
s_p_stock_idx_save->OnQuoteData(t.tv_sec * 1000000 + t.tv_usec, &tdf_my);
++p;
}
}
break;
case MSG_DATA_ORDERQUEUE:
{
TDF_ORDER_QUEUE *p = (TDF_ORDER_QUEUE*)pMsgHead->pData;
timeval t;
gettimeofday(&t, NULL);
for (unsigned int i = 0; i < nItemCount; ++i)
{
T_OrderQueue tdf_my = Convert(*p);
if (order_queue_handler_
&& (subscribe_contracts_.empty() || subscribe_contracts_.find(p->szCode) != subscribe_contracts_.end()))
{
order_queue_handler_(&tdf_my);
}
// 存起来
s_p_stock_oq_save->OnQuoteData(t.tv_sec * 1000000 + t.tv_usec, &tdf_my);
++p;
}
}
break;
case MSG_DATA_ORDER:
{
TDF_ORDER *p = (TDF_ORDER*)pMsgHead->pData;
timeval t;
gettimeofday(&t, NULL);
for (unsigned int i = 0; i < nItemCount; ++i)
{
T_PerEntrust tdf_my = Convert(*p);
if (perentrust_handler_
&& (subscribe_contracts_.empty() || subscribe_contracts_.find(p->szCode) != subscribe_contracts_.end()))
{
perentrust_handler_(&tdf_my);
}
// 存起来
s_p_stock_pe_save->OnQuoteData(t.tv_sec * 1000000 + t.tv_usec, &tdf_my);
++p;
}
}
break;
case MSG_DATA_TRANSACTION:
{
TDF_TRANSACTION *p = (TDF_TRANSACTION*)pMsgHead->pData;
timeval t;
gettimeofday(&t, NULL);
for (unsigned int i = 0; i < nItemCount; ++i)
{
T_PerBargain tdf_my = Convert(*p);
if (perbargain_handler_
&& (subscribe_contracts_.empty() || subscribe_contracts_.find(p->szCode) != subscribe_contracts_.end()))
{
perbargain_handler_(&tdf_my);
}
// 存起来
s_p_stock_pb_save->OnQuoteData(t.tv_sec * 1000000 + t.tv_usec, &tdf_my);
++p;
}
}
break;
default:
break;
}
}
