PrimRunTool.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta 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
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

/* File: PrimRunTool.C                                         */
/* Last Modified On Mon May 23 23:26:37 EDT 2005 by ken@xorian.net         */
/*      Modified On Wed Apr 27 09:50:29 EDT 2005 by irina.furman@intel.com */
/*      Modified On Fri Jun  1 11:50:42 PDT 2001 by yuanyu     */
/*      Modified On Fri Jul 14 20:44:29 PDT 2000 by mann       */
/*      Modified On Wed Feb 10 16:58:42 PST 1999 by heydon     */
/*      Modified On Fri Mar  1 13:29:44 PST 1996 by levin      */
/*      Modified On Fri Jan 26 14:59:36 PST 1996 by horning    */

#include <iomanip>
#include <sstream>
#include <Basics.H>
#include <OS.H>
#include <RegExp.H>
#include <VestaConfig.H>
#include <chars_seq.H>
#include <UniqueId.H>
#include <RunToolClient.H>
#include <SourceOrDerived.H>
#include <VDirSurrogate.H>
#include "PrimRunTool.H"
#include "Expr.H"
#include "ToolDirectoryServer.H"
#include "Err.H"
#include "ListT.H"
#include "Signal.H"
#include "RunToolHost.H"
#include "ThreadData.H"
#include "EvalBasics.H"

using std::ios;
using std::ostream;
using std::ostringstream;
using std::cout;
using std::cin;
using std::cerr;
using std::setw;
using std::setfill;
using std::hex;
using std::dec;
using std::endl;
using std::flush;

// Names for "fields" of RunTool result binding
static Text codeName("code"),
            sigName("signal"),
            stowName("stdout_written"),
            stewName("stderr_written"),
            stdoName("stdout"),
            stdeName("stderr"),
            rootName("root"),
            coreName("dumped_core");

static DepPath rootPath(Text("."));

// Size hint for runtool dependency set:
static const int runToolDepSize = 80;

// Size hint for the number of volatile dirs in a runtool call.
static const int runToolDirNum = 20;

// Some utility functions
struct OurClosure {
  Binding newstuff;
  VestaSource *dir;
  ListT<NodeInfo> *nodeList;
  bool found_core;
  Text dir_path;
};

// A regular expression for matching core files
static Basics::RegExp *core_match_re = 0;

// The default regular expression to use, if
// [Evaluator]core_dump_regexp is not set.
static const char *core_match_re_default = "core(\\.[0-9][0-9]*)?";

extern "C"
{
  void core_match_init()
  {
    // If [Evaluator]core_dump_regexp is set, attempt to parse it as a
    // regular expression.
    if(VestaConfig::is_set("Evaluator", "core_dump_regexp"))
      {
        try
          {
            Text pattern =
              VestaConfig::get_Text("Evaluator", "core_dump_regexp");
            core_match_re = NEW_CONSTR(Basics::RegExp, (pattern));
          }
        catch(Basics::RegExp::ParseError e)
          {
            outputMu.lock();
            cerr << "Error parsing [Evaluator]core_dump_regexp: "
                 << e.msg << endl;
            outputMu.unlock();
              
          }
        catch(VestaConfig::failure f)
          {
            // Shouldn't happen, but if it does we ignore it.
          }
      }

    // If we still don't have a regular expression, either because
    // the config variable wasn't set, or we got a parsing error on
    // it, use a default
    if(core_match_re == 0)
      {
        try
          {
            core_match_re = NEW_CONSTR(Basics::RegExp, (core_match_re_default));
          }
        catch(Basics::RegExp::ParseError e)
          {
            outputMu.lock();
            cerr << "Error parsing default core dump regular expression: "
                 << e.msg << endl;
            outputMu.unlock();
          }
      }
  }
}

