Programmfunktionen in Module verpacken



  • Hallo zusammen,

    ich habe ein kleines Programm geschrieben, dass mir eine Verbindung zu einer MySQL-Datenbank herstellt und bei jedem Aufruf ein paar Systemdaten meines Servers sammelt (RAM, HDD, etc...) und diese in die Datenbank schreibt.

    Nun möchte ich dieses Programm auf meine Server verteilen. Das Problem ist, dass es sich um verschiedene Server mit verschiedenen Konfigurationen und Softwarepaketen handelt. Daher möchte ich die für die entsprechenden Softwarepakete relevanten Abfragen in eigene Module verpacken und die Abfrage über das Execute-Pattern regeln.

    Ich möchte mir einen Ordner "modules" einrichten und alle darin enthaltenen Module sollen inkludiert und über die Methode execute() ausgeführt werden. Diese Methode gibt ein Array mit gesammelten Daten an den Core zurück, der diese in die Datenbank schreibt. Der Core soll also alle Module inkludieren, der Reihe nach mit execute() ausführen und das Ergebnis wegschreiben.

    Und genau da fangen meine Schwierigkeiten an. Ich bin zwar ein professioneller Webentwickler mit einigen Jahren Berufserfahrung und Grundkenntnissen in C++, aber ich finde auch über Google keine Anleitung für exakt diese Problemstellung. Nun ist meine Vermutung, dass ich einfach falsch suche 🙂

    Ich wäre sehr dankbar für ein kurzes Codebeispiel oder einen Link zu einer entsprechenden Anleitung.



  • @dp280678 Welches Execute-Pattern? Welche execute Funktion? Kann es sein dass du C++ und PHP verwechselst?



  • @hustbaer Ich verwechsel da nichts 😉

    Ich arbeite seit einigen Jahren beruflich mit PHP und da gibt es ein Execute-Pattern. Das bedeutet, dass man in jeder betroffenen Klasse eine Methode execute() mit festgelegten Parametern anlegt und dann über Dependencyinjection einzelne Programmteile hinzufügen oder ändern kann.

    Ein Beispiel ist z.B. eine Bezahlschnittstelle. Wenn man mit der Sparkasse arbeitet, dann unterstützt die andere Methoden als z.B. die Volksbank. Damit diese Programmlogik in austauschbare Module gekapselt werden kann, bedient man sich dieses Patterns. Man inkludiert einfach die passende Klasse und führt die execute-Methode aus.

    Beispiel:

    Include SchnittstelleSparkasse as Schnittstelle;
    Schnittstelle::execute(...);

    oder

    Include SchnittstelleVolksbank as Schnittstelle;
    Schnittstelle::execute(...);

    Durch diese lose Koppelung über ein festgelegtes Interface kann dann eine Software leicht und unkompliziert erweitert werden, wenn man das Interface richtig geplant hat.

    Und genau nach diesem Pattern suche ich nun für C++ um auch da meine Software entsprechend modular aufbauen zu können 🙂

    PS: Mir ist natürlich klar, dass die Methode nicht unbedingt execute() heißen muss und es auch mehrere fest definierte Methoden geben kann. Das soll hier nur ein Beispiel sein 😉



  • Prinzipiell geht das:

    Header:

    namespace SchnittstelleSparkasse
    {
            void execute();
    }
    

    main:

    #include <SchnittstelleSparkasse.h>
    
    namespace Schnittstelle = SchnittstelleSparkasse;
    
    int main()
    {
            Schnittstelle::execute();
    }
    

    Aber du musst natürlich auch noch die SchnittstelleSparkasse.cpp übersetzen und dazubinden.



  • @manni66 Danke für deine Antwort, aber die hilft mir leider nicht weiter 😉

    In deinem Beispiel muss ich das (wie du schon geschrieben hast) beim Kompilieren direkt mit drin haben, damit es mit reinkompiliert wird.

    Mein Ziel ist jedoch ein separates Verzeichnis mit eigenständigen Modulen. Diese möchte ich separat kompilieren und dann in dieses Verzeichnis kopieren. Das Programm soll dann die Module in dem Verzeichnis an Hand der Extension .mod oder .lib erkennen und sie der Reihe nach inkludieren und die Methode execute() für jedes Modul ausführen.



  • Klingt für mich nach dynamisch geladenen DLLs.
    Du kannst eine Basisklasse (aka Interface) definieren. Von der abgeleitet machst du dann deine Implementierungen in unterschiedliche DLLs, bei denen du die entsprechenden Funktionen exportierst (https://msdn.microsoft.com/de-de/library/a90k134d.aspx). Die DLLs kannst du dann dynamisch laden mit LoadLibrary() (https://msdn.microsoft.com/en-us/library/windows/desktop/ms684175(v=vs.85).aspx). Das ganze ist jetzt Windows spezifisch, wie das bei Linux Systemen aussieht weiß ich grade nicht.



  • Das geht nicht. C++ ist halt keine Skriptsprache. Grundsätzlich lässt sich das mit Betriebssystemmitteln lösen. Dazu musst du die Module als dll/dylib/so erzeugen und zur Laufzeit laden. Qt macht das z.B. mit den Plugins. Für Unix könntest du z.B. dlopen verwenden.



  • @dp280678 sagte in Programmfunktionen in Module verpacken:

    @hustbaer Ich verwechsel da nichts

    Doch. C++ mit einer Skriptsprache.
    Und das sog. "Execute-Pattern" mit etwas was jemand ausserhalb der PHP Ecke kennen könnte (bzw. überhaupt als Pattern bezeichnen - ich würde das jetzt eher ein Idiom nennen).



  • Jetzt unabhängig von der konkreten Frage... Es ist löblich, dass du dir Gedanken über Modularisierung machst, aber dir ist schon klar, dass das alles nicht ganz so einfach ist und beliebig komplex werden kann und es da schon auch fertige Lösungen gibt? Ich kenn mich mit sowas nicht wirklich aus, aber es gibt z.B. Nagios mit wahrscheinlich tausenden fertigen Plugins. Gibt auch zig Alternativen zu Nagios. Und auch sehr teure kommerzielle Software. Das jetzt selber zu entwickeln ist nur sehr bedingt sinnvoll.



  • @mechanics sagte in Programmfunktionen in Module verpacken:

    Das jetzt selber zu entwickeln ist nur sehr bedingt sinnvoll.

    Das hängt davon ab, was man will. Wenn man sich selber weiterentwickeln will und etwas dazu lernen will, kann es nicht schaden, etwas selber zu bauen, anstatt die vorgefertigte Lösung zu verwenden. Man kann z.B. auch vorgefertigte Compiler für Skriptsprachen verwenden, aber dabei lernt man halt nix über Compilerbau. Das lernt man nur wenn man den steinigen Weg des Selbermachens geht.



  • Ja, wenn es ein Hobby Projekt ist, bei dem man was lernen möchte, dann gerne, sowas hatte ich früher auch mal angefangen (nur etwas größer)...
    Das ging nur aus der Frage nicht hervor und das sieht für mich nicht nach einem Lernprojekt aus.



  • Vielen lieben Dank für all eure Zeit und eure Antworten 😄

    Ich gebe @Mechanics recht, dass es nur bedingt sinnvoll ist, wenn es so komplex ist. Ich habe mir das mit den DLLs und SOs angesehen, was @Schlangenmensch und @manni66 vorgeschlagen haben. Das sieht für meine Zwecke recht vielversprechend aus.

    Das ganze ist zwar teilweise ein Lernprojekt, aber ich habe mich natürlich auch schlau gemacht, wie man fertige Lösungen erweitern kann und ob ich da ausreichend Flexibilität für meine speziellen Zwecke habe.

    Letzten Endes läuft es für mich darauf hinaus zwischen zwei Varianten zu entscheiden:

    1. Ich nehme mir die Zeit, arbeite mich ein und mache es dann selbst bei voller Flexibilität

    2. Ich entwickel Erweiterungen für bestehende Softwarelösungen (mit entsprechenden Einschränkungen) und spare etwas Zeit

    Ich werde mich wahrscheinlich dafür entscheiden es erst selber zu versuchen (schon alleine um mich weiterzubilden, wie @It0101 geschrieben hat) und nur wenn ich es wirklich nicht hinbekommen sollte, werde ich auf fertige Lösungen zurückgreifen.

    Wie schon weiter oben geschrieben, ist C++ absolut nicht meine Kernkompetenz. Ich bilde mich aber immer gerne Weiter und gerade C++ ist für mich aktuell recht spannend.



  • @dp280678
    Naja wenn du dich entscheidest, den steinigen Weg zu gehen, kannst du da ja auch noch varierieren. Man muss ja nicht alles selber machen. Wenn man ohnehin eine Anwendung modularisiert, also in kleine Unteraufgaben unterteilt, kann man ja auch für einzelne Unteraufgaben nach fertigen Lösungen suchen und muss dann nicht jedes Rad neu erfinden, sondern nur manche.
    Und für die Unteraufgaben, die du selber bauen willst, kannst du dich ja dann bei Fragen immer wieder gern hier im C++-Forum melden und dir wird garantiert geholfen 🙂



  • @dp280678

    1. Ich nehme mir die Zeit, arbeite mich ein und mache es dann selbst bei voller Flexibilität

    Das würde ich nur bedingt unterschreiben. Je, wenn man selber etwas schreibt, ist man meist ziemlich flexibel, zumindest in Hinsicht auf das, was man sich vorstellt.
    Aber wenn man etwas fertiges nimmt, ist die Wahrscheinlichkeit hoch, dass es noch weitere Features bietet, oder sich mit anderen Systemen kombinieren lässt, an die man grad nicht denkt. Keine Ahnung, sagen wir mal, du willst plötzlich irgendwelche fancy Diagramme haben, die die Stabilität deiner Systeme im Jahresverlauf auf 20 verschiedene Arten visualisieren. Viel Spass beim selber schreiben. Die Wahrscheinlichkeit ist aber hoch, dass es sowas für Nagios schon gibt.



  • @it0101 sagte in Programmfunktionen in Module verpacken:

    Das hängt davon ab, was man will. Wenn man sich selber weiterentwickeln will und etwas dazu lernen will, kann es nicht schaden, etwas selber zu bauen, anstatt die vorgefertigte Lösung zu verwenden. Man kann z.B. auch vorgefertigte Compiler für Skriptsprachen verwenden, aber dabei lernt man halt nix über Compilerbau. Das lernt man nur wenn man den steinigen Weg des Selbermachens geht.

    Vorgefertigte Compiler für Skriptsprachen... in wie weit sind die vorgefertigt 🤡 das würde mich interessieren, wusste nichtmal das es sie gibt :face_savouring_delicious_food: also kläre mich bitte auf 🤓



  • @ascharan
    guckst du hier:

    https://docs.python.org/2/extending/embedding.html

    Damit kannst du pythoncode in C/C++ ausführen.
    Gibts bestimmt für andere Sprachen auch und es gibt hier auch jede Menge Spezis die sich mit sowas auskennen. Ich gehöre nicht dazu 😉



  • @it0101 Ahh... sowas war gemeint.

    Hatte irgendwie sowas im kopf wie zbsp. Ich hab ein script mit eigener Syntax und brauch den Compiler nur noch beibringen was er damit machen soll. 🤓

    Weis zwar nicht wieso ich diesen gedanken hatte :smiling_face_with_open_mouth_cold_sweat: aber naja 🤡


Log in to reply