initialization of CDB in wrapper interface;added treatment of reconfiguration event

diff --git a/HLT/BASE/AliHLTComponent.cxx b/HLT/BASE/AliHLTComponent.cxx
index 0e999b9c73d9ec472b0baf77e42bef6c33407374..db222bdbeece8d0228a0d405cff24bfd17d4786b 100644 (file)
--- a/HLT/BASE/AliHLTComponent.cxx
+++ b/HLT/BASE/AliHLTComponent.cxx
@@ -43,6 +43,7 @@ using namespace std;
 #include "TClass.h"
 #include "TStopwatch.h"
 #include "AliHLTMemoryFile.h"
 #include "TClass.h"
 #include "TStopwatch.h"
 #include "AliHLTMemoryFile.h"

+#include "AliHLTMisc.h"

 #include <cassert>
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 #include <cassert>
 
 /** ROOT macro for the implementation of ROOT specific class methods */


@@ -76,8 +77,9 @@ AliHLTComponent::AliHLTComponent()
   fpStopwatches(new TObjArray(kSWTypeCount)),
   fMemFiles(),
   fpRunDesc(NULL),
   fpStopwatches(new TObjArray(kSWTypeCount)),
   fMemFiles(),
   fpRunDesc(NULL),

-  fpDDLList(NULL)
-
+  fpDDLList(NULL),
+  fCDBInitialized(false),
+  fChainId()

 {
   // see header file for class documentation
   // or
 {
   // see header file for class documentation
   // or


@@ -197,23 +199,61 @@ int AliHLTComponent::Deinit()
     fpRunDesc=NULL;
     delete pRunDesc;
   }
     fpRunDesc=NULL;
     delete pRunDesc;
   }

+  fEventCount=0;

   return iResult;
 }
 
   return iResult;
 }
 

-int AliHLTComponent::DoInit( int argc, const char** argv )
+int AliHLTComponent::InitCDB(const char* cdbPath)

 {
 {

-  // see header file for function documentation
-  if (argc==0 && argv==NULL) {
-    // this is currently just to get rid of the warning "unused parameter"
+  int iResult=0;
+  // we presume the library already to be loaded
+  // find the symbol
+  AliHLTComponentHandler cHandler;
+  AliHLTMiscInitCDB_t pFunc=(AliHLTMiscInitCDB_t)cHandler.FindSymbol(ALIHLTMISC_LIBRARY, ALIHLTMISC_INIT_CDB); 
+  if (pFunc) {
+    iResult=(*pFunc)(cdbPath);
+    fCDBInitialized=iResult>=0;
+  } else {
+    Message(NULL, kHLTLogError, "AliHLTComponent::InitCDB", "init CDB",
+           "can not find initialization function");
+    iResult=-ENOSYS;

   }
   }

-  fEventCount=0;
+  return iResult;
+}
+
+int AliHLTComponent::SetCDBRunNo(int runNo)
+{
+  int iResult=0;
+  if (!fCDBInitialized) return iResult;
+  // we presume the library already to be loaded
+  // find the symbol
+  AliHLTComponentHandler cHandler;
+  AliHLTMiscSetCDBRunNo_t pFunc=(AliHLTMiscSetCDBRunNo_t)cHandler.FindSymbol(ALIHLTMISC_LIBRARY, ALIHLTMISC_SET_CDB_RUNNO); 
+  if (pFunc) {
+    iResult=(*pFunc)(runNo);
+  } else {
+    Message(NULL, kHLTLogError, "AliHLTComponent::SetCDBRunNo", "init CDB",
+           "can not find initialization function");
+    iResult=-ENOSYS;
+  }
+  return iResult;
+}
+
+int AliHLTComponent::DoInit( int /*argc*/, const char** /*argv*/)
+{
+  // default implementation, childs can overload

   return 0;
 }
 
 int AliHLTComponent::DoDeinit()
 {
   return 0;
 }
 
 int AliHLTComponent::DoDeinit()
 {

-  // see header file for function documentation
-  fEventCount=0;
+  // default implementation, childs can overload
+  return 0;
+}
+
+int AliHLTComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
+{
+  // default implementation, childs can overload

   return 0;
 }
 
   return 0;
 }
 


