Programmation d'applications modulaires

Maintenant que nous savons à quoi ressemble ModuleManager, nous pouvons écrire une application qui l'utilise. J'ai décrit l'en-tête de la bibliothèque dans l'introduction Le reste du code devrait être clair.

Nous pouvons donc écrire l'application. L'application nous permettra de :

• charger un nouveau module ;
• appeler une fonction existante ;
• quitter l'application.

Chaque fonctionnalité sera appelée en utilisant une commande dédiée :

#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <sstream>
 
#include "module_manager.hpp"
 
double add(double, double);
double subtract(double, double);
 
int main(int argc, char **argv)
{
  ModuleManager manager;
  manager.addFunction("addition", add);
  manager.addFunction("soustraction", subtract);
 
  std::string selection;
  do
  {
    auto names = manager.getFunctionsList();
    for (auto &name : names)
    {
      std::cout << name << "\n";
    }
    std::cout << "\\load - charge un nouveau module\n";
    std::cout << "\\quit -- quitte l'application\n";
    std::cin >> selection;
 
    if (selection == "\\load")
    {
      std::string path;
      std::cout << "module path: ";
      std::cin >> path;
      if (manager.loadModule(path))
      {
        std::cout << "++ module chargé!\n";
      } else
      {
        std::cerr << "-- une erreur s'est produite pendant le chargement du module!\n";
      }
    } else if (selection != "\\quit")
    {
      auto func = manager.getFunction(selection);
      if (func == nullptr)
      {
        std::cerr << "-- la fonction n'existe pas!\n";
      } else
      { 
        double a, b;
        std::cout << "arguments (2 doubles): ";
        std::cin >> a >> b;
        std::cout << "args: " << a << " " << b << "\n";
 
        std::cout << "++ résultat de " << selection << "(" << a << ", " << b << ") = " << func(a,b) << "\n";
      }
    }
  } while (selection != "\\quit");
 
  return 0;
}
double add(double a, double b)
{
  return a + b;
}
double subtract(double a, double b)
{
  return a - b;
}

Je vais vous expliquer, maintenant, comment tout ça fonctionne. À la ligne 14, nous créons un objet ModuleManager et nous ajoutons deux fonctions : l'addition et la soustraction. Nous le faisons sans charger de code externe, car elles sont incluses dans l'application. Ensuite, nous montrons toutes les fonctions chargées ainsi que les commandes additionnelles : \load et \quit qui pourront être utilisées pour charger de nouveaux modules et quitter l'application. L'utilisateur effectue son choix à la ligne 28. Puis, nous effectuons ce qui correspond au choix de l'utilisateur. S'il demande de charger un nouveau module, nous lui demandons le chemin vers le fichier binaire contenant le module. S'il choisit quelque chose de différent de la commande \quit, nous le traitons comme un appel à une fonction chargée. Nous la recherchons dans le contrôleur et nous l'appelons à l'aide des arguments reçus après les avoir demandés à l'utilisateur en ligne 52.

Maintenant, place aux modules. Ils sont très simples. La multiplication se trouve dans multiply_module.cpp :

extern "C" double multiply(double a, double b)
{
  return a * b;
}
extern "C" const char * getName()
{
  return "multiply";
}

et la division dans divide_module.cpp:

extern "C" double divide(double a, double b)
{
  return a / b;
}
extern "C" const char * getName()
{
  return "divide";
}

Comme vous pouvez le voir, nous avons deux fonctions dans nos modules. La première est la fonction appropriée qui effectue l'opération mathématique. La seconde (getName) renvoie le nom de la première. Il est utilisé pour charger la fonction appropriée utilisée par la calculatrice et pour obtenir les noms des fonctions pour le ModuleManager.

Vous pouvez compiler la totalité du programme en utilisant ces commandes :

g++ -std=c++11 module_manager.cpp -c -DDEBUG -o module_manager.o
g++ -std=c++11 calc.cpp module_manager.o -DDEBUG -ldl -o calc
g++ -fPIC -shared multiply_module.cpp -DDEBUG -o multiply_module.so
g++ -fPIC -shared divide_module.cpp -DDEBUG -o divide_module.so

C'est une façon simple (mais peut-être pas la plus simple) d'effectuer l'exercice que je vous avais donné dans la partie précédente de l'article. Nous allons, maintenant, programmer quelque chose de plus raffiné !

La classe Shell possède deux membres std::string. Le premier est prompt_ - il contient le message de prompt -, le deuxième est load_name_ qui spécifie le nom de la fonction load qui est responsable du chargement des applications. Ils sont définis dans le constructeur de Shell. Nous avons également deux conteneurs : un map pour les noms des applications et les pointeurs vers les fonctions de chargement et un vector pour toutes les ressources (pointeurs void retournés par la fonction dlopen). En marge du constructeur et destructeur de Shell, on trouve trois fonctions membres publiques : loadApplication, runCommand, loop. La première charge les bibliothèques partagées à partir de leur chemin, runCommand exécute la commande entrée par l'utilisateur, et loop comporte une boucle while qui demande à l'utilisateur d'écrire une commande puis l'exécute. Shell comporte également une fonction membre privée appelée parseCommand_. Elle contient un algorithme très simple qui sépare la commande en jetons (tokens). J'écrirai un article séparé sur ce sujet pour les débutants.

