vupdate.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

// Created on Mon Jul 14 13:58:43 PDT 1997 by heydon
// Last modified on Tue Apr 26 02:07:36 EDT 2005 by ken@xorian.net   
//      modified on Mon Nov 20 18:48:43 PST 2000 by mann   
//      modified on Mon Jan 31 14:48:27 PST 2000 by heydon 
//      modified on Fri Feb  6 17:17:48 PST 1998 by yuanyu 

// vupdate(1) -- update the imports of a specified model


#include <unistd.h>    // for getcwd(3), getpid(2)
#include <stdio.h>     // for rename(2), sprintf(3)
#include <ctype.h>     // for isdigit(3)
#include <errno.h>

#include <Basics.H>
#include <sys/types.h> // for opendir(3), etc.
#include <dirent.h>    // for opendir(3), etc.

#include <FS.H>
#include <Generics.H>
#include <VestaConfig.H>
#include <VestaSource.H>
#include <UniqueId.H>
#include <ParseImports.H>
#include <ReposUI.H>

using std::ostream;
using std::ofstream;
using std::ifstream;
using std::cout;
using std::cin;
using std::cerr;
using std::endl;

// Possible values for the 'verbose' switch variable
static const int Silent = 0;       // don't print anything
static const int ChangesOnly = 1;  // only print models with updates (default)
static const int Verbose = 2;      // print all models considered

// Variables for the command-line switches
static bool doWork = true;            // true iff -no-action switch NOT present
static bool query = false;            // is -query switch present?
static int verbose = ChangesOnly;     // is -silent or -verbose switch present?
static bool update_local = false;     // is -update-local switch present?
static bool update_co = false;       // is -update-checkout switch present?
static bool advance_co = false;       // is -advance-checkout switch present?
static bool onlyMine = false;         // is -only-mine switch present?
static bool toCheckout = false;       // is -to-checkout switch present?
static bool parse_errors_stop = false;
static TextSeq limiters;              // arg(s) to -limit switch(es)
static char *attrName = NULL;         // attribute name to match
static TextSeq *attrVals = NULL;      // list of attribute values
static bool attrMatchSense;           // true for ':', false for '^'

static void Option(char *flag, char *meaning) throw ()
{
    cerr << "  " << flag;
    int pad = max(0, 23 - strlen(flag));
    for (int i = 0; i < pad; i++) cerr << ' ';
    cerr << ' ' << meaning << endl;
}

static void Syntax(char *msg, char *arg = (char *)NULL) throw ()
{
    cerr << "Error: " << msg;
    if (arg != (char *)NULL) cerr << ": '" << arg << "'";
    cerr << endl;
    cerr << "Syntax: vupdate [ options ] [ model ]" << endl;
    cerr << "Possible options are:" << endl;
    Option("-n or -no-action", "do not change any models");
    Option("-q or -query", "ask user about each update");
    Option("-s or -silent", "do not report updates");
    Option("-r or -update-local",
           "recurse on all models imported locally");
    Option("-c or -update-checkout",
           "recurse on all models imported from checkout sessions");
    Option("-u or -update-all", "set both -update-local and -update-checkout");
    Option("-a or -advance-checkout", "advance imported checkout sessions");
    Option("-v or -verbose", "report on all processed models");
    Option("-l or -limit substring",
           "only update imports containing 'substring'");
    Option("-L or -limit-checkout",
           "only update imports from checkout sessions");
    Option("-t or -to-checkout", "update to a more recent checkout session");
    Option("-m or -only-mine", "update a checkout import only if owned by me");
    Option("-A or -attr attr-spec",
           "only update to versions with given attributes");
    Option("-e or -parse-errors-stop",
           "stop if on import paths we can't understand (non-numeric arcs)");
    exit(1);
}

static void Indent(ostream &os, int n) throw ()
{
    for (/*SKIP*/; n > 0; n--) os << ' ';
}

static void CopyFromTo(ifstream &ifs, ofstream &ofs, int loc = -1)
  throw (FS::Failure)
/* Copy characters from "ifs" to "ofs" starting at the current character in
   "ifs" and up to (but not including) the character in "ifs" at position
   "loc". If "loc < 0", copy up to the end of "ifs". */
{
    const int BuffSz = 1024;
    char buff[BuffSz];
    int toCopy = (loc >= 0) ? (loc - (int)FS::Posn(ifs)) : (-1);
    assert(loc < 0 || toCopy >= 0);
    try {
        while (loc < 0 || toCopy > 0) {
            int cnt = (loc < 0) ? BuffSz : min(BuffSz, toCopy);
            FS::Read(ifs, buff, cnt);
            FS::Write(ofs, buff, cnt);
            if (loc >= 0) toCopy -= cnt;
        }
    }
    catch (FS::EndOfFile) {
        // We should only encounter this exception if no definite stopping
        // point was provided.
        assert(loc < 0);

        // write the characters that were read
        FS::Write(ofs, buff, ifs.gcount());
    }
}