@@ -1078,42 +1118,67 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
 
   // find special events
   if (fpInputBlocks) {
 
   // find special events
   if (fpInputBlocks) {

+    // first look for all special events and execute in the appropriate
+    // sequence afterwords
+    int indexComConfEvent=-1;
+    int indexSOREvent=-1;
+    int indexEOREvent=-1;

     for (unsigned int i=0; i<evtData.fBlockCnt && iResult>=0; i++) {
       if (fpInputBlocks[i].fDataType==kAliHLTDataTypeSOR) {
     for (unsigned int i=0; i<evtData.fBlockCnt && iResult>=0; i++) {
       if (fpInputBlocks[i].fDataType==kAliHLTDataTypeSOR) {

-       // start of run
-       if (fpRunDesc==NULL) {
-         fpRunDesc=new AliHLTRunDesc;
-         if (fpRunDesc) {
-           if ((iResult=CopyStruct(fpRunDesc, sizeof(AliHLTRunDesc), i, "AliHLTRunDesc", "SOR"))>0) {
-             HLTDebug("set run decriptor, run no %d", fpRunDesc->fRunNo);
-           }
-         } else {
-           iResult=-ENOMEM;
+       indexSOREvent=i;
+      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeEOR) {
+       indexEOREvent=i;
+      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeDDL) {
+       // DDL list
+       // this event is most likely deprecated
+      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeComConf) {
+       indexComConfEvent=i;
+      }
+    }
+    if (indexSOREvent>=0) {
+      // start of run
+      if (fpRunDesc==NULL) {
+       fpRunDesc=new AliHLTRunDesc;
+       if (fpRunDesc) {
+         if ((iResult=CopyStruct(fpRunDesc, sizeof(AliHLTRunDesc), indexSOREvent, "AliHLTRunDesc", "SOR"))>0) {
+           HLTDebug("set run decriptor, run no %d", fpRunDesc->fRunNo);
+           SetCDBRunNo(fpRunDesc->fRunNo);

          }
        } else {
          }
        } else {

-         HLTWarning("already received SOR event run no %d, ignoring SOR", fpRunDesc->fRunNo);
+         iResult=-ENOMEM;

        }
        }

-      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeEOR) {
-       if (fpRunDesc!=NULL) {
-         if (fpRunDesc) {
-           AliHLTRunDesc rundesc;
-           if ((iResult=CopyStruct(&rundesc, sizeof(AliHLTRunDesc), i, "AliHLTRunDesc", "SOR"))>0) {
-             if (fpRunDesc->fRunNo!=rundesc.fRunNo) {
-               HLTWarning("run no missmatch: SOR %d, EOR %d", fpRunDesc->fRunNo, rundesc.fRunNo);
-             } else {
-               HLTDebug("EOR run no %d", fpRunDesc->fRunNo);
-             }
+      } else {
+       HLTWarning("already received SOR event run no %d, ignoring SOR", fpRunDesc->fRunNo);
+      }
+    }
+    if (indexEOREvent>=0) {
+      if (fpRunDesc!=NULL) {
+       if (fpRunDesc) {
+         AliHLTRunDesc rundesc;
+         if ((iResult=CopyStruct(&rundesc, sizeof(AliHLTRunDesc), indexEOREvent, "AliHLTRunDesc", "SOR"))>0) {
+           if (fpRunDesc->fRunNo!=rundesc.fRunNo) {
+             HLTWarning("run no missmatch: SOR %d, EOR %d", fpRunDesc->fRunNo, rundesc.fRunNo);
+           } else {
+             HLTDebug("EOR run no %d", fpRunDesc->fRunNo);

            }
            }

-           AliHLTRunDesc* pRunDesc=fpRunDesc;
-           fpRunDesc=NULL;
-           delete pRunDesc;

          }
          }

-       } else {
-         HLTWarning("did not receive SOR, ignoring EOR");
+         AliHLTRunDesc* pRunDesc=fpRunDesc;
+         fpRunDesc=NULL;
+         delete pRunDesc;

        }
        }

-       // end of run
-      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeDDL) {
-       // DDL list
+      } else {
+       HLTWarning("did not receive SOR, ignoring EOR");
+      }
+    }
+    if (indexComConfEvent>=0) {
+      TString cdbEntry;
+      if (fpInputBlocks[indexComConfEvent].fPtr!=NULL && fpInputBlocks[indexComConfEvent].fSize>0) {
+       cdbEntry.Append(reinterpret_cast<const char*>(fpInputBlocks[indexComConfEvent].fPtr), fpInputBlocks[indexComConfEvent].fSize);
+      }
+      HLTDebug("received component configuration command: entry %s", cdbEntry.IsNull()?"none":cdbEntry.Data());
+      int tmpResult=Reconfigure(cdbEntry[0]==0?NULL:cdbEntry.Data(), fChainId.c_str());
+      if (tmpResult<0) {
+       HLTWarning("reconfiguration of component %p (%s) failed with error code %d", this, GetComponentID(), tmpResult);

       }
     }
   }
       }
     }
   }