Shell suppose que nous chargeons les applications à partir des fichiers situés dans le répertoire de travail courant. La commande load myapp recherchera un fichier nommé : myapp_application.so dans le répertoire courant.

La fonction loadApplication suppose que chaque module partagé (application de Shell) possède deux fonctions. La première d'entre elles est getName et retourne un const char* contenant le nom de l'application. La seconde fonction initialise un objet de classe qui hérite de ShellApplication (la classe de base pour toutes les applications) et retourne un pointeur vers celui-ci.

La fonction runCommand utilise parseCommand_ pour découper la commande, appelle la fonction load pour cette application et lance la fonction runApplication de l'objet application. Je ne vais pas éclaircir la totalité du code. Si vous ne le comprenez pas, vous pouvez trouver l'explication de chaque instruction de dlfcn.h dans l'introduction.

Une application est représentée par une classe héritée de la classe de base ShellApplication. Pour rendre cet exemple plus clair, ShellApplication ne possède qu'un nom clair et une fonction virtuelle pure runApplication. Nous déclarerons également les fonctions load et getName dans le fichier d'en-tête de ShellApplication. Le compilateur ne criera pas si vous ne les définissez (implémentez) pas dans votre application, car les applications sont des bibliothèques partagées, mais des déclarations rappelleront au programmeur de les écrire. L'absence des fonctions load et getName dans une application en cours de chargement provoquera l'arrêt de Shell.

#ifndef SHELL_APPLICATION_HPP
#define SHELL_APPLICATION_HPP
#include <string>
#include <vector>
 
class ShellApplication
{
  private:
    std::string name_;
 
  public:
    ShellApplication(std::string name) :
      name_(name)
    {}
    virtual ~ShellApplication() {}
    std::string getName()
    {
      return name_;
    }
    virtual int runApplication(std::vector<std::string>&) = 0;
};
extern "C" const char* getName();
extern "C" ShellApplication* load();
#endif

Nous sommes, maintenant, prêts à créer nos applications !

Pour montrer comment fonctionne notre Shell, nous devons avoir au moins une application. J'ai écrit deux exemples similaires : echo et concat. Le premier écrit tous les arguments séparés par un espace à l'écran. concat assemble tous les arguments et les affiche.

#include <iostream>
#include "shell_application.hpp"
 
class EchoApplication :
  public ShellApplication
{
  public:
    EchoApplication() :
      ShellApplication("Echo")
    {}
 
    int runApplication(std::vector<std::string>& argv)
    {
      for (auto it = argv.begin() + 1; it != argv.end(); ++it)
      {
        std::cout << *it << " ";
      }
      std::cout << "\n";
      return 0;
    }
};
extern "C" const char* getName()
{
  return "echo";
}
extern "C" ShellApplication* load()
{
  return new EchoApplication();
}

#include <iostream>
#include "shell_application.hpp"
 
class ConcatApplication :
  public ShellApplication
{
  public:
    ConcatApplication() :
      ShellApplication("Concatenate strings")
    {}
 
    int runApplication(std::vector<std::string>& argv)
    {
      for (auto it = argv.begin() + 1; it != argv.end(); ++it)
      {
        std::cout << *it;
      }
      std::cout << "\n";
      return 0;
    }
};
extern "C" const char* getName()
{
  return "concat";
}
extern "C" ShellApplication* load()
{
  return new ConcatApplication();
}

Pour compiler l'application entière (Shell) et les applications Shell, utilisez ce Makefile :

CXX=g++
CXXFLAGS=-std=c++11 -g -DDEBUG -Wall
APPSFLAGS=-fPIC -shared
OBJS=shell_main.o shell.o
APPS=concat_application.so echo_application.so
LIBS=-ldl
TARGET=shell
 
all: $(OBJS) $(APPS)
  $(CXX) $(CXXFLAGS) $(OBJS) $(LIBS) -o $(TARGET)
 
$(APPS): %so: %cpp 
  $(CXX) $(CXXFLAGS) $(APPSFLAGS) $< -o $@
$(OBJS): %.o: %.cpp
  $(CXX) $(CXXFLAGS) -c $< -o $@
cleanup:
  rm -f $(OBJS) $(TARGET) $(APPS)

Pour ajouter de nouvelles applications au fichier make, ajoutez leur nom à la 5^e ligne. Ensuite, vous pourrez charger les applications existantes en utilisant : load command. Pour le tester, écrivez ces lignes dans votre fenêtre de commandes :

make && ./shell « prompt> »
prompt> :load echo
prompt> :load concat
prompt> echo text one two three
prompt> concat text ont two three « four five »

Vous trouverez tous les fichiers de l'exemple Shell sur mon Gist.