// name and VestaSource of repository's appendable root (/vesta)
static const Text AppendableRootName = "/vesta/";
static VestaSource *RepositoryRoot;

// dummy class for initializing RepositoryRoot
class VUpdateInit {
  public:
    VUpdateInit() throw () {
        RepositoryRoot = VestaSource::repositoryRoot();
    }
};
static VUpdateInit vupdateInit;

static bool ImmutableDir(const Text &path) throw (SRPC::failure)
/* Return "true" iff "path" is the absolute path of an immutable directory
   in the appendable root. */
{
    if (path.FindText(AppendableRootName) != 0) return false;
    Text relPath(path.Sub(AppendableRootName.Length()));
    VestaSource *res = 0;
    VestaSource::errorCode err =
        RepositoryRoot->lookupPathname(relPath.cchars(), /*OUT*/ res);
    bool result = ((err == VestaSource::ok) &&
                   (res->type == VestaSource::immutableDirectory));
    if(res != 0)
      delete res;
    return result;
}

static void VersionDir(const Text &path, /*OUT*/ int &prefixLen,
  /*OUT*/ int &suffixStart, /*OUT*/ int &verNum,
  /*INOUT*/ bool &checkedIn, bool doStat)
  throw (ParseImports::Error, SRPC::failure)
/* "path" is a (possibly relative) path of some model. Set "prefixLen" to
   the length of the prefix of "path" that is the name of the directory
   (ending with a '/') in which to search for the highest version of the
   package or checkout session of the model; "suffixStart" to the index
   of the first character of the suffix of "path" to be appended after
   the correct version (which, if non-empty, will start with '/'); and
   set "verNum" to the current version number. If "suffixStart" is set
   to "path.Length()", then the suffix is empty.

   Examples:

|  path                          prefix                     suffix
|  ----------------------------- ------------------------- --------------
|  thread/3                      thread/                   <empty>
|  thread/3/build.ves            thread/                   /build.ves
|  thread/3/src/progs.ves        thread/                   /src/progs.ves
|  thread/3.test/5               thread/3.test/            <empty>
|  thread/3.test/5/build.ves     thread/3.test/            /build.ves
|  thread/3.test/5/src/progs.ves thread/3.test/            /src/progs.ves
|  thread/checkout/2/5/build.ves thread/checkout/2/        /build.ves
|  thread/3.test/checkout/2/5    thread/3.test/checkout/2/ <empty>

   In the event that "path" names a checkout session, and if "checkedIn" is
   initially true or "doStat" is true and that checkout session has been
   checked in, then "prefixLen" will be set so the highest numbered version
   will be searched for on the main branch, and "checkedIn" will be set to
   "true". Otherwise, "checkedIn" will be unchanged. For example, if version
   2 of both the "thread" and "thread/3.test" packages have been checked in:

|  path                          prefix                     suffix
|  ----------------------------- ------------------------- --------------
|  thread/checkout/2/5/build.ves thread/                   /build.ves
|  thread/3.test/checkout/2/5    thread/3.test/            <empty>
*/
{
    Text verTxt; // package sub-version number

    // first, see if "path" is a checkout version
    int len = path.Length();
    Text pattern("/checkout/");
    int ckout = path.FindText(pattern);
    if (ckout >= 0) {
        // skip first arc after "/checkout/"
        int ckoutEnd = ckout + pattern.Length();
        prefixLen = path.FindChar('/', ckoutEnd);
        if (prefixLen < 0) {
            Text msg("malformed checkout session name: '");
            msg += path; msg += "'";
            throw ParseImports::Error(msg);
        }
        Text ckoutVer(path.Sub(ckoutEnd, prefixLen - ckoutEnd));
        prefixLen++; // skip '/'

        // skip next arc for start of suffix
        // (and set 'verTxt' to name of next arc (package subversion))
        suffixStart = path.FindChar('/', prefixLen);
        if (suffixStart < 0) suffixStart = len;
        verTxt = path.Sub(prefixLen, suffixStart - prefixLen);

        // adjust "prefixLen" and "verTxt" if session has been checked in
        if (doStat) {
            Text dirName(path.Sub(0, ckout + 1) + ckoutVer);
            checkedIn = ImmutableDir(dirName);
        }
        if (checkedIn) {
            prefixLen = ckout + 1;
            verTxt = ckoutVer;
        }
    } else {
        // stop at first arc of "path" that consists entirely of digits
        prefixLen = 0;
        do {
            if (path[prefixLen] == '/') prefixLen++;
            int curr = prefixLen;
            while (curr < len && isdigit((int)(path[curr]))) curr++;
            if (curr >= len || path[curr] == '/') {
                suffixStart = curr;
                break;
            }
            prefixLen = path.FindChar('/', prefixLen);
        } while (prefixLen >= 0);
        if (prefixLen < 0 || prefixLen >= len) {
            Text msg("no numeric arc: '"); msg += path; msg += "'";
            throw ParseImports::Error(msg);
        }
        verTxt = path.Sub(prefixLen, suffixStart - prefixLen);
    }
    // convert "verTxt" to "verNum"
    if (sscanf(verTxt.chars(), "%d", &verNum) != 1) {
        // directory is not a number; give up...
        Text msg("version not numeric: '"); msg += verTxt; msg += "'";
        throw ParseImports::Error(msg);
    }
} // end VersionDir

