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

[DEV] nearly finish the send and get file

Browse Source
This commit is contained in:
Edouard DUPIN 2016-12-06 21:14:11 +01:00
parent 615486529d
commit d13a239878
31 changed files with 244 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lutinMacro_zeus.py
View File

@ -463,7 +463,7 @@ class ServiceDefinition:
""" """
out += " addType(data, createType<" + class_name + ">());\n" out += " addType(data, createType<" + class_name + ">());\n"
""" """
out += " addTypeObject(data, \"" + class_name + "\");\n" out += " addTypeObject(data, \"obj:" + class_name + "\");\n"
out += " int32_t currentOffset = data.size();\n" out += " int32_t currentOffset = data.size();\n"
out += " int32_t startOffset = data.size();\n" out += " int32_t startOffset = data.size();\n"
out += " data.resize(data.size()+4);\n" out += " data.resize(data.size()+4);\n"

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

@ -11,6 +11,7 @@
#include <etk/etk.hpp> #include <etk/etk.hpp>
#include <zeus/zeus.hpp> #include <zeus/zeus.hpp>
#include <etk/os/FSNode.hpp> #include <etk/os/FSNode.hpp>
#include <elog/elog.hpp>
#include <etk/stdTools.hpp> #include <etk/stdTools.hpp>
@ -23,6 +24,7 @@
int main(int _argc, const char *_argv[]) { int main(int _argc, const char *_argv[]) {
etk::init(_argc, _argv); etk::init(_argc, _argv);
elog::init(_argc, _argv);
zeus::init(_argc, _argv); zeus::init(_argc, _argv);
zeus::Client client1; zeus::Client client1;
for (int32_t iii=0; iii<_argc ; ++iii) { for (int32_t iii=0; iii<_argc ; ++iii) {
@ -92,7 +94,7 @@ int main(int _argc, const char *_argv[]) {
} }
*/ */
if (true) { if (false) {
APPL_INFO(" ----------------------------------"); APPL_INFO(" ----------------------------------");
APPL_INFO(" -- Get service system-user"); APPL_INFO(" -- Get service system-user");
APPL_INFO(" ----------------------------------"); APPL_INFO(" ----------------------------------");
@ -143,6 +145,7 @@ int main(int _argc, const char *_argv[]) {
if (true) { if (true) {
zeus::service::ProxyPicture remoteServicePicture = client1.getService("picture"); zeus::service::ProxyPicture remoteServicePicture = client1.getService("picture");
if (remoteServicePicture.exist() == true) { if (remoteServicePicture.exist() == true) {
#if 0
zeus::Future<std::vector<std::string>> retCall = remoteServicePicture.getAlbums().wait(); zeus::Future<std::vector<std::string>> retCall = remoteServicePicture.getAlbums().wait();
APPL_INFO(" album list: "); APPL_INFO(" album list: ");
for (auto &it : retCall.get()) { for (auto &it : retCall.get()) {
@ -166,7 +169,7 @@ int main(int _argc, const char *_argv[]) {
APPL_INFO(" - " << it3); APPL_INFO(" - " << it3);
// TODO : This is really bad : Do it better ... // TODO : This is really bad : Do it better ...
zeus::Future<ememory::SharedPtr<zeus::ObjectRemoteBase>> retListImage = remoteServicePicture.getAlbumListPicture(it3).wait(); zeus::Future<ememory::SharedPtr<zeus::ObjectRemoteBase>> retListImage = remoteServicePicture.getAlbumListPicture(it3).wait();
zeus::ProxyFile tmpFile = zeus::ObjectRemote(retListImage.get(client1.m_interfaceWeb)); zeus::ProxyFile tmpFile = zeus::ObjectRemote(retListImage.get());
APPL_INFO(" mine-type: " << tmpFile.getMineType().wait().get()); APPL_INFO(" mine-type: " << tmpFile.getMineType().wait().get());
APPL_INFO(" size: " << tmpFile.size().wait().get()); APPL_INFO(" size: " << tmpFile.size().wait().get());
APPL_INFO(" receive in =" << int64_t(retListImage.getTransmitionTime().count()/1000)/1000.0 << " ms"); APPL_INFO(" receive in =" << int64_t(retListImage.getTransmitionTime().count()/1000)/1000.0 << " ms");
@ -184,15 +187,16 @@ int main(int _argc, const char *_argv[]) {
} }
} }
} }
#endif
#if 1 #if 1
echrono::Steady start = echrono::Steady::now(); echrono::Steady start = echrono::Steady::now();
//zeus::File tmp("./testzz.png"); //zeus::File tmp("./testzz.png");
// TODO : Read file size before .. // TODO : Read file size before ..
int32_t size = 1024; int32_t size = 1024;
ememory::SharedPtr<zeus::File> tmp = zeus::File::create("./tmpResult.bmp"); ememory::SharedPtr<zeus::File> tmp = zeus::File::create("./tmpResult.bmp");
zeus::FutureBase retSendImage = remoteServicePicture.addFile(tmp).wait(); auto retSendImage = remoteServicePicture.addFile(tmp).wait();
echrono::Steady stop = echrono::Steady::now(); echrono::Steady stop = echrono::Steady::now();
APPL_WARNING(" IO*=" << (stop-start)); APPL_WARNING(" IO*=" << (stop-start) << " " << retSendImage.get());
double megaParSec = double(size)/(double((stop-start).count())/1000000000.0); double megaParSec = double(size)/(double((stop-start).count())/1000000000.0);
APPL_WARNING(" speed=" << int64_t(megaParSec/1024.0)/1024.0 << " Mo/s"); APPL_WARNING(" speed=" << int64_t(megaParSec/1024.0)/1024.0 << " Mo/s");
#endif #endif

28
tools/service-picture/appl/main.cpp
View File

@ -189,8 +189,11 @@ namespace appl {
} }
std::string addFile(zeus::ProxyFile _dataFile) { std::string addFile(zeus::ProxyFile _dataFile) {
std::unique_lock<std::mutex> lock(g_mutex); std::unique_lock<std::mutex> lock(g_mutex);
APPL_ERROR("Call add file ... ");
// TODO : Check right ... // TODO : Check right ...
uint64_t id = createFileID(); uint64_t id = createFileID();
APPL_ERROR("New ID : " << id);
/*
auto fut = _dataFile.getPart(0, 6400); auto fut = _dataFile.getPart(0, 6400);
fut.andThen([](zeus::FutureBase _data){ fut.andThen([](zeus::FutureBase _data){
zeus::Future<zeus::Raw> data(_data); zeus::Future<zeus::Raw> data(_data);
@ -198,6 +201,29 @@ namespace appl {
APPL_ERROR("Get data In andThen " << ppp.size()); APPL_ERROR("Get data In andThen " << ppp.size());
return true; return true;
}); });
*/
auto futType = _dataFile.getMineType();
auto futName = _dataFile.getName();
auto futSize = _dataFile.getSize();
futType.wait();
APPL_ERROR("mine-type : " << futType.get());
futName.wait();
APPL_ERROR("name : " << futName.get());
futSize.wait();
APPL_ERROR("size : " << futSize.get());
int64_t retSize = futSize.get();
int64_t offset = 0;
while (retSize > 0) {
int32_t nbElement = 4096;
if (retSize<nbElement) {
nbElement = retSize;
}
auto futData = _dataFile.getPart(offset, offset + nbElement);
futData.wait();
offset += nbElement;
retSize -= nbElement;
}
/* /*
APPL_ERROR(" ==> Receive FILE " << _dataFile.getMineType() << " size=" << _dataFile.getData().size()); APPL_ERROR(" ==> Receive FILE " << _dataFile.getMineType() << " size=" << _dataFile.getData().size());
std::stringstream val; std::stringstream val;
@ -208,7 +234,7 @@ namespace appl {
_dataFile.storeIn(g_basePath + filename); _dataFile.storeIn(g_basePath + filename);
m_listFile.insert(std::make_pair(id, filename)); m_listFile.insert(std::make_pair(id, filename));
*/ */
return etk::to_string(id);//zeus::FileServer(); return etk::to_string(id);
} }
/* /*
// Return a global UTC time // Return a global UTC time

8
zeus/AbstractFunctionTypeClass.hpp
View File

@ -32,10 +32,10 @@ namespace zeus {
// clang generate a basic warning: // clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0; int32_t idParam = 0;
ret = (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam++)...); ret = (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam++)...);
} else { } else {
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
ret = (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam--)...); ret = (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam--)...);
} }
if (_interfaceClient == nullptr) { if (_interfaceClient == nullptr) {
ZEUS_ERROR("Nullptr for _interfaceWeb"); ZEUS_ERROR("Nullptr for _interfaceWeb");
@ -65,10 +65,10 @@ namespace zeus {
// clang generate a basic warning: // clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0; int32_t idParam = 0;
(*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam++)...); (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam++)...);
} else { } else {
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
(*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(idParam--)...); (*_pointer.*_func)(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam--)...);
} }
if (_interfaceClient == nullptr) { if (_interfaceClient == nullptr) {
ZEUS_ERROR("Nullptr for _interfaceWeb"); ZEUS_ERROR("Nullptr for _interfaceWeb");

8
zeus/AbstractFunctionTypeDirect.hpp
View File

@ -27,10 +27,10 @@ namespace zeus {
// clang generate a basic warning: // clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0; int32_t idParam = 0;
ret = _func(_obj->getParameter<ZEUS_TYPES>(idParam++)...); ret = _func(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam++)...);
} else { } else {
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
ret = _func(_obj->getParameter<ZEUS_TYPES>(idParam--)...); ret = _func(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam--)...);
} }
if (_interfaceClient == nullptr) { if (_interfaceClient == nullptr) {
ZEUS_ERROR("Nullptr for _interfaceWeb"); ZEUS_ERROR("Nullptr for _interfaceWeb");
@ -58,10 +58,10 @@ namespace zeus {
// clang generate a basic warning: // clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0; int32_t idParam = 0;
_func(_obj->getParameter<ZEUS_TYPES>(idParam++)...); _func(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam++)...);
} else { } else {
int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1;
_func(_obj->getParameter<ZEUS_TYPES>(idParam--)...); _func(_obj->getParameter<ZEUS_TYPES>(_interfaceClient, idParam--)...);
} }
if (_interfaceClient == nullptr) { if (_interfaceClient == nullptr) {
ZEUS_ERROR("Nullptr for _interfaceWeb"); ZEUS_ERROR("Nullptr for _interfaceWeb");

19
zeus/Buffer.cpp
View File

@ -16,6 +16,8 @@
#include <zeus/BufferData.hpp> #include <zeus/BufferData.hpp>
#include <zeus/BufferFlow.hpp> #include <zeus/BufferFlow.hpp>
#include <zeus/BufferEvent.hpp> #include <zeus/BufferEvent.hpp>
#include <zeus/WebServer.hpp>
namespace etk { namespace etk {
template<> std::string to_string<enum zeus::Buffer::typeMessage>(const enum zeus::Buffer::typeMessage& _value) { template<> std::string to_string<enum zeus::Buffer::typeMessage>(const enum zeus::Buffer::typeMessage& _value) {
@ -59,7 +61,8 @@ static enum zeus::Buffer::typeMessage getTypeType(uint16_t _value) {
return zeus::Buffer::typeMessage::unknow; return zeus::Buffer::typeMessage::unknow;
} }
zeus::Buffer::Buffer() { zeus::Buffer::Buffer(ememory::SharedPtr<zeus::WebServer> _iface):
m_iface(_iface) {
clear(); clear();
} }
@ -230,11 +233,11 @@ enum zeus::Buffer::typeMessage zeus::Buffer::getType() const {
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
// -- Factory // -- Factory
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create() { ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create(ememory::SharedPtr<zeus::WebServer> _iface) {
return ememory::SharedPtr<zeus::Buffer>(new zeus::Buffer); return ememory::SharedPtr<zeus::Buffer>(new zeus::Buffer(_iface));
} }
ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create(const std::vector<uint8_t>& _buffer) { ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create(ememory::SharedPtr<zeus::WebServer> _iface, const std::vector<uint8_t>& _buffer) {
headerBin header; headerBin header;
if (_buffer.size() < sizeof(headerBin)) { if (_buffer.size() < sizeof(headerBin)) {
ZEUS_ERROR("wrong size of the buffer"); ZEUS_ERROR("wrong size of the buffer");
@ -246,7 +249,7 @@ ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create(const std::vector<uint8_t>
case zeus::Buffer::typeMessage::unknow: case zeus::Buffer::typeMessage::unknow:
return nullptr; return nullptr;
case zeus::Buffer::typeMessage::ctrl: { case zeus::Buffer::typeMessage::ctrl: {
ememory::SharedPtr<zeus::BufferCtrl> value = zeus::BufferCtrl::create(); ememory::SharedPtr<zeus::BufferCtrl> value = zeus::BufferCtrl::create(_iface);
if (value == nullptr) { if (value == nullptr) {
return nullptr; return nullptr;
} }
@ -262,7 +265,7 @@ ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create(const std::vector<uint8_t>
} }
break; break;
case zeus::Buffer::typeMessage::call: { case zeus::Buffer::typeMessage::call: {
ememory::SharedPtr<zeus::BufferCall> value = zeus::BufferCall::create(); ememory::SharedPtr<zeus::BufferCall> value = zeus::BufferCall::create(_iface);
if (value == nullptr) { if (value == nullptr) {
return nullptr; return nullptr;
} }
@ -278,7 +281,7 @@ ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create(const std::vector<uint8_t>
} }
break; break;
case zeus::Buffer::typeMessage::answer: { case zeus::Buffer::typeMessage::answer: {
ememory::SharedPtr<zeus::BufferAnswer> value = zeus::BufferAnswer::create(); ememory::SharedPtr<zeus::BufferAnswer> value = zeus::BufferAnswer::create(_iface);
if (value == nullptr) { if (value == nullptr) {
return nullptr; return nullptr;
} }
@ -294,7 +297,7 @@ ememory::SharedPtr<zeus::Buffer> zeus::Buffer::create(const std::vector<uint8_t>
} }
break; break;
case zeus::Buffer::typeMessage::data: { case zeus::Buffer::typeMessage::data: {
ememory::SharedPtr<zeus::BufferData> value = zeus::BufferData::create(); ememory::SharedPtr<zeus::BufferData> value = zeus::BufferData::create(_iface);
if (value == nullptr) { if (value == nullptr) {
return nullptr; return nullptr;
} }

8
zeus/Buffer.hpp
View File

@ -104,11 +104,13 @@ namespace zeus {
*/ */
class Buffer { class Buffer {
friend std::ostream& operator<<(std::ostream&, zeus::Buffer*); friend std::ostream& operator<<(std::ostream&, zeus::Buffer*);
protected:
ememory::SharedPtr<zeus::WebServer> m_iface;
protected: protected:
/** /**
* @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::Buffer::create * @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::Buffer::create
*/ */
Buffer(); Buffer(ememory::SharedPtr<zeus::WebServer> _iface);
public: public:
/** /**
* Virtualize the buffer class * Virtualize the buffer class
@ -118,13 +120,13 @@ namespace zeus {
* @brief Create a shared pointer on the buffer * @brief Create a shared pointer on the buffer
* @return Allocated Buffer. * @return Allocated Buffer.
*/ */
static ememory::SharedPtr<zeus::Buffer> create(); static ememory::SharedPtr<zeus::Buffer> create(ememory::SharedPtr<zeus::WebServer> _iface);
/** /**
* @brief Create a shared pointer on the buffer * @brief Create a shared pointer on the buffer
* @param[in] _buffer Buffer on the data * @param[in] _buffer Buffer on the data
* @return Allocated Buffer. * @return Allocated Buffer.
*/ */
static ememory::SharedPtr<zeus::Buffer> create(const std::vector<uint8_t>& _buffer); static ememory::SharedPtr<zeus::Buffer> create(ememory::SharedPtr<zeus::WebServer> _iface, const std::vector<uint8_t>& _buffer);
protected: protected:
uint32_t m_interfaceID; //!< For debug ==> unterface ID ... uint32_t m_interfaceID; //!< For debug ==> unterface ID ...
headerBin m_header; //!< header of the protocol headerBin m_header; //!< header of the protocol

4
zeus/BufferAnswer.cpp
View File

@ -80,7 +80,7 @@ void zeus::BufferAnswer::appendBufferData(ememory::SharedPtr<zeus::BufferData> _
// -- Factory // -- Factory
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
ememory::SharedPtr<zeus::BufferAnswer> zeus::BufferAnswer::create() { ememory::SharedPtr<zeus::BufferAnswer> zeus::BufferAnswer::create(ememory::SharedPtr<zeus::WebServer> _iface) {
return ememory::SharedPtr<zeus::BufferAnswer>(new zeus::BufferAnswer); return ememory::SharedPtr<zeus::BufferAnswer>(new zeus::BufferAnswer(_iface));
} }

12
zeus/BufferAnswer.hpp
View File

@ -21,7 +21,8 @@ namespace zeus {
/** /**
* @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferAnswer::create * @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferAnswer::create
*/ */
BufferAnswer() { BufferAnswer(ememory::SharedPtr<zeus::WebServer> _iface):
zeus::BufferParameter(_iface) {
m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::answer); m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::answer);
}; };
void composeWith(const uint8_t* _buffer, uint32_t _lenght) override; void composeWith(const uint8_t* _buffer, uint32_t _lenght) override;
@ -33,7 +34,7 @@ namespace zeus {
* @brief Create a shared pointer on the BufferAnswer * @brief Create a shared pointer on the BufferAnswer
* @return Allocated Buffer. * @return Allocated Buffer.
*/ */
static ememory::SharedPtr<zeus::BufferAnswer> create(); static ememory::SharedPtr<zeus::BufferAnswer> create(ememory::SharedPtr<zeus::WebServer> _iface);
public: public:
enum zeus::Buffer::typeMessage getType() const override { enum zeus::Buffer::typeMessage getType() const override {
return zeus::Buffer::typeMessage::answer; return zeus::Buffer::typeMessage::answer;
@ -50,14 +51,9 @@ namespace zeus {
* @brief get the answer value * @brief get the answer value
* @param[in] Data of the answer * @param[in] Data of the answer
*/ */
// TODO : Do it better check error ... ==> can be good ...
template<class ZEUS_TYPE_DATA> template<class ZEUS_TYPE_DATA>
ZEUS_TYPE_DATA getAnswer() const { ZEUS_TYPE_DATA getAnswer() const {
return getParameter<ZEUS_TYPE_DATA>(0); return getParameter<ZEUS_TYPE_DATA>(m_iface, 0);
}
template<class ZEUS_TYPE_DATA>
ZEUS_TYPE_DATA getAnswer(const ememory::SharedPtr<zeus::WebServer>& _iface) const {
return getParameter<ZEUS_TYPE_DATA>(_iface, 0);
} }
/** /**
* @brief Ann an error on the message answer * @brief Ann an error on the message answer

4
zeus/BufferCall.cpp
View File

@ -64,6 +64,6 @@ void zeus::BufferCall::appendBufferData(ememory::SharedPtr<zeus::BufferData> _ob
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
ememory::SharedPtr<zeus::BufferCall> zeus::BufferCall::create() { ememory::SharedPtr<zeus::BufferCall> zeus::BufferCall::create(ememory::SharedPtr<zeus::WebServer> _iface) {
return ememory::SharedPtr<zeus::BufferCall>(new zeus::BufferCall); return ememory::SharedPtr<zeus::BufferCall>(new zeus::BufferCall(_iface));
} }

5
zeus/BufferCall.hpp
View File

@ -20,7 +20,8 @@ namespace zeus {
/** /**
* @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferCall::create * @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferCall::create
*/ */
BufferCall() { BufferCall(ememory::SharedPtr<zeus::WebServer> _iface):
zeus::BufferParameter(_iface) {
m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::call); m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::call);
}; };
void composeWith(const uint8_t* _buffer, uint32_t _lenght) override; void composeWith(const uint8_t* _buffer, uint32_t _lenght) override;
@ -32,7 +33,7 @@ namespace zeus {
* @brief Create a shared pointer on the BufferCall * @brief Create a shared pointer on the BufferCall
* @return Allocated Buffer. * @return Allocated Buffer.
*/ */
static ememory::SharedPtr<zeus::BufferCall> create(); static ememory::SharedPtr<zeus::BufferCall> create(ememory::SharedPtr<zeus::WebServer> _iface);
public: public:
enum zeus::Buffer::typeMessage getType() const override { enum zeus::Buffer::typeMessage getType() const override {
return zeus::Buffer::typeMessage::call; return zeus::Buffer::typeMessage::call;

4
zeus/BufferCtrl.cpp
View File

@ -52,6 +52,6 @@ void zeus::BufferCtrl::appendBufferData(ememory::SharedPtr<zeus::BufferData> _ob
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
ememory::SharedPtr<zeus::BufferCtrl> zeus::BufferCtrl::create() { ememory::SharedPtr<zeus::BufferCtrl> zeus::BufferCtrl::create(ememory::SharedPtr<zeus::WebServer> _iface) {
return ememory::SharedPtr<zeus::BufferCtrl>(new zeus::BufferCtrl); return ememory::SharedPtr<zeus::BufferCtrl>(new zeus::BufferCtrl(_iface));
} }

5
zeus/BufferCtrl.hpp
View File

@ -19,7 +19,8 @@ namespace zeus {
/** /**
* @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferCall::create * @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferCall::create
*/ */
BufferCtrl() { BufferCtrl(ememory::SharedPtr<zeus::WebServer> _iface):
zeus::Buffer(_iface) {
m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::ctrl); m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::ctrl);
}; };
void composeWith(const uint8_t* _buffer, uint32_t _lenght) override; void composeWith(const uint8_t* _buffer, uint32_t _lenght) override;
@ -31,7 +32,7 @@ namespace zeus {
* @brief Create a shared pointer on the BufferCall * @brief Create a shared pointer on the BufferCall
* @return Allocated Buffer. * @return Allocated Buffer.
*/ */
static ememory::SharedPtr<zeus::BufferCtrl> create(); static ememory::SharedPtr<zeus::BufferCtrl> create(ememory::SharedPtr<zeus::WebServer> _iface);
public: public:
enum zeus::Buffer::typeMessage getType() const override { enum zeus::Buffer::typeMessage getType() const override {
return zeus::Buffer::typeMessage::ctrl; return zeus::Buffer::typeMessage::ctrl;

4
zeus/BufferData.cpp
View File

@ -62,6 +62,6 @@ void zeus::BufferData::composeWith(const uint8_t* _buffer, uint32_t _lenght) {
// -- Factory // -- Factory
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
ememory::SharedPtr<zeus::BufferData> zeus::BufferData::create() { ememory::SharedPtr<zeus::BufferData> zeus::BufferData::create(ememory::SharedPtr<zeus::WebServer> _iface) {
return ememory::SharedPtr<zeus::BufferData>(new zeus::BufferData); return ememory::SharedPtr<zeus::BufferData>(new zeus::BufferData(_iface));
} }

5
zeus/BufferData.hpp
View File

@ -22,7 +22,8 @@ namespace zeus {
/** /**
* @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferData::create * @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::BufferData::create
*/ */
BufferData(): BufferData(ememory::SharedPtr<zeus::WebServer> _iface):
zeus::Buffer(_iface),
m_partId(0) { m_partId(0) {
m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::data); m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::Buffer::typeMessage::data);
}; };
@ -35,7 +36,7 @@ namespace zeus {
* @brief Create a shared pointer on the BufferData * @brief Create a shared pointer on the BufferData
* @return Allocated Buffer. * @return Allocated Buffer.
*/ */
static ememory::SharedPtr<zeus::BufferData> create(); static ememory::SharedPtr<zeus::BufferData> create(ememory::SharedPtr<zeus::WebServer> _iface);
public: public:
enum zeus::Buffer::typeMessage getType() const override { enum zeus::Buffer::typeMessage getType() const override {
return zeus::Buffer::typeMessage::data; return zeus::Buffer::typeMessage::data;

5
zeus/BufferParameter.cpp
View File

@ -12,6 +12,11 @@
#include <zeus/BufferParameter.hpp> #include <zeus/BufferParameter.hpp>
#include <zeus/File.hpp> #include <zeus/File.hpp>
zeus::BufferParameter::BufferParameter(ememory::SharedPtr<zeus::WebServer> _iface):
Buffer(_iface) {
}
bool zeus::BufferParameter::writeOn(enet::WebSocket& _interface) { bool zeus::BufferParameter::writeOn(enet::WebSocket& _interface) {
uint8_t* data = nullptr; uint8_t* data = nullptr;
uint32_t dataSize = 0; uint32_t dataSize = 0;

18
zeus/BufferParameter.hpp
View File

@ -16,20 +16,24 @@ namespace zeus {
protected: protected:
mutable std::vector<std::pair<int32_t,std::vector<uint8_t>>> m_parameter; //!< list of the parameter (offset of start data and buffer of data (subprotocol...) mutable std::vector<std::pair<int32_t,std::vector<uint8_t>>> m_parameter; //!< list of the parameter (offset of start data and buffer of data (subprotocol...)
public: public:
BufferParameter(ememory::SharedPtr<zeus::WebServer> _iface);
/** /**
* @brief Template to get a parameter with a specific type * @brief Template to get a parameter with a specific type
* @param[in] _id Number of the parameter * @param[in] _id Number of the parameter
* @return Converted type of the parameter (or empty value) * @param[in] _iface IO Web interface
*/
template<class ZEUS_TYPE_DATA>
ZEUS_TYPE_DATA getParameter(int32_t _id) const;
/**
* @brief Template to get a parameter with a specific type
* @param[in] _id Number of the parameter
* @return Converted type of the parameter (or empty value) * @return Converted type of the parameter (or empty value)
*/ */
template<class ZEUS_TYPE_DATA> template<class ZEUS_TYPE_DATA>
ZEUS_TYPE_DATA getParameter(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const; ZEUS_TYPE_DATA getParameter(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const;
/**
* @brief Template to get a parameter with a specific type
* @param[in] _id Number of the parameter
* @return Converted type of the parameter (or empty value)
*/
template<class ZEUS_TYPE_DATA>
ZEUS_TYPE_DATA getParameter(int32_t _id) const {
return getParameter<ZEUS_TYPE_DATA>(m_iface, _id);
}
/** /**
* @brief Get the type of a parameter. * @brief Get the type of a parameter.
* @param[in] _id Number of the parameter * @param[in] _id Number of the parameter

3
zeus/BufferParameter_addParameter.cpp
View File

@ -324,12 +324,13 @@ namespace zeus {
~SendData() { ~SendData() {
} }
// TODO : Set it with a sharedPtr instaed of pointer ...
bool operator() (zeus::WebServer* _interface, bool operator() (zeus::WebServer* _interface,
uint32_t _source, uint32_t _source,
uint32_t _destination, uint32_t _destination,
uint32_t _transactionId, uint32_t _transactionId,
uint32_t _partId) { uint32_t _partId) {
ememory::SharedPtr<zeus::BufferData> answer = zeus::BufferData::create(); ememory::SharedPtr<zeus::BufferData> answer = zeus::BufferData::create(_interface->sharedFromThis());
answer->setTransactionId(_transactionId); answer->setTransactionId(_transactionId);
answer->setSource(_source); answer->setSource(_source);
answer->setDestination(_destination); answer->setDestination(_destination);

52
zeus/BufferParameter_getParameter.cpp
View File

@ -14,7 +14,7 @@
#include <climits> #include <climits>
namespace zeus { namespace zeus {
template<> template<>
bool BufferParameter::getParameter<bool>(int32_t _id) const { bool BufferParameter::getParameter<bool>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -31,7 +31,7 @@ namespace zeus {
} }
template<> template<>
std::string BufferParameter::getParameter<std::string>(int32_t _id) const { std::string BufferParameter::getParameter<std::string>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::string out; std::string out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -43,7 +43,7 @@ namespace zeus {
template<> template<>
uint8_t BufferParameter::getParameter<uint8_t>(int32_t _id) const { uint8_t BufferParameter::getParameter<uint8_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -83,7 +83,7 @@ namespace zeus {
return 0; return 0;
} }
template<> template<>
uint16_t BufferParameter::getParameter<uint16_t>(int32_t _id) const { uint16_t BufferParameter::getParameter<uint16_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -124,7 +124,7 @@ namespace zeus {
} }
template<> template<>
uint32_t BufferParameter::getParameter<uint32_t>(int32_t _id) const { uint32_t BufferParameter::getParameter<uint32_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -165,7 +165,7 @@ namespace zeus {
} }
template<> template<>
uint64_t BufferParameter::getParameter<uint64_t>(int32_t _id) const { uint64_t BufferParameter::getParameter<uint64_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -208,12 +208,12 @@ namespace zeus {
#if defined(__TARGET_OS__MacOs) \ #if defined(__TARGET_OS__MacOs) \
|| defined(__TARGET_OS__IOs) || defined(__TARGET_OS__IOs)
template<> template<>
size_t BufferParameter::getParameter<size_t>(int32_t _id) const { size_t BufferParameter::getParameter<size_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
return getParameter<uint64_t>(_id); return getParameter<uint64_t>(_id);
} }
#endif #endif
template<> template<>
int8_t BufferParameter::getParameter<int8_t>(int32_t _id) const { int8_t BufferParameter::getParameter<int8_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -254,7 +254,7 @@ namespace zeus {
} }
template<> template<>
int16_t BufferParameter::getParameter<int16_t>(int32_t _id) const { int16_t BufferParameter::getParameter<int16_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -295,7 +295,7 @@ namespace zeus {
} }
template<> template<>
int32_t BufferParameter::getParameter<int32_t>(int32_t _id) const { int32_t BufferParameter::getParameter<int32_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -336,7 +336,7 @@ namespace zeus {
} }
template<> template<>
int64_t BufferParameter::getParameter<int64_t>(int32_t _id) const { int64_t BufferParameter::getParameter<int64_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -377,7 +377,7 @@ namespace zeus {
} }
template<> template<>
float BufferParameter::getParameter<float>(int32_t _id) const { float BufferParameter::getParameter<float>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -417,7 +417,7 @@ namespace zeus {
return 0.0f; return 0.0f;
} }
template<> template<>
double BufferParameter::getParameter<double>(int32_t _id) const { double BufferParameter::getParameter<double>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);
@ -481,7 +481,7 @@ namespace zeus {
template<> template<>
std::vector<uint8_t> BufferParameter::getParameter<std::vector<uint8_t>>(int32_t _id) const { std::vector<uint8_t> BufferParameter::getParameter<std::vector<uint8_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<uint8_t> out; std::vector<uint8_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -571,7 +571,7 @@ namespace zeus {
return out; return out;
} }
template<> template<>
std::vector<uint16_t> BufferParameter::getParameter<std::vector<uint16_t>>(int32_t _id) const { std::vector<uint16_t> BufferParameter::getParameter<std::vector<uint16_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<uint16_t> out; std::vector<uint16_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -662,7 +662,7 @@ namespace zeus {
} }
template<> template<>
std::vector<uint32_t> BufferParameter::getParameter<std::vector<uint32_t>>(int32_t _id) const { std::vector<uint32_t> BufferParameter::getParameter<std::vector<uint32_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<uint32_t> out; std::vector<uint32_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -753,7 +753,7 @@ namespace zeus {
} }
template<> template<>
std::vector<uint64_t> BufferParameter::getParameter<std::vector<uint64_t>>(int32_t _id) const { std::vector<uint64_t> BufferParameter::getParameter<std::vector<uint64_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<uint64_t> out; std::vector<uint64_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -844,7 +844,7 @@ namespace zeus {
} }
template<> template<>
std::vector<int8_t> BufferParameter::getParameter<std::vector<int8_t>>(int32_t _id) const { std::vector<int8_t> BufferParameter::getParameter<std::vector<int8_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<int8_t> out; std::vector<int8_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -935,7 +935,7 @@ namespace zeus {
} }
template<> template<>
std::vector<int16_t> BufferParameter::getParameter<std::vector<int16_t>>(int32_t _id) const { std::vector<int16_t> BufferParameter::getParameter<std::vector<int16_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<int16_t> out; std::vector<int16_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -1026,7 +1026,7 @@ namespace zeus {
} }
template<> template<>
std::vector<int32_t> BufferParameter::getParameter<std::vector<int32_t>>(int32_t _id) const { std::vector<int32_t> BufferParameter::getParameter<std::vector<int32_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<int32_t> out; std::vector<int32_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -1117,7 +1117,7 @@ namespace zeus {
} }
template<> template<>
std::vector<int64_t> BufferParameter::getParameter<std::vector<int64_t>>(int32_t _id) const { std::vector<int64_t> BufferParameter::getParameter<std::vector<int64_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<int64_t> out; std::vector<int64_t> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -1208,7 +1208,7 @@ namespace zeus {
} }
template<> template<>
std::vector<float> BufferParameter::getParameter<std::vector<float>>(int32_t _id) const { std::vector<float> BufferParameter::getParameter<std::vector<float>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<float> out; std::vector<float> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -1299,7 +1299,7 @@ namespace zeus {
} }
template<> template<>
std::vector<double> BufferParameter::getParameter<std::vector<double>>(int32_t _id) const { std::vector<double> BufferParameter::getParameter<std::vector<double>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<double> out; std::vector<double> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -1390,7 +1390,7 @@ namespace zeus {
} }
template<> template<>
std::vector<bool> BufferParameter::getParameter<std::vector<bool>>(int32_t _id) const { std::vector<bool> BufferParameter::getParameter<std::vector<bool>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<bool> out; std::vector<bool> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -1412,7 +1412,7 @@ namespace zeus {
} }
template<> template<>
std::vector<std::string> BufferParameter::getParameter<std::vector<std::string>>(int32_t _id) const { std::vector<std::string> BufferParameter::getParameter<std::vector<std::string>>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
std::vector<std::string> out; std::vector<std::string> out;
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
@ -1473,7 +1473,7 @@ namespace zeus {
} }
*/ */
template<> template<>
zeus::Raw BufferParameter::getParameter<zeus::Raw>(int32_t _id) const { zeus::Raw BufferParameter::getParameter<zeus::Raw>(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _id) const {
zeus::ParamType type = getParameterType(_id); zeus::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id); const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id); uint32_t dataSize = getParameterSize(_id);

2
zeus/Client.cpp
View File

@ -148,7 +148,7 @@ zeus::ObjectRemote zeus::Client::getService(const std::string& _name) {
ZEUS_WARNING("Can not unlink with the service id: '" << _name << "' ==> link error"); ZEUS_WARNING("Can not unlink with the service id: '" << _name << "' ==> link error");
return zeus::ObjectRemote(); return zeus::ObjectRemote();
} }
return zeus::ObjectRemote(ret.get(m_interfaceWeb)); return zeus::ObjectRemote(ret.get());
} }
void zeus::Client::onPropertyChangeIp() { void zeus::Client::onPropertyChangeIp() {

2
zeus/Client.hpp
View File

@ -116,7 +116,7 @@ namespace zeus {
const std::string& _functionName, const std::string& _functionName,
_ARGS&&... _args) { _ARGS&&... _args) {
if (m_interfaceWeb == nullptr) { if (m_interfaceWeb == nullptr) {
ememory::SharedPtr<zeus::BufferAnswer> ret = zeus::BufferAnswer::create(); ememory::SharedPtr<zeus::BufferAnswer> ret = zeus::BufferAnswer::create(nullptr); // TODO : This is really a bad case ...
ret->addError("NULLPTR", "call " + _functionName + " with no interface open"); ret->addError("NULLPTR", "call " + _functionName + " with no interface open");
return zeus::FutureBase(0, ret); return zeus::FutureBase(0, ret);
} }

27
zeus/FileImpl.cpp
View File

@ -5,6 +5,7 @@
*/ */
#include <zeus/FileImpl.hpp> #include <zeus/FileImpl.hpp>
#include <zeus/mineType.hpp>
#include "debug.hpp" #include "debug.hpp"
namespace zeus { namespace zeus {
@ -21,27 +22,43 @@ namespace zeus {
zeus::FileImpl::FileImpl(std::string _filename) : zeus::FileImpl::FileImpl(std::string _filename) :
m_filename(_filename), m_filename(_filename),
m_node(_filename) { m_node(_filename) {
m_size = m_node.fileSize();
m_node.fileOpenRead(); m_node.fileOpenRead();
std::string extention = std::string(_filename.begin()+_filename.size() -3, _filename.end());
m_mineType = zeus::getMineType(extention);
} }
zeus::FileImpl::~FileImpl() { zeus::FileImpl::~FileImpl() {
m_node.fileClose(); m_node.fileClose();
} }
uint64_t zeus::FileImpl::size() { uint64_t zeus::FileImpl::getSize() {
return 4092; return m_size;
} }
std::string zeus::FileImpl::name() { std::string zeus::FileImpl::getName() {
return m_filename; return m_filename;
} }
std::string zeus::FileImpl::getMineType() { std::string zeus::FileImpl::getMineType() {
return "audio/x-matroska"; return m_mineType;
} }
zeus::Raw zeus::FileImpl::getPart(uint64_t _start, uint64_t _stop) { zeus::Raw zeus::FileImpl::getPart(uint64_t _start, uint64_t _stop) {
return zeus::Raw(4092); if ((_stop - _start) > 25*1024*1024) {
ZEUS_ERROR("REQUEST more that 25 Mo in a part file ...");
// TODO : throw an error ...
return zeus::Raw();
}
zeus::Raw tmp(_stop - _start);
if (m_node.fileSeek(_start, etk::seekNode_start) == false) {
ZEUS_ERROR("REQUEST seek error ...");
// TODO : throw an error ...
return zeus::Raw();
}
int64_t sizeCopy = m_node.fileRead(tmp.writeData(), 1, _stop-_start);
// TODO : Check if copy is correct ...
return std::move(tmp);
} }

6
zeus/FileImpl.hpp
View File

@ -13,11 +13,13 @@ namespace zeus {
private: private:
std::string m_filename; std::string m_filename;
etk::FSNode m_node; etk::FSNode m_node;
size_t m_size;
std::string m_mineType;
public: public:
FileImpl(std::string _filename); FileImpl(std::string _filename);
~FileImpl(); ~FileImpl();
uint64_t size() override; uint64_t getSize() override;
std::string name() override; std::string getName() override;
std::string getMineType() override; std::string getMineType() override;
zeus::Raw getPart(uint64_t _start, uint64_t _stop) override; zeus::Raw getPart(uint64_t _start, uint64_t _stop) override;

9
zeus/Future.cpp
View File

@ -335,13 +335,8 @@ namespace zeus {
} }
return static_cast<zeus::BufferAnswer*>(m_data->m_returnData.get())->getAnswer<zeus::Raw>(); return static_cast<zeus::BufferAnswer*>(m_data->m_returnData.get())->getAnswer<zeus::Raw>();
} }
}
// NamespaceSpace for Object and services
namespace zeus {
template<> template<>
ememory::SharedPtr<zeus::ObjectRemoteBase> zeus::Future<ememory::SharedPtr<zeus::ObjectRemoteBase>>::get(const ememory::SharedPtr<zeus::WebServer>& _iface) { ememory::SharedPtr<zeus::ObjectRemoteBase> zeus::Future<ememory::SharedPtr<zeus::ObjectRemoteBase>>::get() {
ememory::SharedPtr<zeus::ObjectRemoteBase> out; ememory::SharedPtr<zeus::ObjectRemoteBase> out;
if ( m_data == nullptr if ( m_data == nullptr
|| m_data->m_returnData == nullptr) { || m_data->m_returnData == nullptr) {
@ -351,7 +346,7 @@ namespace zeus {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; return out;
} }
out = static_cast<zeus::BufferAnswer*>(m_data->m_returnData.get())->getAnswer<ememory::SharedPtr<zeus::ObjectRemoteBase>>(_iface); out = static_cast<zeus::BufferAnswer*>(m_data->m_returnData.get())->getAnswer<ememory::SharedPtr<zeus::ObjectRemoteBase>>();
return out; return out;
} }
} }

6
zeus/Future.hpp
View File

@ -38,12 +38,6 @@ namespace zeus {
* @return requested value * @return requested value
*/ */
ZEUS_RETURN get(); ZEUS_RETURN get();
/**
* @brief Get the value Requested with the type expecially for object and services
* @return requested value
*/
ZEUS_RETURN get(const ememory::SharedPtr<zeus::WebServer>& _iface);
const Future<ZEUS_RETURN>& wait() const { const Future<ZEUS_RETURN>& wait() const {
zeus::FutureBase::wait(); zeus::FutureBase::wait();
return *this; return *this;

2
zeus/ObjectRemote.hpp
View File

@ -99,7 +99,7 @@ namespace zeus {
zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) { zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) {
if ( m_interface == nullptr if ( m_interface == nullptr
|| m_interface->m_interfaceWeb == nullptr) { || m_interface->m_interfaceWeb == nullptr) {
ememory::SharedPtr<zeus::BufferAnswer> ret = zeus::BufferAnswer::create(); ememory::SharedPtr<zeus::BufferAnswer> ret = zeus::BufferAnswer::create(nullptr); // TODO : This is a real bad case ...
if (ret != nullptr) { if (ret != nullptr) {
ret->addError("NULLPTR", "call " + _functionName + " with no interface open"); ret->addError("NULLPTR", "call " + _functionName + " with no interface open");
} }

57
zeus/Raw.cpp
View File

@ -0,0 +1,57 @@
/** @file
* @author Edouard DUPIN
* @copyright 2016, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#include <zeus/Raw.hpp>
#include "debug.hpp"
zeus::Raw::Raw() :
m_size(0),
m_dataExternal(nullptr),
m_dataInternal() {
}
zeus::Raw::Raw(uint32_t _size) :
m_size(_size),
m_dataExternal(nullptr),
m_dataInternal() {
m_dataInternal.resize(_size);
}
zeus::Raw::Raw(uint32_t _size, const uint8_t* _data) :
m_size(_size),
m_dataExternal(_data),
m_dataInternal() {
}
zeus::Raw::~Raw() {
}
uint32_t zeus::Raw::size() const {
return m_size;
}
const uint8_t* zeus::Raw::data() const {
if (m_dataExternal != nullptr) {
return m_dataExternal;
}
return &m_dataInternal[0];
}
uint8_t* zeus::Raw::writeData() {
if (m_dataExternal != nullptr) {
ZEUS_ERROR("Try to write on Data that is not allowed ...");
return nullptr;
}
return &m_dataInternal[0];
}

42
zeus/Raw.hpp
View File

@ -15,52 +15,26 @@ namespace zeus {
private: private:
uint32_t m_size; uint32_t m_size;
const uint8_t* m_dataExternal; const uint8_t* m_dataExternal;
uint8_t* m_dataInternal; std::vector<uint8_t> m_dataInternal;
public: public:
/** /**
* @brief generic constructor * @brief generic constructor
*/ */
Raw() : Raw();
m_size(0),
m_dataExternal(nullptr),
m_dataInternal(nullptr) {
}
/** /**
* @brief generic constructor * @brief generic constructor
*/ */
Raw(uint32_t _size) : Raw(uint32_t _size);
m_size(_size),
m_dataExternal(nullptr),
m_dataInternal(new uint8_t[_size]) {
}
Raw(uint32_t _size, const uint8_t* _data) : Raw(uint32_t _size, const uint8_t* _data);
m_size(_size),
m_dataExternal(_data),
m_dataInternal(nullptr) {
}
~Raw() { ~Raw();
if (m_dataInternal != nullptr) {
delete[] m_dataInternal;
m_dataInternal = nullptr;
}
}
uint32_t size() const { uint32_t size() const;
return m_size;
}
const uint8_t* data() const { const uint8_t* data() const;
if (m_dataExternal != nullptr) { uint8_t* writeData();
return m_dataExternal;
}
return m_dataInternal;
}
}; };
} }

68
zeus/WebServer.cpp
View File

@ -11,8 +11,8 @@
#include <zeus/BufferCtrl.hpp> #include <zeus/BufferCtrl.hpp>
ememory::SharedPtr<zeus::BufferCall> zeus::createBaseCall(uint64_t _transactionId, const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName) { ememory::SharedPtr<zeus::BufferCall> zeus::createBaseCall(const ememory::SharedPtr<zeus::WebServer>& _iface, uint64_t _transactionId, const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName) {
ememory::SharedPtr<zeus::BufferCall> obj = zeus::BufferCall::create(); ememory::SharedPtr<zeus::BufferCall> obj = zeus::BufferCall::create(_iface);
if (obj == nullptr) { if (obj == nullptr) {
return nullptr; return nullptr;
} }
@ -146,6 +146,7 @@ class SendAsyncBinary {
m_partId(1) { m_partId(1) {
} }
// TODO : Use shared ptr instaed of pointer ....
bool operator() (zeus::WebServer* _interface){ bool operator() (zeus::WebServer* _interface){
auto it = m_async.begin(); auto it = m_async.begin();
while (it != m_async.end()) { while (it != m_async.end()) {
@ -159,7 +160,7 @@ class SendAsyncBinary {
m_partId++; m_partId++;
} }
if (m_async.size() == 0) { if (m_async.size() == 0) {
ememory::SharedPtr<zeus::BufferData> obj = zeus::BufferData::create(); ememory::SharedPtr<zeus::BufferData> obj = zeus::BufferData::create(_interface->sharedFromThis());
if (obj == nullptr) { if (obj == nullptr) {
return true; return true;
} }
@ -224,7 +225,7 @@ void zeus::WebServer::onReceiveData(std::vector<uint8_t>& _frame, bool _isBinary
disconnect(true); disconnect(true);
return; return;
} }
ememory::SharedPtr<zeus::Buffer> dataRaw = zeus::Buffer::create(_frame); ememory::SharedPtr<zeus::Buffer> dataRaw = zeus::Buffer::create(sharedFromThis(), _frame);
if (dataRaw == nullptr) { if (dataRaw == nullptr) {
ZEUS_ERROR("Buffer Allocation ERROR ... "); ZEUS_ERROR("Buffer Allocation ERROR ... ");
disconnect(true); disconnect(true);
@ -250,7 +251,8 @@ void zeus::WebServer::newBuffer(ememory::SharedPtr<zeus::Buffer> _buffer) {
// Try to find in the current call that has been done to add data in an answer : // Try to find in the current call that has been done to add data in an answer :
zeus::FutureBase future; zeus::FutureBase future;
uint64_t tid = _buffer->getTransactionId(); uint64_t tid = _buffer->getTransactionId();
{ // TODO : Check the UDI reaaly utility ...
if (_buffer->getType() == zeus::Buffer::typeMessage::answer) {
std::unique_lock<std::mutex> lock(m_pendingCallMutex); std::unique_lock<std::mutex> lock(m_pendingCallMutex);
auto it = m_pendingCall.begin(); auto it = m_pendingCall.begin();
while (it != m_pendingCall.end()) { while (it != m_pendingCall.end()) {
@ -278,6 +280,7 @@ void zeus::WebServer::newBuffer(ememory::SharedPtr<zeus::Buffer> _buffer) {
m_processingPool.async( m_processingPool.async(
[=](){ [=](){
ememory::SharedPtr<zeus::WebObj> tmpObj = it; ememory::SharedPtr<zeus::WebObj> tmpObj = it;
ZEUS_INFO("PROCESS : " << _buffer);
tmpObj->receive(_buffer); tmpObj->receive(_buffer);
}, },
dest dest
@ -298,6 +301,7 @@ void zeus::WebServer::newBuffer(ememory::SharedPtr<zeus::Buffer> _buffer) {
m_processingPool.async( m_processingPool.async(
[=](){ [=](){
zeus::FutureBase fut = future; zeus::FutureBase fut = future;
ZEUS_INFO("PROCESS FUTURE : " << _buffer);
// add data ... // add data ...
bool ret = fut.appendData(_buffer); bool ret = fut.appendData(_buffer);
if (ret == true) { if (ret == true) {
@ -364,7 +368,7 @@ zeus::FutureBase zeus::WebServer::callBinary(uint64_t _transactionId,
const uint32_t& _destination) { const uint32_t& _destination) {
if (isActive() == false) { if (isActive() == false) {
ZEUS_ERROR("Send [STOP] ==> not connected (no TCP)"); ZEUS_ERROR("Send [STOP] ==> not connected (no TCP)");
ememory::SharedPtr<zeus::BufferAnswer> obj = zeus::BufferAnswer::create(); ememory::SharedPtr<zeus::BufferAnswer> obj = zeus::BufferAnswer::create(sharedFromThis());
obj->addError("NOT-CONNECTED", "Client interface not connected (no TCP)"); obj->addError("NOT-CONNECTED", "Client interface not connected (no TCP)");
return zeus::FutureBase(_transactionId, obj); return zeus::FutureBase(_transactionId, obj);
} }
@ -376,56 +380,10 @@ zeus::FutureBase zeus::WebServer::callBinary(uint64_t _transactionId,
writeBinary(_obj); writeBinary(_obj);
return tmpFuture; return tmpFuture;
} }
/*
zeus::FutureBase zeus::WebServer::callForward(uint16_t _srcObjectId,
ememory::SharedPtr<zeus::Buffer> _buffer,
uint64_t _singleReferenceId) {
//zeus::FutureBase ret = callBinary(id, _Buffer, async, _callback);
//ret.setSynchronous();
if (isActive() == false) {
auto obj = zeus::BufferAnswer::create();
obj->addError("NOT-CONNECTED", "Client interface not connected (no TCP)");
return zeus::FutureBase(0, obj);
}
uint64_t id = getId();
_buffer->setTransactionId(id);
_buffer->setClientId(_srcObjectId);
zeus::FutureBase tmpFuture(id);
tmpFuture.setSynchronous();
{
std::unique_lock<std::mutex> lock(m_pendingCallMutex);
m_pendingCall.push_back(std::make_pair(_singleReferenceId, tmpFuture));
}
writeBinary(_buffer);
return tmpFuture;
}
void zeus::WebServer::callForwardMultiple(uint16_t _srcObjectId,
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 ==> transmit it ...
_buffer->setTransactionId(itCall.second.getTransactionId());
_buffer->setClientId(_srcObjectId);
writeBinary(_buffer);
return;
}
}
ZEUS_ERROR("Can not transfer part of a message ...");
}
*/
/* /*
void zeus::WebServer::sendCtrl(uint32_t _source, uint32_t _destination, const std::string& _ctrlValue) { void zeus::WebServer::sendCtrl(uint32_t _source, uint32_t _destination, const std::string& _ctrlValue) {
auto ctrl = zeus::BufferCtrl::create(); auto ctrl = zeus::BufferCtrl::create(sharedFromThis());
if (ctrl == nullptr) { if (ctrl == nullptr) {
return; return;
} }
@ -438,7 +396,7 @@ void zeus::WebServer::sendCtrl(uint32_t _source, uint32_t _destination, const st
*/ */
void zeus::WebServer::answerError(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination, const std::string& _errorValue, const std::string& _errorHelp) { void zeus::WebServer::answerError(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination, const std::string& _errorValue, const std::string& _errorHelp) {
auto answer = zeus::BufferAnswer::create(); auto answer = zeus::BufferAnswer::create(sharedFromThis());
if (answer == nullptr) { if (answer == nullptr) {
return; return;
} }
@ -451,7 +409,7 @@ void zeus::WebServer::answerError(uint32_t _clientTransactionId, uint32_t _sourc
void zeus::WebServer::answerVoid(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination) { void zeus::WebServer::answerVoid(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination) {
auto answer = zeus::BufferAnswer::create(); auto answer = zeus::BufferAnswer::create(sharedFromThis());
if (answer == nullptr) { if (answer == nullptr) {
return; return;
} }

12
zeus/WebServer.hpp
View File

@ -30,7 +30,11 @@ namespace zeus {
* @param[in] * @param[in]
* @return * @return
*/ */
ememory::SharedPtr<zeus::BufferCall> createBaseCall(uint64_t _transactionId, const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName); ememory::SharedPtr<zeus::BufferCall> createBaseCall(const ememory::SharedPtr<zeus::WebServer>& _iface,
uint64_t _transactionId,
const uint32_t& _source,
const uint32_t& _destination,
const std::string& _functionName);
/** /**
* @brief * @brief
* @param[in] * @param[in]
@ -76,7 +80,7 @@ namespace zeus {
*/ */
template<class... _ARGS> template<class... _ARGS>
ememory::SharedPtr<zeus::BufferCall> createCall(const ememory::SharedPtr<zeus::WebServer>& _iface, uint64_t _transactionId, const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName, _ARGS&&... _args) { ememory::SharedPtr<zeus::BufferCall> createCall(const ememory::SharedPtr<zeus::WebServer>& _iface, uint64_t _transactionId, const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName, _ARGS&&... _args) {
ememory::SharedPtr<zeus::BufferCall> callElem = createBaseCall(_transactionId, _source, _destination, _functionName); ememory::SharedPtr<zeus::BufferCall> callElem = createBaseCall(_iface, _transactionId, _source, _destination, _functionName);
if (callElem == nullptr) { if (callElem == nullptr) {
return nullptr; return nullptr;
} }
@ -158,7 +162,7 @@ namespace zeus {
* @param[in] * @param[in]
* @return * @return
*/ */
WebServer(); WebServer(); // TODO : Set it in a factory to force the use of sharedPtr
/** /**
* @brief * @brief
* @param[in] * @param[in]
@ -325,7 +329,7 @@ namespace zeus {
*/ */
template<class ZEUS_ARG> template<class ZEUS_ARG>
void answerValue(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination, ZEUS_ARG _value) { void answerValue(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination, ZEUS_ARG _value) {
ememory::SharedPtr<zeus::BufferAnswer> answer = zeus::BufferAnswer::create(); ememory::SharedPtr<zeus::BufferAnswer> answer = zeus::BufferAnswer::create(sharedFromThis());
answer->setTransactionId(_clientTransactionId); answer->setTransactionId(_clientTransactionId);
answer->setSource(_source); answer->setSource(_source);
answer->setDestination(_destination); answer->setDestination(_destination);

4
zeus/zeus-File.obj.zeus.idl
View File

@ -5,11 +5,11 @@
#brief:Get size of the file #brief:Get size of the file
#return:current size of the file #return:current size of the file
uint64 size() uint64 getSize()
#brief:Get the name of the file #brief:Get the name of the file
#return:Full name of the file (sha512) #return:Full name of the file (sha512)
string name() string getName()
#brief:Get the file "mine-type" #brief:Get the file "mine-type"
#return:string of the mine-type #return:string of the mine-type