// Test a filename to see if it looks like a core file
static bool core_match(Text arc)
{
  static pthread_once_t core_match_once = PTHREAD_ONCE_INIT;
  pthread_once(&core_match_once, core_match_init);

  if(core_match_re != 0) return core_match_re->match(arc);

  // Something must have gone wrong with initializing the core
  // matching regular expression.
  return false;
}

Text ToolCommandLineAsText(const RunToolArgs &args)
{
  // list is known to be a list of texts; see ApplyCache
  Vals vlist = args.command_line->elems;
  Text result;
  while (!vlist.Null()) {
    if(!result.Empty())
      {
        result += " ";
      }
    result += ((TextVC*)(vlist.Pop()))->NDS();
  }
  return result;
}

chars_seq *ConvertVals(ListVC *list) {
  // list is known to be a list of texts; see ApplyCache
  Vals vlist = list->elems;
  chars_seq *result = NEW_CONSTR(chars_seq, (5, 100));

  while (!vlist.Null()) {
    result->append(((TextVC*)(vlist.Pop()))->NDS().chars());
  }
  return result;
}

chars_seq *ConvertEnvVars(BindingVC *b) {
  // b is known to be a binding of texts; see BindRunToolArgs.
  Context c = b->elems;

  chars_seq *result = NEW_CONSTR(chars_seq, (10, 20));
  while (!c.Null()) {
    Assoc a = c.Pop();
    Text t(a->name + "=");
    t += ((TextVC*)a->val)->NDS();
    result->append(t);
  }    
  return result;
}

// The callback
bool ProcessDirectory(void* cl, VestaSource::typeTag type, Arc arc,
                      unsigned int index, Bit32 pseudoInode,
                      ShortId filesid, bool master) {
  NodeInfo ni = NEW(nodeinfo);

  ni->type  = type;
  ni->arc   = Text(arc);
  ni->index = index;
  ((OurClosure*)cl)->nodeList->Push(ni);
  return true;
}

// Helper function for a workaround for late deletion of ".nfsXXX"
// files that are are used by NFS clients for files deleted while a
// process still has them open.
static inline bool nfs_open_but_deleted_name(Arc arc)
{
  // If it doesn't start with ".nfs", it's not an open-but-deleted
  // name.
  if(strncmp(arc, ".nfs", 4) != 0)
    {
      return false;
    }
  // Skip over the ".nfs"
  arc += 4;
  // Skip characters until we find the end of the string or a
  // non-hex-digit.
  while(*arc && isxdigit(*arc))
    {
      arc++;
    }
  // If we've reached the end of the string (meaning all characters
  // after ".nfs" were hex digits), then this is an open-but-deleted
  // name.  Otherwise, it's not.
  return (*arc == 0);
}