diff --git a/HLT/BASE/AliHLTComponent.h b/HLT/BASE/AliHLTComponent.h
index 91e00268f96613cd6ade69d04ba57b81ce91c43b..f4586e6a2976af397afe61f9f076aa80b030a089 100644 (file)
--- a/HLT/BASE/AliHLTComponent.h
+++ b/HLT/BASE/AliHLTComponent.h
@@ -323,6 +323,28 @@ class AliHLTComponent : public AliHLTLogging {
                            AliHLTComponentBlockDataList& outputBlocks,
                            AliHLTComponentEventDoneData*& edd ) = 0;
 
                            AliHLTComponentBlockDataList& outputBlocks,
                            AliHLTComponentEventDoneData*& edd ) = 0;
 

+  /**
+   * Init the CDB.
+   * The function must not be called when running in AliRoot unless it it
+   * really wanted. The CDB path will be set to the specified path, which might
+   * override the path initialized at the beginning of the AliRoot reconstruction.
+   *
+   * The method is used from the external interface in order to set the correct
+   * path when running on-line.
+   */
+  int InitCDB(const char* cdbPath);
+
+  /**
+   * Set the run no for the CDB.
+   * The function must not be called when running in AliRoot unless it it
+   * really wanted. The CDB path will be set to the specified path, which might
+   * override the run no initialized at the beginning of the AliRoot reconstruction.
+   *
+   * The method is used from the external interface in order to set the correct
+   * path when running on-line.
+   */
+  int SetCDBRunNo(int runNo);
+

   // Information member functions for registration.
 
   /**
   // Information member functions for registration.
 
   /**


@@ -572,6 +594,25 @@ class AliHLTComponent : public AliHLTLogging {
    */
   virtual int DoDeinit();
 
    */
   virtual int DoDeinit();
 

+  /**
+   * Reconfigure the component.
+   * The method is called when an event of type @ref kAliHLTDataTypeComConf
+   * {COM_CONF:PRIV} is received by the component. If the event is sent as
+   * part of a normal event, the component configuration is called first.
+   *
+   * The CDB path parameter specifies the path in the CDB, i.e. without
+   * leading absolute path of the CDB location. The framework might alse
+   * provide the id of the component in the analysis chain.
+   *
+   * \b Note: The CDB will be initialized by the framework, either already set
+   * from AliRoot or from the wrapper interface during initialization.
+   *
+   * @param cdbEntry     path of the cdbEntry
+   * @param chainId      the id of the component in the analysis chain
+   * @note both parameters can be NULL, check before usage
+   */
+  virtual int Reconfigure(const char* cdbEntry, const char* chainId);
+

   /**
    * General memory allocation method.
    * All memory which is going to be used 'outside' of the interface must
   /**
    * General memory allocation method.
    * All memory which is going to be used 'outside' of the interface must


@@ -1149,6 +1190,12 @@ class AliHLTComponent : public AliHLTLogging {
   /** the current DDL list */
   AliHLTEventDDL* fpDDLList;                                       //! transient
 
   /** the current DDL list */
   AliHLTEventDDL* fpDDLList;                                       //! transient
 

-  ClassDef(AliHLTComponent, 3)
+  /** indicates that the CDB has been initialized locally */
+  bool fCDBInitialized;                                            //! transient
+
+  /** id of the component in the analysis chain */
+  string fChainId;                                                 //! transient
+
+  ClassDef(AliHLTComponent, 4)

 };
 #endif
 };
 #endif