static bool AllDigits(const char *str) throw ()
/* Return "true" iff "str" is a string consisting of all digits. */
{
    for (/*SKIP*/; *str != '\0'; str++) {
        if (!isdigit((int)(*str))) return false;
    }
    return true;
}

static bool AttribMatch(VestaSource *child) throw (SRPC::failure)
/* Return true iff the attributes of 'child' match the '-attr' specification
   embodied by the global variables 'attrName', 'attrVals', and
   'attrMatchSense'. */
{
  // does 'child' define attribute?
  const char *attrVal = child->getAttrib(attrName);
  if (attrVal != (char *)NULL) {
    delete [] attrVal;
    // were any attribute values specified?
    if (attrVals != (TextSeq *)NULL) {
      for (int i = 0; i < attrVals->size(); i++) {
        Text val = attrVals->get(i);
        if (child->inAttribs(attrName, val.cchars())) {
          return attrMatchSense;
        }
      }
      // there was no match on any value
      return !attrMatchSense;
    } else {
      // this is the '-attr attrName' case
      return true;
    }
  } else {
    // otherwise, there is a match iff this is the 'attr^vals' case
    return (attrVals != NULL && !attrMatchSense);
  }
}

// Structure type for 'ListCallback' closure argument
typedef struct {
    int max;
    VestaSource *parent;
} CallbackClosure;

static bool ListCallback(void *closure, VestaSource::typeTag type,
  Arc arc, unsigned int index, Bit32 pseudoInode, ShortId filesid, bool master)
  throw (SRPC::failure)
/* The 'closure' argument is actually a 'CallbackClosure *' that points
   to the largest version number seen so far. If 'type' is immutable
   directory and if 'arc' names a numeric directory whose value is larger
   than the current maximum, update the maximum value in 'closure'. */
{
    CallbackClosure *cc = (CallbackClosure *)closure;
    if (type == VestaSource::immutableDirectory && AllDigits(arc)) {
        if (attrName != (char *)NULL) {
            // Fetch the 'VestaSource' object for 'index'
            VestaSource *child = 0;
            VestaSource::errorCode err =
              cc->parent->lookupIndex(index, /*OUT*/ child);
            bool no_good = (err != VestaSource::ok || !AttribMatch(child));
            if (child != NULL) delete child;
            if(no_good)
              return true;
        }
        int val;
        int scanRes = sscanf(arc, "%d", &val);
        assert(scanRes == 1);
        if (val > cc->max) cc->max = val;
    }
    return true;
}

static int HighestVersion(const Text &path)
  throw (ParseImports::Error, SRPC::failure)
/* Return the numerical value of the name in the directory "dir" that
   consists of all digits, has the largest numerical value, and names
   a sub-directory (and hence, is not a ghost or stub). */
{
    // verify that 'path' names an appendable directory, and get it
    if (path.FindText(AppendableRootName) != 0) {
        Text errMsg("imported path not in appendable root: ");
        errMsg += path;
        throw ParseImports::Error(errMsg);
    }
    Text relPath(path.Sub(AppendableRootName.Length()));
    VestaSource *dir = 0;
    VestaSource::errorCode err =
      RepositoryRoot->lookupPathname(relPath.cchars(), /*OUT*/ dir);
    if (err != VestaSource::ok) {
        Text errMsg("unable to open directory in import: ");
        errMsg += path;
        throw ParseImports::Error(errMsg);
    } else if (dir->type != VestaSource::appendableDirectory) {
        delete dir;
        Text errMsg("package import is not an appendable directory: ");
        errMsg += path;
        throw ParseImports::Error(errMsg);
    }

    assert(dir != 0);

    // iterate over the directory
    CallbackClosure cc;
    cc.max = -1;
    cc.parent = dir;
    err = dir->list(/*firstIndex=*/ 0, ListCallback, (void *)(&cc));

    // clean up
    delete dir;
    return cc.max;
} // end HighestVersion

