Files.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: Files.C                                               */

#include "Files.H"
#include "EvalBasics.H"
#include "ModelState.H"
#include "Err.H"
#include <ReposUI.H>
#include <Replicator.H>

using std::fstream;
using std::cout;
using std::cerr;
using std::endl;

extern "C" {void *opendir(const char *);}
extern "C" {int closedir(void *);}

const char UnixDelimiter = '/';

bool IsDelimiter(const char c) {
  return (c == '/' || c == '\\');
}

Text Canonical(const Text& path) {
  // Platform-dependent.  Take a Vesta path (with either kind of
  // delimiter) and convert to the appropriate delimiter for the
  // underlying file system.
  int len = path.Length();
  const char *p = path.cchars();
  char *s = NEW_PTRFREE_ARRAY(char, len+1);
  int i;

  for (i = 0; i < len; i++) {
    if (IsDelimiter(p[i])) s[i] = UnixDelimiter;
    else s[i] = p[i];
  }
  s[i] = 0;
  return Text(s);
}
  
Text setSuffix(const Text& s, const Text& suff) {
  bool sf = false;

  if (s == "/dev/null") return s;   // hack: Unix only
  for (int i = 0; i < s.Length(); i++) {
    if (s[i] == '.') sf = true;
    else if (IsDelimiter(s[i])) sf = false;
  }
  return (sf) ? s : s + suff;
}

bool IsAbsolutePath(const Text& path) {
  return !path.Empty() && IsDelimiter(path[0]);
}

void SplitPath(const Text& path, Text& prefix, Text& name) {
  int n = path.Length() - 1; 
  while (n >= 0 && !IsDelimiter(path[n])) n--;
  prefix = path.Sub(0, n+1);
  name = path.Sub(n+1);
  return;
}

VestaSource::errorCode LookupPath(const Text& path, VestaSource *mRoot,
                                  VestaSource*& newRoot) {
  Text relPath;
  VestaSource *tempRoot;
  VestaSource::errorCode code = VestaSource::ok;

  if (IsAbsolutePath(path)) {
    int i = 1;
    while (!IsDelimiter(path[i]) && i < path.Length()) i++;
    relPath = path.Sub(i+1);  // strip off first arc
    tempRoot = rRoot;
  }
  else {
    relPath = path;
    tempRoot = mRoot;
  }
  if (relPath.Empty())
    newRoot = tempRoot;
  else {
    code = tempRoot->lookupPathname(relPath.cchars(), newRoot);
    if((code == VestaSource::notFound) && autoRepl) {
      if(ReplicateMissing(tempRoot, relPath, newRoot)) 
        code = VestaSource::ok;
    }  
  }
  return code;
}

// Split up a whitespace-delimited set of main model names to try in
// sequence.
TextSeq SplitDefaultMains(const Text& defaultmain) throw()
{
  TextSeq l_result;
  // Start at the beginning and go until we run out of text.
  unsigned int l_i = 0;
  while(l_i < defaultmain.Length())
    {
      // Remember where we started.
      unsigned int l_start = l_i;
      // Skip forward until we rech whictespace or the end of the
      // string.
      while(!isspace(defaultmain[l_i]) &&
            (l_i < defaultmain.Length()))
        {
          l_i++;
        }
      // If we found a non-whitespace chunk, add that to the list.
      if(l_i > l_start)
        {
          l_result.addhi(defaultmain.Sub(l_start, (l_i - l_start)));
        }
      // Skip over any whitespace after the filename.
      while(isspace(defaultmain[l_i]) &&
            (l_i < defaultmain.Length()))
        {
          l_i++;
        }
    }
  // Return the collected filenames.
  return l_result;
}

// Try a sequence of default model names in order.  Return the first
// one that exists.
Text FindExistingModel(const TextSeq &p_defaults, const Text& p_dir = "")
{
  Text l_result;
  // Try the default model names in sequence.
  for(unsigned int l_i = 0; l_i < p_defaults.size(); l_i++)
    {
      l_result = p_dir + p_defaults.get(l_i);
      // If this one exists, accept it.
      if(FS::Exists(l_result))
        {
          break;
        }
    }
  return l_result;
}

