HLT/BASE/AliHLTComponentHandler.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
   7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
   8  *          Artur Szostak <artursz@iafrica.com>                           *
   9  *          for The ALICE Off-line Project.                               *
  10  *                                                                        *
  11  * Permission to use, copy, modify and distribute this software and its   *
  12  * documentation strictly for non-commercial purposes is hereby granted   *
  13  * without fee, provided that the above copyright notice appears in all   *
  14  * copies and that both the copyright notice and this permission notice   *
  15  * appear in the supporting documentation. The authors make no claims     *
  16  * about the suitability of this software for any purpose. It is          *
  17  * provided "as is" without express or implied warranty.                  *
  18  **************************************************************************/
  19
  20 ///////////////////////////////////////////////////////////////////////////////
  21 //                                                                           //
  22 // handler class for HLT analysis components                                 //
  23 //                                                                           //
  24 ///////////////////////////////////////////////////////////////////////////////
  25
  26 #if __GNUC__== 3
  27 using namespace std;
  28 #endif
  29
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <dlfcn.h>
  33 #include "AliL3StandardIncludes.h"
  34 #include "AliHLTComponentHandler.h"
  35 #include "AliHLTComponent.h"
  36 #include "AliHLTDataTypes.h"
  37 #include "AliHLTSystem.h"
  38
  39 ClassImp(AliHLTComponentHandler)
  40
  41 AliHLTComponentHandler::AliHLTComponentHandler()
  42 {
  43 }
  44
  45
  46 AliHLTComponentHandler::~AliHLTComponentHandler()
  47 {
  48   UnloadLibraries();
  49 }
  50
  51 Int_t AliHLTComponentHandler::RegisterComponent(AliHLTComponent* pSample)
  52 {
  53   Int_t iResult=0;
  54   if (pSample) {
  55     if (FindComponent(pSample->GetComponentID())==NULL) {
  56       iResult=InsertComponent(pSample);
  57       if (iResult>=0) {
  58         Logging(kHLTLogInfo, "BASE", "Component Handler", "component %s registered", pSample->GetComponentID());
  59       }
  60     } else {
  61       // component already registered
  62       Logging(kHLTLogInfo, "BASE", "Component Handler", "component %s already registered, skipped", pSample->GetComponentID());
  63       iResult=-EEXIST;
  64     }
  65   } else {
  66     iResult=-EINVAL;
  67   }
  68   return iResult;
  69 }
  70
  71 int AliHLTComponentHandler::DeregisterComponent( const char* componentID )
  72 {
  73   return 0;
  74 }
  75
  76 Int_t AliHLTComponentHandler::ScheduleRegister(AliHLTComponent* pSample)
  77 {
  78   Int_t iResult=0;
  79   if (pSample) {
  80     fScheduleList.push_back(pSample);
  81   } else {
  82     iResult=-EINVAL;
  83   }
  84   return iResult;
  85 }
  86
  87 int AliHLTComponentHandler::CreateComponent(const Char_t* componentID, void* environ_param, int argc, const char** argv, AliHLTComponent*& component )
  88 {
  89   int iResult=0;
  90   if (componentID) {
  91     AliHLTComponent* pSample=FindComponent(componentID);
  92     if (pSample!=NULL) {
  93       component=pSample->Spawn();
  94       if (component) {
  95         Logging(kHLTLogDebug, "BASE", "Component Handler", "component \"%s\" created (%p)", componentID, component);
  96         component->Init(&fEnvironment, environ_param, argc, argv);
  97       } else {
  98         Logging(kHLTLogError, "BASE", "Component Handler", "can not spawn component \"%s\"", componentID);
  99         iResult=-ENOENT;
 100       }
 101     } else {
 102       Logging(kHLTLogWarning, "BASE", "Component Handler", "can not find component \"%s\"", componentID);
 103       iResult=-ENOENT;
 104     }
 105   } else {
 106     iResult=-EINVAL;
 107   }
 108   return iResult;
 109 }
 110
 111 Int_t AliHLTComponentHandler::FindComponentIndex(const Char_t* componentID)
 112 {
 113   Int_t iResult=0;
 114   if (componentID) {
 115     vector<AliHLTComponent*>::iterator element=fComponentList.begin();
 116     while (element!=fComponentList.end() && iResult>=0) {
 117       if (strcmp(componentID, (*element)->GetComponentID())==0) {
 118         break;
 119       }
 120       element++;
 121       iResult++;
 122     }
 123     if (element==fComponentList.end()) iResult=-ENOENT;
 124   } else {
 125     iResult=-EINVAL;
 126   }
 127   return iResult;
 128 }
 129
 130 AliHLTComponent* AliHLTComponentHandler::FindComponent(const Char_t* componentID)
 131 {
 132   AliHLTComponent* pSample=NULL;
 133   Int_t index=FindComponentIndex(componentID);
 134   if (index>=0) {
 135     pSample=(AliHLTComponent*)fComponentList.at(index);
 136   }
 137   return pSample;
 138 }
 139
 140 Int_t AliHLTComponentHandler::InsertComponent(AliHLTComponent* pSample)
 141 {
 142   Int_t iResult=0;
 143   if (pSample!=NULL) {
 144     fComponentList.push_back(pSample);
 145   } else {
 146     iResult=-EINVAL;
 147   }
 148   return iResult;
 149 }
 150
 151 void AliHLTComponentHandler::List() {
 152   vector<AliHLTComponent*>::iterator element=fComponentList.begin();
 153   int index=0;
 154   while (element!=fComponentList.end()) {
 155     Logging(kHLTLogInfo, "BASE", "Component Handler", "%d. %s", index++, (*element++)->GetComponentID());
 156   }
 157 }
 158
 159 void AliHLTComponentHandler::SetEnvironment(AliHLTComponentEnvironment* pEnv) {
 160   if (pEnv) {
 161     memcpy(&fEnvironment, pEnv, sizeof(AliHLTComponentEnvironment));
 162   }
 163 }
 164
 165 int AliHLTComponentHandler::LoadLibrary( const char* libraryPath )
 166 {
 167   int iResult=0;
 168   if (libraryPath) {
 169     AliHLTComponent::SetGlobalComponentHandler(this);
 170     AliHLTLibHandle hLib=dlopen(libraryPath, RTLD_NOW);
 171     if (hLib) {
 172       AliHLTComponent::UnsetGlobalComponentHandler();
 173       Logging(kHLTLogDebug, "BASE", "Component Handler", "library %s loaded", libraryPath);
 174       fLibraryList.push_back(hLib);
 175       vector<AliHLTComponent*>::iterator element=fScheduleList.begin();
 176       int iSize=fScheduleList.size();
 177       int iLocalResult=0;
 178       while (iSize-- > 0) {
 179         element=fScheduleList.begin();
 180         iLocalResult=RegisterComponent(*element);
 181         if (iResult==0) iResult=iLocalResult;
 182         fScheduleList.erase(element);
 183       }
 184     } else {
 185       Logging(kHLTLogError, "BASE", "Component Handler", "can not load library %s", libraryPath);
 186       Logging(kHLTLogError, "BASE", "Component Handler", "dlopen error: %s", dlerror());
 187       iResult=-ELIBACC;
 188     }
 189   } else {
 190     iResult=-EINVAL;
 191   }
 192   return iResult;
 193 }
 194
 195 int AliHLTComponentHandler::UnloadLibrary( const char* libraryPath )
 196 {
 197   int iResult=0;
 198   return iResult;
 199 }
 200
 201 int AliHLTComponentHandler::UnloadLibraries()
 202 {
 203   int iResult=0;
 204   vector<AliHLTLibHandle>::iterator element=fLibraryList.begin();
 205   while (element!=fLibraryList.end()) {
 206     dlclose(*element);
 207     element++;
 208   }
 209   return iResult;
 210 }