static bool OthersCheckout(const Text &p_path)
/* Return true iff the imported path 'p_path' is a checkout session
   belonging to someone else. */
{
    // pattern to search for
    Text pattern("/checkout/");

    int ckout = p_path.FindText(pattern);
    int ckoutEnd = ckout + pattern.Length();
    int l_session_len;
    // Assume that this is either not a checkout session, or that it
    // must belong to us.
    bool result = false;
  
    if ((ckout >= 0) && // If we found "/checkout/"...
        // skip first arc after "/checkout/"
        ((l_session_len = p_path.FindChar('/', ckoutEnd)) >= 0))
    {
        Text l_session_path = p_path.Sub(0, l_session_len);
        // Look up the session
        VestaSource *l_session = NULL;
        try {
            l_session = ReposUI::filenameToVS(l_session_path);
        } catch (...) {
            // ReposUI::filenameToVS may throw an exception.  We need to
            // catch it if it does, but we really only care if we got
            // something.
        }
        // As long as we got it and it is a session...
        if ((l_session != NULL) && l_session->inAttribs("type", "session")) {
            // Get the global username
            Text l_uspec(AccessControl::self()->user());

            // Test if the session is checked out by someone who isn't
            // us.  (If it has no "checkout-by" attribute, assume it's
            // *not* ours.)
            char *l_checkout_user = l_session->getAttrib("checkout-by");
            if((l_checkout_user == 0) ||
               (strcmp(l_uspec.cchars(), l_checkout_user) != 0))
              result = true;
            if(l_checkout_user != 0)
              delete [] l_checkout_user;
        }
        if(l_session != 0)
          delete l_session;
    }

     return result;
}

static void Update(const Text &model, /*INOUT*/ TextSeq &localModels)
  throw (FS::DoesNotExist, FS::Failure, ParseImports::Error, 
         VestaConfig::failure, SRPC::failure);  // forward

static void RecurseOnCheckout(const Text &p_path, const Text& suffix)
  throw (FS::DoesNotExist, FS::Failure, ParseImports::Error, 
         VestaConfig::failure, SRPC::failure)
/* If p_path comes from a checkout session belonging to this user:
   If the -c flag was given, invoke vupdate recursively on the session.
   If the -a flag or -c flag was given, advance the session. */
{
  if (!advance_co && !update_co) return;

  // pattern to search for
  Text pattern("/checkout/");

  int ckout = p_path.FindText(pattern);
  int ckoutEnd = ckout + pattern.Length();
  int l_session_len;
 
  // skip first arc after "/checkout/"
  if (ckout < 0 || (l_session_len = p_path.FindChar('/', ckoutEnd)) < 0) { 
    // Not a checkout import
    return;
  }

  Text l_session_path = p_path.Sub(0, l_session_len);
  // Look up the session
  VestaSource *l_session = NULL;
  try {
    l_session = ReposUI::filenameToVS(l_session_path);
  } catch (...) {
    // ReposUI::filenameToVS may throw an exception.  We need to
    // catch it if it does, but we really only care if we got
    // something.
  }
  if (l_session == NULL || !l_session->inAttribs("type", "session")) {
    // Not a session
    return;
  }

  // Get the global username
  Text l_uspec(AccessControl::self()->user());
  
  // Test if the session is checked out by someone who isn't us.  (If
  // it has no "checkout-by" attribute, assume it's *not* ours.)
  char *l_checkout_user = l_session->getAttrib("checkout-by");
  bool not_my_checkout = ((l_checkout_user == 0) ||
                          (strcmp(l_uspec.cchars(), l_checkout_user) != 0));
  if(l_checkout_user != 0)
    delete [] l_checkout_user;
  if(not_my_checkout)
    {
      delete l_session;
      return;
    }

  // Find working directory.
  char *l_workdir = l_session->getAttrib("work-dir");
  delete l_session;
  if (l_workdir == NULL) return;  // no workdir attribute
  // It's also possible that the session was non-exclusive, and the
  // working directory has since been deleted.  In this case, the
  // work-dir attribute exists, but the directory itself does not.
  // Return silently under this condition as well...
  if (!FS::IsDirectory(l_workdir))
    {
      if (verbose != Silent)
        cerr << "vupdate:  the working directory of checkout session "
             << p_path << " (" << l_workdir
             << ("), no longer exists!  "
                 "Skipping recursive updates for this import.")
             << endl;
      delete [] l_workdir;
      return;
    }
  
  // Construct model name in working directory
  Text w_path = Text(l_workdir) + (suffix.Empty() ? "/build.ves" : suffix);

  // OK to update it?
  if (update_co) {
    if (query) {
      cout << "  Update \"" << w_path << "\" (y/n)? ";
      cout.flush();
      const int BuffLen = 20; char buff[BuffLen];
      cin.getline(buff, BuffLen);
      if (buff[0] != 'y')
        {
          delete [] l_workdir;
          return;
        }
    }

    // Update the imported model
    TextSeq localModels(/*sizeHint=*/ 10);
    Update(w_path, /*INOUT*/ localModels);
    while (localModels.size() > 0) {
      // Update the imported model's local imports
      Text model = localModels.remlo();
      Update(model, /*INOUT*/ localModels);
    }
  }

  // Advance (by invoking a separate program).
  // If we get here, advance_co must be true.
  if (doWork) {
    Text cmd = Text("vadvance ") + l_workdir;
    system(cmd.cchars());
  }
  delete [] l_workdir;
}

