[DEBUG] update picture service
This commit is contained in:
parent
5601fde3db
commit
940dc0458a
@ -16,29 +16,253 @@
|
||||
#include <sstream>
|
||||
|
||||
#include <etk/stdTools.hpp>
|
||||
|
||||
static std::mutex g_mutex;
|
||||
static std::string g_basePath;
|
||||
static std::string g_baseDBName = std::string(SERVICE_NAME) + "-database.json";
|
||||
static ejson::Document g_database;
|
||||
static std::map<uint64_t,std::string> m_listFile;
|
||||
static uint64_t m_lastMaxId = 0;
|
||||
|
||||
static uint64_t createFileID() {
|
||||
m_lastMaxId++;
|
||||
return m_lastMaxId;
|
||||
}
|
||||
|
||||
namespace appl {
|
||||
class User {
|
||||
class PictureService {
|
||||
private:
|
||||
std::mutex m_mutex;
|
||||
std::string m_userName;
|
||||
std::string m_basePath;
|
||||
ejson::Document m_database;
|
||||
std::map<uint64_t,std::string> m_listFile;
|
||||
uint64_t m_lastMaxId;
|
||||
ememory::SharedPtr<zeus::ClientProperty> m_client;
|
||||
public:
|
||||
User(const std::string& _userName) :
|
||||
m_userName(_userName),
|
||||
m_lastMaxId(1024) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
APPL_WARNING("new USER: " << m_userName << " [START]");
|
||||
m_basePath = std::string("USERDATA:") + m_userName + "/";
|
||||
APPL_WARNING("new USER: " << m_userName);
|
||||
bool ret = m_database.load(m_basePath + "database.json");
|
||||
PictureService() {
|
||||
APPL_WARNING("New PictureService ...");
|
||||
}
|
||||
PictureService(ememory::SharedPtr<zeus::ClientProperty> _client) :
|
||||
m_client(_client) {
|
||||
APPL_WARNING("New PictureService ... for user: ");
|
||||
}
|
||||
~PictureService() {
|
||||
APPL_WARNING("delete PictureService ...");
|
||||
}
|
||||
public:
|
||||
std::vector<std::string> getAlbums() {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
std::vector<std::string> out;
|
||||
ejson::Array globalGroups = g_database["group-global"].toArray();
|
||||
if (globalGroups.exist() == false) {
|
||||
APPL_DEBUG("'group-global' ==> does not exist ==> No album");
|
||||
return out;
|
||||
}
|
||||
ejson::Object groups = g_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;
|
||||
/*
|
||||
ejson::Object groups = g_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
return std::vector<std::string>();
|
||||
}
|
||||
groups
|
||||
return getSubAlbums("");
|
||||
*/
|
||||
}
|
||||
// Get the list of sub album
|
||||
std::vector<std::string> getSubAlbums(std::string _parrentAlbum) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
std::vector<std::string> out;
|
||||
ejson::Object groups = g_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
return out;
|
||||
}
|
||||
// find parrentAlbum ==> to get sub group
|
||||
/*
|
||||
for (size_t iii=0; iii<groups.size(); ++iii) {
|
||||
//ejson::Object group = groups[iii].toObject()["sub"];
|
||||
if (groups.getKey(iii) != _parrentAlbum) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
*/
|
||||
ejson::Object group = groups[_parrentAlbum].toObject();
|
||||
if (group.exist() == false) {
|
||||
return out;
|
||||
}
|
||||
ejson::Array groupSubs = group["sub"].toArray();
|
||||
for (auto it: groupSubs) {
|
||||
std::string tmpString = it.toString().get();
|
||||
if (tmpString == "") {
|
||||
continue;
|
||||
}
|
||||
out.push_back(tmpString);
|
||||
}
|
||||
// TODO: Check right
|
||||
return out;
|
||||
}
|
||||
uint32_t getAlbumCount(std::string _album) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
ejson::Object groups = g_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return 0;
|
||||
}
|
||||
ejson::Object group = groups[_album].toObject();
|
||||
if (group.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return 0;
|
||||
}
|
||||
ejson::Array groupSubs = group["files"].toArray();
|
||||
// TODO: Check right
|
||||
return groupSubs.size();
|
||||
}
|
||||
// Return the list of the album files
|
||||
std::vector<std::string> getAlbumListPicture(std::string _album) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
std::vector<std::string> out;
|
||||
ejson::Object groups = g_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return out;
|
||||
}
|
||||
ejson::Object group = groups[_album].toObject();
|
||||
if (group.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return out;
|
||||
}
|
||||
ejson::Array groupSubs = group["files"].toArray();
|
||||
|
||||
for (auto it: groupSubs) {
|
||||
uint64_t id = it.toNumber().getU64();
|
||||
/*
|
||||
auto itImage = m_listFile.find(id);
|
||||
if (itImage == m_listFile.end()) {
|
||||
|
||||
}*/
|
||||
if (id == 0) {
|
||||
continue;
|
||||
}
|
||||
out.push_back(etk::to_string(id));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
// Return a File Data (might be a picture .tiff/.png/.jpg)
|
||||
zeus::FileServer getAlbumPicture(std::string _pictureName) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
uint64_t id = etk::string_to_uint64_t(_pictureName);
|
||||
APPL_WARNING("try to get file : " << _pictureName << " with id=" << id);
|
||||
{
|
||||
auto it = m_listFile.find(id);
|
||||
if (it != m_listFile.end()) {
|
||||
return zeus::FileServer(g_basePath + it->second);
|
||||
}
|
||||
}
|
||||
for (auto &it : m_listFile) {
|
||||
APPL_WARNING("compare: " << it.first << " with " << id << " " << it.second);
|
||||
if (it.first == id) {
|
||||
return zeus::FileServer(g_basePath + it.second);
|
||||
}
|
||||
}
|
||||
APPL_ERROR(" ==> Not find ...");
|
||||
return zeus::FileServer();
|
||||
}
|
||||
std::string addFile(zeus::File _dataFile) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
APPL_ERROR(" ==> Receive FILE " << _dataFile.getMineType() << " size=" << _dataFile.getData().size());
|
||||
uint64_t id = createFileID();
|
||||
std::stringstream val;
|
||||
val << std::hex << std::setw(16) << std::setfill('0') << id;
|
||||
std::string filename = val.str();
|
||||
filename += ".";
|
||||
filename += zeus::getExtention(_dataFile.getMineType());
|
||||
_dataFile.storeIn(g_basePath + filename);
|
||||
m_listFile.insert(std::make_pair(id, filename));
|
||||
return etk::to_string(id);//zeus::FileServer();
|
||||
}
|
||||
/*
|
||||
// Return a global UTC time
|
||||
zeus::Time getAlbumPictureTime(std::string _pictureName) {
|
||||
return m_user->getAlbumPictureTime(_pictureName);
|
||||
}
|
||||
// Return a Geolocalization information (latitude, longitude)
|
||||
zeus::Geo getAlbumPictureGeoLocalization(std::string _pictureName) {
|
||||
return m_user->getAlbumPictureGeoLocalization(_pictureName);
|
||||
}
|
||||
*/
|
||||
bool removeFile(const std::string& _file) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string createAlbum(const std::string& _name) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return "";
|
||||
}
|
||||
bool removeAlbum(const std::string& _name) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
bool setAlbumDescription(const std::string& _name, const std::string& _desc) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
std::string getAlbumDescription(const std::string& _name) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return "";
|
||||
}
|
||||
bool addInAlbum(const std::string& _nameAlbum, const std::string& _nameElement) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
bool removeFromAlbum(const std::string& _nameAlbum, const std::string& _nameElement) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
/*
|
||||
// Return a global UTC time
|
||||
zeus::Time getAlbumPictureTime(const std::string& _pictureName) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return zeus::Time();
|
||||
}
|
||||
// Return a Geolocalization information (latitude, longitude)
|
||||
zeus::Geo getAlbumPictureGeoLocalization(const std::string& _pictureName) {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
// TODO : Check right ...
|
||||
return zeus::Geo();
|
||||
}
|
||||
*/
|
||||
};
|
||||
}
|
||||
|
||||
bool SERVICE_IO_init(std::string _basePath) {
|
||||
g_basePath = _basePath;
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
APPL_WARNING("Load USER: " << g_basePath);
|
||||
bool ret = g_database.load(g_basePath + g_baseDBName);
|
||||
if (ret == false) {
|
||||
APPL_WARNING(" ==> LOAD error");
|
||||
}
|
||||
// Load all files (image and video ...)
|
||||
etk::FSNode node(m_basePath);
|
||||
etk::FSNode node(g_basePath);
|
||||
std::vector<etk::FSNode*> tmpList = node.folderGetSubList(false, false, true, false);
|
||||
APPL_WARNING("Find " << tmpList.size() << " files");
|
||||
for (auto &it : tmpList) {
|
||||
@ -72,337 +296,34 @@ namespace appl {
|
||||
APPL_WARNING(" ==> REJECT file " << it->getNameFile());
|
||||
}
|
||||
}
|
||||
APPL_WARNING("new USER: " << m_userName << " [STOP]");
|
||||
}
|
||||
~User() {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
APPL_WARNING("delete USER [START]");
|
||||
APPL_DEBUG("Store User Info:");
|
||||
bool ret = m_database.storeSafe(m_basePath + "database.json");
|
||||
if (ret == false) {
|
||||
APPL_WARNING(" ==> Store error");
|
||||
}
|
||||
APPL_WARNING("delete USER [STOP]");
|
||||
}
|
||||
// Return the list of root albums
|
||||
std::vector<std::string> getAlbums() {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
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;
|
||||
/*
|
||||
ejson::Object groups = m_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
return std::vector<std::string>();
|
||||
}
|
||||
groups
|
||||
return getSubAlbums("");
|
||||
*/
|
||||
}
|
||||
// Get the list of sub album
|
||||
std::vector<std::string> getSubAlbums(const std::string& _album) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
std::vector<std::string> out;
|
||||
ejson::Object groups = m_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
return out;
|
||||
}
|
||||
// find parrentAlbum ==> to get sub group
|
||||
/*
|
||||
for (size_t iii=0; iii<groups.size(); ++iii) {
|
||||
//ejson::Object group = groups[iii].toObject()["sub"];
|
||||
if (groups.getKey(iii) != _parrentAlbum) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
*/
|
||||
ejson::Object group = groups[_album].toObject();
|
||||
if (group.exist() == false) {
|
||||
return out;
|
||||
}
|
||||
ejson::Array groupSubs = group["sub"].toArray();
|
||||
for (auto it: groupSubs) {
|
||||
std::string tmpString = it.toString().get();
|
||||
if (tmpString == "") {
|
||||
continue;
|
||||
}
|
||||
out.push_back(tmpString);
|
||||
}
|
||||
// TODO: Check right
|
||||
return out;
|
||||
}
|
||||
uint32_t getAlbumCount(const std::string& _album) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
ejson::Object groups = m_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return 0;
|
||||
}
|
||||
ejson::Object group = groups[_album].toObject();
|
||||
if (group.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return 0;
|
||||
}
|
||||
ejson::Array groupSubs = group["files"].toArray();
|
||||
// TODO: Check right
|
||||
return groupSubs.size();
|
||||
/*
|
||||
for (auto it: groupSubs) {
|
||||
uint64_t id = it.toNumber().getU64();
|
||||
if (id == 0) {
|
||||
continue;
|
||||
}
|
||||
out.push_back(id);
|
||||
}
|
||||
*/
|
||||
}
|
||||
// Return the list of the album files
|
||||
std::vector<std::string> getAlbumListPicture(const std::string& _album) {//, uint32_t _startId, uint32_t _stopId) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
std::vector<std::string> out;
|
||||
ejson::Object groups = m_database["groups"].toObject();
|
||||
if (groups.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return out;
|
||||
}
|
||||
ejson::Object group = groups[_album].toObject();
|
||||
if (group.exist() == false) {
|
||||
// TODO : Throw an error ...
|
||||
return out;
|
||||
}
|
||||
ejson::Array groupSubs = group["files"].toArray();
|
||||
|
||||
for (auto it: groupSubs) {
|
||||
uint64_t id = it.toNumber().getU64();
|
||||
/*
|
||||
auto itImage = m_listFile.find(id);
|
||||
if (itImage == m_listFile.end()) {
|
||||
|
||||
}*/
|
||||
if (id == 0) {
|
||||
continue;
|
||||
}
|
||||
out.push_back(etk::to_string(id));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
// Return a File Data (might be a picture .tiff/.png/.jpg)
|
||||
zeus::FileServer getAlbumPicture(const std::string& _pictureName) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
uint64_t id = etk::string_to_uint64_t(_pictureName);
|
||||
APPL_WARNING("try to get file : " << _pictureName << " with id=" << id);
|
||||
{
|
||||
auto it = m_listFile.find(id);
|
||||
if (it != m_listFile.end()) {
|
||||
return zeus::FileServer(m_basePath + it->second);
|
||||
}
|
||||
}
|
||||
for (auto &it : m_listFile) {
|
||||
APPL_WARNING("compare: " << it.first << " with " << id << " " << it.second);
|
||||
if (it.first == id) {
|
||||
return zeus::FileServer(m_basePath + it.second);
|
||||
}
|
||||
}
|
||||
APPL_ERROR(" ==> Not find ...");
|
||||
return zeus::FileServer();
|
||||
}
|
||||
std::string addFile(const zeus::File& _dataFile) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
APPL_ERROR(" ==> Receive FILE " << _dataFile.getMineType() << " size=" << _dataFile.getData().size());
|
||||
uint64_t id = createFileID();
|
||||
std::stringstream val;
|
||||
val << std::hex << std::setw(16) << std::setfill('0') << id;
|
||||
std::string filename = val.str();
|
||||
filename += ".";
|
||||
filename += zeus::getExtention(_dataFile.getMineType());
|
||||
_dataFile.storeIn(m_basePath + filename);
|
||||
m_listFile.insert(std::make_pair(id, filename));
|
||||
return etk::to_string(id);//zeus::FileServer();
|
||||
}
|
||||
bool removeFile(const std::string& _file) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string createAlbum(const std::string& _name) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return "";
|
||||
}
|
||||
bool removeAlbum(const std::string& _name) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
bool setAlbumDescription(const std::string& _name, const std::string& _desc) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
std::string getAlbumDescription(const std::string& _name) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return "";
|
||||
}
|
||||
|
||||
|
||||
bool addInAlbum(const std::string& _nameAlbum, const std::string& _nameElement) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
bool removeFromAlbum(const std::string& _nameAlbum, const std::string& _nameElement) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return false;
|
||||
}
|
||||
/*
|
||||
// Return a global UTC time
|
||||
zeus::Time getAlbumPictureTime(const std::string& _pictureName) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return zeus::Time();
|
||||
}
|
||||
// Return a Geolocalization information (latitude, longitude)
|
||||
zeus::Geo getAlbumPictureGeoLocalization(const std::string& _pictureName) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// TODO : Check right ...
|
||||
return zeus::Geo();
|
||||
}
|
||||
*/
|
||||
private:
|
||||
uint64_t createFileID() {
|
||||
m_lastMaxId++;
|
||||
return m_lastMaxId;
|
||||
}
|
||||
};
|
||||
|
||||
class UserManager {
|
||||
private:
|
||||
std::mutex m_mutex;
|
||||
std::map<std::string, ememory::SharedPtr<appl::User>> m_listLoaded;
|
||||
public:
|
||||
UserManager() {
|
||||
|
||||
}
|
||||
ememory::SharedPtr<appl::User> getUser(const std::string& _userName) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
auto it = m_listLoaded.find(_userName);
|
||||
if (it != m_listLoaded.end()) {
|
||||
// User already loaded:
|
||||
return it->second;
|
||||
}
|
||||
// load New User:
|
||||
ememory::SharedPtr<appl::User> tmp(new appl::User(_userName));
|
||||
m_listLoaded.insert(std::make_pair(_userName, tmp));
|
||||
return tmp;
|
||||
}
|
||||
};
|
||||
class PictureService {
|
||||
private:
|
||||
ememory::SharedPtr<appl::User> m_user;
|
||||
private:
|
||||
ememory::SharedPtr<zeus::ClientProperty> m_client;
|
||||
public:
|
||||
PictureService() {
|
||||
APPL_WARNING("New PictureService ...");
|
||||
}
|
||||
PictureService(ememory::SharedPtr<appl::User> _user, ememory::SharedPtr<zeus::ClientProperty> _client) :
|
||||
m_user(_user),
|
||||
m_client(_client) {
|
||||
APPL_WARNING("New PictureService ... for user: ");
|
||||
}
|
||||
~PictureService() {
|
||||
APPL_WARNING("delete PictureService ...");
|
||||
}
|
||||
public:
|
||||
std::vector<std::string> getAlbums() {
|
||||
return m_user->getAlbums();
|
||||
}
|
||||
// Get the list of sub album
|
||||
std::vector<std::string> getSubAlbums(std::string _parrentAlbum) {
|
||||
return m_user->getSubAlbums(_parrentAlbum);
|
||||
}
|
||||
uint32_t getAlbumCount(std::string _album) {
|
||||
return m_user->getAlbumCount(_album);
|
||||
}
|
||||
// Return the list of the album files
|
||||
std::vector<std::string> getAlbumListPicture(std::string _album) {
|
||||
return m_user->getAlbumListPicture(_album);
|
||||
}
|
||||
// Return a File Data (might be a picture .tiff/.png/.jpg)
|
||||
zeus::FileServer getAlbumPicture(std::string _pictureName) {
|
||||
return m_user->getAlbumPicture(_pictureName);
|
||||
}
|
||||
std::string addFile(zeus::File _dataFile) {
|
||||
return m_user->addFile(_dataFile);
|
||||
}
|
||||
/*
|
||||
// Return a global UTC time
|
||||
zeus::Time getAlbumPictureTime(std::string _pictureName) {
|
||||
return m_user->getAlbumPictureTime(_pictureName);
|
||||
}
|
||||
// Return a Geolocalization information (latitude, longitude)
|
||||
zeus::Geo getAlbumPictureGeoLocalization(std::string _pictureName) {
|
||||
return m_user->getAlbumPictureGeoLocalization(_pictureName);
|
||||
}
|
||||
*/
|
||||
};
|
||||
APPL_WARNING("new USER: [STOP]");
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SERVICE_IO_uninit() {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
APPL_DEBUG("Store User Info:");
|
||||
bool ret = g_database.storeSafe(g_basePath + g_baseDBName);
|
||||
if (ret == false) {
|
||||
APPL_WARNING(" ==> Store error");
|
||||
return false;
|
||||
}
|
||||
APPL_WARNING("delete USER [STOP]");
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int _argc, const char *_argv[]) {
|
||||
etk::init(_argc, _argv);
|
||||
zeus::init(_argc, _argv);
|
||||
std::string ip;
|
||||
uint16_t port = 0;
|
||||
for (int32_t iii=0; iii<_argc ; ++iii) {
|
||||
std::string data = _argv[iii];
|
||||
if (etk::start_with(data, "--ip=") == true) {
|
||||
ip = std::string(&data[5]);
|
||||
} else if (etk::start_with(data, "--port=") == true) {
|
||||
port = etk::string_to_uint16_t(std::string(&data[7]));
|
||||
} else if ( data == "-h"
|
||||
|| data == "--help") {
|
||||
APPL_PRINT(etk::getApplicationName() << " - help : ");
|
||||
APPL_PRINT(" " << _argv[0] << " [options]");
|
||||
APPL_PRINT(" --ip=XXX Server connection IP (default: 1.7.0.0.1)");
|
||||
APPL_PRINT(" --port=XXX Server connection PORT (default: 1983)");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
while (true) {
|
||||
bool SERVICE_IO_execute(std::string _ip, uint16_t _port) {
|
||||
APPL_INFO("===========================================================");
|
||||
APPL_INFO("== ZEUS instanciate service: " << SERVICE_NAME << " [START]");
|
||||
APPL_INFO("===========================================================");
|
||||
ememory::SharedPtr<appl::UserManager> userMng = ememory::makeShared<appl::UserManager>();
|
||||
zeus::ServiceType<appl::PictureService, appl::UserManager> serviceInterface(userMng);
|
||||
if (ip != "") {
|
||||
serviceInterface.propertyIp.set(ip);
|
||||
zeus::ServiceType<appl::PictureService> serviceInterface([](ememory::SharedPtr<zeus::ClientProperty> _client){
|
||||
return ememory::makeShared<appl::PictureService>(_client);
|
||||
});
|
||||
if (_ip != "") {
|
||||
serviceInterface.propertyIp.set(_ip);
|
||||
}
|
||||
if (port != 0) {
|
||||
serviceInterface.propertyPort.set(port);
|
||||
if (_port != 0) {
|
||||
serviceInterface.propertyPort.set(_port);
|
||||
}
|
||||
serviceInterface.propertyNameService.set(SERVICE_NAME);
|
||||
serviceInterface.setDescription("Picture Private Interface");
|
||||
@ -424,14 +345,18 @@ int main(int _argc, const char *_argv[]) {
|
||||
APPL_INFO("===========================================================");
|
||||
APPL_INFO("== ZEUS service: " << *serviceInterface.propertyNameService << " [service instanciate]");
|
||||
APPL_INFO("===========================================================");
|
||||
serviceInterface.connect();
|
||||
if (serviceInterface.connect() == false) {
|
||||
APPL_INFO("wait 5 second ...");
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
return false;
|
||||
}
|
||||
if (serviceInterface.GateWayAlive() == false) {
|
||||
APPL_INFO("===========================================================");
|
||||
APPL_INFO("== ZEUS service: " << *serviceInterface.propertyNameService << " [STOP] Can not connect to the GateWay");
|
||||
APPL_INFO("===========================================================");
|
||||
APPL_INFO("wait 5 second ...");
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
continue;
|
||||
return false;
|
||||
}
|
||||
int32_t iii=0;
|
||||
while (serviceInterface.GateWayAlive() == true) {
|
||||
@ -448,6 +373,50 @@ int main(int _argc, const char *_argv[]) {
|
||||
APPL_INFO("===========================================================");
|
||||
APPL_INFO("== ZEUS service: " << *serviceInterface.propertyNameService << " [STOP] GateWay Stop");
|
||||
APPL_INFO("===========================================================");
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifndef APPL_BUILD_SHARED_LIBRARY
|
||||
|
||||
int main(int _argc, const char *_argv[]) {
|
||||
etk::init(_argc, _argv);
|
||||
zeus::init(_argc, _argv);
|
||||
std::string ip;
|
||||
uint16_t port = 0;
|
||||
std::string basePath;
|
||||
for (int32_t iii=0; iii<_argc ; ++iii) {
|
||||
std::string data = _argv[iii];
|
||||
if (etk::start_with(data, "--ip=") == true) {
|
||||
ip = std::string(&data[5]);
|
||||
} else if (etk::start_with(data, "--port=") == true) {
|
||||
port = etk::string_to_uint16_t(std::string(&data[7]));
|
||||
} else if (etk::start_with(data, "--base-path=") == true) {
|
||||
basePath = std::string(&data[12]);
|
||||
} else if ( data == "-h"
|
||||
|| data == "--help") {
|
||||
APPL_PRINT(etk::getApplicationName() << " - help : ");
|
||||
APPL_PRINT(" " << _argv[0] << " [options]");
|
||||
APPL_PRINT(" --base-path=XXX base path to search data (default: 'USERDATA:')");
|
||||
APPL_PRINT(" --ip=XXX Server connection IP (default: 1.7.0.0.1)");
|
||||
APPL_PRINT(" --port=XXX Server connection PORT (default: 1983)");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
if (basePath.size() == 0) {
|
||||
basePath = "USERDATA:";
|
||||
APPL_PRINT("Use base path: " << basePath);
|
||||
}
|
||||
SERVICE_IO_init(basePath);
|
||||
// TODO: Remove the While true, ==> sevice must be spown by a user call, if a service die, the wall system will die ...
|
||||
while (true) {
|
||||
SERVICE_IO_execute(ip, port);
|
||||
}
|
||||
APPL_INFO("Stop service ==> flush internal datas ...");
|
||||
SERVICE_IO_uninit();
|
||||
APPL_INFO("===========================================================");
|
||||
APPL_INFO("== ZEUS service: " << SERVICE_NAME << " [END-APPLICATION]");
|
||||
APPL_INFO("===========================================================");
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -17,10 +17,10 @@
|
||||
|
||||
static std::mutex g_mutex;
|
||||
static std::string g_basePath;
|
||||
static std::string g_baseDBName = std::string(SERVICE_NAME) + "-database.json";
|
||||
static ejson::Document g_database;
|
||||
|
||||
namespace appl {
|
||||
|
||||
class SystemService {
|
||||
private:
|
||||
ememory::SharedPtr<zeus::ClientProperty> m_client;
|
||||
@ -116,7 +116,7 @@ bool SERVICE_IO_init(std::string _basePath) {
|
||||
g_basePath = _basePath;
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
APPL_WARNING("Load USER: " << g_basePath);
|
||||
bool ret = g_database.load(g_basePath + "config.json");
|
||||
bool ret = g_database.load(g_basePath + g_baseDBName);
|
||||
if (ret == false) {
|
||||
APPL_WARNING(" ==> LOAD error");
|
||||
}
|
||||
@ -126,7 +126,7 @@ bool SERVICE_IO_init(std::string _basePath) {
|
||||
bool SERVICE_IO_uninit() {
|
||||
std::unique_lock<std::mutex> lock(g_mutex);
|
||||
APPL_DEBUG("Store User Info:");
|
||||
bool ret = g_database.storeSafe(g_basePath + "config.json");
|
||||
bool ret = g_database.storeSafe(g_basePath + g_baseDBName);
|
||||
if (ret == false) {
|
||||
APPL_WARNING(" ==> Store error");
|
||||
return false;
|
||||
|
||||
@ -4,6 +4,7 @@ import lutin.tools as tools
|
||||
|
||||
|
||||
def get_type():
|
||||
#return "LIBRARY_DYNAMIC"
|
||||
return "BINARY"
|
||||
|
||||
def get_sub_type():
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user