bool AddToNewStuff(OurClosure *cl, bool look_for_cores, Text label) {
  VestaSource *f, *d;
  Text name;
  TextVC *file;
  NodeInfo ni;
  OurClosure newcl;
  Arc arc;

  while(!cl->nodeList->Null()) {
    ni = cl->nodeList->Pop();
    arc = ni->arc.chars();
    name = Text(arc);
    try {
      switch (ni->type) {
      case VestaSource::mutableFile:
      case VestaSource::immutableFile:
        {
          VestaSource::errorCode res = cl->dir->lookup(arc, f);
          // Workaround for late delete-on-close of files deleted
          // while open on client.  If one happens to get removed
          // between the list call that got us its name and this
          // lookup call, just ignore it and move on to the next entry
          // in the directory.  (Note that this doesn't prevent such
          // files from making it into the result of _run_tool.)
          if((res == VestaSource::notFound) &&
             nfs_open_but_deleted_name(arc))
            {
              break;
            }
          assert(res == VestaSource::ok);
          assert(f->type == VestaSource::mutableFile ||
                 f->type == VestaSource::immutableFile);
          file = NEW_CONSTR(TextVC, (name, f->shortId(), f->fptag));
          cl->newstuff = cl->newstuff->AddBindingAssoc(name, file);
          if(look_for_cores && core_match(name)) {
            char *sid =
              SourceOrDerived::shortIdToName(f->shortId(), false);
            outputMu.lock();
            cerr << label << "Possible core file: "
                 << cl->dir_path << name << "\n"
                 << label << "at " << sid << endl;
            outputMu.unlock();
            delete[] sid;
            cl->found_core = true;
          }
          break;
        }
      case VestaSource::volatileDirectory:
      case VestaSource::immutableDirectory:
      case VestaSource::volatileROEDirectory:
        {
          VestaSource::errorCode res = cl->dir->lookup(arc, d);
          assert(res == VestaSource::ok);
          assert(d->type == VestaSource::volatileDirectory ||
                 d->type == VestaSource::immutableDirectory ||
                 d->type == VestaSource::volatileROEDirectory);
          newcl.newstuff = NEW(BindingVC);
          newcl.dir = d;
          newcl.nodeList = NEW(ListT<NodeInfo>);
          newcl.found_core = false;
          newcl.dir_path = cl->dir_path + name + "/";
          res = d->list(0, ProcessDirectory, &newcl, NULL, true);
          assert(res == VestaSource::ok);
          bool new_stuff_added = AddToNewStuff(&newcl, look_for_cores, label);
          assert(new_stuff_added);
          cl->newstuff = cl->newstuff->AddBindingAssoc(name, newcl.newstuff);
          cl->found_core = newcl.found_core || cl->found_core;
          break;
        }
      case VestaSource::deleted:
        // Might have existed in original binding, or could have been
        // created and deleted by tool.
        cl->newstuff = cl->newstuff->AddBindingAssoc(name, valFalse);
        break;
      default:  // impossible
        outputMu.lock();        
        Error(Text("AddToNewStuff failed, bad type: ") +
              IntToText(ni->type) + ".\n");
        outputMu.unlock();      
        return false;
      }
    } catch (SRPC::failure f) {
      outputMu.lock();      
      Error(Text("AddToNewStuff failed (") + IntToText(f.r) +
            "): " + f.msg + ".\n");
      outputMu.unlock();      
      return false;
    }
  }
  return true;
}

// Format the volatile directory name into a Text
Text volatileDirName(const LongId &fsroot)
{
  unsigned int index;
  (void) fsroot.getParent(&index);
  char arc[(sizeof(index) * 2) + 1];
  sprintf(arc, "%08x", index);
  return VestaConfig::get_Text("Run_Tool", "VolatileRootName") + "/" + arc;
}