static bool NewVersion(const Import *imp, /*OUT*/ Text &newPath,
  /*OUT*/ Text &toWrite)
  throw (FS::DoesNotExist, FS::Failure, ParseImports::Error, 
         VestaConfig::failure, SRPC::failure)
/* Given the import "imp", return "true" iff the import needs to be
   updated. If "true" is returned, "newPath" is set to the complete
   path of the new import, and "toWrite" is set to the portion of
   "newPath" that should be written to the new model. If "false" is
   returned, the values of "newPath" and "toWrite" are undefined.

   In the event that "imp" refers to a model in a checkout session, and
   if the checkout session has since been checked in, "NewVersion" will
   return "true" and set "newPath" and "toWrite" so as to refer to the
   latest version along the checked-in branch. */
{
    int prefixLen, suffixPos, verNum;
    bool checkedIn = false;
    char buff[20]; // for storing new version number

    // determine directory containing versions
    int pathLen = imp->path.Length();
    VersionDir(imp->path, /*OUT*/ prefixLen, /*OUT*/ suffixPos,
      /*OUT*/ verNum, /*INOUT*/ checkedIn, /*doStat=*/ true);
    Text verDir(imp->path.Sub(0, prefixLen));
    Text suffix(imp->path.Sub(suffixPos));

    // update and/or advance imported checkout session if needed
    if (!checkedIn) RecurseOnCheckout(imp->path, suffix);

    // determine the new version
    int newVerNum = HighestVersion(verDir);

    // check for version in model that is too large
    if (verNum > newVerNum) {
        // If the '-attr' switch was used, it's quite possible that there
        // was no match, or that the match was to a smaller version number
        // than the existing import. In that case, simply return 'false'
        // to indicate that the import should not be updated.
        if (attrName != (char *)NULL) return false;

        // Otherwise, the existing import names a non-existant version
        // number, so report an error.
        Text msg("version number exceeds largest existing version:\n  ");
        msg += imp->path;
        throw ParseImports::Error(msg);
    }

    // ----------------------------------------------------------------------
    // Determine whether it has been checked out again by looking for
    // a new version stub.  This will fail if the path we'd be
    // updating to is still in a checkout session (because there
    // aren't ever any version stubs in checkout sessions).
    bool newest_is_checkout = false;
    Text l_session_path;
    int l_session_ver_num;
    if (toCheckout) {
        int printRes = sprintf(buff, "%d", newVerNum + 1);
        assert(printRes > 0);
        Text newVerTxt(buff);
        // Build the path of the stub
        Text l_stub_path = verDir + newVerTxt;
        // Look up the stub, if it exists
        VestaSource *l_stub = 0;
        // ReposUI::filenameToVS may throw an exception.  We need to
        // catch it if it does, but we really only care if we got
        // something.
        try
          {
            l_stub = ReposUI::filenameToVS(l_stub_path);
          }
        catch (...) { }
        if (l_stub && l_stub->type == VestaSource::stub) {
          const char *l_session_dir = l_stub->getAttrib("session-dir");
          if(l_session_dir != NULL)
            {
              l_session_path = l_session_dir + Text('/');
              // If we don't care about who this checkout belongs to
              // or it belongs to us, we'll update to this. Also, we
              // have to make sure that the session path starts with
              // the right prefix, otherwise we won't be able to munge
              // the model text in place.
              if ((!onlyMine || !OthersCheckout(l_session_path)) &&
                  (l_session_path.Sub(0, prefixLen) == verDir))
                {
                  newest_is_checkout = true;
                  // Update/advance imported checkout session if
                  // needed.
                  RecurseOnCheckout(l_session_path, suffix);
                  l_session_ver_num = HighestVersion(l_session_path);
                }
              delete [] l_session_dir;
            }
        }
        if(l_stub != 0)
          delete l_stub;
    }

    // return if the highest version is already specified
    if (newVerNum == verNum && !checkedIn && !newest_is_checkout) {
        return false;
    }
    assert((verNum < newVerNum && !checkedIn)
           || (verNum <= newVerNum && checkedIn)
           || newest_is_checkout);

    Text newVerTxt;
    if (newest_is_checkout) {
        // format "l_session_ver_num" as a text
        int printRes = sprintf(buff, "%d", l_session_ver_num);
        assert(printRes > 0);

        // The new version is everything after the prefix in the
        // session path, plus a path separator and the session version
        // number.
        newVerTxt = l_session_path.Sub(prefixLen) + buff;

        // set "newPath"
        newPath = verDir + newVerTxt + imp->path.Sub(suffixPos);
    } else {
        // format "newVerNum" as a text
        int printRes = sprintf(buff, "%d", newVerNum); assert(printRes > 0);
        newVerTxt = buff;

        // set "newPath"
        newPath = verDir + newVerTxt + imp->path.Sub(suffixPos);

        // If the user said "-only-mine", and we would be updating a
        // checkout session reference belonging to another user,
        // report that we don't have an update to make.
        if (onlyMine && OthersCheckout(newPath)) return false;
    }

    // set "toWrite"
    VersionDir(imp->orig, /*OUT*/ prefixLen, /*OUT*/ suffixPos,
      /*OUT*/ verNum, /*INOUT*/ checkedIn, /*doStat=*/ false);
    toWrite = imp->orig.Sub(0, prefixLen) +newVerTxt+ imp->orig.Sub(suffixPos);
    return true;
} // end NewVersion

