tres beau projet, je te felecite

L'intéret de cette tech serait qu'elle soit disponible directement dans tout navigateur, grace à une quelconque surcouche js je pense (les gens ne changeront pas de navigateur juste pour ça)

Ce qui me gêne, c'est que tu me dis que les ressources représentent un type de donnée...sauf qu'ils sont organisés de manière hiérarchique? Quel est l'intérêt? Pour moi, ça pose un gros problème de compréhension : la "ressource root" ne représente aucun type de données, je ne vois même pas quelle interface peut lui correspondre. Sauf si ça fonctionne comme une succession de filtres, et que dans ce cas root représente toutes les ressources?

Quant à l'interface, elle est de quel type, web (HTML/CSSS/JS), ou il faut employer une technologie particulière pour décrire son rendu graphique?

-
Edité par Genroa 10 novembre 2015 à 9:38:41

Oui c'est pour ça que je l'ai rendu compatible avec le web, c'était dans un but de transition. J'ai ajouté un module hdd qui permet de servir d'explorateur de fichier local, en JS je ne sais pas si c'est possible

Une ressource n'est pas un type de donnée, c'est une information structurée qui peut posséder un ou plusieurs types. Ensuite elles sont connectées entre elles (je génère l'arborescence à partir des connexions)

La ressource root sert de noeud pour y connecter les autres ressources. Quand tu arrives sur un serveur, tu tombes sur cette ressource et tu explores toutes les connexions en partant de ce point. Je me suis fait une interface home pour cette ressource, ça me sert de page d'accueil.

Par exemple pour ma gestion de série, j'ai une ressource Série qui sert de noeud et je connecte les ressources de type serie à ce noeud, puis j'ajoute l'interface à ce noeud qui va lister toutes les séries.

Les interfaces peuvent être côté client ou serveur, soit on récupère les données de rendu depuis le serveur, soit on utilise une interface client qui récupère les données depuis le serveur.

Sur le client nex, on peut avoir plusieurs moteurs de rendu, actuellement web et j'ai teste avec openGL. Par défaut c'est du web et pour changer il faut le spécifier dans le protocole :

NEX:1.0/render:gl;/nxs::res_get;id=10;;

 Imaginons que la ressource 10 représente une molécule, on pourrait donc la visualiser en 3D.

Désolé, mais je ne saisis toujours pas le concept de "ressource". Tu n'aurais pas une image simple pour représenter le concept, comme les classes en prog objet, ou je ne sais pas moi? ^^' pour moi le terme "ressource" n'est absolument pas correct ou approprié

Qu'est-ce qui permet à un client de savoir, lorsqu'il récupère une "ressource", qu'elle possède ou non une interface appropriée pour l'afficher? Ca ne peut être par un simple id je suppose

Quand tu récupères une ressource nxs::res_get;id=2; tu reçois une ressource sérialisée, puis à partir de ça tu construis un objet ressource.

Et tu as accès a toute la structure de la ressource (comme sur le schéma)

c_resource resource(id);
resource.interface_list();
resource.type("movie").property("image").data;
resource.property("note").data;
// etc ...

Et si tu veux juste connaitre les interfaces disponibles pour une ressource, tu envoies au serveur : nxs::res_interface_list;res_id=2;

Salut,

J'ai fait un module de chat pour tester quelques nouveaux trucs :

Le client exécute les commande d'interface envoyée par le serveur, si l'interface est active, la commande est appelée sinon une notification est ajoutée.

Exemple :

Le serveur envoie nexcom:new_message;msg=salut;

Le client appelle la fonction new_message de l'interface active puis affiche le message.

On peut donc utiliser l'interface client ou serveur (à voir comment choisir sur le client)

-
Edité par ads00 18 novembre 2015 à 2:34:18

Salut,

J'ai ajouté les notifications sur le client :

Salut,

J'ai ajouté un système de notification sur le serveur.

On peut rendre une commande notifiable, ensuite le user peut demander une notification pour cette commande avec les paramètres choisis

Exemple :

nxs::notify;__module=nxs;__command=res_add;id=1;type_id=2;

Le user recevra donc une notification quand une ressource de type 2 (movie par exemple) sera ajouté depuis la ressource d'id 1 (Movie list)

On peut également être notifié en fonction d'une date pour être averti quand une ressource expire.

Par exemple, on crée  une ressource "Rendez-vous", on spécifie la date d'expiration puis on envoie la requête :

nxs::notify;__timer=date_expire;res_id=3;remind=10;30;

On recevra une notification 10min, 30min avant et à la date d'expiration.

Salut,

J'ai ajouté un moteur de rendu 3D (Nazara)

Salut,

On peut maintenant créer des timers qui exécutent une requête à une date précise.

J'ai donc modifié le système de notification pour qu'il crée un timer quand on veut ajouter une notification sur une ressource.

up

Je t'ai envoyé un message !

Salut,

Je dev actuellement la version 2 du serveur, voici les changements :

Général

 - Ajout de modules JS et python

 - Ajout d'un système de gestions d'évènements

Réseau

 - Amélioration de la structure du code et certains algos

 - Ajout de gestion des headers

 - Sérialisation remplacée par un système d'encodage générique

Base de donnée

 - Suppression de toutes les requêtes chainées

 - Ajout d'expressions template pour les requêtes

 - Gestion de la structure de la base et types stockés via c++

 - Gestion de plusieurs sgbd

Salut, j'ai pas tout suivie, mais est-il possible d'inclure Nex à un projet C++.

De façon minimal, quels en sont les dépendances? Ce "protocole" pourrais être inclue de base à GZE, et aussi d'autre projets comme CpcDos avec lequel je collabore.

C'est open source?

Salut,

Oui c'est possible.

Actuellement, j'utilise boost asio, filesystem et serialization en librairie statique et botan / sqlite en amalgamation.

Si tu veux moins de dépendances, il est possible de virer filesystem, serialization et botan assez facilement.

Après il faut voir les besoins du projet, pour l'instant je ne m'occupe pas des performances.

C'est fait pour être intégré à d'autres projets par exemple, tu peux rajouter un header assez facilement dans le protocole, côté base de donnée, j'essaie de faire des requêtes style sql pour n'importe quel sgbd du style :

// insert
q2 >> (r::name = "zeta", r::author = "ads", r::network = "net", r::id = 4, r::date = std::chrono::system_clock::now());
// select
q << (r::id, r::name, r::author, r::network) << (r::id == 5 || r::name == "zeta" || r::date == std::chrono::system_clock::now());

Tu aurais besoin de quelles fonctionnalités ?

Pour l'instant j'ai les sources sur mon serveur git mais je peux ajouter des accès.

Je trouve l'idée intéressante, par contre je suis un peu retissant par les dépendance que tu cite.

En fait j'ai besoin de quelque chose de très très léger pour gérer des ressources Web.
Je suis très difficile, il faut que ça soit léger pour plusieurs raison, la taille du binaire, le temps de compilation et surtout la portabilité.

Si on prend CpcDos par exemple qui à une interface Web un peu rudimentaire, ça serait très intéressant d'y ajouté ton projet et pouvoir naviguer dans les ressources Web

Par exemple si tu veux porter ton projet sous CpcDos, celui-ci va te fournir quelques fonctions de base, comme des requête FTP, connexion à une DB. L'idéal est d'utiliser le moins de fonction externe possible, ensuite il est aisé de mapper les fonctions et de trouver les équivalents

Je lance l'idée, tu peux y penser, même commencé à rendre ton projet modulable, de pouvoir en désactiver certain monceaux, etc.

Sinon, quel en est la licence?

Oui j'ai vu que tu n'aimais pas les dépendances, mais ce n'est pas dans mes priorités de recoder ces dépendances.

Le projet était déjà modulable et il le sera encore plus dans cette 2e version, tu peux choisir les types de connexions que tu utilises, les protocoles, les sgbd etc ...

Mais la gestion des ressources est liée à la partie db, tes ressources web sont stockées comment ? ce sont juste de fichiers ?

Pour la licence, je ne sais pas, je ne me suis pas posé la question

Pour les ressources, javais pensé entre autre à un format sur lequel je travail en ce moment. Un format qui a pour but d'être portable, et qui peut exécuter/interpréter du C++, tout ça en JIT. On peut imaginer des jeux ou applications.

Ce qui serait parfaitement adapté pour ton système, qui peut traiter des ressources à partir de Linux, Windows, etc.

Mais Nex peut-il servir aussi de serveur pour entreposé et faire des backup de fichiers? Ou bien, obtenir la dernière version d'un programme, pour faire des mises à jours automatique?

Mais je ne pense pas qu'une DB soit nécessaire pour ça?

En fait j'utilise une DB pour stocker la structure d'une ressource.

J'appelle "ressource" une information structurée qui peut avoir :

 - des types (film, image, contact ...)

 - des propriétés (email, volume, adresse ...)

 - des interfaces (pour visualiser l'information)

 - des connexions de différents types (pour avoir un lien logique entre les différentes ressources)

A long terme, l'idéal serait d'avoir un sgdb interne qui gère tout ça mais en attendant j'utilise sqlite.

Pour la partie serveur, tu peux ajouter les commandes que tu veux, je compte faire quelques fonctionnalités de bases puis on peut ajouter des modules / interfaces (c++, html, python prévus) pour ajouter des commandes ou faire des interfaces persos.

Par exemple, la commande pour envoyer des fichiers ressemble à ça :

    void file_add(nxs::nex& nex)
    {
        std::string path = nxs::config::network_download_path;
        std::string name = "";
        for (size_t i = 0; i < nex.input().data_count(); i++)
        {
            name = nex.input().param("name", i);
            if (name == "") name = "file_" + std::to_string(i);
            nxs::file::rename(nex.input().data(i).get(), name);
        }
        nex.output().add("NXS_TRANSFER_COMPLETE");
    }

Et pour ajouter et configurer la commande :

command& file_add = nxs::command::add("nxs", "file_add", &nxs::server_command::file_add);
        file_add.wait_transfer(true);
        file_add.header_add<headers::data_target>(headers::data_target::hdd);

Ensuite, il suffit d'envoyer une requête :

NEX:1.0/data_size=5;5;/nxs::file_add;;1234512345

La je viens de finir les headers et j'ai modifié un peu le système de requêtes,

on peut ajouter assez facilement des headers au protocole et utiliser différentes versions de requêtes.

Je prévois de faire des requêtes binaires qui utilisent un système d'encodage perso (style codage zeta)

@ads00 & Maeiky: Salut à tous les deux.

Je me permet d'intervenir, car j'ai quelques infos qui pourraient vous aider tous les deux.

_______________________

Concernant SQLite, qui est semble-t-il très léger (utilisé en embarqué) et portable (que la bibliothèque standard du C comme dépendance), il semble possible de l'utiliser sous FreeDOS (la base de CpcDOS d'après ce que j'avais compris après ma dernière discussion avec un des membres du projet), via DJGPP.

De ce que j'ai compris, il s'agit d'un port des outils de compilation GNU sur la famille des systèmes CP/M & DOS.

Par contre, il faut voir si un programme est utile et utilisable pour CpcDOS, car il se peut qu'il y ait déjà des outils du projet GNU intégrer dans FreeDOS d'une part, et d'autre part il semble que d'après une information que Maeiky m'a envoyée le projet CpcDOS utilise maintenant Clang comme compilateur (surtout pour LLVM de ce que j'ai compris), alors que DJGPP repose sur GCC.

Bref, à voir et à étudier pour voir de quoi il en retourne.

Voici un lien supplémentaire que j'ai trouvé sur la compilation de SQLite avec DJGPP.

______________

Concernant un futur remplacement du SQLite, il serait intéressant de regarder du côté du système de fichiers de Haïku (système d'exploitation descendant de BeOS et se voulant sa continuation Open Source): (Open)BFS.

D'après ce que j'ai lu, ce système de fichier natif permet de donner des attributs à des fichiers, et de classer et trier ces fichiers grâce à ces attributs, ce qui semble être une caractéristique des bases de données.

Pour plus d'informations, je vous laisse fouiller sur le site du projet Haiku, où il y aura sûrement des personnes qui pourront répondre à vos éventuelles questions sur le sujet.

______________________

Enfin, concernant les mises à jour logicielles, il devrait être possible d'implémenter avec Nex un système similaire aux systèmes des paquets et des dépôts que l'on retrouve dans les distributions GNU/Linux.

En effet, on pourrait définir comme ressource un "paquet" avec comme propriété une dépendance ou plusieurs dépendances (tel logiciel a besoin de telle bibliothèque de telle version pour fonctionner).

Pour la gestion des dépendances (qui peut vite devenir un casse-tête avec les dépendances inverses et cycliques), il serait utile de regarder comment les gestionnaires de paquets arrivent à les gérer comme Pacman (famille ArchLinux) ou le couple APT/dpkg (famille Debian), et de s'en inspirer.

Mais là, c'est plutôt le rôle du client type NXI (à créer justement), qui permet en même temps d'accéder au réseau Nex.

____________________________

Voilà, en espérant que mon intervention vous ait été utile à tous les deux.

Bonne soirée.

Salut,

Je cherche toujours de l'aide pour le dev

Salut,

Je cherche toujours de l'aide pour continuer.

Je dev actuellement une interface c++ pour faire des requêtes sur sgbd pour simplifier la partie DB du soft.

Salut,

Toujours up

Salut,

L'interface pour les sgdb a été ajoutée, voici un exemple d'utilisation :

        static void test(nxs::nex& nex)
        {
            std::stringstream result;
            const auto& u = db::nex.user;

            for (auto& item : user::get(u.name == "ads"))
            {
                result << "<br />" << item[u.id] << " - " << item[u.name];
            }
            nex.output().add(result.str());
        }

-
Edité par ads00 8 octobre 2016 à 6:15:59

Salut,

Quelques news :

 - Ajout d'un gestionnaire client / serveur pour les connexions

 - Amélioration de la gestion des données à transférer

 - Le protocole gère l'envoi et la réponse lorsqu'il est de type sortant

Exemple :

connexion().protocol().send(url_.command(), [this](nxs::nex& nex)
{
    page_load(nex.input().data().get().c_str());
});

Le client nxi utilise désormais WebEngine et gère correctement les évènements asynchrones des connexions.

Si vous voulez participer, contactez moi !

Salut,

ndb étant assez avancé maintenant (https://github.com/ads00/ndb)

Je continue donc l'UI (nxi). Le but est d'avoir une interface entièrement personnalisable et flexible. Une fois la gestion de la sauvegarde terminée, je montrerai quelques features du navigateur !

-
Edité par ads00 6 mai 2018 à 8:37:42