#include "bh_api.h"
|
#include <stdlib.h>
|
#include <string.h>
|
#include "proto/bhome_msg.pb.h"
|
#include "proto/bhome_msg_api.pb.h"
|
|
using namespace bhome_msg;
|
|
int BHRegister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
|
{
|
//反序列化入参
|
ProcInfo input;
|
if(!input.ParseFromArray(proc_info,proc_info_len))
|
return false;
|
struct _ProcInfo
|
{
|
const char *proc_id;
|
const char *name;
|
const char *public_info;
|
const char *private_info;
|
}_input;
|
_input.proc_id=input.proc_id().c_str();
|
_input.name=input.name().c_str();
|
_input.public_info=input.public_info().c_str();
|
_input.private_info=input.private_info().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_Register(&_input,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgCommonReply mcr;
|
mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mcr.mutable_errmsg()->set_errstring(errString);
|
*reply_len=mcr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mcr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
int BHUnregister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
|
{
|
//反序列化入参
|
ProcInfo input;
|
if(!input.ParseFromArray(proc_info,proc_info_len))
|
return false;
|
struct _ProcInfo
|
{
|
const char *proc_id;
|
const char *name;
|
const char *public_info;
|
const char *private_info;
|
}_input;
|
_input.proc_id=input.proc_id().c_str();
|
_input.name=input.name().c_str();
|
_input.public_info=input.public_info().c_str();
|
_input.private_info=input.private_info().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_UnRegister(&_input,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgCommonReply mcr;
|
mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mcr.mutable_errmsg()->set_errstring(errString);
|
*reply_len=mcr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mcr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHHeartbeatEasy(const int timeout_ms)
|
{
|
bool Rel=true;
|
//Rel=call_HeartbeatEasy(timeout_ms);//这句是功能的具体实现
|
return Rel;
|
}
|
|
int BHHeartbeat(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
|
{
|
//反序列化入参
|
ProcInfo input;
|
if(!input.ParseFromArray(proc_info,proc_info_len))
|
return false;
|
struct _ProcInfo
|
{
|
const char *proc_id;
|
const char *name;
|
const char *public_info;
|
const char *private_info;
|
}_input;
|
_input.proc_id=input.proc_id().c_str();
|
_input.name=input.name().c_str();
|
_input.public_info=input.public_info().c_str();
|
_input.private_info=input.private_info().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_Heartbeat(&_input,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgCommonReply mcr;
|
mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mcr.mutable_errmsg()->set_errstring(errString);
|
*reply_len=mcr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mcr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHRegisterTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
|
{
|
//反序列化入参
|
MsgTopicList input;
|
if(!input.ParseFromArray(topics,topics_len))
|
return false;
|
struct _MsgTopicList
|
{
|
int amount;
|
const char *topics[128];
|
}_input;
|
_input.amount=input.topic_list_size();
|
for(int i=0;i<_input.amount;i++)
|
_input.topics[i]=input.topic_list(i).c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_RegisterTopics(&_input,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgCommonReply mcr;
|
mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mcr.mutable_errmsg()->set_errstring(errString);
|
*reply_len=mcr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mcr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHQueryTopicAddress(const void *remote, const int remote_len,
|
const void *topic, const int topic_len,
|
void **reply, int *reply_len,
|
const int timeout_ms)
|
{
|
//反序列化入参
|
BHAddress input0;
|
MsgQueryTopic input1;
|
if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(topic,topic_len))
|
return false;
|
struct _BHAddress
|
{
|
unsigned long long mq_id;
|
long long abs_addr;
|
const char *ip;
|
int port;
|
}_input0;
|
const char *_input1;
|
_input0.mq_id=input0.mq_id();
|
_input0.abs_addr=input0.abs_addr();
|
_input0.ip=input0.ip().c_str();
|
_input0.port=input0.port();
|
_input1=input1.topic().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//此种以固定结构返回数据的方式,只能暂时固定数量上限。这里限制最多128个
|
//若不限数量,需重新设计数据返回的方式
|
struct _MsgQueryTopicReply
|
{
|
std::string proc_id;
|
|
unsigned long long mq_id;
|
long long abs_addr;
|
std::string ip;
|
int port;
|
}mtr_list[128];
|
int mtr_list_num=0;//实际在mtr_list中填写了多少个项目
|
//errCode=call_QueryTopicAddress(&_input0,_input1,mtr_list,&mtr_list_num,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgQueryTopicReply mtr;
|
mtr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mtr.mutable_errmsg()->set_errstring(errString);
|
for(int i=0;i<mtr_list_num;i++)
|
{
|
MsgQueryTopicReply_BHNodeAddress *mtrb=mtr.add_node_address();
|
mtrb->set_proc_id(mtr_list[i].proc_id);
|
mtrb->mutable_addr()->set_mq_id(mtr_list[i].mq_id);
|
mtrb->mutable_addr()->set_abs_addr(mtr_list[i].abs_addr);
|
mtrb->mutable_addr()->set_ip(mtr_list[i].ip);
|
mtrb->mutable_addr()->set_port(mtr_list[i].port);
|
}
|
*reply_len=mtr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mtr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHQueryProcs(const void *remote,
|
const int remote_len,
|
const void *query,
|
const int query_len,
|
void **reply,
|
int *reply_len,
|
const int timeout_ms)
|
{
|
//反序列化入参
|
BHAddress input0;
|
MsgQueryProc input1;
|
if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(query,query_len))
|
return false;
|
struct _BHAddress
|
{
|
unsigned long long mq_id;
|
long long abs_addr;
|
const char *ip;
|
int port;
|
}_input0;
|
const char *_input1;
|
_input0.mq_id=input0.mq_id();
|
_input0.abs_addr=input0.abs_addr();
|
_input0.ip=input0.ip().c_str();
|
_input0.port=input0.port();
|
_input1=input1.proc_id().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//此种以固定结构返回数据的方式,只能暂时固定数量上限。这里限制最多128个client,每个client最多128个topic
|
//若不限数量,需重新设计数据返回的方式
|
struct _MsgQueryProcReply
|
{
|
std::string proc_id;
|
std::string name;
|
std::string public_info;
|
std::string private_info;
|
|
bool online;
|
|
std::string topic_list[128];
|
int topic_list_num;//实际在topic_list中填写了多少个项目
|
}mpr_list[128];
|
int mpr_list_num=0;//实际在mpr_list中填写了多少个项目
|
//errCode=call_QueryProcs(&_input0,_input1,mpr_list,&mpr_list_num,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgQueryProcReply mpr;
|
mpr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mpr.mutable_errmsg()->set_errstring(errString);
|
for(int i=0;i<mpr_list_num;i++)
|
{
|
MsgQueryProcReply_Info *mpri=mpr.add_proc_list();
|
mpri->mutable_proc()->set_proc_id(mpr_list[i].proc_id);
|
mpri->mutable_proc()->set_name(mpr_list[i].name);
|
mpri->mutable_proc()->set_public_info(mpr_list[i].public_info);
|
mpri->mutable_proc()->set_private_info(mpr_list[i].private_info);
|
mpri->set_online(mpr_list[i].online);
|
for(int j=0;j<mpr_list[i].topic_list_num;j++)
|
{
|
mpri->mutable_topics()->add_topic_list(mpr_list[i].topic_list[j]);
|
}
|
}
|
*reply_len=mpr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mpr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHSubscribeTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
|
{
|
//反序列化入参
|
MsgTopicList input;
|
if(!input.ParseFromArray(topics,topics_len))
|
return false;
|
struct _MsgTopicList
|
{
|
int amount;
|
const char *topics[128];
|
}_input;
|
_input.amount=input.topic_list_size();
|
for(int i=0;i<_input.amount;i++)
|
_input.topics[i]=input.topic_list(i).c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_SubscribeTopics(&_input,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgCommonReply mcr;
|
mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mcr.mutable_errmsg()->set_errstring(errString);
|
*reply_len=mcr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mcr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHSubscribeNetTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
|
{
|
//same as BHSubscribeTopics
|
|
//反序列化入参
|
MsgTopicList input;
|
if(!input.ParseFromArray(topics,topics_len))
|
return false;
|
struct _MsgTopicList
|
{
|
int amount;
|
const char *topics[128];
|
}_input;
|
_input.amount=input.topic_list_size();
|
for(int i=0;i<_input.amount;i++)
|
_input.topics[i]=input.topic_list(i).c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_SubscribeTopics(&_input,timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
MsgCommonReply mcr;
|
mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mcr.mutable_errmsg()->set_errstring(errString);
|
*reply_len=mcr.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mcr.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHPublish(const void *msgpub,
|
const int msgpub_len,
|
const int timeout_ms)
|
{
|
//反序列化入参
|
MsgPublish input;
|
if(!input.ParseFromArray(msgpub,msgpub_len))
|
return false;
|
struct _MsgPublish
|
{
|
const char *topic;
|
const char *data;
|
}_input;
|
_input.topic=input.topic().c_str();
|
_input.data=input.data().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_Publish(&_input,timeout_ms);//这句是功能的具体实现
|
|
return errCode==0?true:false;
|
}
|
|
int BHReadSub(void **proc_id,
|
int *proc_id_len,
|
void **msgpub,
|
int *msgpub_len,
|
const int timeout_ms)
|
{
|
//无入参,皆为返回
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
struct _ReadSubReply
|
{
|
std::string proc_id;
|
std::string topic;
|
std::string data;
|
}rsr;
|
//errCode=call_ReadSub(&rsr,&timeout_ms);//这句是功能的具体实现
|
if(errCode!=0)
|
return false;
|
|
//序列化返回数据
|
*proc_id_len=rsr.proc_id.size();
|
*proc_id=malloc(*proc_id_len);
|
memcpy(*proc_id,rsr.proc_id.data(),*proc_id_len);
|
|
MsgPublish Mp;
|
Mp.set_topic(rsr.topic);
|
Mp.set_data(rsr.data.data());
|
*msgpub_len=Mp.ByteSizeLong();
|
*msgpub=malloc(*msgpub_len);
|
Mp.SerializePartialToArray(*msgpub,*msgpub_len);
|
|
return true;
|
}
|
|
int BHAsyncRequest(const void *remote,
|
const int remote_len,
|
const void *request,
|
const int request_len,
|
void **msg_id,
|
int *msg_id_len)
|
{
|
//反序列化入参
|
BHAddress input0;
|
MsgRequestTopic input1;
|
if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(request,request_len))
|
return false;
|
struct _BHAddress
|
{
|
unsigned long long mq_id;
|
long long abs_addr;
|
const char *ip;
|
int port;
|
}_input0;
|
struct _MsgRequestTopic
|
{
|
const char *topic;
|
const char *data;
|
}_input1;
|
_input0.mq_id=input0.mq_id();
|
_input0.abs_addr=input0.abs_addr();
|
_input0.ip=input0.ip().c_str();
|
_input0.port=input0.port();
|
_input1.topic=input1.topic().c_str();
|
_input1.data=input1.data().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
std::string MsgID;
|
//errCode=call_AsyncRequest(&_input0,&_input1,&MsgID,&timeout_ms);//这句是功能的具体实现
|
if(errCode!=0)
|
return false;
|
|
//序列化返回数据
|
if(msg_id==nullptr||msg_id_len==nullptr)//这里有可能调用者不需要返回
|
return true;
|
*msg_id_len=MsgID.size();
|
*msg_id=malloc(*msg_id_len);
|
memcpy(*msg_id,MsgID.data(),*msg_id_len);
|
|
return true;
|
}
|
|
int BHRequest(const void *remote,
|
const int remote_len,
|
const void *request,
|
const int request_len,
|
void **proc_id,
|
int *proc_id_len,
|
void **reply,
|
int *reply_len,
|
const int timeout_ms)
|
{
|
//反序列化入参
|
BHAddress input0;
|
MsgRequestTopic input1;
|
if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(request,request_len))
|
return false;
|
struct _BHAddress
|
{
|
unsigned long long mq_id;
|
long long abs_addr;
|
const char *ip;
|
int port;
|
}_input0;
|
struct _MsgRequestTopic
|
{
|
const char *topic;
|
const char *data;
|
}_input1;
|
_input0.mq_id=input0.mq_id();
|
_input0.abs_addr=input0.abs_addr();
|
_input0.ip=input0.ip().c_str();
|
_input0.port=input0.port();
|
_input1.topic=input1.topic().c_str();
|
_input1.data=input1.data().c_str();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
struct _RequestReply
|
{
|
std::string proc_id;
|
std::string data;
|
}rr;
|
//errCode=call_Request(&_input0,&_input1,&rr,&timeout_ms);//这句是功能的具体实现
|
char errString[32]={0};
|
if(errCode!=0)
|
strcpy(errString,"错误原因描述...");
|
|
//序列化返回数据
|
*proc_id_len=rr.proc_id.size();
|
*proc_id=malloc(*proc_id_len);
|
memcpy(*proc_id,rr.proc_id.data(),*proc_id_len);
|
|
MsgRequestTopicReply mrt;
|
mrt.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
|
mrt.mutable_errmsg()->set_errstring(errString);
|
mrt.set_data(rr.data.data());
|
*reply_len=mrt.ByteSizeLong();
|
*reply=malloc(*reply_len);
|
mrt.SerializePartialToArray(*reply,*reply_len);
|
|
return errCode==0?true:false;
|
}
|
|
int BHReadRequest(void **proc_id,
|
int *proc_id_len,
|
void **request,
|
int *request_len,
|
void **src,
|
const int timeout_ms)
|
{
|
//无入参,皆为返回
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
struct _ReadRequestReply
|
{
|
std::string proc_id;
|
std::string topic;
|
std::string data;
|
void *src;
|
}rrr;
|
//errCode=call_ReadRequest(&rrr,&timeout_ms);//这句是功能的具体实现
|
if(errCode!=0)
|
return false;
|
|
//序列化返回数据
|
*proc_id_len=rrr.proc_id.size();
|
*proc_id=malloc(*proc_id_len);
|
memcpy(*proc_id,rrr.proc_id.data(),*proc_id_len);
|
|
MsgRequestTopic mrt;
|
mrt.set_topic(rrr.topic);
|
mrt.set_data(rrr.data.data());
|
*request_len=mrt.ByteSizeLong();
|
*request=malloc(*request_len);
|
mrt.SerializePartialToArray(*request,*request_len);
|
|
*src=rrr.src;
|
|
return true;
|
}
|
|
int BHSendReply(void *src,
|
const void *reply,
|
const int reply_len)
|
{
|
//反序列化入参
|
MsgRequestTopicReply input;
|
if(!input.ParseFromArray(reply,reply_len))
|
return false;
|
const char *_input;
|
_input=input.data().data();
|
|
//调用函数实现
|
int errCode=0;//0 is success
|
//errCode=call_SendReply(src,_input,timeout_ms);//这句是功能的具体实现
|
|
return errCode==0?true:false;
|
}
|
|
void BHFree(void *data, int size)
|
{
|
free(data);
|
}
|
|
int BHCleanup()
|
{
|
int errCode=0;//0 is success
|
//errCode=call_Cleanup();//这句是功能的具体实现
|
return errCode==0?true:false;
|
}
|