// Run the tool!
Val RunTool(const RunToolArgs &args, VestaSource*& rootForTool) {
  // Returns a Binding; fields documented below.

  rootForTool = NULL;
  LongId fsroot;
  ostream *report_out, *report_err, *value_out, *value_err;
  SourceOrDerived out_sd, err_sd;
  ShortId out_sid = NullShortId, err_sid = NullShortId;
  bool stdout_cache, stderr_cache, status_cache, signal_cache;
  Text stdin_name;

  create_tool_directory_server();

  // command_line:
  chars_seq *argv = ConvertVals(args.command_line);

  // stdin_data:
  if (args.stdin_data->Length() != 0) {
    ShortId id = args.stdin_data->Sid();
    SourceOrDerived sd;
    sd.open(id);
    stdin_name = VestaConfig::get_Text("Repository", "metadata_root") +
      sd.shortIdToName(id);
    sd.close();
  }

  // ./root: already type-checked by BindRunToolArgs
  Binding root = (BindingVC*)args.dot->LookupNoDpnd("root");

  // Initialize dirInfos of this runtool call, and put it into the 
  // table runToolCalls.
  DirInfo *rootDir = NEW(DirInfo);
  rootDir->b = root;
  rootDir->path = rootPath;
  rootDir->isRoot = true;
  rootDir->child_lookup = false;
  rootDir->coarseDep = false;
  Word rootHandle = GetNewHandle();
  DirInfos *dirInfos = NEW(DirInfos);
  dirInfos->dirInfoTbl = NEW_CONSTR(DirInfoTbl, (runToolDirNum));
  dirInfos->dirInfoTbl->Put(WordKey(rootHandle), rootDir);
  dirInfos->dep = NEW_CONSTR(DPaths, (runToolDepSize));
  runToolCalls.Put(WordKey(rootHandle>>20), dirInfos);

  // stdout_treatment:
  Text stdout_treatment((args.stdout_treatment)->NDS());
  stdout_cache = true;
  report_out = NULL;
  value_out = NULL;
  if (stdout_treatment == "value" ||
      stdout_treatment == "report_value") {
    try {
      out_sid = CreateDerived();
      out_sd.open(out_sid, ios::out);
      value_out = &out_sd;
    } catch (SRPC::failure f) {
      outputMu.lock();  
      Error(Text("RunTool: Cannot create fstream for standard output; ")
            + f.msg + ".\n");
      outputMu.unlock();        
      return NEW(ErrorVC);
    } catch (SourceOrDerived::Fatal f) {
      outputMu.lock();  
      Error(Text("RunTool: Cannot create fstream for standard output; ")
            + f.msg + ".\n");
      outputMu.unlock();        
      return NEW(ErrorVC);
    }
    if (out_sd.bad()) {
      outputMu.lock();  
      Error(Text("RunTool: Cannot create fstream for standard output; errno = "
                 + IntToText(errno)));
      outputMu.unlock();
      return NEW(ErrorVC);
    }
  }
  if (stdout_treatment == "report_nocache" ||
      stdout_treatment == "report" ||
      stdout_treatment == "report_value") {
    stdout_cache = stdout_treatment != "report_nocache";
    report_out = &cout;
  }

  // stderr_treatment:
  Text stderr_treatment((args.stderr_treatment)->NDS());
  stderr_cache = true;
  report_err = NULL;
  value_err = NULL;
  if (stderr_treatment == "value" ||
      stderr_treatment == "report_value") {
    try {
      err_sid = CreateDerived();
      err_sd.open(err_sid, ios::out);
      value_err = &err_sd;
    } catch (SRPC::failure f) {
      outputMu.lock();  
      Error(Text("RunTool: Cannot create fstream for standard err; ")
            + f.msg + ".\n");
      outputMu.unlock();        
      return NEW(ErrorVC);
    } catch (SourceOrDerived::Fatal f) {
      outputMu.lock();  
      Error(Text("RunTool: Cannot create fstream for standard err; ")
            + f.msg + ".\n");
      outputMu.unlock();        
      return NEW(ErrorVC);
    }
    if (err_sd.bad()) {
      outputMu.lock();  
      Error(Text("RunTool: Cannot create fstream for standard err; errno = "
                 + IntToText(errno)));
      outputMu.unlock();
      return NEW(ErrorVC);
    }
  }
  if (stderr_treatment == "report_nocache" ||
      stderr_treatment == "report" ||
      stderr_treatment == "report_value") {
    stderr_cache = stderr_treatment != "report_nocache";
    report_err = &cerr;
  }
  
  // status_treatment:
  Text status_treatment((args.status_treatment)->NDS());
  if (status_treatment == "report_nocache")
    status_cache = false;
  else {
    assert(status_treatment == "report");
    status_cache = true;
  }

  // signal_treatment:
  Text signal_treatment((args.signal_treatment)->NDS());
  if (signal_treatment == "report_nocache")
    signal_cache = false;
  else {
    assert(signal_treatment == "report");
    signal_cache = true;
  }

  // wd_name:
  const Text wd((args.wd_name)->NDS());

  // ./envVars:   type-checked by BindRunToolArgs
  BindingVC *envVars = (BindingVC*)args.dot->Lookup("envVars");
  chars_seq *ev = ConvertEnvVars(envVars);

  // create the volatile directory:
  try {
    VestaSource::errorCode err =
      VDirSurrogate::createVolatileDirectory(SRPC::this_host().chars(),
                                             toolDirServerIntfName.chars(),
                                             rootHandle, rootForTool, 0,
                                             !args.existing_writable->b);
    if (err != VestaSource::ok) {
      outputMu.lock();      
      Error(Text("RunTool: createVolatileDirectory failed (") +
            VestaSource::errorCodeString(err) + ".\n");
      outputMu.unlock();      
      return NEW(ErrorVC);
    }
  } catch (SRPC::failure f) {
    outputMu.lock();    
    Error(Text("RunTool: createVolatileDirectory failed (")
          + IntToText(f.r) + "): " + f.msg + ".\n");
    outputMu.unlock();    
    return NEW(ErrorVC);
  }
  fsroot = rootForTool->longid;

  // host:
  void* handle;
  const Text host(RunToolHost(args.platform, args.loc, /*OUT*/handle));
  const Text label = ThreadLabel();

  // print the command-line:
  outputMu.lock();
  cout << label << host << ": ";
  for (int arg = 0; arg < argv->length(); arg++) {
    cout << (*argv)[arg] << " ";
  }
  cout << endl;
  if(getenv("DEBUG_TOOL_DIR_SERVER"))
    {
      // Print out the root handle for the tool directory server, the
      // LongId of the root, and the name of the root within the
      // volatile root.
      char handle_buff[17];
      sprintf(handle_buff, "%016" FORMAT_LENGTH_INT_64 "x", rootHandle);
      cout << label << "[tool dir server root handle = "
           << handle_buff << "]" << endl
           << label << "[root LongId = ";
      for(unsigned int i = 0, len = fsroot.length(); i < len; i++)
        {
          cout << setw(2) << setfill('0') << hex
               << (int) (fsroot.value.byte[i] & 0xff);
        }
      cout << setfill(' ') << dec << "]" << endl
           << label << "[root directory name = ";
      cout << volatileDirName(fsroot) << "]" << endl;
    }
  if(pauseBeforeTool) {
          cout << label << "Running in " << volatileDirName(fsroot) << "/"
                << wd << endl;
          cout << label << "Using the following environment variables:"
                << endl;
          for(int i = 0; i < ev->length(); i++) {
                  cout << label << "\t" << (*ev)[i] << endl;
          }
          char enter;
          cout << label << "Press Enter to continue...";
          cout << flush;
          cin.get(enter);
          cout << label << "Continuing." << endl;
  }
  outputMu.unlock();  

  // Call the RunTool!
  RunTool::Tool_result r;
  try {
    r = RunTool::do_it(
      host,       // const Text &host
      argv,       // chars_seq *argv
      fsroot,     // LongId &fsroot
      wd,         // const Text &wd = DEFAULT_TOOL_WD
      ev,         // chars_seq *ev = NULL
      report_out,
      value_out,
      report_err,
      value_err,
      &outputMu,
      label,
      stdin_name  // const Text &stdin_name = ""
    );
    //  struct Tool_result {
    //    int status;
    //    int sigval;
    //    bool stdout_written;
    //    bool stderr_written;
    //  };
    if (out_sid != NullShortId) { FS::Close(out_sd); }
    if (err_sid != NullShortId) { FS::Close(err_sd); }
  } catch (SRPC::failure f) {
    outputMu.lock();    
    Error("invoking _run_tool: " + f.msg + "\n");
    outputMu.unlock();    
    if (out_sid != NullShortId) out_sd.close();
    if (err_sid != NullShortId) err_sd.close();
    RunToolDone(handle);
    throw(Evaluator::failure(Text("_run_tool failure"), false));
  } catch (FS::Failure f) {
    // Failed because of filesystem error
    outputMu.lock();
    ostringstream l_err_msg;
    l_err_msg << "writing standard output/error file:" << endl
              << f;
    Error(l_err_msg.str());
    outputMu.unlock();
    RunToolDone(handle);
    throw(Evaluator::failure(Text("_run_tool failure"), false));
  }
  if(pauseAfterTool || (pauseAfterToolSignal && r.sigval) ||
        (pauseAfterToolError && r.status)) {
          outputMu.lock();
          cout << label << "Ran in " << volatileDirName(fsroot) << "/" << wd
               << endl;
          cout << label << "Used the following environment variables:" << endl;
          for(int i = 0; i < ev->length(); i++) {
                  cout << label << "\t" << (*ev)[i] << endl;
          }
          cout << label << "Exited with status " << r.status << ", signal "
                << r.sigval << endl;
          char enter;
          cout << label << "Press Enter to continue...";
          cout << flush;
          cin.get(enter);
          cout << label << "Continuing." << endl;
          outputMu.unlock();
  }
  RunToolDone(handle);

  OurClosure cl;
  cl.newstuff = NEW(BindingVC);
  cl.dir = rootForTool;
  cl.nodeList = NEW(ListT<NodeInfo>);
  cl.found_core = false;
  cl.dir_path = "/";

  try {
    VestaSource::errorCode ok;
    ok = rootForTool->list(0, ProcessDirectory, &cl, NULL, true);
    if (ok != VestaSource::ok)
      throw (SRPC::failure(ok, "problem listing volatile directory"));
    ok = rootForTool->makeFilesImmutable(args.fp_content->num);
    if (ok != VestaSource::ok)
      throw (SRPC::failure(ok,
        "problem with making files immutable for volatile directory"));
    bool new_stuff_added = AddToNewStuff(&cl, r.dumped_core, label);
    assert(new_stuff_added);
  } catch (SRPC::failure f) {
    outputMu.lock();    
    Error(Text("RunTool error (") + IntToText(f.r) + "): " + f.msg + ".\n");
    outputMu.unlock();    
    return NEW(ErrorVC);
  }
  if (r.dumped_core && !cl.found_core) {
          outputMu.lock();
          cerr << label << "Warning: tool dumped core but couldn't find the file." << endl;
          outputMu.unlock();
  }

  if (r.sigval && !signal_cache) {
    if (stopOnError) {
      outputMu.lock();      
      Error(Text("RunTool error: tool terminated with signal ") +
            IntToText(r.sigval) + "(" + getSigMsg(r.sigval) + ").\n");
      outputMu.unlock();      
      throw(Evaluator::failure(Text("exiting"), false));
    }
  }
  else if (r.status && !status_cache) {
    if (stopOnError) {
      outputMu.lock();      
      Error(Text("RunTool error: tool terminated with non-zero status (") +
            IntToText(r.status) + ").\n");
      outputMu.unlock();      
      throw(Evaluator::failure(Text("exiting"), false));
    }
  }

  // Collect the result:
  Context assocs;
  assocs.Push(NEW_CONSTR(AssocVC, (rootName, cl.newstuff)));
  if (stderr_treatment == "value" || stderr_treatment == "report_value") {
    assocs.Push(NEW_CONSTR(AssocVC, (stdeName, 
      NEW_CONSTR(TextVC, (Text("stderr"), err_sid, args.fp_content->num)))));
  }
  if (stdout_treatment == "value" || stdout_treatment == "report_value") {
    assocs.Push(NEW_CONSTR(AssocVC, (stdoName,
      NEW_CONSTR(TextVC, (Text("stdout"), out_sid, args.fp_content->num)))));
  }
  assocs.Push(NEW_CONSTR(AssocVC, 
                         (stewName, NEW_CONSTR(BooleanVC, (r.stderr_written)))));
  assocs.Push(NEW_CONSTR(AssocVC, 
                         (stowName, NEW_CONSTR(BooleanVC, (r.stdout_written)))));
  assocs.Push(NEW_CONSTR(AssocVC, 
                         (sigName, NEW_CONSTR(IntegerVC, (r.sigval)))));
  assocs.Push(NEW_CONSTR(AssocVC, 
                         (codeName, NEW_CONSTR(IntegerVC, (r.status)))));
  assocs.Push(NEW_CONSTR(AssocVC, 
                         (coreName, NEW_CONSTR(BooleanVC, (r.dumped_core)))));

  Val result = NEW_CONSTR(BindingVC, (assocs));

  // Set the cacheit bit:
  result->cacheit = ((!r.sigval || signal_cache) &&
                     (!r.status || status_cache) &&
                     (!r.stdout_written || stdout_cache) &&
                     (!r.stderr_written || stderr_cache) &&
                     (!(pauseAfterToolSignal && r.sigval)) &&
                     (!(pauseAfterToolError && r.status)) &&
                     (!pauseBeforeTool) &&
                     (!pauseAfterTool) &&
                     // It would be very strange for a process to dump
                     // core w/o getting a signal.  If that happens,
                     // we trat it like a signal for caching purposes.
                     (!r.dumped_core || signal_cache));

  // remove information about this volatile directory.  (Note: there's
  // a minor race condition here as a ToolDirectoryServer thread could
  // already have a pointer to dirInfos and be using it past the point
  // we delete it from the table.)
  runToolCalls.Delete(rootHandle>>20, dirInfos);

  // For any directory which was looked up itself but for which none
  // of its children were looked up, add a type dependency on the
  // directory being a binding.
  DirInfoIter it(dirInfos->dirInfoTbl);
  WordKey unused;
  DirInfo *dirInfo;
  while(it.Next(unused, dirInfo))
    if(!dirInfo->child_lookup)
      dirInfos->dep->Add(&(dirInfo->path), valTBinding, TypePK);

  // Set the dependency:
  result->dps = dirInfos->dep;

  // return result
  return result;
}

