atria-soft/zeus
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] start send file data throw the service

Browse Source
This commit is contained in:
Edouard DUPIN 2016-06-22 22:52:18 +02:00
parent 7ce31359c9
commit ae7d28552a
32 changed files with 2516 additions and 2258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lutin_zeus.py
View File

@ -39,6 +39,8 @@ def create(target, module_name):
'zeus/Future.cpp',
'zeus/File.cpp',
'zeus/Buffer.cpp',
'zeus/Buffer_addParameter.cpp',
'zeus/Buffer_getParameter.cpp',
'zeus/ParamType.cpp',
'zeus/Client.cpp',
'zeus/GateWay.cpp',

24
test/client/appl/main.cpp
View File

@ -87,7 +87,7 @@ int main(int _argc, const char *_argv[]) {
}
*/
if (true) {
if (false) {
APPL_INFO(" ----------------------------------");
APPL_INFO(" -- Get service system-user");
APPL_INFO(" ----------------------------------");
@ -140,10 +140,9 @@ int main(int _argc, const char *_argv[]) {
APPL_INFO(" ----------------------------------");
APPL_INFO(" -- Get service picture");
APPL_INFO(" ----------------------------------");
if (false) {
if (true) {
zeus::ServiceRemote remoteServicePicture = client1.getService("picture");
if (remoteServicePicture.exist() == true) {
/*
zeus::Future<std::vector<std::string>> retCall = remoteServicePicture.call("getAlbums").wait();
APPL_INFO(" album list: ");
for (auto &it : retCall.get()) {
@ -182,16 +181,15 @@ int main(int _argc, const char *_argv[]) {
}
}
}
*/
#if 0
std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
zeus::File tmp("./photo_2016_33913.bmp");//"image/jpg", {0,5,2,6,7,5,8,4,5,2,1,5,65,5,2,6,85,4,6,6,54,65,88,64,14,6,4,64,51,3,16,4});
int32_t size = tmp.getData().size();
zeus::FutureBase retSendImage = remoteServicePicture.call("addFile", tmp).wait();
std::chrono::steady_clock::time_point stop = std::chrono::steady_clock::now();
APPL_WARNING(" IO*=" << int64_t((stop-start).count()/1000)/1000.0 << " ms");
double megaParSec = double(size)/(double((stop-start).count())/1000000000.0);
APPL_WARNING(" speed=" << int64_t(megaParSec/1024.0)/1024.0 << " Mo/s");
#if 1
std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
zeus::File tmp("./testzz.png");
int32_t size = tmp.getData().size();
zeus::FutureBase retSendImage = remoteServicePicture.call("addFile", tmp).wait();
std::chrono::steady_clock::time_point stop = std::chrono::steady_clock::now();
APPL_WARNING(" IO*=" << int64_t((stop-start).count()/1000)/1000.0 << " ms");
double megaParSec = double(size)/(double((stop-start).count())/1000000000.0);
APPL_WARNING(" speed=" << int64_t(megaParSec/1024.0)/1024.0 << " Mo/s");
#endif
}
}

4
tools/picture/appl/main.cpp
View File

@ -89,17 +89,21 @@ namespace appl {
std::vector<std::string> out;
ejson::Array globalGroups = m_database["group-global"].toArray();
if (globalGroups.exist() == false) {
APPL_DEBUG("'group-global' ==> does not exist ==> No album");
return out;
}
ejson::Object groups = m_database["groups"].toObject();
if (groups.exist() == false) {
APPL_DEBUG("'group' ==> does not exist ==> No album");
return out;
}
APPL_DEBUG("for element in 'group-global'");
for (auto it: globalGroups) {
std::string tmpString = it.toString().get();
if (tmpString == "") {
continue;
}
APPL_DEBUG(" find emlement:" << tmpString);
out.push_back(tmpString);
}
return out;

21
zeus/AbstractFunction.cpp
View File

@ -7,21 +7,18 @@
#include <zeus/debug.h>
#include <etk/os/FSNode.h>
zeus::Buffer zeus::createBinaryCall(uint64_t _transactionId, const std::string& _functionName, const zeus::Buffer& _params) {
zeus::Buffer callElem = createBinaryBaseCall(_transactionId, _functionName);
//callElem.add("param", _params);
return callElem;
}
zeus::Buffer zeus::createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId) {
zeus::Buffer obj;
obj.setServiceId(_serviceId);
obj.setCall(_functionName);
obj.setTransactionId(_transactionId);
ememory::SharedPtr<zeus::Buffer> zeus::createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId) {
ememory::SharedPtr<zeus::Buffer> obj = zeus::Buffer::create();
if (obj == nullptr) {
return nullptr;
}
obj->setServiceId(_serviceId);
obj->setCall(_functionName);
obj->setTransactionId(_transactionId);
return obj;
}
void zeus::createBinaryParam(std::vector<ActionAsyncClient>& _asyncAction, int32_t _paramId, zeus::Buffer& _obj) {
void zeus::createBinaryParam(int32_t _paramId, const ememory::SharedPtr<zeus::Buffer>& _obj) {
// Finish recursive parse ...
}

57
zeus/AbstractFunction.h
View File

@ -11,14 +11,6 @@
#include <zeus/Buffer.h>
#include <ememory/memory.h>
namespace zeus {
class TcpString;
// define basic async call element ...
using ActionAsyncClient = std::function<bool(TcpString* _interface, const uint32_t& _serviceId, uint64_t _transactionId, uint64_t _part)>;
}
namespace zeus {
class AbstractFunction {
@ -64,48 +56,53 @@ namespace zeus {
virtual std::string getPrototype() const = 0;
virtual std::string getPrototypeReturn() const = 0;
virtual std::vector<std::string> getPrototypeParam() const = 0;
virtual void execute(const ememory::SharedPtr<zeus::TcpString>& _interfaceClient, uint64_t _transactionId, uint64_t _clientId, zeus::Buffer& _params, void* _class=nullptr) = 0;
virtual void execute(const ememory::SharedPtr<zeus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
const ememory::SharedPtr<zeus::Buffer>& _params,
void* _class=nullptr) = 0;
};
zeus::Buffer createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId=0);
void createBinaryParam(std::vector<ActionAsyncClient>& _asyncAction,
int32_t _paramId,
zeus::Buffer& _obj);
ememory::SharedPtr<zeus::Buffer> createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId=0);
void createBinaryParam(int32_t _paramId,
const ememory::SharedPtr<zeus::Buffer>& _obj);
template<class ZEUS_TYPE, class... _ARGS>
void createBinaryParam(std::vector<ActionAsyncClient>& _asyncAction,
int32_t _paramId,
zeus::Buffer& _obj,
void createBinaryParam(int32_t _paramId,
const ememory::SharedPtr<zeus::Buffer>& _obj,
const ZEUS_TYPE& _param,
_ARGS&&... _args) {
_obj.addParameter<ZEUS_TYPE>(/*_asyncAction, _paramId,*/ _param);
_obj->addParameter<ZEUS_TYPE>(_param);
_paramId++;
createBinaryParam(_asyncAction, _paramId, _obj, std::forward<_ARGS>(_args)...);
createBinaryParam(_paramId, _obj, std::forward<_ARGS>(_args)...);
}
// convert const char in std::string ...
template<class... _ARGS>
void createBinaryParam(std::vector<ActionAsyncClient>& _asyncAction,
int32_t _paramId,
zeus::Buffer& _obj,
void createBinaryParam(int32_t _paramId,
const ememory::SharedPtr<zeus::Buffer>& _obj,
const char* _param,
_ARGS&&... _args) {
createBinaryParam(_asyncAction, _paramId, _obj, std::string(_param), std::forward<_ARGS>(_args)...);
createBinaryParam(_paramId, _obj, std::string(_param), std::forward<_ARGS>(_args)...);
}
template<class... _ARGS>
zeus::Buffer createBinaryCall(std::vector<ActionAsyncClient>& _asyncAction, uint64_t _transactionId, const std::string& _functionName, _ARGS&&... _args) {
zeus::Buffer callElem = createBinaryBaseCall(_transactionId, _functionName);
createBinaryParam(_asyncAction, 0, callElem, std::forward<_ARGS>(_args)...);
ememory::SharedPtr<zeus::Buffer> createBinaryCall(uint64_t _transactionId, const std::string& _functionName, _ARGS&&... _args) {
ememory::SharedPtr<zeus::Buffer> callElem = createBinaryBaseCall(_transactionId, _functionName);
if (callElem == nullptr) {
return nullptr;
}
createBinaryParam(0, callElem, std::forward<_ARGS>(_args)...);
return callElem;
}
template<class... _ARGS>
zeus::Buffer createBinaryCallService(std::vector<ActionAsyncClient>& _asyncAction, uint64_t _transactionId, const uint32_t& _serviceName, const std::string& _functionName, _ARGS&&... _args) {
zeus::Buffer callElem = createBinaryBaseCall(_transactionId, _functionName, _serviceName);
createBinaryParam(_asyncAction, 0, callElem, std::forward<_ARGS>(_args)...);
ememory::SharedPtr<zeus::Buffer> createBinaryCallService(uint64_t _transactionId, const uint32_t& _serviceName, const std::string& _functionName, _ARGS&&... _args) {
ememory::SharedPtr<zeus::Buffer> callElem = createBinaryBaseCall(_transactionId, _functionName, _serviceName);
if (callElem == nullptr) {
return nullptr;
}
createBinaryParam(0, callElem, std::forward<_ARGS>(_args)...);
return callElem;
}
zeus::Buffer createBinaryCall(uint64_t _transactionId, const std::string& _functionName, const zeus::Buffer& _params);
}
#include <zeus/TcpString.h>

119
zeus/AbstractFunctionTypeClass.h
View File

@ -10,7 +10,6 @@
#include <zeus/debug.h>
#include <zeus/AbstractFunction.h>
#include <zeus/mineType.h>
#include <etk/os/FSNode.h>
namespace zeus {
@ -20,129 +19,46 @@ namespace zeus {
uint64_t _clientId,
ZEUS_CLASS_TYPE* _pointer,
ZEUS_RETURN (ZEUS_CLASS_TYPE::*_func)(ZEUS_TYPES...),
zeus::Buffer& _obj) {
std::vector<ActionAsyncClient> asyncAction;
const ememory::SharedPtr<zeus::Buffer>& _obj) {
if (_obj == nullptr) {
return;
}
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
ZEUS_RETURN ret = (*_pointer.*_func)(_obj.getParameter<ZEUS_TYPES>(idParam++)...);
ZEUS_RETURN ret = (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam++)...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
ZEUS_RETURN ret = (*_pointer.*_func)(_obj.getParameter<ZEUS_TYPES>(idParam--)...);
ZEUS_RETURN ret = (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam--)...);
#else
#error Must be implemented ...
ZEUS_RETURN ret;
return;
#endif
if (asyncAction.size() != 0) {
ZEUS_ERROR("Missing send async messages");
}
_interfaceClient->addAsync([=](TcpString* _interface) {
_interface->answerValue(_transactionId, ret, _clientId);
return true;
});
}
class SendFile {
private:
zeus::FileServer m_data;
uint64_t m_transactionId;
uint64_t m_clientId;
uint32_t m_partId;
etk::FSNode m_node;
uint64_t m_size;
public:
SendFile(zeus::FileServer _data,
uint64_t _transactionId,
uint64_t _clientId) :
m_data(_data),
m_transactionId(_transactionId),
m_clientId(_clientId),
m_partId(0),
m_node(_data.getFileName()),
m_size(0) {
}
~SendFile() {
//m_node.fileClose();
}
bool operator() (TcpString* _interface) {
zeus::Buffer answer;
answer.setTransactionId(m_transactionId);
answer.setClientId(m_clientId);
answer.setPartId(m_partId);
answer.setPartFinish(false);
if (m_partId == 0) {
answer.setType(zeus::Buffer::typeMessage::answer);
m_node.fileOpenRead();
std::string extention = std::string(m_data.getFileName().begin()+m_data.getFileName().size() -3, m_data.getFileName().end());
ZEUS_WARNING("send file: '" << m_data.getFileName() << "' with extention: '" << extention << "'");
m_size = m_node.fileSize();
zeus::File tmpFile(zeus::getMineType(extention), std::vector<uint8_t>(), m_size);
answer.addAnswer(tmpFile);
_interface->writeBinary(answer);
m_partId++;
return false;
}
answer.setType(zeus::Buffer::typeMessage::data);
int32_t tmpSize = 1024;
if (m_size < 1024) {
tmpSize = m_size;
}
uint8_t tmpData[1024];
m_node.fileRead(tmpData, 1, tmpSize);
answer.addData(tmpData, tmpSize);
m_size -= tmpSize;
if (m_size <= 0) {
answer.setPartFinish(true);
m_node.fileClose();
}
_interface->writeBinary(answer);;
m_partId++;
if (m_size <= 0) {
return true;
}
return false;
}
};
template <class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
void executeClassCall(const ememory::SharedPtr<zeus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
ZEUS_CLASS_TYPE* _pointer,
zeus::FileServer (ZEUS_CLASS_TYPE::*_func)(ZEUS_TYPES...),
zeus::Buffer& _obj) {
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
zeus::FileServer tmpElem = (*_pointer.*_func)(_obj.getParameter<ZEUS_TYPES>(idParam++)...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
zeus::FileServer tmpElem = (*_pointer.*_func)(_obj.getParameter<ZEUS_TYPES>(idParam--)...);
#else
#error Must be implemented ...
zeus::FileServer tmpElem;
return;
#endif
_interfaceClient->addAsync(SendFile(tmpElem, _transactionId, _clientId));
}
template <class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
void executeClassCall(const ememory::SharedPtr<zeus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
ZEUS_CLASS_TYPE* _pointer,
void (ZEUS_CLASS_TYPE::*_func)(ZEUS_TYPES...),
zeus::Buffer& _obj) {
const ememory::SharedPtr<zeus::Buffer>& _obj) {
if (_obj == nullptr) {
return;
}
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
(*_pointer.*_func)(_obj.getParameter<ZEUS_TYPES>(idParam++)...);
(*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam++)...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
(*_pointer.*_func)(_obj.getParameter<ZEUS_TYPES>(idParam--)...);
(*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam--)...);
#else
#error Must be implemented ...
return;
@ -193,18 +109,21 @@ namespace zeus {
void execute(const ememory::SharedPtr<zeus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
zeus::Buffer& _obj,
const ememory::SharedPtr<zeus::Buffer>& _obj,
void* _class) override {
if (_obj == nullptr) {
return;
}
ZEUS_CLASS_TYPE* tmpClass = nullptr;
if (_class != nullptr) {
tmpClass = (ZEUS_CLASS_TYPE*)_class;
}
// check parameter number
if (_obj.getNumberParameter() != sizeof...(ZEUS_TYPES)) {
if (_obj->getNumberParameter() != sizeof...(ZEUS_TYPES)) {
ZEUS_ERROR("Wrong number of Parameters ...");
std::string help = "request ";
help += etk::to_string(_obj.getNumberParameter());
help += etk::to_string(_obj->getNumberParameter());
help += " parameters and need ";
help += etk::to_string(sizeof...(ZEUS_TYPES));
help += " parameters. prototype function:";
@ -217,7 +136,7 @@ namespace zeus {
}
// check parameter compatibility
for (size_t iii=0; iii<sizeof...(ZEUS_TYPES); ++iii) {
if (checkCompatibility(m_paramType[iii], _obj.getParameterType(iii)) == false) {
if (checkCompatibility(m_paramType[iii], _obj->getParameterType(iii)) == false) {
_interfaceClient->answerError(_transactionId,
"WRONG-PARAMETER-TYPE",
std::string("Parameter id ") + etk::to_string(iii) + " not compatible with type: '" + m_paramType[iii].getName() + "'",

29
zeus/AbstractFunctionTypeDirect.h
View File

@ -15,15 +15,18 @@ namespace zeus {
uint64_t _transactionId,
uint64_t _clientId,
ZEUS_RETURN (*_func)(ZEUS_TYPES...),
zeus::Buffer& _obj) {
const ememory::SharedPtr<zeus::Buffer>& _obj) {
if (_obj == nullptr) {
return;
}
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
ZEUS_RETURN ret = _func(_obj.getParameter<ZEUS_TYPES>(idParam++)...);
ZEUS_RETURN ret = _func(_obj->getParameter<ZEUS_TYPES>(idParam++)...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
ZEUS_RETURN ret = _func(_obj.getParameter<ZEUS_TYPES>(idParam--)...);
ZEUS_RETURN ret = _func(_obj->getParameter<ZEUS_TYPES>(idParam--)...);
#else
#error Must be implemented ...
#endif
@ -38,15 +41,18 @@ namespace zeus {
uint64_t _transactionId,
uint64_t _clientId,
void (*_func)(ZEUS_TYPES...),
zeus::Buffer& _obj) {
const ememory::SharedPtr<zeus::Buffer>& _obj) {
if (_obj == nullptr) {
return;
}
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
_func(_obj.getParameter<ZEUS_TYPES>(idParam++)...);
_func(_obj->getParameter<ZEUS_TYPES>(idParam++)...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
_func(_obj.getParameter<ZEUS_TYPES>(idParam--)...);
_func(_obj->getParameter<ZEUS_TYPES>(idParam--)...);
#else
#error Must be implemented ...
#endif
@ -96,12 +102,15 @@ namespace zeus {
void execute(const ememory::SharedPtr<zeus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
zeus::Buffer& _obj,
const ememory::SharedPtr<zeus::Buffer>& _obj,
void* _class) override {
if (_obj == nullptr) {
return;
}
// check parameter number
if (_obj.getNumberParameter() != sizeof...(ZEUS_TYPES)) {
if (_obj->getNumberParameter() != sizeof...(ZEUS_TYPES)) {
std::string help = "request ";
help += etk::to_string(_obj.getNumberParameter());
help += etk::to_string(_obj->getNumberParameter());
help += " parameters and need ";
help += etk::to_string(sizeof...(ZEUS_TYPES));
help += " parameters. prototype function:";
@ -114,7 +123,7 @@ namespace zeus {
}
// check parameter compatibility
for (size_t iii=0; iii<sizeof...(ZEUS_TYPES); ++iii) {
if (checkCompatibility(m_paramType[iii], _obj.getParameterType(iii)) == false) {
if (checkCompatibility(m_paramType[iii], _obj->getParameterType(iii)) == false) {
_interfaceClient->answerError(_transactionId,
"WRONG-PARAMETER-TYPE",
std::string("Parameter id ") + etk::to_string(iii) + " not compatible with type: '" + m_paramType[iii].getName() + "'",

1833
zeus/Buffer.cpp
View File

File diff suppressed because it is too large Load Diff

42
zeus/Buffer.h
View File

@ -8,6 +8,14 @@
#include <enet/WebSocket.h>
#include <zeus/ParamType.h>
namespace zeus {
class TcpString;
// define basic async call element ...
using ActionAsyncClient = std::function<bool(TcpString* _interface, const uint32_t& _serviceId, uint64_t _transactionId, uint64_t _part)>;
}
namespace zeus {
//U32 message lenght
#pragma pack(push,1)
@ -82,13 +90,25 @@ namespace zeus {
- obj:file
*/
class Buffer {
private:
protected:
Buffer();
public:
static ememory::SharedPtr<zeus::Buffer> create();
protected:
headerBin m_header;
mutable std::vector<std::pair<int32_t,std::vector<uint8_t>>> m_parameter;
private:
std::vector<zeus::ActionAsyncClient> m_multipleSend;
public:
bool haveAsync() const {
return m_multipleSend.size() != 0;
}
std::vector<zeus::ActionAsyncClient> moveAsync() {
return std::move(m_multipleSend);
}
void appendBufferData(const ememory::SharedPtr<zeus::Buffer>& _obj);
protected:
void internalComposeWith(const uint8_t* _buffer, uint32_t _lenght);
public:
Buffer();
void composeWith(const std::vector<uint8_t>& _buffer);
void composeWith(const std::string& _buffer);
std::string generateHumanString();
@ -109,6 +129,7 @@ namespace zeus {
bool getPartFinish() const;
void setPartFinish(bool _value);
enum class typeMessage {
unknow = 0x0000, // Init value
call = 0x0001, // Remote call on a service ID
answer = 0x0002, // Answer from a previous call
data = 0x0003, // data message happend when partId > 0 it compleate the data of a parameter or an answer or an event
@ -120,7 +141,7 @@ namespace zeus {
// ===============================================
// == Section call
// ===============================================
private:
protected:
template<class ZEUS_TYPE_DATA>
ZEUS_TYPE_DATA internalGetParameter(int32_t _id) const;
zeus::ParamType internalGetParameterType(int32_t _id) const;
@ -135,9 +156,14 @@ namespace zeus {
const uint8_t* getParameterPointer(int32_t _id) const;
uint32_t getParameterSize(int32_t _id) const;
protected:
template<class ZEUS_TYPE_DATA>
void internalAddParameter(uint16_t _paramId, const ZEUS_TYPE_DATA& _value);
public:
template<class ZEUS_TYPE_DATA>
void addParameter(const ZEUS_TYPE_DATA& _value);
void addParameter(const ZEUS_TYPE_DATA& _value) {
internalAddParameter<ZEUS_TYPE_DATA>(m_parameter.size(), _value);
}
void addParameterEmptyVector();
void addParameter();
@ -167,10 +193,14 @@ namespace zeus {
public:
//multiple section of data (part ...)
void addData(void* _data, uint32_t _size);
void addData(uint16_t _parameterId, void* _data, uint32_t _size);
bool writeOn(enet::WebSocket& _interface);
};
std::ostream& operator <<(std::ostream& _os, enum zeus::Buffer::typeMessage _value);
void addType(std::vector<uint8_t>& _data, zeus::ParamType _type);
void addTypeObject(std::vector<uint8_t>& _data, const std::string _type);
void addTypeRaw(std::vector<uint8_t>& _data);
}

449
zeus/Buffer_addParameter.cpp Normal file
View File

@ -0,0 +1,449 @@
/** @file
* @author Edouard DUPIN
* @copyright 2016, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#include <etk/types.h>
#include <zeus/Buffer.h>
#include <zeus/debug.h>
#include <zeus/ParamType.h>
#include <etk/stdTools.h>
#include <zeus/AbstractFunction.h>
#include <climits>
#include <etk/os/FSNode.h>
#include <zeus/mineType.h>
void zeus::addType(std::vector<uint8_t>& _data, zeus::ParamType _type) {
_data.push_back(uint8_t(_type.getId()>>8));
_data.push_back(uint8_t(_type.getId()));
}
void zeus::addTypeObject(std::vector<uint8_t>& _data, const std::string _type) {
_data.push_back(uint8_t(zeus::paramTypeObject>>8));
_data.push_back(uint8_t(zeus::paramTypeObject));
for (auto &it : _type) {
_data.push_back(uint8_t(it));
}
_data.push_back(0);
}
void zeus::addTypeRaw(std::vector<uint8_t>& _data) {
_data.push_back(uint8_t(zeus::paramTypeRaw>>8));
_data.push_back(uint8_t(zeus::paramTypeRaw));
}
void zeus::Buffer::addParameter() {
std::vector<uint8_t> data;
addType(data, createType<void>());
m_parameter.push_back(std::make_pair(2,data));
}
void zeus::Buffer::addParameterEmptyVector() {
// special case of json change mode
std::vector<uint8_t> data;
addType(data, createType<std::vector<void>>());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::string>(uint16_t _paramId, const std::string& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::string>());
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], _value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<std::string>>(uint16_t _paramId, const std::vector<std::string>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<std::string>>());
// count all datas:
uint32_t size = 0;
for (auto &it : _value) {
size+=it.size()+1;
}
uint16_t nb = _value.size();
int32_t currentOffset = data.size();
data.resize(data.size()+size+2);
memcpy(&data[currentOffset], &nb, sizeof(uint16_t));
currentOffset += sizeof(uint16_t);
for (auto &it : _value) {
memcpy(&data[currentOffset], &it[0], it.size());
currentOffset += it.size();
data[currentOffset] = '\0';
currentOffset++;
}
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<bool>>(uint16_t _paramId, const std::vector<bool>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<bool>>());
// add size:
uint16_t nb = _value.size();
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
for (const auto &it : _value) {
if (it == true) {
data[currentOffset] = 'T';
} else {
data[currentOffset] = 'F';
}
currentOffset++;
}
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<int8_t>>(uint16_t _paramId, const std::vector<int8_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<int8_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(int8_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<int16_t>>(uint16_t _paramId, const std::vector<int16_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<int16_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(int16_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<int32_t>>(uint16_t _paramId, const std::vector<int32_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<int32_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(int32_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<int64_t>>(uint16_t _paramId, const std::vector<int64_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<int64_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(int64_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<uint8_t>>(uint16_t _paramId, const std::vector<uint8_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<uint8_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(uint8_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<uint16_t>>(uint16_t _paramId, const std::vector<uint16_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<uint16_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(uint16_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<uint32_t>>(uint16_t _paramId, const std::vector<uint32_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<uint32_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(uint32_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<uint64_t>>(uint16_t _paramId, const std::vector<uint64_t>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<uint64_t>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(uint64_t)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<float>>(uint16_t _paramId, const std::vector<float>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<float>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(float)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<std::vector<double>>(uint16_t _paramId, const std::vector<double>& _value) {
std::vector<uint8_t> data;
addType(data, createType<std::vector<double>>());
// add size:
int32_t currentOffset = data.size();
data.resize(data.size()+_value.size());
memcpy(&data[currentOffset], &_value[0], sizeof(double)*_value.size());
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<int8_t>(uint16_t _paramId, const int8_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<int8_t>());
data.push_back(uint8_t(_value));
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<uint8_t>(uint16_t _paramId, const uint8_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<uint8_t>());
data.push_back(_value);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<int16_t>(uint16_t _paramId, const int16_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<int16_t>());
int32_t currentOffset = data.size();
data.resize(data.size()+2);
memcpy(&data[currentOffset], &_value, 2);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<uint16_t>(uint16_t _paramId, const uint16_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<uint16_t>());
int32_t currentOffset = data.size();
data.resize(data.size()+2);
memcpy(&data[currentOffset], &_value, 2);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<int32_t>(uint16_t _paramId, const int32_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<int32_t>());
int32_t currentOffset = data.size();
data.resize(data.size()+4);
memcpy(&data[currentOffset], &_value, 4);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<uint32_t>(uint16_t _paramId, const uint32_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<uint32_t>());
int32_t currentOffset = data.size();
data.resize(data.size()+4);
memcpy(&data[currentOffset], &_value, 4);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<int64_t>(uint16_t _paramId, const int64_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<int64_t>());
int32_t currentOffset = data.size();
data.resize(data.size()+8);
memcpy(&data[currentOffset], &_value, 8);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<uint64_t>(uint16_t _paramId, const uint64_t& _value) {
std::vector<uint8_t> data;
addType(data, createType<uint64_t>());
int32_t currentOffset = data.size();
data.resize(data.size()+8);
memcpy(&data[currentOffset], &_value, 8);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<float>(uint16_t _paramId, const float& _value) {
std::vector<uint8_t> data;
addType(data, createType<float>());
int32_t currentOffset = data.size();
data.resize(data.size()+4);
memcpy(&data[currentOffset], &_value, 4);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<double>(uint16_t _paramId, const double& _value) {
std::vector<uint8_t> data;
addType(data, createType<double>());
int32_t currentOffset = data.size();
data.resize(data.size()+8);
memcpy(&data[currentOffset], &_value, 8);
m_parameter.push_back(std::make_pair(2,data));
}
template<>
void zeus::Buffer::internalAddParameter<bool>(uint16_t _paramId, const bool& _value) {
std::vector<uint8_t> data;
addType(data, createType<bool>());
if (_value == true) {
data.push_back('T');
} else {
data.push_back('F');
}
m_parameter.push_back(std::make_pair(2,data));
}
#define ZEUS_MINIMUM_SIZE_MULTIPLE (1024*40)
namespace zeus {
class SendData {
private:
std::vector<uint8_t> m_data;
uint16_t m_parameterId;
int64_t m_size;
uint64_t m_offset;
public:
SendData(const std::vector<uint8_t>& _data, uint16_t _parameterId) :
m_data(_data),
m_parameterId(_parameterId),
m_size(_data.size()-1),
m_offset(0) {
}
~SendData() {
}
bool operator() (zeus::TcpString* _interface,
uint32_t _clientId,
uint32_t _transactionId,
uint32_t _partId) {
ememory::SharedPtr<zeus::Buffer> answer = zeus::Buffer::create();
answer->setTransactionId(_transactionId);
answer->setClientId(_clientId);
answer->setPartId(_partId);
answer->setPartFinish(false);
answer->setType(zeus::Buffer::typeMessage::data);
int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE;
if (m_size < ZEUS_MINIMUM_SIZE_MULTIPLE) {
tmpSize = m_size;
}
answer->addData(m_parameterId, &m_data[m_offset], tmpSize);
m_size -= tmpSize;
m_offset += tmpSize;
_interface->writeBinary(answer);;
if (m_size <= 0) {
return true;
}
return false;
}
};
}
template<>
void zeus::Buffer::internalAddParameter<zeus::File>(uint16_t _paramId, const zeus::File& _value) {
std::vector<uint8_t> data;
addType(data, createType<zeus::File>());
// set mine type in string:
std::string name = _value.getMineType();
int32_t currentOffset = data.size();
data.resize(data.size()+name.size()+1);
memcpy(&data[currentOffset], &name[0], name.size());
// finish with '\0'
currentOffset = data.size()-1;
data[currentOffset] = 0;
// set size if the file in int32_t
int32_t size = _value.getTheoricFileSize();
currentOffset = data.size();
data.resize(data.size()+sizeof(int32_t));
memcpy(&data[currentOffset], &size, sizeof(int32_t));
// and now the data (can be none ...):
const std::vector<uint8_t>& dataFile = _value.getData();
if (dataFile.size() != 0) {
currentOffset = data.size();
ZEUS_ERROR("set buffer with size: " << dataFile.size());
if (dataFile.size() < ZEUS_MINIMUM_SIZE_MULTIPLE) {
data.resize(data.size()+dataFile.size());
memcpy(&data[currentOffset], &dataFile[0], dataFile.size());
} else {
ZEUS_WARNING("multiple send the data file: " << _value.getMineType());
// multiple send ... (no data in the first frame ...
// TODO : m_multipleSend.push_back(SendFile(std::move(node), _paramId, size));
m_multipleSend.push_back(zeus::SendData(dataFile, _paramId));
}
}
m_parameter.push_back(std::make_pair(2,data));
}
namespace zeus {
class SendFile {
private:
etk::FSNode m_node;
uint16_t m_parameterId;
int64_t m_size;
public:
SendFile(const std::string& _data, uint16_t _parameterId, uint32_t _size) :
m_node(_data),
m_parameterId(_parameterId),
m_size(_size) {
}
~SendFile() {
}
bool operator() (zeus::TcpString* _interface,
uint32_t _clientId,
uint32_t _transactionId,
uint32_t _partId) {
if (m_node.fileIsOpen() == false) {
m_node.fileOpenRead();
}
ememory::SharedPtr<zeus::Buffer> answer = zeus::Buffer::create();
answer->setTransactionId(_transactionId);
answer->setClientId(_clientId);
answer->setPartId(_partId);
answer->setPartFinish(false);
answer->setType(zeus::Buffer::typeMessage::data);
int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE;
if (m_size < ZEUS_MINIMUM_SIZE_MULTIPLE) {
tmpSize = m_size;
}
uint8_t tmpData[ZEUS_MINIMUM_SIZE_MULTIPLE];
m_node.fileRead(tmpData, 1, tmpSize);
answer->addData(m_parameterId, tmpData, tmpSize);
m_size -= tmpSize;
_interface->writeBinary(answer);;
if (m_size <= 0) {
m_node.fileClose();
return true;
}
return false;
}
};
}
template<>
void zeus::Buffer::internalAddParameter<zeus::FileServer>(uint16_t _paramId, const zeus::FileServer& _value) {
etk::FSNode node(_value.getFileName());
node.fileOpenRead();
std::string extention = std::string(_value.getFileName().begin()+_value.getFileName().size() -3, _value.getFileName().end());
ZEUS_WARNING("send file: '" << _value.getFileName() << "' with extention: '" << extention << "'");
uint64_t size = node.fileSize();
std::vector<uint8_t> fileData;
if (size < ZEUS_MINIMUM_SIZE_MULTIPLE) {
// if the file is small ==> send directly ...
fileData.resize(size);
node.fileRead(&fileData[0], 1, size);
}
zeus::File tmpFile(zeus::getMineType(extention), fileData, size);
internalAddParameter(_paramId, tmpFile);
node.fileClose();
if (size < ZEUS_MINIMUM_SIZE_MULTIPLE) {
//node.fileClose();
} else {
ZEUS_WARNING("multiple send the file: " << _value.getFileName() << " with size " << size);
// multiple send ... (no data in the first frame ...
// TODO : m_multipleSend.push_back(SendFile(std::move(node), _paramId, size));
m_multipleSend.push_back(zeus::SendFile(_value.getFileName(), _paramId, size));
}
}

1466
zeus/Buffer_getParameter.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

7
zeus/Client.cpp
View File

@ -20,8 +20,11 @@ zeus::Client::~Client() {
}
void zeus::Client::onClientData(zeus::Buffer& _value) {
ZEUS_ERROR("Get Data On the Communication interface that is not understand ... : " << _value.generateHumanString());
void zeus::Client::onClientData(const ememory::SharedPtr<zeus::Buffer>& _value) {
if (_value == nullptr) {
return;
}
ZEUS_ERROR("Get Data On the Communication interface that is not understand ... : " << _value->generateHumanString());
}
zeus::ServiceRemote zeus::Client::getService(const std::string& _name) {

10
zeus/Client.h
View File

@ -53,13 +53,13 @@ namespace zeus {
// Connect to ourself:
//client1.authentificate("coucou");
private:
void onClientData(zeus::Buffer& _value);
void onClientData(const ememory::SharedPtr<zeus::Buffer>& _value);
public:
template<class... _ARGS>
zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) {
if (m_interfaceClient == nullptr) {
zeus::Buffer ret;
ret.addError("NULLPTR", "call " + _functionName + " with no interface open");
ememory::SharedPtr<zeus::Buffer> ret = zeus::Buffer::create();
ret->addError("NULLPTR", "call " + _functionName + " with no interface open");
return zeus::FutureBase(0, true, ret);
}
return m_interfaceClient->call(_functionName, _args...);
@ -67,8 +67,8 @@ namespace zeus {
template<class... _ARGS>
zeus::FutureBase callAction(const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) {
if (m_interfaceClient == nullptr) {
zeus::Buffer ret;
ret.addError("NULLPTR", "call " + _functionName + " with no interface open");
ememory::SharedPtr<zeus::Buffer> ret = zeus::Buffer::create();
ret->addError("NULLPTR", "call " + _functionName + " with no interface open");
return zeus::FutureBase(0, true, ret, _callback);
}
return m_interfaceClient->callAction(_functionName, _args..., _callback);

13
zeus/File.cpp
View File

@ -9,6 +9,7 @@
#include <etk/stdTools.h>
#include <zeus/mineType.h>
#include <etk/os/FSNode.h>
#include <string.h>
@ -38,14 +39,22 @@ zeus::File::File(const std::string& _mineType, std::vector<uint8_t> _data, int32
}
void zeus::File::setData(uint64_t _offset, const std::vector<uint8_t>& _data) {
// TODO : Check size/offset before set
memcpy(&m_data[_offset], &_data[0], _data.size());
setData(_offset, &_data[0], _data.size());
}
void zeus::File::setData(uint64_t _offset, const uint8_t* _data, uint32_t _size) {
if (_size+_offset >= m_data.size()) {
ZEUS_ERROR("Need Resize file buffer ...");
m_data.resize(_size+_offset);
}
memcpy(&m_data[_offset], _data, _size);
}
zeus::FileServer::FileServer() {
}
zeus::FileServer::FileServer(const std::string& _filename) :
m_name(_filename) {

6
zeus/File.h
View File

@ -16,6 +16,9 @@ namespace zeus {
File();
File(const std::string& _filename);
File(const std::string& _mineType, std::vector<uint8_t> _data, int32_t _fileSize = -1);
int32_t getTheoricFileSize() const {
return m_fileSize;
}
void storeIn(const std::string& _filename) const;
const std::string& getMineType() const {
return m_mineType;
@ -30,6 +33,7 @@ namespace zeus {
return m_data;
}
void setData(uint64_t _offset, const std::vector<uint8_t>& _data);
void setData(uint64_t _offset, const uint8_t* _data, uint32_t _size);
};
class FileServer {
private:
@ -37,7 +41,7 @@ namespace zeus {
public:
FileServer();
FileServer(const std::string& _filename);
const std::string& getFileName() {
const std::string& getFileName() const {
return m_name;
}
};

198
zeus/Future.cpp
View File

@ -11,326 +11,328 @@
namespace zeus {
template<>
bool zeus::Future<bool>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return false;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return false;
}
return m_data->m_returnData.getAnswer<bool>();
return m_data->m_returnData->getAnswer<bool>();
}
template<>
int64_t zeus::Future<int64_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<bool>();
return m_data->m_returnData->getAnswer<bool>();
}
template<>
int32_t zeus::Future<int32_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<int32_t>();
return m_data->m_returnData->getAnswer<int32_t>();
}
template<>
int16_t zeus::Future<int16_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<int16_t>();
return m_data->m_returnData->getAnswer<int16_t>();
}
template<>
int8_t zeus::Future<int8_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<int8_t>();
return m_data->m_returnData->getAnswer<int8_t>();
}
template<>
uint64_t zeus::Future<uint64_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<int64_t>();
return m_data->m_returnData->getAnswer<int64_t>();
}
template<>
uint32_t zeus::Future<uint32_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<uint32_t>();
return m_data->m_returnData->getAnswer<uint32_t>();
}
template<>
uint16_t zeus::Future<uint16_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<uint16_t>();
return m_data->m_returnData->getAnswer<uint16_t>();
}
template<>
uint8_t zeus::Future<uint8_t>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0;
}
return m_data->m_returnData.getAnswer<uint8_t>();
return m_data->m_returnData->getAnswer<uint8_t>();
}
template<>
double zeus::Future<double>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0.0;
}
return m_data->m_returnData.getAnswer<double>();
return m_data->m_returnData->getAnswer<double>();
}
template<>
float zeus::Future<float>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return 0.0f;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return 0.0f;
}
return m_data->m_returnData.getAnswer<float>();
return m_data->m_returnData->getAnswer<float>();
}
template<>
std::string zeus::Future<std::string>::get() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return "";
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return "";
}
return m_data->m_returnData.getAnswer<std::string>();
return m_data->m_returnData->getAnswer<std::string>();
}
template<>
std::vector<int64_t> zeus::Future<std::vector<int64_t>>::get() {
std::vector<int64_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<int64_t>>();
out = m_data->m_returnData->getAnswer<std::vector<int64_t>>();
return out;
}
template<>
std::vector<int32_t> zeus::Future<std::vector<int32_t>>::get() {
std::vector<int32_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<int32_t>>();
out = m_data->m_returnData->getAnswer<std::vector<int32_t>>();
return out;
}
template<>
std::vector<int16_t> zeus::Future<std::vector<int16_t>>::get() {
std::vector<int16_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<int16_t>>();
out = m_data->m_returnData->getAnswer<std::vector<int16_t>>();
return out;
}
template<>
std::vector<int8_t> zeus::Future<std::vector<int8_t>>::get() {
std::vector<int8_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<int8_t>>();
out = m_data->m_returnData->getAnswer<std::vector<int8_t>>();
return out;
}
template<>
std::vector<uint64_t> zeus::Future<std::vector<uint64_t>>::get() {
std::vector<uint64_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<uint64_t>>();
out = m_data->m_returnData->getAnswer<std::vector<uint64_t>>();
return out;
}
template<>
std::vector<uint32_t> zeus::Future<std::vector<uint32_t>>::get() {
std::vector<uint32_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<uint32_t>>();
out = m_data->m_returnData->getAnswer<std::vector<uint32_t>>();
return out;
}
template<>
std::vector<uint16_t> zeus::Future<std::vector<uint16_t>>::get() {
std::vector<uint16_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<uint16_t>>();
out = m_data->m_returnData->getAnswer<std::vector<uint16_t>>();
return out;
}
template<>
std::vector<uint8_t> zeus::Future<std::vector<uint8_t>>::get() {
std::vector<uint8_t> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<uint8_t>>();
out = m_data->m_returnData->getAnswer<std::vector<uint8_t>>();
return out;
}
template<>
std::vector<double> zeus::Future<std::vector<double>>::get() {
std::vector<double> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<double>>();
out = m_data->m_returnData->getAnswer<std::vector<double>>();
return out;
}
template<>
std::vector<float> zeus::Future<std::vector<float>>::get() {
std::vector<float> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<float>>();
out = m_data->m_returnData->getAnswer<std::vector<float>>();
return out;
}
template<>
std::vector<std::string> zeus::Future<std::vector<std::string>>::get() {
std::vector<std::string> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<std::string>>();
out = m_data->m_returnData->getAnswer<std::vector<std::string>>();
return out;
}
template<>
std::vector<bool> zeus::Future<std::vector<bool>>::get() {
std::vector<bool> out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
out = m_data->m_returnData.getAnswer<std::vector<bool>>();
out = m_data->m_returnData->getAnswer<std::vector<bool>>();
return out;
}
template<>
zeus::File zeus::Future<zeus::File>::get() {
zeus::File out;
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return out;
}
/* TODO : ...
ejson::Value val = m_data->m_returnData["return"];
if (val.exist() == false) {
if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) {
ZEUS_WARNING("No Return value ...");
return out;
}
if (val.isObject() == false) {
ZEUS_WARNING("Wrong return Type get '" << val.getType() << " instead of 'Object'");
return out;
}
ejson::Object retVal = val.toObject();
if (retVal["type"].toString().get() != "file") {
ZEUS_WARNING("Wrong return object-type get '" << retVal["type"].toString().get() << " instead of 'file'");
return out;
}
out.setMineType(retVal["mine-type"].toString().get());
out.preSetDataSize(retVal["size"].toNumber().getU64());
// no data might be stored in the first packet ...
uint64_t offset = 0;
// TODO: check part ID
for (auto &it : m_data->m_returnDataPart) {
ejson::String valData = it.toString();
std::vector<uint8_t> tmpData = ejson::base64::decode(valData.get());
out.setData(offset, tmpData);
offset += tmpData.size();
}
*/
out = m_data->m_returnData->getAnswer<zeus::File>();
return out;
}
}

85
zeus/FutureBase.cpp
View File

@ -28,15 +28,14 @@ zeus::FutureBase::FutureBase(uint64_t _transactionId, zeus::FutureData::Observer
m_data->m_callbackFinish = _callback;
}
const zeus::Buffer& zeus::FutureBase::getRaw() {
ememory::SharedPtr<zeus::Buffer> zeus::FutureBase::getRaw() {
if (m_data == nullptr) {
static zeus::Buffer tmpp;
return tmpp;
return nullptr;
}
return m_data->m_returnData;
}
zeus::FutureBase::FutureBase(uint64_t _transactionId, bool _isFinished, zeus::Buffer _returnData, zeus::FutureData::ObserverFinish _callback) {
zeus::FutureBase::FutureBase(uint64_t _transactionId, bool _isFinished, const ememory::SharedPtr<zeus::Buffer>& _returnData, zeus::FutureData::ObserverFinish _callback) {
m_data = std::make_shared<zeus::FutureData>();
if (m_data == nullptr) {
return;
@ -69,45 +68,31 @@ zeus::FutureBase zeus::FutureBase::operator= (const zeus::FutureBase& _base) {
return *this;
}
bool zeus::FutureBase::setAnswer(const zeus::Buffer& _returnValue) {
bool zeus::FutureBase::setAnswer(const ememory::SharedPtr<zeus::Buffer>& _value) {
if (m_data == nullptr) {
ZEUS_ERROR(" Not a valid future ...");
return true;
}
m_data->m_receiveTime = std::chrono::steady_clock::now();
if (m_data->m_isSynchronous == true) {
m_data->m_returnData = _returnValue;
m_data->m_returnData = _value;
if (m_data->m_callbackFinish != nullptr) {
return m_data->m_callbackFinish(*this);
}
return true;
}
/* TODO : ...
if (_returnValue.valueExist("part") == true) {
uint64_t idPart = _returnValue["part"].toNumber().getU64();
if (idPart == 0) {
m_data->m_returnData = _returnValue;
} else {
m_data->m_returnDataPart.push_back(_returnValue["data"]);
if (_value->getType() == zeus::Buffer::typeMessage::data) {
if (m_data->m_returnData != nullptr) {
m_data->m_returnData->appendBufferData(_value);
}
if (_returnValue.valueExist("finish") == true) {
if (_returnValue["finish"].toBoolean().get() == true) {
m_data->m_isFinished = true;
if (m_data->m_callbackFinish != nullptr) {
return m_data->m_callbackFinish(*this);
}
return true;
}
// finish is false ==> normal case ...
}
return false;
}*/
m_data->m_returnData = _returnValue;
m_data->m_isFinished = true;
} else {
m_data->m_returnData = _value;
}
m_data->m_isFinished = _value->getPartFinish();
if (m_data->m_callbackFinish != nullptr) {
return m_data->m_callbackFinish(*this);
}
return true;
return m_data->m_isFinished;
}
void zeus::FutureBase::setSynchronous() {
if (m_data == nullptr) {
@ -127,28 +112,30 @@ bool zeus::FutureBase::hasError() {
if (m_data == nullptr) {
return true;
}
return m_data->m_returnData.hasError();
return m_data->m_returnData->hasError();
}
std::string zeus::FutureBase::getErrorType() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return "NULL_PTR";
}
return m_data->m_returnData.getError();
return m_data->m_returnData->getError();
}
std::string zeus::FutureBase::getErrorHelp() {
if (m_data == nullptr) {
if ( m_data == nullptr
|| m_data->m_returnData == nullptr) {
return "Thsi is a nullptr future";
}
return m_data->m_returnData.getErrorHelp();
return m_data->m_returnData->getErrorHelp();
}
bool zeus::FutureBase::isValid() {
bool zeus::FutureBase::isValid() const {
return m_data != nullptr;
}
bool zeus::FutureBase::isFinished() {
bool zeus::FutureBase::isFinished() const {
if (m_data == nullptr) {
return true;
}
@ -184,35 +171,43 @@ zeus::FutureBase& zeus::FutureBase::waitUntil(std::chrono::steady_clock::time_po
}
zeus::FutureCall::FutureCall(uint64_t _clientId, uint64_t _transactionId, zeus::Buffer& _callValue) :
zeus::FutureCall::FutureCall(uint64_t _clientId, uint64_t _transactionId, const ememory::SharedPtr<zeus::Buffer>& _callValue) :
m_transactionId(_transactionId),
m_clientId(_clientId),
m_isFinished(false) {
m_data = _callValue;
m_isFinished = m_data.getPartFinish();
m_isFinished = m_data->getPartFinish();
}
void zeus::FutureCall::appendData(zeus::Buffer& _callValue) {
m_dataMultiplePack.push_back(_callValue);
m_isFinished = _callValue.getPartFinish();
void zeus::FutureCall::appendData(const ememory::SharedPtr<zeus::Buffer>& _value) {
if (_value->getType() == zeus::Buffer::typeMessage::data) {
if (m_data == nullptr) {
return;
}
m_data->appendBufferData(_value);
} else {
m_data = _value;
}
m_dataMultiplePack.push_back(_value);
m_isFinished = _value->getPartFinish();
}
uint64_t zeus::FutureCall::getTransactionId() {
uint64_t zeus::FutureCall::getTransactionId() const {
return m_transactionId;
}
uint64_t zeus::FutureCall::getClientId() {
uint64_t zeus::FutureCall::getClientId() const {
return m_clientId;
}
bool zeus::FutureCall::isFinished() {
bool zeus::FutureCall::isFinished() const {
return m_isFinished;
}
zeus::Buffer& zeus::FutureCall::getRaw() {
ememory::SharedPtr<zeus::Buffer> zeus::FutureCall::getRaw() const {
return m_data;
}
std::chrono::nanoseconds zeus::FutureCall::getTransmitionTime() {
std::chrono::nanoseconds zeus::FutureCall::getTransmitionTime() const {
return m_answerTime - m_receiveTime;
}

28
zeus/FutureBase.h
View File

@ -15,20 +15,20 @@ namespace zeus {
FutureBase(const zeus::FutureBase& _base);
FutureBase();
FutureBase(uint64_t _transactionId, zeus::FutureData::ObserverFinish _callback=nullptr);
FutureBase(uint64_t _transactionId, bool _isFinished, zeus::Buffer _returnData, zeus::FutureData::ObserverFinish _callback=nullptr);
FutureBase(uint64_t _transactionId, bool _isFinished, const ememory::SharedPtr<zeus::Buffer>& _returnData, zeus::FutureData::ObserverFinish _callback=nullptr);
zeus::FutureBase operator= (const zeus::FutureBase& _base);
bool setAnswer(const zeus::Buffer& _returnValue);
bool setAnswer(const ememory::SharedPtr<zeus::Buffer>& _returnValue);
void setSynchronous();
uint64_t getTransactionId();
bool hasError();
std::string getErrorType();
std::string getErrorHelp();
bool isValid();
bool isFinished();
bool isValid() const;
bool isFinished() const;
FutureBase& wait();
FutureBase& waitFor(std::chrono::microseconds _delta = std::chrono::seconds(30));
FutureBase& waitUntil(std::chrono::steady_clock::time_point _endTime);
const zeus::Buffer& getRaw();
ememory::SharedPtr<zeus::Buffer> getRaw();
std::chrono::nanoseconds getTransmitionTime();
};
class FutureCall {
@ -36,18 +36,18 @@ namespace zeus {
uint64_t m_transactionId;
uint64_t m_clientId;
bool m_isFinished;
zeus::Buffer m_data;
std::vector<zeus::Buffer> m_dataMultiplePack;
ememory::SharedPtr<zeus::Buffer> m_data;
std::vector<ememory::SharedPtr<zeus::Buffer>> m_dataMultiplePack;
std::chrono::steady_clock::time_point m_receiveTime;
std::chrono::steady_clock::time_point m_answerTime;
public:
FutureCall(uint64_t _clientId, uint64_t _transactionId, zeus::Buffer& _callValue);
void appendData(zeus::Buffer& _callValue);
uint64_t getTransactionId();
uint64_t getClientId();
bool isFinished();
std::chrono::nanoseconds getTransmitionTime();
zeus::Buffer& getRaw();
FutureCall(uint64_t _clientId, uint64_t _transactionId, const ememory::SharedPtr<zeus::Buffer>& _callValue);
void appendData(const ememory::SharedPtr<zeus::Buffer>& _callValue);
uint64_t getTransactionId() const;
uint64_t getClientId() const;
bool isFinished() const;
std::chrono::nanoseconds getTransmitionTime() const;
ememory::SharedPtr<zeus::Buffer> getRaw() const;
};
}

2
zeus/FutureData.h
View File

@ -20,7 +20,7 @@ namespace zeus {
uint64_t m_transactionId;
bool m_isSynchronous;
bool m_isFinished;
zeus::Buffer m_returnData;
ememory::SharedPtr<zeus::Buffer> m_returnData;
ObserverFinish m_callbackFinish;
std::chrono::steady_clock::time_point m_sendTime;
std::chrono::steady_clock::time_point m_receiveTime;

2
zeus/GateWay.cpp
View File

@ -129,7 +129,7 @@ std::vector<std::string> zeus::GateWay::getAllServiceName() {
}
void zeus::GateWay::answer(uint64_t _userSessionId, zeus::Buffer& _data) {
void zeus::GateWay::answer(uint64_t _userSessionId, const ememory::SharedPtr<zeus::Buffer>& _data) {
for (auto &it : m_clientList) {
if (it == nullptr) {
continue;

2
zeus/GateWay.h
View File

@ -32,7 +32,7 @@ namespace zeus {
void stop();
ememory::SharedPtr<zeus::GateWayService> get(const std::string& _serviceName);
std::vector<std::string> getAllServiceName();
void answer(uint64_t _userSessionId, zeus::Buffer& _data);
void answer(uint64_t _userSessionId, const ememory::SharedPtr<zeus::Buffer>& _data);
void newService(enet::Tcp _connection);
void newClient(enet::Tcp _connection);
void cleanIO();

46
zeus/GateWayClient.cpp
View File

@ -66,19 +66,22 @@ void zeus::GateWayClient::answerProtocolError(uint32_t _transactionId, const std
}
void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
uint32_t transactionId = _value.getTransactionId();
void zeus::GateWayClient::onClientData(const ememory::SharedPtr<zeus::Buffer>& _value) {
if (_value == nullptr) {
return;
}
uint32_t transactionId = _value->getTransactionId();
if (transactionId == 0) {
ZEUS_ERROR("Protocol error ==>missing id");
answerProtocolError(transactionId, "missing parameter: 'id'");
return;
}
if (_value.getType() != zeus::Buffer::typeMessage::call) {
if (_value->getType() != zeus::Buffer::typeMessage::call) {
ZEUS_ERROR("Protocol error ==>missing 'call'");
answerProtocolError(transactionId, "missing parameter: 'call' / wrong type 'call'");
return;
}
std::string callFunction = _value.getCall();
std::string callFunction = _value->getCall();
switch (m_state) {
case zeus::GateWayClient::state::disconnect:
case zeus::GateWayClient::state::unconnect:
@ -94,7 +97,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
return;
}
if (callFunction == "connectToUser") {
m_userConnectionName = _value.getParameter<std::string>(0);
m_userConnectionName = _value->getParameter<std::string>(0);
if (m_userConnectionName == "") {
answerProtocolError(transactionId, "Call connectToUser with no parameter 'user'");
} else {
@ -127,8 +130,8 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
return;
}
if (callFunction == "identify") {
std::string clientName = _value.getParameter<std::string>(0);
std::string clientTocken = _value.getParameter<std::string>(1);
std::string clientName = _value->getParameter<std::string>(0);
std::string clientTocken = _value->getParameter<std::string>(1);
if (m_userService == nullptr) {
answerProtocolError(transactionId, "gateWay internal error 3");
return;
@ -149,7 +152,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
m_clientName = clientName;
}
if (callFunction == "auth") {
std::string password = _value.getParameter<std::string>(0);
std::string password = _value->getParameter<std::string>(0);
zeus::Future<bool> fut = m_userService->m_interfaceClient.callClient(m_uid2, "checkAuth", password);
fut.wait(); // TODO: Set timeout ...
if (fut.hasError() == true) {
@ -204,7 +207,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
break;
case zeus::GateWayClient::state::clientIdentify:
{
uint32_t serviceId = _value.getServiceId();
uint32_t serviceId = _value->getServiceId();
if (serviceId == 0) {
// This is 2 default service for the cient interface that manage the authorisation of view:
if (callFunction == "getServiceCount") {
@ -218,7 +221,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
}
if (callFunction == "link") {
// first param:
std::string serviceName = _value.getParameter<std::string>(0);
std::string serviceName = _value->getParameter<std::string>(0);
// Check if service already link:
auto it = m_listConnectedService.begin();
while (it != m_listConnectedService.end()) {
@ -259,7 +262,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
}
if (callFunction == "unlink") {
// first param: the service we want to unconnect ...
int64_t localServiceID = _value.getParameter<int64_t>(0)-1;
int64_t localServiceID = _value->getParameter<int64_t>(0)-1;
// Check if service already link:
if (localServiceID >= m_listConnectedService.size()) {
m_interfaceClient.answerError(transactionId, "NOT-CONNECTED-SERVICE");
@ -291,7 +294,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
ZEUS_ERROR("TODO : Manage this case ...");
return;
}
uint16_t partId = _value.getPartId();
uint16_t partId = _value->getPartId();
if (partId != 0) {
m_listConnectedService[serviceId]->m_interfaceClient.callForwardMultiple(
m_uid,
@ -304,21 +307,24 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) {
_value,
(uint64_t(m_uid) << 32) + uint64_t(transactionId),
[=](zeus::FutureBase _ret) {
zeus::Buffer tmpp = _ret.getRaw();
ZEUS_DEBUG(" ==> transmit : " << tmpp.getTransactionId() << " -> " << transactionId);
ZEUS_DEBUG(" msg=" << tmpp.generateHumanString());
tmpp.setTransactionId(transactionId);
tmpp.setServiceId(serviceId+1);
ZEUS_DEBUG("transmit=" << tmpp.generateHumanString());
ememory::SharedPtr<zeus::Buffer> tmpp = _ret.getRaw();
if (tmpp == nullptr) {
return true;
}
ZEUS_DEBUG(" ==> transmit : " << tmpp->getTransactionId() << " -> " << transactionId);
ZEUS_DEBUG(" msg=" << tmpp->generateHumanString());
tmpp->setTransactionId(transactionId);
tmpp->setServiceId(serviceId+1);
ZEUS_DEBUG("transmit=" << tmpp->generateHumanString());
m_interfaceClient.writeBinary(tmpp);
// multiple send element ...
return tmpp.getPartFinish();
return tmpp->getPartFinish();
});
}
}
}
}
void zeus::GateWayClient::returnMessage(zeus::Buffer& _data) {
void zeus::GateWayClient::returnMessage(const ememory::SharedPtr<zeus::Buffer>& _data) {
ZEUS_ERROR("Get call from the Service to the user ...");
}

4
zeus/GateWayClient.h
View File

@ -44,8 +44,8 @@ namespace zeus {
virtual ~GateWayClient();
void start(uint64_t _uid, uint64_t _uid2);
void stop();
void onClientData(zeus::Buffer& _value);
void returnMessage(zeus::Buffer& _data);
void onClientData(const ememory::SharedPtr<zeus::Buffer>& _value);
void returnMessage(const ememory::SharedPtr<zeus::Buffer>& _data);
bool checkId(uint64_t _id) const {
return m_uid == _id
|| m_uid2 == _id;

25
zeus/GateWayService.cpp
View File

@ -43,15 +43,18 @@ void zeus::GateWayService::stop() {
}
void zeus::GateWayService::SendData(uint64_t _userSessionId, zeus::Buffer& _data) {
_data.setClientId(_userSessionId);
void zeus::GateWayService::SendData(uint64_t _userSessionId, const ememory::SharedPtr<zeus::Buffer>& _data) {
_data->setClientId(_userSessionId);
m_interfaceClient.writeBinary(_data);
}
void zeus::GateWayService::onServiceData(zeus::Buffer& _value) {
uint32_t transactionId = _value.getTransactionId();
void zeus::GateWayService::onServiceData(const ememory::SharedPtr<zeus::Buffer>& _value) {
if (_value == nullptr) {
return;
}
uint32_t transactionId = _value->getTransactionId();
//data.add("from-service", ejson::String(m_name));
if (_value.getType() == zeus::Buffer::typeMessage::event) {
if (_value->getType() == zeus::Buffer::typeMessage::event) {
/*
if (data.valueExist("event") == true) {
// No need to have a user ID ...
@ -70,26 +73,26 @@ void zeus::GateWayService::onServiceData(zeus::Buffer& _value) {
*/
return;
}
if (_value.getType() == zeus::Buffer::typeMessage::call) {
std::string callFunction = _value.getCall();
if (_value->getType() == zeus::Buffer::typeMessage::call) {
std::string callFunction = _value->getCall();
if (callFunction == "connect-service") {
if (m_name != "") {
ZEUS_WARNING("Service interface ==> try change the servie name after init: '" << _value.getParameter<std::string>(0));
ZEUS_WARNING("Service interface ==> try change the servie name after init: '" << _value->getParameter<std::string>(0));
m_interfaceClient.answerValue(transactionId, false);
return;
}
m_name = _value.getParameter<std::string>(0);
m_name = _value->getParameter<std::string>(0);
m_interfaceClient.setInterfaceName("srv-" + m_name);
m_interfaceClient.answerValue(transactionId, true);
return;
}
answerProtocolError(transactionId, "unknow function");
}
if (_value.getClientId() == 0) {
if (_value->getClientId() == 0) {
ZEUS_ERROR("Service interface ==> wrong service answer ==> missing 'client-id'");
return;
}
m_gatewayInterface->answer(_value.getClientId(), _value);
m_gatewayInterface->answer(_value->getClientId(), _value);
}

4
zeus/GateWayService.h
View File

@ -25,9 +25,9 @@ namespace zeus {
virtual ~GateWayService();
void start();
void stop();
void onServiceData(zeus::Buffer& _value);
void onServiceData(const ememory::SharedPtr<zeus::Buffer>& _value);
public:
void SendData(uint64_t _userSessionId, zeus::Buffer& _data);
void SendData(uint64_t _userSessionId, const ememory::SharedPtr<zeus::Buffer>& _data);
const std::string& getName() {
return m_name;
}

1
zeus/ParamType.cpp
View File

@ -117,4 +117,5 @@ generate_basic_type(zeus::File, "file", 0x000E, false, false);
generate_basic_type(zeus::FileServer, "file", 0x000E, false, false);
const uint16_t zeus::paramTypeObject = 0xFFFF;
const uint16_t zeus::paramTypeRaw = 0xFFFE;

1
zeus/ParamType.h
View File

@ -29,6 +29,7 @@ namespace zeus {
bool isVector() const;
};
extern const uint16_t paramTypeObject;
extern const uint16_t paramTypeRaw;
std::ostream& operator <<(std::ostream& _os, const zeus::ParamType& _obj);
template<class ZEUS_TYPE>

26
zeus/Service.cpp
View File

@ -32,9 +32,9 @@ std::vector<std::string> zeus::Service::getExtention() {
}
void zeus::Service::onClientData(zeus::Buffer& _value) {
uint32_t tmpID = _value.getTransactionId();
uint32_t clientId = _value.getClientId();;
void zeus::Service::onClientData(const ememory::SharedPtr<zeus::Buffer>& _value) {
uint32_t tmpID = _value->getTransactionId();
uint32_t clientId = _value->getClientId();;
auto it = m_callMultiData.begin();
while (it != m_callMultiData.end()) {
if ( it->getTransactionId() == tmpID
@ -119,24 +119,26 @@ void zeus::Service::pingIsAlive() {
}
}
void zeus::Service::callBinary(uint32_t _transactionId, zeus::Buffer& _obj) {
if (_obj.getType() == zeus::Buffer::typeMessage::event) {
void zeus::Service::callBinary(uint32_t _transactionId, const ememory::SharedPtr<zeus::Buffer>& _obj) {
if (_obj == nullptr) {
return;
}
if (_obj->getType() == zeus::Buffer::typeMessage::event) {
ZEUS_ERROR("Unknow event: '...'");
return;
}
if (_obj.getType() == zeus::Buffer::typeMessage::answer) {
if (_obj->getType() == zeus::Buffer::typeMessage::answer) {
ZEUS_ERROR("Local Answer: '...'");
return;
}
//if (_obj.getType() == zeus::Buffer::typeMessage::event) {
uint32_t clientId = _obj.getClientId();
std::string callFunction = _obj.getCall();
uint32_t clientId = _obj->getClientId();
std::string callFunction = _obj->getCall();
if (callFunction[0] == '_') {
if (callFunction == "_new") {
std::string userName = _obj.getParameter<std::string>(0);
std::string clientName = _obj.getParameter<std::string>(1);
std::vector<std::string> clientGroup = _obj.getParameter<std::vector<std::string>>(2);
std::string userName = _obj->getParameter<std::string>(0);
std::string clientName = _obj->getParameter<std::string>(1);
std::vector<std::string> clientGroup = _obj->getParameter<std::vector<std::string>>(2);
clientConnect(clientId, userName, clientName, clientGroup);
} else if (callFunction == "_delete") {
clientDisconnect(clientId);

8
zeus/Service.h
View File

@ -68,7 +68,7 @@ namespace zeus {
void connect(const std::string& _serviceName, uint32_t _numberRetry = 1);
void disconnect();
private:
void onClientData(zeus::Buffer& _value);
void onClientData(const ememory::SharedPtr<zeus::Buffer>& _value);
public:
void pingIsAlive();
bool GateWayAlive();
@ -84,8 +84,8 @@ namespace zeus {
virtual void clientConnect(uint64_t _clientId, const std::string& _userName, const std::string& _clientName, const std::vector<std::string>& _groups) = 0;
virtual void clientDisconnect(uint64_t _clientId) = 0;
// Genenric function call:
void callBinary(uint32_t _transactionId, zeus::Buffer& _obj);
virtual void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, zeus::Buffer& _obj) = 0;
void callBinary(uint32_t _transactionId, const ememory::SharedPtr<zeus::Buffer>& _obj);
virtual void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, const ememory::SharedPtr<zeus::Buffer>& _obj) = 0;
std::vector<std::string> getExtention();
public:
// Add Local fuction (depend on this class)
@ -208,7 +208,7 @@ namespace zeus {
}
it->second.first->setGroups(_clientGroups);
}
void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, zeus::Buffer& _obj) {
void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, const ememory::SharedPtr<zeus::Buffer>& _obj) {
auto it = m_interface.find(_clientId);
if (it == m_interface.end()) {
m_interfaceClient->answerError(_transactionId, "CLIENT-UNKNOW", "", _clientId);

12
zeus/ServiceRemote.h
View File

@ -29,8 +29,10 @@ namespace zeus {
template<class... _ARGS>
zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) {
if (m_interfaceClient == nullptr) {
zeus::Buffer ret;
ret.addError("NULLPTR", "call " + _functionName + " with no interface open");
ememory::SharedPtr<zeus::Buffer> ret = zeus::Buffer::create();
if (ret != nullptr) {
ret->addError("NULLPTR", "call " + _functionName + " with no interface open");
}
return zeus::FutureBase(0, true, ret);
}
return m_interfaceClient->callService(m_serviceId, _functionName, _args...);
@ -38,8 +40,10 @@ namespace zeus {
template<class... _ARGS>
zeus::FutureBase callAction(const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) {
if (m_interfaceClient == nullptr) {
zeus::Buffer ret;
ret.addError("NULLPTR", "call " + _functionName + " with no interface open");
ememory::SharedPtr<zeus::Buffer> ret = zeus::Buffer::create();
if (ret != nullptr) {
ret->addError("NULLPTR", "call " + _functionName + " with no interface open");
}
return zeus::FutureBase(0, true, ret, _callback);
}
return m_interfaceClient->callServiceAction(m_serviceId, _functionName, _args..., _callback);

195
zeus/TcpString.cpp
View File

@ -90,11 +90,62 @@ void zeus::TcpString::disconnect(bool _inThreadStop){
ZEUS_DEBUG("disconnect [STOP]");
}
int32_t zeus::TcpString::writeBinary(zeus::Buffer& _data) {
class SendAsyncBinary {
private:
std::vector<zeus::ActionAsyncClient> m_async;
uint64_t m_transactionId;
uint32_t m_serviceId;
uint32_t m_partId;
public:
SendAsyncBinary(uint64_t _transactionId, const uint32_t& _serviceId, std::vector<zeus::ActionAsyncClient> _async) :
m_async(std::move(_async)),
m_transactionId(_transactionId),
m_serviceId(_serviceId),
m_partId(1) {
}
bool operator() (zeus::TcpString* _interface){
auto it = m_async.begin();
while (it != m_async.end()) {
bool ret = (*it)(_interface, m_serviceId, m_transactionId, m_partId);
if (ret == true) {
// Remove it ...
it = m_async.erase(it);
} else {
++it;
}
m_partId++;
}
if (m_async.size() == 0) {
ememory::SharedPtr<zeus::Buffer> obj = zeus::Buffer::create();
if (obj == nullptr) {
return true;
}
obj->setType(zeus::Buffer::typeMessage::data);
obj->setServiceId(m_serviceId);
obj->setTransactionId(m_transactionId);
obj->setPartId(m_partId);
obj->setPartFinish(true);
_interface->writeBinary(obj);
return true;
}
return false;
}
};
int32_t zeus::TcpString::writeBinary(const ememory::SharedPtr<zeus::Buffer>& _obj) {
if (m_connection.isAlive() == false) {
return -2;
}
if (_data.writeOn(m_connection) == true) {
if (_obj->haveAsync() == true) {
ZEUS_WARNING("Set Flag not finish ...");
_obj->setPartFinish(false);
}
if (_obj->writeOn(m_connection) == true) {
if (_obj->haveAsync() == true) {
ZEUS_WARNING("Add async");
addAsync(SendAsyncBinary(_obj->getTransactionId(), _obj->getServiceId(), std::move(_obj->moveAsync())));
}
return 1;
}
return -1;
@ -115,14 +166,13 @@ bool zeus::TcpString::onReceiveUri(const std::string& _uri, const std::vector<st
}
void zeus::TcpString::onReceiveData(std::vector<uint8_t>& _frame, bool _isBinary) {
ZEUS_VERBOSE("Receive Frame ... " << _frame.size());
zeus::Buffer dataRaw;
ememory::SharedPtr<zeus::Buffer> dataRaw = zeus::Buffer::create();
if (_isBinary == true) {
ZEUS_ERROR("Receive non binary frame ...");
disconnect(true);
return;
}
dataRaw.composeWith(_frame);
dataRaw->composeWith(_frame);
newBuffer(dataRaw);
}
@ -130,10 +180,10 @@ void zeus::TcpString::ping() {
m_connection.controlPing();
}
void zeus::TcpString::newBuffer(zeus::Buffer& _buffer) {
ZEUS_VERBOSE("Receive Binary :" << _buffer.generateHumanString());
void zeus::TcpString::newBuffer(const ememory::SharedPtr<zeus::Buffer>& _buffer) {
ZEUS_DEBUG("Receive :" << _buffer->generateHumanString());
zeus::FutureBase future;
uint64_t tid = _buffer.getTransactionId();
uint64_t tid = _buffer->getTransactionId();
if (tid == 0) {
ZEUS_ERROR("Get a Protocol error ... No ID ...");
/*
@ -195,16 +245,28 @@ void zeus::TcpString::newBuffer(zeus::Buffer& _buffer) {
}
}
void zeus::TcpString::addAsync(zeus::TcpString::ActionAsync _elem) {
std::unique_lock<std::mutex> lock(m_threadAsyncMutex);
m_threadAsyncList2.push_back(_elem);
}
void zeus::TcpString::threadAsyncCallback() {
ethread::setName("Async-sender");
ZEUS_INFO("Async Sender [START]...");
// get datas:
while ( m_threadAsyncRunning == true
&& m_connection.isAlive() == true) {
if (m_threadAsyncList2.size() != 0) {
std::unique_lock<std::mutex> lock(m_threadAsyncMutex);
for (auto &it : m_threadAsyncList2) {
m_threadAsyncList.push_back(it);
}
m_threadAsyncList2.clear();
}
if (m_threadAsyncList.size() == 0) {
usleep(10000);
continue;
}
std::unique_lock<std::mutex> lock(m_threadAsyncMutex);
auto it = m_threadAsyncList.begin();
while (it != m_threadAsyncList.end()) {
bool ret = (*it)(this);
@ -217,58 +279,19 @@ void zeus::TcpString::threadAsyncCallback() {
}
}
m_threadAsyncRunning = false;
ZEUS_DEBUG("End of thread");
ZEUS_INFO("Async Sender [STOP]");
}
class SendAsyncBinary {
private:
std::vector<zeus::ActionAsyncClient> m_async;
uint64_t m_transactionId;
uint32_t m_serviceId;
uint32_t m_partId;
public:
SendAsyncBinary(uint64_t _transactionId, const uint32_t& _serviceId, const std::vector<zeus::ActionAsyncClient>& _async) :
m_async(_async),
m_transactionId(_transactionId),
m_serviceId(_serviceId),
m_partId(1) {
}
bool operator() (zeus::TcpString* _interface){
auto it = m_async.begin();
while (it != m_async.end()) {
bool ret = (*it)(_interface, m_serviceId, m_transactionId, m_partId);
if (ret == true) {
// Remove it ...
it = m_async.erase(it);
} else {
++it;
}
m_partId++;
}
if (m_async.size() == 0) {
zeus::Buffer obj;
obj.setServiceId(m_serviceId);
obj.setTransactionId(m_transactionId);
obj.setPartId(m_partId);
obj.setPartFinish(true);
_interface->writeBinary(obj);
return true;
}
return false;
}
};
zeus::FutureBase zeus::TcpString::callBinary(uint64_t _transactionId,
zeus::Buffer& _obj,
const std::vector<ActionAsyncClient>& _async,
const ememory::SharedPtr<zeus::Buffer>& _obj,
zeus::FutureData::ObserverFinish _callback,
const uint32_t& _serviceId) {
ZEUS_VERBOSE("Send Binary [START] ");
ZEUS_VERBOSE("Send [START] ");
if (isActive() == false) {
zeus::Buffer obj;
obj.setType(zeus::Buffer::typeMessage::answer);
obj.addError("NOT-CONNECTED", "Client interface not connected (no TCP)");
ememory::SharedPtr<zeus::Buffer> obj = zeus::Buffer::create();
obj->setType(zeus::Buffer::typeMessage::answer);
obj->addError("NOT-CONNECTED", "Client interface not connected (no TCP)");
return zeus::FutureBase(_transactionId, true, obj, _callback);
}
zeus::FutureBase tmpFuture(_transactionId, _callback);
@ -276,37 +299,28 @@ zeus::FutureBase zeus::TcpString::callBinary(uint64_t _transactionId,
std::unique_lock<std::mutex> lock(m_pendingCallMutex);
m_pendingCall.push_back(std::make_pair(uint64_t(0), tmpFuture));
}
if (_async.size() != 0) {
_obj.setPartFinish(false);
} else {
_obj.setPartFinish(true);
}
writeBinary(_obj);
if (_async.size() != 0) {
addAsync(SendAsyncBinary(_transactionId, _serviceId, _async));
}
ZEUS_VERBOSE("Send Binary [STOP]");
ZEUS_VERBOSE("Send [STOP]");
return tmpFuture;
}
zeus::FutureBase zeus::TcpString::callForward(uint32_t _clientId,
zeus::Buffer& _buffer,
uint64_t _singleReferenceId,
zeus::FutureData::ObserverFinish _callback) {
const ememory::SharedPtr<zeus::Buffer>& _buffer,
uint64_t _singleReferenceId,
zeus::FutureData::ObserverFinish _callback) {
ZEUS_VERBOSE("Call Forward [START]");
//zeus::FutureBase ret = callBinary(id, _Buffer, async, _callback);
//ret.setSynchronous();
if (isActive() == false) {
zeus::Buffer obj;
obj.setType(zeus::Buffer::typeMessage::answer);
obj.addError("NOT-CONNECTED", "Client interface not connected (no TCP)");
ememory::SharedPtr<zeus::Buffer> obj = zeus::Buffer::create();
obj->setType(zeus::Buffer::typeMessage::answer);
obj->addError("NOT-CONNECTED", "Client interface not connected (no TCP)");
return zeus::FutureBase(0, true, obj, _callback);
}
uint64_t id = getId();
_buffer.setTransactionId(id);
_buffer.setClientId(_clientId);
_buffer->setTransactionId(id);
_buffer->setClientId(_clientId);
zeus::FutureBase tmpFuture(id, _callback);
tmpFuture.setSynchronous();
{
@ -319,16 +333,19 @@ zeus::FutureBase zeus::TcpString::callForward(uint32_t _clientId,
}
void zeus::TcpString::callForwardMultiple(uint32_t _clientId,
zeus::Buffer& _buffer,
uint64_t _singleReferenceId){
const ememory::SharedPtr<zeus::Buffer>& _buffer,
uint64_t _singleReferenceId){
if (_buffer == nullptr) {
return;
}
// subMessage ... ==> try to forward message:
std::unique_lock<std::mutex> lock(m_pendingCallMutex);
for (auto &itCall : m_pendingCall) {
ZEUS_INFO(" compare : " << itCall.first << " =?= " << _singleReferenceId);
if (itCall.first == _singleReferenceId) {
// Find element ==> transit it ...
_buffer.setTransactionId(itCall.second.getTransactionId());
_buffer.setClientId(_clientId);
_buffer->setTransactionId(itCall.second.getTransactionId());
_buffer->setClientId(_clientId);
writeBinary(_buffer);
return;
}
@ -337,20 +354,26 @@ void zeus::TcpString::callForwardMultiple(uint32_t _clientId,
}
void zeus::TcpString::answerError(uint64_t _clientTransactionId, const std::string& _errorValue, const std::string& _errorHelp, uint32_t _clientId) {
zeus::Buffer answer;
answer.setType(zeus::Buffer::typeMessage::answer);
answer.setTransactionId(_clientTransactionId);
answer.setClientId(_clientId);
answer.addError(_errorValue, _errorHelp);
ememory::SharedPtr<zeus::Buffer> answer = zeus::Buffer::create();
if (answer == nullptr) {
return;
}
answer->setType(zeus::Buffer::typeMessage::answer);
answer->setTransactionId(_clientTransactionId);
answer->setClientId(_clientId);
answer->addError(_errorValue, _errorHelp);
writeBinary(answer);
}
void zeus::TcpString::answerVoid(uint64_t _clientTransactionId, uint32_t _clientId) {
zeus::Buffer answer;
answer.setType(zeus::Buffer::typeMessage::answer);
answer.setTransactionId(_clientTransactionId);
answer.setClientId(_clientId);
answer.addParameter();
ememory::SharedPtr<zeus::Buffer> answer = zeus::Buffer::create();
if (answer == nullptr) {
return;
}
answer->setType(zeus::Buffer::typeMessage::answer);
answer->setTransactionId(_clientTransactionId);
answer->setClientId(_clientId);
answer->addParameter();
writeBinary(answer);
}

53
zeus/TcpString.h
View File

@ -24,7 +24,7 @@ namespace zeus {
std::mutex m_pendingCallMutex;
std::vector<std::pair<uint64_t, zeus::FutureBase>> m_pendingCall;
public:
using Observer = std::function<void(zeus::Buffer&)>; //!< Define an Observer: function pointer
using Observer = std::function<void(const ememory::SharedPtr<zeus::Buffer>&)>; //!< Define an Observer: function pointer
Observer m_observerElement;
/**
* @brief Connect an function member on the signal with the shared_ptr object.
@ -33,8 +33,8 @@ namespace zeus {
* @param[in] _args Argument optinnal the user want to add.
*/
template<class CLASS_TYPE>
void connect(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(zeus::Buffer&)) {
m_observerElement = [=](zeus::Buffer& _value){
void connect(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(const ememory::SharedPtr<zeus::Buffer>&)) {
m_observerElement = [=](const ememory::SharedPtr<zeus::Buffer>& _value){
(*_class.*_func)(_value);
};
}
@ -47,11 +47,11 @@ namespace zeus {
void disconnect(bool _inThreadStop = false);
bool isActive() const;
void setInterfaceName(const std::string& _name);
int32_t writeBinary(zeus::Buffer& _data);
int32_t writeBinary(const ememory::SharedPtr<zeus::Buffer>& _data);
void ping();
bool onReceiveUri(const std::string& _uri, const std::vector<std::string>& _protocols);
void onReceiveData(std::vector<uint8_t>& _frame, bool _isBinary);
void newBuffer(zeus::Buffer& _buffer);
void newBuffer(const ememory::SharedPtr<zeus::Buffer>& _buffer);
public:
const std::chrono::steady_clock::time_point& getLastTimeReceive() {
return m_connection.getLastTimeReceive();
@ -65,49 +65,42 @@ namespace zeus {
std::thread* m_threadAsync;
bool m_threadAsyncRunning;
std::vector<ActionAsync> m_threadAsyncList;
std::vector<ActionAsync> m_threadAsyncList2;
private:
void threadAsyncCallback();
public:
void addAsync(ActionAsync _elem) {
std::unique_lock<std::mutex> lock(m_threadAsyncMutex);
m_threadAsyncList.push_back(_elem);
}
void addAsync(ActionAsync _elem);
private:
zeus::FutureBase callBinary(uint64_t _transactionId,
zeus::Buffer& _obj,
const std::vector<ActionAsyncClient>& _async,
const ememory::SharedPtr<zeus::Buffer>& _obj,
zeus::FutureData::ObserverFinish _callback=nullptr,
const uint32_t& _service=0);
public: // section call direct
template<class... _ARGS>
zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) {
uint16_t id = getId();
std::vector<zeus::ActionAsyncClient> asyncAction;
zeus::Buffer callElem = zeus::createBinaryCall(asyncAction, id, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem, asyncAction);
ememory::SharedPtr<zeus::Buffer> callElem = zeus::createBinaryCall(id, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem);
}
template<class... _ARGS>
zeus::FutureBase callAction(const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) {
uint16_t id = getId();
std::vector<zeus::ActionAsyncClient> asyncAction;
zeus::Buffer callElem = zeus::createBinaryCall(asyncAction, id, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem, asyncAction, _callback);
ememory::SharedPtr<zeus::Buffer> callElem = zeus::createBinaryCall(id, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem, _callback);
}
public: // section call with service ID / Client ID
template<class... _ARGS>
zeus::FutureBase callService(uint32_t _serviceId, const std::string& _functionName, _ARGS&&... _args) {
uint16_t id = getId();
std::vector<zeus::ActionAsyncClient> asyncActionToDo;
zeus::Buffer callElem = zeus::createBinaryCallService(asyncActionToDo, id, _serviceId, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem, asyncActionToDo);
ememory::SharedPtr<zeus::Buffer> callElem = zeus::createBinaryCallService(id, _serviceId, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem);
}
template<class... _ARGS>
zeus::FutureBase callServiceAction(uint32_t _serviceId, const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) {
uint16_t id = getId();
std::vector<zeus::ActionAsyncClient> asyncActionToDo;
zeus::Buffer callElem = zeus::createBinaryCallService(asyncActionToDo, id, _serviceId, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem, asyncActionToDo, _callback);
ememory::SharedPtr<zeus::Buffer> callElem = zeus::createBinaryCallService(id, _serviceId, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem, _callback);
}
template<class... _ARGS>
zeus::FutureBase callClient(uint32_t _clientId,
@ -123,22 +116,22 @@ namespace zeus {
return callServiceAction(_clientId, _functionName, _args..., _callback);
}
zeus::FutureBase callForward(uint32_t _clientId,
zeus::Buffer& _Buffer,
const ememory::SharedPtr<zeus::Buffer>& _Buffer,
uint64_t _singleReferenceId,
zeus::FutureData::ObserverFinish _callback);
void callForwardMultiple(uint32_t _clientId,
zeus::Buffer& _Buffer,
const ememory::SharedPtr<zeus::Buffer>& _Buffer,
uint64_t _singleReferenceId);
public: // answers ...
void answerProtocolError(uint32_t _transactionId, const std::string& _errorHelp);
template<class ZEUS_ARG>
void answerValue(uint64_t _clientTransactionId, ZEUS_ARG _value, uint32_t _clientId=0) {
zeus::Buffer answer;
answer.setType(zeus::Buffer::typeMessage::answer);
answer.setTransactionId(_clientTransactionId);
answer.setClientId(_clientId);
answer.addAnswer(_value);
ememory::SharedPtr<zeus::Buffer> answer = zeus::Buffer::create();
answer->setType(zeus::Buffer::typeMessage::answer);
answer->setTransactionId(_clientTransactionId);
answer->setClientId(_clientId);
answer->addAnswer(_value);
writeBinary(answer);
}
void answerVoid(uint64_t _clientTransactionId, uint32_t _clientId=0);