Text MainModel(const Text& filename, const Text& defaultmain) {
  Text modelname(Canonical(filename));
  TextSeq l_defaults = SplitDefaultMains(defaultmain);
  if(modelname.Length() == 0)
    {
      // No model was specified.  Chose a default in the current
      // working directory.
      modelname = FindExistingModel(l_defaults);
    }
  else
    {
      char c = modelname[modelname.Length()-1];
      if (IsDelimiter(c))
        {
          // Assume it's a directory and append the default model
          // name.
          modelname = FindExistingModel(l_defaults, modelname);
        }
      else
        {
          // See if this is a directory.
          void *d = opendir(modelname.cchars());
          if (d == NULL)
            {
              // Not a directory, assume it's a file.  Make sure it
              // has the right suffix.
              modelname = setSuffix(modelname, ".ves");
            }
          else
            {
              (void)closedir(d);
              // A directory was specified, append the default model
              // name.
              modelname = FindExistingModel(l_defaults,
                                            modelname + PathnameSep);
            }
        }
    }
  return modelname;
}

bool IsDirectory(VestaSource *mRoot, Text& path, VestaSource*& vSource,
                 VestaSource::errorCode& vSourceErr) {
  vSourceErr = LookupPath(path, mRoot, vSource);
  return (vSourceErr == VestaSource::ok &&
          vSource->type != VestaSource::immutableFile &&
          vSource->type != VestaSource::mutableFile);
}

bool OpenSource(VestaSource *mRoot, const Text& fname, SrcLoc *loc,
                fstream*& iFile, VestaSource*& newRoot, ShortId& shortId,
                VestaSource*& vSource) {
  Text prefix, tail;
  VestaSource::errorCode err;

  shortId = NullShortId;
  SplitPath(fname, prefix, tail);
  err = LookupPath(prefix, mRoot, newRoot);
  if(err != VestaSource::ok) {
    outputMu.lock();      
    Error(VestaSourceErrorMsg(err) + " opening directory `" + prefix + "'.\n",
          loc);
    outputMu.unlock();      
    return false;
  }
  err = newRoot->lookup(tail.cchars(), vSource);
  if (err != VestaSource::ok) {
    outputMu.lock();      
    Error(VestaSourceErrorMsg(err) + " opening `" + fname + "'.\n", loc);
    outputMu.unlock();      
    return false;
  }
  iFile = NULL;
  shortId = vSource->shortId();
  return true;
}

bool ReplicateMissing(VestaSource* root, const Text& name, 
                      /*OUT*/VestaSource*& vSource)
{
  assert(autoRepl);
  if(!RootLongId.isAncestorOf(root->longid))
    return false;
  try {
    Text path = ReposUI::vsToFilename(root) + "/" + name;
    const int vlen = 7; // ==strlen("/vesta/")

    outputMu.lock();
    cout << "Trying to find a copy of " << path << endl; 
    outputMu.unlock(); 

    Text defhints;
    (void) VestaConfig::get("UserInterface", "DefaultHints", defhints);
    VestaSource* real_source = ReposUI::filenameToRealVS(path, defhints);
    
    outputMu.lock();
    cout << "Replicating " << path << " from "
         << real_source->host() << ":" << real_source->port() << endl;
    outputMu.unlock(); 

    Replicator repl(real_source->host(), real_source->port(), 
                    rRoot->host(), rRoot->port());
    Replicator::Directive d('+', path.Sub(vlen));
    Replicator::DirectiveSeq direcs;
    direcs.addhi(d);
    Replicator::Flags flags = (Replicator::Flags) 
      (Replicator::attrNew | Replicator::attrOld | Replicator::attrAccess |
       Replicator::revive | Replicator::inclStubs | Replicator::latest);
    repl.replicate(&direcs, flags);
    vSource = ReposUI::filenameToVS(path, rRoot->host(), rRoot->port());
    delete real_source;
    return true;
  }
  catch(ReposUI::failure f){
    outputMu.lock();
    cerr << "ReposUI failure during replication of " << name << ": "
         << f.msg << endl;
    outputMu.unlock();
    return false;
  }
  catch(VestaConfig::failure f){
    outputMu.lock();
    cerr << "VestaConfig failure during replication of " << name << ": "
         << f.msg << endl;
    outputMu.unlock();
    return false;
  }
  catch(SRPC::failure f){
    outputMu.lock();
    cerr << "SRPC failure during replication of " << name << ": "
         << f.msg << " (" << f.r << ")" << endl;
    outputMu.unlock();
    return false;
  }
  catch(Replicator::Failure f){
    if(f.code == (VestaSource::errorCode) -1) {
      outputMu.lock();
      cerr << "Failure during replication of " << name << ": " << f.msg << endl;
      outputMu.unlock();
    } 
    else {
      outputMu.lock();
      cerr << "Failure during replication of " << name << ": " 
           << ReposUI::errorCodeText(f.code) << ", " << f.msg << endl;
      outputMu.unlock();
    }
    return false;
  }
}

---