static void RenameTempFile(const Text &temp, const Text &orig)
  throw (FS::DoesNotExist, FS::Failure)
{
    // first, try using rename(2)
    if (rename(temp.cchars(), orig.cchars()) != 0) {
        if (errno == EXDEV) {
            // in event of "cross-device link" error, copy instead
            ifstream ifs;
            ofstream ofs;
            FS::OpenReadOnly(temp, /*OUT*/ ifs);
            FS::OpenForWriting(orig, /*OUT*/ ofs);
            CopyFromTo(ifs, ofs);
            FS::Close(ifs);
            FS::Close(ofs);

            // delete temp file
            (void)unlink(temp.cchars());
        } else {
            throw FS::Failure("rename(2)", temp + " " + orig);
        }
    }
} // RenameTempFile

static Text TempSuffix()
{
  char pidBuff[40];
  FP::Tag uid = UniqueId();
  int sres = sprintf(pidBuff, "-%016" FORMAT_LENGTH_INT_64 "x-%016" FORMAT_LENGTH_INT_64 "x~",
                     uid.Word0(), uid.Word1());
  assert(sres > 0);
  assert(sres < sizeof(pidBuff));

  return pidBuff;
}

/* Return the name of a temporary file, and open "ofs" on that file. This
   function guarantees that a unique filename is chosen across an entire
   Vesta site by using the "UniqueId" interface. */
static Text OpenTempFile(/*OUT*/ ofstream &ofs) throw (FS::Failure)
{
    char pidBuff[40];
    Text prefix = (VestaConfig::get_Text("UserInterface", "TempDir") +
                   "/vup");
    // Pick a unique temporary filename
    Text res = FS::TempFname(prefix, TempSuffix);
    // Open it.
    FS::OpenForWriting(res, /*OUT*/ ofs);
    // Return the filename.
    return res;
}

static bool LimiterMatch(const Text &p_path) throw ()
/* Return true iff 'p_path' contains all of the strings in the command-line
   'limiters' as substrings. */
{
    for (int i = 0; i < limiters.size(); i++) {
        if (p_path.FindText(limiters.get(i)) < 0) return false;
    }
    return true;
}

static void Update(const Text &model, /*INOUT*/ TextSeq &localModels)
  throw (FS::DoesNotExist, FS::Failure, ParseImports::Error, 
         VestaConfig::failure, SRPC::failure)
