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

[DEV] send file is OF, not get

Browse Source
This commit is contained in:
Edouard DUPIN 2016-11-28 21:29:45 +01:00
parent 9f4872ba7b
commit 42e6f1da59
6 changed files with 33 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -15,6 +15,7 @@
#include <etk/stdTools.hpp> #include <etk/stdTools.hpp>
#include <zeus/service/ProxyUser.hpp> #include <zeus/service/ProxyUser.hpp>
#include <zeus/service/ProxyPicture.hpp>
#include <echrono/Steady.hpp> #include <echrono/Steady.hpp>
@ -93,19 +94,19 @@ int main(int _argc, const char *_argv[]) {
APPL_INFO(" ----------------------------------"); APPL_INFO(" ----------------------------------");
APPL_INFO(" -- Get service system-user"); APPL_INFO(" -- Get service system-user");
APPL_INFO(" ----------------------------------"); APPL_INFO(" ----------------------------------");
#if 1
zeus::service::ProxyUser remoteServiceUser; zeus::service::ProxyUser remoteServiceUser;
remoteServiceUser = client1.getService("user"); remoteServiceUser = client1.getService("user");
if (remoteServiceUser.exist() == true) { if (remoteServiceUser.exist() == true) {
zeus::Future<std::vector<std::string>> retCall = remoteServiceUser.clientGroupsGet("clientTest1#atria-soft.com"); zeus::Future<std::vector<std::string>> retCall = remoteServiceUser.clientGroupsGet("clientTest1#atria-soft.com");
retCall.wait(); retCall.wait();
APPL_INFO("system-user.getGroups() = " << retCall.get()); APPL_INFO("system-user.getGroups() = " << retCall.get());
// system DOC
zeus::Future<std::string> retDesc = remoteServiceUser.sys.getDescription(); zeus::Future<std::string> retDesc = remoteServiceUser.sys.getDescription();
zeus::Future<std::string> retVersion = remoteServiceUser.sys.getVersion(); zeus::Future<std::string> retVersion = remoteServiceUser.sys.getVersion();
zeus::Future<std::string> retType = remoteServiceUser.sys.getType(); zeus::Future<std::string> retType = remoteServiceUser.sys.getType();
zeus::Future<std::vector<std::string>> retExtention = remoteServiceUser.srv.getExtention();
zeus::Future<std::vector<std::string>> retMaintainer = remoteServiceUser.sys.getAuthors(); zeus::Future<std::vector<std::string>> retMaintainer = remoteServiceUser.sys.getAuthors();
//service DOC
zeus::Future<std::vector<std::string>> retExtention = remoteServiceUser.srv.getExtention();
retDesc.wait(); retDesc.wait();
retVersion.wait(); retVersion.wait();
retType.wait(); retType.wait();
@ -140,81 +141,35 @@ int main(int _argc, const char *_argv[]) {
APPL_INFO(" IO*=" << (stop-start)); APPL_INFO(" IO*=" << (stop-start));
} }
} }
#else
zeus::ServiceRemote remoteServiceUser = client1.getService("user");
if (remoteServiceUser.exist() == true) {
zeus::Future<std::vector<std::string>> retCall = remoteServiceUser.call("clientGroupsGet", "clientTest1#atria-soft.com");
retCall.wait();
APPL_INFO("system-user.getGroups() = " << retCall.get());
zeus::Future<std::string> retDesc = remoteServiceUser.call("sys.getDescription");
zeus::Future<std::string> retVersion = remoteServiceUser.call("sys.getVersion");
zeus::Future<std::string> retType = remoteServiceUser.call("sys.getType");
zeus::Future<std::vector<std::string>> retExtention = remoteServiceUser.call("srv.getExtention");
zeus::Future<std::vector<std::string>> retMaintainer = remoteServiceUser.call("sys.getAuthors");
retDesc.wait();
retVersion.wait();
retType.wait();
retExtention.wait();
retMaintainer.wait();
APPL_INFO("Service: system-user");
APPL_INFO(" version : " << retVersion.get());
APPL_INFO(" type : " << retType.get());
APPL_INFO(" Extention : " << retExtention.get().size());
for (auto &it : retExtention.get()) {
APPL_INFO(" - " << it);
}
APPL_INFO(" maintainer: " << retMaintainer.get().size());
for (auto &it : retMaintainer.get()) {
APPL_INFO(" - " << it);
}
APPL_INFO(" description:");
APPL_INFO(" " << retDesc.get());
APPL_INFO(" Function List:");
zeus::Future<std::vector<std::string>> retFuctions = remoteServiceUser.call("sys.getFunctions").wait();
for (auto it : retFuctions.get()) {
std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
zeus::Future<std::string> retFunctionPrototype = remoteServiceUser.call("sys.getFunctionPrototype", it);
zeus::Future<std::string> retFunctionHelp = remoteServiceUser.call("sys.getFunctionDescription", it);
retFunctionPrototype.wait();
retFunctionHelp.wait();
std::chrono::steady_clock::time_point stop = std::chrono::steady_clock::now();
APPL_INFO(" - " << retFunctionPrototype.get());
APPL_INFO(" " << retFunctionHelp.get());
APPL_INFO(" IO1=" << int64_t(retFunctionPrototype.getTransmitionTime().count()/1000)/1000.0 << " ms");
APPL_INFO(" IO2=" << int64_t(retFunctionHelp.getTransmitionTime().count()/1000)/1000.0 << " ms");
APPL_INFO(" IO*=" << int64_t((stop-start).count()/1000)/1000.0 << " ms");
}
}
#endif
} }
APPL_INFO(" ----------------------------------"); APPL_INFO(" ----------------------------------");
APPL_INFO(" -- Get service picture"); APPL_INFO(" -- Get service picture");
APPL_INFO(" ----------------------------------"); APPL_INFO(" ----------------------------------");
if (false) { if (true) {
zeus::ServiceRemote remoteServicePicture = client1.getService("picture"); zeus::service::ProxyPicture remoteServicePicture = client1.getService("picture");
if (remoteServicePicture.exist() == true) { if (remoteServicePicture.exist() == true) {
zeus::Future<std::vector<std::string>> retCall = remoteServicePicture.call("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()) {
zeus::Future<uint32_t> retCount = remoteServicePicture.call("getAlbumCount", it).wait(); zeus::Future<uint32_t> retCount = remoteServicePicture.getAlbumCount(it).wait();
if (retCount.get() != 0) { if (retCount.get() != 0) {
APPL_INFO(" - " << it << " / " << retCount.get() << " images"); APPL_INFO(" - " << it << " / " << retCount.get() << " images");
zeus::Future<std::vector<std::string>> retListImage = remoteServicePicture.call("getAlbumListPicture", it).wait(); zeus::Future<std::vector<std::string>> retListImage = remoteServicePicture.getAlbumListPicture(it).wait();
for (auto &it3 : retListImage.get()) { for (auto &it3 : retListImage.get()) {
APPL_INFO(" - " << it3); APPL_INFO(" - " << it3);
} }
} else { } else {
APPL_INFO(" - " << it); APPL_INFO(" - " << it);
} }
zeus::Future<std::vector<std::string>> retCall2 = remoteServicePicture.call("getSubAlbums", it).wait(); zeus::Future<std::vector<std::string>> retCall2 = remoteServicePicture.getSubAlbums(it).wait();
for (auto &it2 : retCall2.get()) { for (auto &it2 : retCall2.get()) {
zeus::Future<uint32_t> retCount2 = remoteServicePicture.call("getAlbumCount", it2).wait(); zeus::Future<uint32_t> retCount2 = remoteServicePicture.getAlbumCount(it2).wait();
if (retCount2.get() != 0) { if (retCount2.get() != 0) {
APPL_INFO(" - " << it2 << " / " << retCount2.get() << " images"); APPL_INFO(" - " << it2 << " / " << retCount2.get() << " images");
zeus::Future<std::vector<std::string>> retListImage = remoteServicePicture.call("getAlbumListPicture", it2).wait(); zeus::Future<std::vector<std::string>> retListImage = remoteServicePicture.getAlbumListPicture(it2).wait();
for (auto &it3 : retListImage.get()) { for (auto &it3 : retListImage.get()) {
APPL_INFO(" - " << it3); APPL_INFO(" - " << it3);
zeus::Future<zeus::File> retListImage = remoteServicePicture.call("getAlbumPicture", it3).wait(); zeus::Future<zeus::File> retListImage = remoteServicePicture.getAlbumListPicture(it3).wait();
zeus::File tmpFile = retListImage.get(); zeus::File tmpFile = retListImage.get();
APPL_INFO(" mine-type: " << tmpFile.getMineType()); APPL_INFO(" mine-type: " << tmpFile.getMineType());
APPL_INFO(" size: " << tmpFile.getData().size()); APPL_INFO(" size: " << tmpFile.getData().size());
@ -232,12 +187,13 @@ int main(int _argc, const char *_argv[]) {
} }
} }
#if 1 #if 1
std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now(); echrono::Steady start = echrono::Steady::now();
zeus::File tmp("./testzz.png"); //zeus::File tmp("./testzz.png");
zeus::File tmp("./tmpResult.bmp");
int32_t size = tmp.getData().size(); int32_t size = tmp.getData().size();
zeus::FutureBase retSendImage = remoteServicePicture.call("addFile", tmp).wait(); zeus::FutureBase retSendImage = remoteServicePicture.addFile(tmp).wait();
std::chrono::steady_clock::time_point stop = std::chrono::steady_clock::now(); echrono::Steady stop = echrono::Steady::now();
APPL_WARNING(" IO*=" << int64_t((stop-start).count()/1000)/1000.0 << " ms"); APPL_WARNING(" IO*=" << (stop-start));
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

3
test/client/lutin_zeus-test-client.py
View File

@ -28,7 +28,8 @@ def configure(target, my_module):
my_module.add_path(".") my_module.add_path(".")
my_module.add_depend([ my_module.add_depend([
'zeus', 'zeus',
'zeus-service-user' 'zeus-service-user',
'zeus-service-picture'
]) ])
my_module.add_src_file([ my_module.add_src_file([
'appl/debug.cpp', 'appl/debug.cpp',

2
tools/service-picture/appl/zeus-service-picture.zeus.idl
View File

@ -9,7 +9,7 @@ vector:string getSubAlbums(string)
uint32 getAlbumCount(string) uint32 getAlbumCount(string)
vector:string getAlbumListPicture(string) vector:string getAlbumListPicture(string)
//file getAlbumPicture(string) //file getAlbumPicture(string)
//string addFile(file) string addFile(file)
bool removeFile(string) bool removeFile(string)
/* /*
// ----------------- Get media with their ID ----------------------- // ----------------- Get media with their ID -----------------------

2
zeus/Buffer.hpp
View File

@ -11,7 +11,7 @@
namespace zeus { namespace zeus {
class WebServer; class WebServer;
// define basic async call element ... // define basic async call element ...
using ActionAsyncClient = std::function<bool(WebServer* _interface, const uint32_t& _serviceId, uint64_t _transactionId, uint64_t _part)>; using ActionAsyncClient = std::function<bool(WebServer* _interface, const uint32_t& _clientId, const uint32_t& _serviceId, uint64_t _transactionId, uint64_t _part)>;
} }

4
zeus/BufferParameter_addParameter.cpp
View File

@ -327,11 +327,13 @@ namespace zeus {
} }
bool operator() (zeus::WebServer* _interface, bool operator() (zeus::WebServer* _interface,
uint32_t _clientId, uint32_t _clientId,
uint32_t _serviceId,
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();
answer->setTransactionId(_transactionId); answer->setTransactionId(_transactionId);
answer->setClientId(_clientId); answer->setClientId(_clientId);
answer->setServiceId(_serviceId);
answer->setPartId(_partId); answer->setPartId(_partId);
answer->setPartFinish(false); answer->setPartFinish(false);
int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE; int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE;
@ -395,6 +397,7 @@ namespace zeus {
} }
bool operator() (zeus::WebServer* _interface, bool operator() (zeus::WebServer* _interface,
uint32_t _clientId, uint32_t _clientId,
uint32_t _serviceId,
uint32_t _transactionId, uint32_t _transactionId,
uint32_t _partId) { uint32_t _partId) {
if (m_node.fileIsOpen() == false) { if (m_node.fileIsOpen() == false) {
@ -403,6 +406,7 @@ namespace zeus {
ememory::SharedPtr<zeus::BufferData> answer = zeus::BufferData::create(); ememory::SharedPtr<zeus::BufferData> answer = zeus::BufferData::create();
answer->setTransactionId(_transactionId); answer->setTransactionId(_transactionId);
answer->setClientId(_clientId); answer->setClientId(_clientId);
answer->setServiceId(_serviceId);
answer->setPartId(_partId); answer->setPartId(_partId);
answer->setPartFinish(false); answer->setPartFinish(false);
int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE; int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE;

9
zeus/WebServer.cpp
View File

@ -118,12 +118,14 @@ class SendAsyncBinary {
private: private:
std::vector<zeus::ActionAsyncClient> m_async; std::vector<zeus::ActionAsyncClient> m_async;
uint64_t m_transactionId; uint64_t m_transactionId;
uint32_t m_clientId;
uint32_t m_serviceId; uint32_t m_serviceId;
uint32_t m_partId; uint32_t m_partId;
public: public:
SendAsyncBinary(uint64_t _transactionId, const uint32_t& _serviceId, std::vector<zeus::ActionAsyncClient> _async) : SendAsyncBinary(uint64_t _transactionId, const uint32_t& _clientId, const uint32_t& _serviceId, std::vector<zeus::ActionAsyncClient> _async) :
m_async(std::move(_async)), m_async(std::move(_async)),
m_transactionId(_transactionId), m_transactionId(_transactionId),
m_clientId(_clientId),
m_serviceId(_serviceId), m_serviceId(_serviceId),
m_partId(1) { m_partId(1) {
@ -131,7 +133,7 @@ class SendAsyncBinary {
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()) {
bool ret = (*it)(_interface, m_serviceId, m_transactionId, m_partId); bool ret = (*it)(_interface, m_clientId, m_serviceId, m_transactionId, m_partId);
if (ret == true) { if (ret == true) {
// Remove it ... // Remove it ...
it = m_async.erase(it); it = m_async.erase(it);
@ -146,6 +148,7 @@ class SendAsyncBinary {
return true; return true;
} }
//obj->setInterfaceId(m_interfaceId); //obj->setInterfaceId(m_interfaceId);
obj->setClientId(m_clientId);
obj->setServiceId(m_serviceId); obj->setServiceId(m_serviceId);
obj->setTransactionId(m_transactionId); obj->setTransactionId(m_transactionId);
obj->setPartId(m_partId); obj->setPartId(m_partId);
@ -173,7 +176,7 @@ int32_t zeus::WebServer::writeBinary(ememory::SharedPtr<zeus::Buffer> _obj) {
if (_obj->writeOn(m_connection) == true) { if (_obj->writeOn(m_connection) == true) {
m_connection.send(); m_connection.send();
if (_obj->haveAsync() == true) { if (_obj->haveAsync() == true) {
addAsync(SendAsyncBinary(_obj->getTransactionId(), _obj->getServiceId(), std::move(_obj->moveAsync()))); addAsync(SendAsyncBinary(_obj->getTransactionId(), _obj->getClientId(), _obj->getServiceId(), std::move(_obj->moveAsync())));
} }
return 1; return 1;
} }