Plugin architecture design by C

PLUGIN ARCHITECTURE DESIGN BY C



TABLE OF CONTENTS




* 1 How to make a plugin architecture in C?

* 2 Problems I met

* 3 How I solve this problem?

* 4 Pros and Cons of plugin architecture.



1 HOW TO MAKE A PLUGIN ARCHITECTURE IN C?



PLUGIN ARCHITECTURE IS A GREAT DESIGN IN ORDER TO MAKING EXTENSIBLE AND RESILIENCE SOFTWARE. THE SOFTWARE'S MODULES WAS LOADED DYNAMICALLY FROM THE PLUGIN MODULES AT RUNNING TIME. IN C LANGUAGE, THIS ARCHITECTURE CAN BE IMPLEMENTED BY DLOPEN WHICH IS THE PROGRAMMING INTERFACE TO DYNAMIC LINKING LOADER IN LINUX.



IN OTHER WORDS, A SOFTWARE IS SPLIT INTO SEPARATED MODULES WHICH IS COMPILED AND LINKED INTO SHARED LIBS. AND THE SOFTWARE CAN LOAD THE SHARED LIBS INTO MEMORY DYNAMICALLY, THIS IS WHAT I WANNA TO BE. IS A REACTOR ARCHITECTURE MIDDLEWARE LIB THAT I AM WORKING ON.



2 PROBLEMS I MET



IN ORDER TO MAKE A PLUGIN ARCHITECTURE, I USE DLOPEN API TO IMPLEMENT PLUGIN MODULES. BUT I MET SOME TROUBLES IN THE DEVELOPMENT, THE SHARED LIBS, OR THE MODULES, SHOULD NOT DEPENDED ON OTHER LIBS. IN OTHER WORDS, THE DLOPEN WILL FAIL WHEN LOAD THE LIBS WHICH INVOKING THE SYMBOLS THAT NOT BELONG TO IT.



SO THE MODULES SHOULD BE DEVELOPED INDEPENDENTLY OF THE OTHER PARTS OF THE SOURCE CODE. INCLUDE THE DATA STRUCTURE IN THE HEADER FILE IS FINE, BUT INVOKE THE FUNCTIONS CAN MAKE THE DLOPEN FAIL.



DLOPEN HAVE TWO FLAGS TO CONTROL ITS BEHAVIOR - RTLDLAZY, RTLDNOW. WHEN YOU USE THE RTLDNOW FLAG, DLOPEN JUST RETURN A NONE HANDLER WHEN YOU MAKE ABOVE MISTAKES, WHILE WHEN USE THE RTLDLAZY FLAG, DLOPEN CAN RETURN THE HANDLER, BUT IT REPORT AN ERROR NAMED "CAN NOT FIND SYMBOL" AT RUNNING TIME.



3 HOW I SOLVE THIS PROBLEM?



TAKE THE 'S CLASS FOR EXAMPLE, I WRITE ANOTHER HEADER FILE , WHICH EXPORT THE REACTOR CLASS'S DETAILS TO OUTSIDE. BUT THIS WAY DAMAGE THE ENCAPSULATION PARTLY.



// reactor.h

#ifndef REACTORH

#define REACTORH



#include "typedef.h"

#include "config.h"

#include "allocator.h"



DECLESBEGIN



struct Reactor;

typedef struct Reactor Reactor;



Reactor* reactorcreate(Config* config, Allocator* alloc);



Ret reactorrun(Reactor* thiz);

Ret reactorstop(Reactor* thiz);



void reactordestroy(Reactor* thiz);



DECLESEND



#endif /* REACTORH */



// reactor-internal.h

#ifndef REACTORINTERNALH

#define REACTORINTERNALH



#include "typedef.h"

#include "reactor.h"

#include "mainloop.h"

#include "modulesmanager.h"

#include "sourcesmanager.h"

#include "logger.h"



DECLESBEGIN



struct Reactor {

Logger* logger;

Allocator* alloc;

Config* config;

SourcesManager* sourcesmanager;

ModulesManager* modulesmanager;

MainLoop* mainloop;



Ret reactorgetmainloop(Reactor* thiz, MainLoop** mainloop);

Ret reactorsetmainloop(Reactor* thiz, MainLoop* mainloop);



Ret reactorgetmodulesmanager(Reactor* thiz, ModulesManager** modulesmanager);

Ret reactorsetmodulesmanager(Reactor* thiz, ModulesManager* modulesmanager);



Ret reactorgetsourcesmanager(Reactor* thiz, SourcesManager** sourcesmanager);

Ret reactorsetsourcesmanager(Reactor* thiz, SourcesManager* sourcesmanager);



DECLESEND



#endif /* REACTORNTERNALH */



ANOTHER WAY TO SOLVE THIS PROBLEM IS TO LINKING THE REACTOR'S OBJECT FILE INTO THE PLUGIN MODULES. IT'S THE MOST EFFICIENTLY WAY, BUT SO UGLY.



4 PROS AND CONS OF PLUGIN ARCHITECTURE.



HERE IS MY POINT, THE PROS OF PLUGIN ARCHITECTURE IN C IS THAT IT PROVIDED THE EXTENSIBLE ARCHITECTURE IN SOFTWARE DESIGN, THE CONS OF THE PLUGIN ARCHITECTURE IS THAT IT DESTROY THE OOP PRINCIPLE.



SO THE HIGHLY OOP STYLE C CODE IS NOT SUITABLE TO USING PLUGIN ARCHITECTURE, AND PLUGIN ARCHITECTURE ORIENTED C CODE LACK THE OOP STYLE. BUT ONE OF THE FABULOUS FEATURE OF C CODE IS THAT IT NOT BOUND TO OOP PRINCIPLES, OOP IS JUST SOME THOUGHTS IN SOFTWARE DEVELOPMENT. SO THE PROS .VS. CONS, WELL
Full Post