PluginManagement.cpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include<ImLib3D/PluginManagement.hpp>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include<ImLib3D/ImageProcessorDescription.hpp>
#include<ImLib3D/Base64.hpp>

vector<string> 
PluginManagement::PluginPaths()
{
    vector<string> res;
    char *cpath=getenv("IMLIB3D_PLUGIN_PATH");
    string path=(cpath ? cpath : "");
    // split into seperate components
    vector<string> paths;
    Split(path, ':', paths);
    // check if each component is valid directory
    for(int i=0;i<(int)paths.size();i++)
    {
        if(paths[i]==""){continue;}
        struct stat buf;
        if(stat(paths[i].c_str(),&buf)>=0 && S_ISDIR(buf.st_mode))
        {
            res.push_back(paths[i]);
        }
        else
        {
            printf("ignoring invalid entry in IMLIB3D_PLUGIN_PATH path \"%s\"\n",paths[i].c_str());
        }
    }
    return res;
}


PluginManagement::PluginManagement():ImageProcessorsDescription()
{
    // setup paths
    paths=PluginPaths();

    // read main description file
#include"HardcodedImageProcessorsDescription.cpp"
    ReadFromString(Base64::Decode(hardcodedDescription));
    // find main exec
    imlib3dExec=FindFileInPath(paths,"imlib3d");
    if(imlib3dExec==""){imlib3dExec="imlib3d";}
    
    // find plugin names, and add main description at begining
    pluginNames=FindPlugins();
    pluginNames.insert(pluginNames.begin(),imlib3dExec);

    // add plugin identification number to each image processor
    for(uint j=0;j<imageProcessors.size();j++)
    {
        imageProcessorsPluginId[imageProcessors[j].name]=0;
    }

    // merge in the descriptions in each plugin
    for(uint i=1;i<pluginNames.size();i++)
    {
        // read description from plugin
        string descriptionStr=Command(SPrintf("%s --query-full-xml-description",pluginNames[i]));
        if(descriptionStr.substr(0,string("<?xml").size())!="<?xml")
        {
            ThrowError("PluginManagement description read from plugin \"%s\" does not begin with \"<?xml\" and does not seem to be valid xml");
        }
        xmlpp::DomParser pluginXmlParser;
        pluginXmlParser.parse_memory(descriptionStr);
        XIPD::ImageProcessorsDescription pluginDesc
            (pluginXmlParser.get_document()->get_root_node());
        // add plugin identification number to each image processor
        for(uint j=0;j<pluginDesc.imageProcessors.size();j++)
        {
            imageProcessorsPluginId[pluginDesc.imageProcessors[j].name]=i;
        }
        // merge in the description xml tree
        Merge(pluginDesc);
    }
    Init();
}

vector<string> 
PluginManagement::FindPlugins()
{
    vector<string> res;
    // get path
    for(uint i=0;i<paths.size();i++)
    {
        fprintf(stderr,"searching for plugins, considering directory:\"%s\"\n", paths[i].c_str());
        
        vector<string> dirNames;        
        // get directory listing and copy it to dirNames
        {
            struct dirent **namelist;
            int n=scandir(paths[i].c_str(), &namelist, NULL, alphasort);
            if(n<0) {perror("scandir");continue;}
            while(n--) 
            {
                dirNames.push_back(namelist[n]->d_name);
                free(namelist[n]);
            }
            free(namelist);
        }
        for(uint j=0;j<dirNames.size();j++)
        {
            if(dirNames[j]==".." || dirNames[j]=="."){continue;}
            string name=paths[i]+"/";
            name+=dirNames[j];
            string pluginSuffix=".plugin";
            if(name.rfind(pluginSuffix)!=name.size()-pluginSuffix.size()){continue;}
            mprintf("searching for plugins, considering:\"%s\"\n",name);
            struct stat filestat;
            if(stat(name.c_str(),&filestat)<0){perror("stat");continue;}
            if(!S_ISREG(filestat.st_mode)){continue;}
            if(!(filestat.st_mode & 0111)){continue;}
            //                      printf("found candidate plugin:%s, querying\n",name.c_str());
            string queryRes=Command(SPrintf("%s --query-imlib3d",name));
            if(queryRes.substr(0,string("imlib3d-plugin").size())=="imlib3d-plugin")
            {
                fprintf(stderr,"Found plugin:\"%s\" ... ok.\n",name.c_str());
                res.push_back(name);
            }
            else
            {
                printf("invalid plugin response to --query-imlib3d for candidate plugin: \"%s\" ... ignored\n",
                       name.c_str());
                continue;
            }
        }
    }
    return res;
}

int 
PluginManagement::PluginNumber(const string &name)
{
    if(imageProcessorsPluginId.find(name)==imageProcessorsPluginId.end())
    {
        ThrowError("PluginManagement::PluginNumber Unknown image processor:\"%s\"",name);
    }
    return imageProcessorsPluginId[name];
}

void 
PluginManagement::ExecuteImageProcessor(const vector<string> &args)
{
    int id=PluginNumber(args[0]);
    mprintf("trying plugin %2d:\"%s\"\n",id,pluginNames[id]);
    string cmd=pluginNames[id]+" ";
    for(uint j=0;j<args.size();j++){cmd+=args[j]+" ";}
    mprintf("trying to execute:\"%s\"\n",cmd);
    bool callFailed=system(cmd.c_str());
    if(callFailed){printf("Tried for plugin, failed\n");exit(1);}           
}

---