AAFPluginRailway.C

Go to the documentation of this file.

#ifndef AAFPLUGINHELPER_C
#define AAFPLUGINHELPER_C
#include "PluginRailway.C"
#ifndef __CINT__
# include <TUrl.h>
# include <TString.h>
# include <AliAnalysisManager.h>
# include <AliAnalysisAlien.h>
#else
class TUrl;
class AliAnalysisAlien;
#endif

// ===================================================================
struct AAFPluginRailway : public PluginRailway
{
  AAFPluginRailway(const TUrl& url, Int_t verbose)
    : PluginRailway(url, verbose)
  {
    fOptions.Add("workers", "N[x]", "Number of workers to use", 0);
    fOptions.Add("dsname",  "NAME", "Make output dataset", "");
    fOptions.Add("wrapper", "CMD", "Wrapper command", "");
    fOptions.Add("clear",   "Clear all packages");
    fOptions.Add("reset",   "soft|hard", "Reset cluster", "hard");

  }
  virtual ~AAFPluginRailway() {}
  virtual Bool_t PreSetup()
  {
    // --- Handle software options -----------------------------------
    // TString root = fOptions.Get("root");
    // fHandler->SetRootVersionForProof(Form("VO_ALICE@ROOT::%s", root.Data()));
    fHandler->SetProofCluster(fUrl.GetHost());
    fHandler->SetProofDataSet(fUrl.GetFile());

    // --- Handle worker options -------------------------------------
    if (fOptions.Has("workers")) {
      TString nwork = fOptions.Get("workers");
      if (nwork.EndsWith("x")) 
  fHandler->SetNproofWorkersPerSlave(nwork.Atoi());
      else 
  fHandler->SetNproofWorkers(nwork.Atoi());
    }
    
    // --- Check if we're using a wrapper ----------------------------
    if (fOptions.Has("wrapper")) { 
      TString wrapper = fOptions.Get("wrapper");
      if (wrapper.IsNull()) 
  // In case of no argument, use GDB 
  // Just run and backtrace 
  wrapper = "/usr/bin/gdb --batch -ex run -ex bt --args";
      Info("ProofRailway::PreSetup", "Using wrapper command: %s", 
     wrapper.Data());
      TProof::AddEnvVar("PROOF_WRAPPERCMD", wrapper);
    }
    
    // --- Check if we need to clear packages ------------------------
    fHandler->SetClearPackages(fOptions.Has("clear"));

    // --- Check if we need to reset first ---------------------------
    if (fOptions.Has("reset")) { 
      TString reset = fOptions.Get("reset");
      Bool_t  hard  = (reset.IsNull() || 
           reset.EqualTo("hard", TString::kIgnoreCase));
      Info("AAFPluginRailway::PreSetup", "Will do a %s reset of %s", 
     hard ? "hard" : "soft", fUrl.GetHost());
      fHandler->SetProofReset(hard ? 2 : 1);
    }
    
    return PluginRailway::PreSetup();
  }
  virtual Bool_t PostSetup() 
  {
    if (!PluginRailway::PostSetup()) return false;
    if (fOptions.Has("dsname")) 
      OutputUtilities::RegisterDataset(fOptions.Get("dsname"));

    return true;
  };
  virtual UShort_t Mode() const { return kProof; }
  virtual const char* ModeString() const { return "proof"; }
  virtual Long64_t Run(Long64_t nEvents=-1) 
  {
    AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
    
    TString dsName(fUrl.GetFile());
    if (fUrl.GetAnchor() && fUrl.GetAnchor()[0] != '\0') 
      dsName.Append(Form("#%s", fUrl.GetAnchor()));
    return mgr->StartAnalysis(fUrl.GetProtocol(), dsName, nEvents);
  }
  virtual const Char_t* UrlHelp() const 
  {
    return "proof://alice-caf*/<dataset>?plugin[&<options>][#<treename>]";
  }
  virtual const char* Desc() const { return "CAF w/plugin (deprecated)"; }
};
#endif
//
// EOF
//