void DeleteRootForTool(VestaSource* rootForTool) {
  bool err = VDirSurrogate::deleteVolatileDirectory(rootForTool);
  if (err != VestaSource::ok)
    throw (SRPC::failure(err, "problem deleting volatile directory for runtool"));
}

void CreateRootForDeriveds() {
  create_tool_directory_server();
  VestaSource::errorCode err =
    VDirSurrogate::createVolatileDirectory(SRPC::this_host().chars(),
                                           toolDirServerIntfName.chars(),
                                           GetNewHandle(), rootForDeriveds);
  if (err != VestaSource::ok) {
    throw (SRPC::failure(err, "problem creating volatile directory"));
  }
}

void DeleteRootForDeriveds() {
  VestaSource::errorCode err = VDirSurrogate::deleteVolatileDirectory(rootForDeriveds);
  if (err != VestaSource::ok) {
    throw (SRPC::failure(err, "problem deleting volatile directory"));
  }
}

ShortId CreateDerived() {
  VestaSource* newvs;
  static Basics::mutex cdmu;
  static int cdcnt = 0;
  char arc[32];
  cdmu.lock();
  sprintf(arc, "%d", cdcnt++);
  cdmu.unlock();
  VestaSource::errorCode err =
    rootForDeriveds->insertMutableFile(arc, NullShortId, true,
                                       NULL,VestaSource::replaceDiff, &newvs);
  if (err != VestaSource::ok) {
    throw (SRPC::failure(err, "problem creating derived."));
  }
  ShortId sid = newvs->shortId();
  delete newvs;
  newvs = NULL; // help out the garbage collector
  if (sid == NullShortId) {
    outputMu.lock();    
    Error(Text("Failed to create derived"));
    outputMu.unlock();    
    throw(Evaluator::failure(Text("exiting"), false));
  }
  return sid;
}

void PrimRunToolInit() {
  rootPath.Extend(Text("root"));
  RunToolHostInit();
}

---