diff --git a/HLT/BASE/AliHLT_C_Component_WrapperInterface.cxx b/HLT/BASE/AliHLT_C_Component_WrapperInterface.cxx
index f53f65a4e241a3d3b62d1ea51fd10eb7c29d1ec8..e4329d96659bcdba214ff22cafaa387ba9f040b8 100644 (file)
--- a/HLT/BASE/AliHLT_C_Component_WrapperInterface.cxx
+++ b/HLT/BASE/AliHLT_C_Component_WrapperInterface.cxx
@@ -90,6 +90,11 @@ int AliHLT_C_CreateComponent( const char* componentType, void* environ_param, in
   if ( !handle ) return EINVAL;
   AliHLTComponent* comp;
   int ret = gComponentHandler_C->CreateComponent( componentType, environ_param, argc, argv, comp );
   if ( !handle ) return EINVAL;
   AliHLTComponent* comp;
   int ret = gComponentHandler_C->CreateComponent( componentType, environ_param, argc, argv, comp );

+  if (comp) {
+    const char* cdbPath = getenv("ALIHLT_HCDBDIR");
+    if (!cdbPath) cdbPath = getenv("ALICE_ROOT");
+    if (cdbPath) comp->InitCDB(cdbPath);
+  }

   *handle = reinterpret_cast<AliHLTComponentHandle>( comp );
 
   return ret;
   *handle = reinterpret_cast<AliHLTComponentHandle>( comp );
 
   return ret;

diff --git a/HLT/BASE/AliHLT_C_Component_WrapperInterface.h b/HLT/BASE/AliHLT_C_Component_WrapperInterface.h
index 4b25b8737caa83db09c20ed02a1cbc3d6c50b89d..14448c69ea21588e07e6b2c3ab717b246f270d15 100644 (file)
--- a/HLT/BASE/AliHLT_C_Component_WrapperInterface.h
+++ b/HLT/BASE/AliHLT_C_Component_WrapperInterface.h
@@ -20,6 +20,9 @@
  *
  * \image html PubSub_WrapperComponent.png "Wrapper interface"
  *
  *
  * \image html PubSub_WrapperComponent.png "Wrapper interface"
  *

+ * CDB handling: The interface initializes the CDB from the path found
+ * in the environment variable ALIHLT_HCDBDIR. Default path is
+ * <tt>$ALICE_ROOT</tt>.

  */
 
 #include <AliHLTDataTypes.h>
  */
 
 #include <AliHLTDataTypes.h>

diff --git a/HLT/BASE/util/AliHLTFileWriter.h b/HLT/BASE/util/AliHLTFileWriter.h
index ff6d9f01ed39f99d3f75ae2bfea3742760358e1e..8ab5de342f93e107c40c25841777518eb4d48354 100644 (file)
--- a/HLT/BASE/util/AliHLTFileWriter.h
+++ b/HLT/BASE/util/AliHLTFileWriter.h
@@ -21,7 +21,7 @@
  * An HLT data sink component which writes data to file(s).
  *
  * Component ID: \b FileWriter <br>
  * An HLT data sink component which writes data to file(s).
  *
  * Component ID: \b FileWriter <br>

- * Library: \b libAliHLTUtil.
+ * Library: \b libAliHLTUtil.so

  *
  * Mandatory arguments: <br>
  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
  *
  * Mandatory arguments: <br>
  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->

diff --git a/HLT/libHLTrec.pkg b/HLT/libHLTrec.pkg
index 7f0f66759217c3621fa81ba6bf8a6a4583c8131e..c4803b07e5c32d8e3ca5744879518550a2273988 100644 (file)
--- a/HLT/libHLTrec.pkg
+++ b/HLT/libHLTrec.pkg
@@ -9,6 +9,7 @@ CLASS_HDRS:=    AliHLTReconstructor.h \
                AliHLTOUTRawReader.h
 
 MODULE_SRCS:=  AliHLTDynamicAliLog.cxx \
                AliHLTOUTRawReader.h
 
 MODULE_SRCS:=  AliHLTDynamicAliLog.cxx \

+               AliHLTMisc.cxx \

                $(CLASS_HDRS:.h=.cxx)
 
 MODULE_HDRS:=  $(CLASS_HDRS)
                $(CLASS_HDRS:.h=.cxx)
 
 MODULE_HDRS:=  $(CLASS_HDRS)

diff --git a/HLT/rec/AliHLTMisc.cxx b/HLT/rec/AliHLTMisc.cxx
new file mode 100644 (file)
index 0000000..c992703
--- /dev/null
+++ b/HLT/rec/AliHLTMisc.cxx
@@ -0,0 +1,55 @@
+// @(#) $Id: AliHLTDynamicAliLog.cxx 23318 2008-01-14 12:43:28Z hristov $
+
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ *                                                                        *
+ * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+ *                  for The ALICE HLT Project.                            *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/** @file   AliHLTMisc.cxx
+    @author Matthias Richter
+    @date   
+    @brief  Miscellaneous methods for the HLT AliRoot integration
+*/
+
+#include "AliHLTMisc.h"
+#include "AliHLTLogging.h"
+#include "AliCDBManager.h"
+
+int AliHLTMiscInitCDB(const char* cdbpath)
+{
+  int iResult=0;
+  AliCDBManager* pCDB = AliCDBManager::Instance();
+  AliHLTLogging log;
+  if (!pCDB) {
+    log.Logging(kHLTLogError, "InitCDB", "CDB handling", "Could not get CDB instance");
+  } else {
+    pCDB->SetRun(0); // This will be retrieved during the SOR event
+    pCDB->SetDefaultStorage(cdbpath);
+    log.Logging(kHLTLogDebug, "InitCDB", "CDB handling", "CDB instance 0x%x", pCDB);
+  }
+  return iResult;
+}
+
+int AliHLTMiscSetCDBRunNo(int runNo)
+{
+  int iResult=0;
+  AliCDBManager* pCDB = AliCDBManager::Instance();
+  AliHLTLogging log;
+  if (!pCDB) {
+    log.Logging(kHLTLogError, "InitCDB", "CDB handling", "Could not get CDB instance");
+  } else {
+    pCDB->SetRun(runNo);
+  }
+  return iResult;
+}