/* Update the model named "model", which is expected to be an absolute path.
   If "doWork" is "true", then the model file is rewritten on disk. If "query"
   is true, then "doWork" is required to be true, and the program prompts the
   user on each query. If "verbose != Quiet", then messages are printed
   indicating the old/new versions of any updated imports. If a model does
   not have any updates, its name is printed only if "verbose == Verbose."
   As a side-effect (to support recursive updates), the names of any
   local models imported by "model" are appended to "localModels".

   Implementation: This function takes care of reading and parsing the
   input model, communicating update information to the user, and
   writing the revised model. The work of determining which non-local
   models require updating and the path to update to is handled by the
   NewVersion function above. */
{
    ImportSeq imports(/*sizehint=*/ 10);
    ParseImports::P(model, /*INOUT*/ imports);

    // open input file and temporary output file
    ifstream ifs;
    ofstream ofs;
    Text newModel;
    if (doWork) {
        FS::OpenReadOnly(model, /*OUT*/ ifs);
        newModel = OpenTempFile(/*OUT*/ ofs);
    }

    try {
        // write new version
        bool modelPrinted = false;
        if (verbose == Verbose) {
            cout << model << endl;
            modelPrinted = true;
        }
        bool modelChanged = false; // monotonically increasing only
        while (imports.size() > 0) {
            // skip local imports
            Import imp(*(imports.getlo()));
            delete imports.remlo();
            if (imp.local) {
                localModels.addhi(imp.path);
                continue;
            }

            // skip imports preceeded by "noupdate" pragma
            if (imp.noUpdate) continue;

            // skip imports that don't match the limiting strings (if any)
            if (!LimiterMatch(imp.path)) continue;

            // copy part of input file if necessary
            if (doWork) {
                CopyFromTo(ifs, ofs, imp.start);
                FS::Seek(ifs, imp.end);
            }

            try
              {
                // determine replacement for "imp.path"
                Text newPath, pathToWrite;
                if (NewVersion(&imp, /*OUT*/ newPath, /*OUT*/ pathToWrite)) {
                  // write report if necessary
                  if (verbose != Silent) {
                    if (!modelPrinted) {
                      cout << model << endl;
                      modelPrinted = true;
                    }
                    cout << "     " << imp.path << endl;
                    cout << "  -> " << newPath << endl;
                  }

                  // write new path
                  if (doWork) {
                    bool useNewVersion = true;
                    if (query) {
                      cout << "  Update this import (y/n)? "; cout.flush();
                      const int BuffLen = 20; char buff[BuffLen];
                      cin.getline(buff, BuffLen);
                      useNewVersion = (buff[0] == 'y');
                    }
                    ofs << (useNewVersion ? pathToWrite : imp.orig);

                    // note change was made
                    if (useNewVersion) modelChanged = true;
                  }
                  //if (verbose != Silent) cout << endl;
                } else {
                  // copy original path
                  if (doWork) ofs << imp.orig;
                }
              }
            // In the event of the kind of exception thrown by
            // VersionDir...
            catch (const ParseImports::Error &err)
              {
                // If these should be fatal, re-throw the exception.
                if(parse_errors_stop)
                  {
                    throw;
                  }
                else
                  {
                    // Report the parsing problem
                    cerr << "vupdate: " << err << endl;

                    // copy original path
                    if (doWork) ofs << imp.orig;
                  }
              }
            // Any othe exceptions we just pass on
            catch(...)
              {
                throw;
              }
        }
        if (doWork) {
            // copy the tail portion of the file
            if (modelChanged) CopyFromTo(ifs, ofs);

            // close files and rename or delete temp file
            FS::Close(ifs);
            FS::Close(ofs);
            if (modelChanged) {
                RenameTempFile(newModel, model);
            } else {
                // delete temp file
                (void)unlink(newModel.cchars());
            }
        }
    }
    catch (...) {
        // in the event of a FS exception, delete the temp file
        (void)unlink(newModel.cchars());
        // Free any remaining Import objects.
        while (imports.size() > 0)
          delete imports.remlo();
        throw;
    }
} // Update

void CheckExclusive(/*INOUT*/ bool &exclusive) throw ()
/* If "exclusive" is already "true", invoke "Syntax" with the correct error
   message. Otherwise, set "exclusive" to "true". */
{
    if (exclusive) {
        Syntax("more than one mutually exclusive argument specified");
    }
    exclusive = true;
}


int main(int argc, char *argv[]) 
{
    // parse command-line
    bool nqsExclusive = false, svExclusive = false;
    int arg;
    for (arg = 1; arg < argc && *argv[arg] == '-'; arg++) {
        char *argp = argv[arg];
        if (strncmp(argp, "--", 2) == 0) argp++;
        if (strcmp(argp, "-no-action") == 0 ||
            strcmp(argp, "-n") == 0) {
            CheckExclusive(/*INOUT*/ nqsExclusive);
            doWork = false;
        } else if (strcmp(argp, "-query") == 0 ||
                   strcmp(argp, "-q") == 0) {
            CheckExclusive(/*INOUT*/ nqsExclusive);
            query = true;
        } else if (strcmp(argp, "-silent") == 0 ||
                   strcmp(argp, "-s") == 0) {
            CheckExclusive(/*INOUT*/ nqsExclusive);
            CheckExclusive(/*INOUT*/ svExclusive);
            verbose = Silent;
        } else if (strcmp(argp, "-update-local") == 0 ||
                   strcmp(argp, "-r") == 0) {
            update_local = true;
        } else if (strcmp(argp, "-update-checkout") == 0 ||
                   strcmp(argp, "-c") == 0) {
            update_co = true;
            advance_co = true;
        } else if (strcmp(argp, "-update-all") == 0 ||
                   strcmp(argp, "-u") == 0) {
            update_local = true;
            update_co = true;
            advance_co = true;
        } else if (strcmp(argp, "-verbose") == 0 ||
                   strcmp(argp, "-v") == 0) {
            CheckExclusive(/*INOUT*/ svExclusive);
            verbose = Verbose;
        } else if (strcmp(argp, "-advance-checkout") == 0 ||
                   strcmp(argp, "-a") == 0) {
            advance_co = true;
        } else if (strcmp(argp, "-limit") == 0 ||
                   strcmp(argp, "-l") == 0) {
            // Move up one argument to get the substring argument
            arg++;
            // As long as we haven't run out of arguments...
            if (arg < argc) {
                // Add this string to the list of limiters.
                limiters.addhi(Text(argv[arg]));
            } else {
                // Complain that the user didn't give us an argument
                Syntax("-limit requires a string argument");
            }
        } else if (strcmp(argp, "-limit-checkout") == 0 ||
                   strcmp(argp, "-L") == 0) {
            // Add the string "/checkout/" to the list of limiters.
            // (Sort of a hack, but the vupdate documentation already
            // says it makes this assumption about checkout directories.)
            limiters.addhi("/checkout/");
        } else if (strcmp(argp, "-only-mine") == 0 ||
                   strcmp(argp, "-m") == 0) {
            onlyMine = true;
        } else if (strcmp(argp, "-to-checkout") == 0 ||
                   strcmp(argp, "-t") == 0) {
            toCheckout = true;
        } else if (strcmp(argp, "-attr") == 0 ||
                   strcmp(argp, "-A") == 0) {
            // Move up one argument to get the substring argument
            arg++;
            // As long as we haven't run out of arguments...
            if (arg < argc) {
                // read attribute name
                char *colon = index(argv[arg], ':');
                char *circum = index(argv[arg], '^');
                if (colon != (char *)NULL && circum != (char *)NULL) {
                    Syntax("illegal argument to '-attr' switch");
                }
                char *nextVal = (char *)NULL;
                if (colon != (char *)NULL) {
                    *colon = '\0';
                    attrMatchSense = true;
                    nextVal = colon + 1;
                } else if (circum != (char *)NULL) {
                    *circum = '\0';
                    attrMatchSense = false;
                    nextVal = circum + 1;
                }
                attrName = argv[arg];

                // parse attribute values (if any)
                if (nextVal != NULL) {
                    attrVals = NEW(TextSeq);
                    char *lastChar = nextVal + strlen(nextVal);
                    *lastChar = ','; // sentinel
                    while (nextVal <= lastChar) {
                        char *end = index(nextVal, ',');
                        *end++ = '\0'; // replace ',' with '\0'; advance
                        attrVals->addhi(Text(nextVal));
                        nextVal = end;
                    }
                }
            } else {
                // Complain that the user didn't give us an argument
                Syntax("-attr requires an attr-spec argument");
            }
        } else if (strcmp(argp, "-parse-errors-stop") == 0 ||
                   strcmp(argp, "-e") == 0) {
            parse_errors_stop = true;
        } else {
            Syntax("illegal argument", argv[arg]);
        }
    }
    if (toCheckout && attrName != (char *)NULL) {
        Syntax("-to-checkout and -attr cannot both be specified");
    }
    if (arg < argc - 1) Syntax("too many arguments");
    Text model((arg < argc) ? argv[arg] : ".main.ves");

    // get the working directory
    char wd_buff[PATH_MAX+1];
    char *res = getcwd(wd_buff, PATH_MAX+1); assert(res != (char *)NULL);
    res = strcat(wd_buff, "/"); assert(res != (char *)NULL);

    // scan the model
    try {
        // update the specified model
        TextSeq localModels(/*sizeHint=*/ 10);
        Update(ParseImports::ResolvePath(model, Text(wd_buff)),
          /*INOUT*/ localModels);

        // if "-r" was specified, update imported local models also
        if (update_local) {
            while (localModels.size() > 0) {
                model = localModels.remlo();
                Update(model, /*INOUT*/ localModels);
            }
        }
    } catch (FS::DoesNotExist) {
        cerr << "vupdate: model file does not exist" << endl;
        exit(2);
    } catch (const FS::Failure &f) {
        cerr << "vupdate: " << f << endl;
        exit(2);
    } catch (const ParseImports::Error &err) {
        cerr << "vupdate: " << err << endl;
        exit(2);
    } catch (const VestaConfig::failure &f) {
        cerr << "vupdate: " << f.msg << endl;
        exit(2);
    } catch (const SRPC::failure &f) {
        cerr << "vupdate: error contacting Vesta repository: " << f.msg <<endl;
        exit(2);
    }

    // print warning message if "-n" specified
    if (!doWork && verbose) {
        cout << "WARNING: At your request, nothing was updated!" << endl;
    }
    exit(0);
}

---