# Part of the A-A-P recipe executive: CVS access

# Copyright (C) 2002 Stichting NLnet Labs
# Permission to copy and use this file is specified in the file COPYING.
# If this file is missing you can find it here: http://www.a-a-p.org/COPYING

#
# Functions to get files out of a CVS repository and put them back.
# See interface.txt for an explanation of what each function does.
#

import string
import os
import os.path

from Error import *
from Message import *
from Util import *

def cvs_command(server, url_dict, nodelist, action):
   """Handle CVS command "action".
      Return non-zero when it worked."""
   # Since CVS doesn't do locking, quite a few commands can be simplified:
   if action == "refresh":
       action = "checkout"    # "refresh" is exactly the same as "checkout"
   elif action in [ "checkin", "publish" ]:
       action = "commit"   # "checkin" and "publish" are the same as "commit"
   elif action == "unlock":
       return 1            # unlocking is a no-op

   # TODO: Should group nodes in the same directory together and do them all
   # at once.
   res = 1
   for node in nodelist:
       if cvs_command_node(server, url_dict, node, action) == 0:
           res = 0
   return res


def cvs_command_node(server, url_dict, node, action):
   """Handle CVS command for one node."""

   if not server:
       # Obtain the previously used CVSROOT from CVS/Root.
       # There are several of these files that contain the same info, just use
       # the one in the current directory.
       try:
           f = open("CVS/Root")
       except StandardError, e:
           msg_warning(_('Cannot open for obtaining CVSROOT: "CVS/Root"')
                                                                     + str(e))
       else:
           try:
               server = f.readline()
               f.close()
           except StandardError, e:
               msg_warning(_('Cannot read for obtaining CVSROOT: "CVS/Root"')
                                                                     + str(e))
               server = ''     # in case something was read
           else:
               if server[-1] == '\n':
                   server = server[:-1]
   if server:
       serverarg = "-d" + server
   else:
       serverarg = ''


   msg_info(_('CVS %s for node "%s"') % (action, node.short_name()))

   # A "checkout" only works reliably when in the top directory  of the
   # module.
   # "add" must be done in the current directory of the file.
   # Change to the directory where "path" + "node.name" is valid.
   # Use node.recipe_dir and take off one part for each part in "path".
   # Try to obtain the path from the CVS/Repository file.
   if os.path.isdir(node.absname):
       node_dir = node.absname
   else:
       node_dir = os.path.dirname(node.absname)

   if action == "checkout":
       cvspath = ''
       if url_dict.has_key("path"):
           # Use the specified "path" attribute.
           cvspath = url_dict["path"]
           dir_for_path = node.recipe_dir
       else:
           dir_for_path = node_dir
           fname = os.path.join(dir_for_path, "CVS/Repository")
           try:
               f = open(fname)
           except StandardError, e:
               msg_warning((_('Cannot open for obtaining path in module: "%s"')
                                                                % fname) + str(e))
               return 0
           try:
               cvspath = f.readline()
               f.close()
           except StandardError, e:
               msg_warning((_('Cannot read for obtaining path in module: "%s"')
                                                                % fname) + str(e))
               return 0
           if cvspath[-1] == '\n':
               cvspath = cvspath[:-1]

       dir = dir_for_path
       path = cvspath
       while path:
           if os.path.basename(dir) != os.path.basename(path):
               msg_warning(_('mismatch between path in cvs:// and tail of recipe directory: "%s" and "%s"') % (cvspath, dir_for_path))
           ndir = os.path.dirname(dir)
           if ndir == dir:
               msg_error(_('path in cvs:// is longer than recipe directory: "%s" and "%s"') % (cvspath, dir_for_path))
           dir = ndir
           npath = os.path.dirname(path)
           if npath == path:   # just in case: avoid getting stuck
               break
           path = npath
   else:
       dir = node_dir

   cwd = os.getcwd()
   if cwd == dir:
       cwd = ''        # we're already there, avoid a chdir()
   else:
       try:
           os.chdir(dir)
       except StandardError, e:
           msg_warning((_('Could not change to directory "%s"') % dir)
                                                                     + str(e))
           return 0

   # Use the specified "logentry" attribute or generate a message.
   if url_dict.has_key("logentry"):
       logentry = url_dict["logentry"]
   else:
       logentry = "Done by A-A-P"

   node_name = node.short_name()

   tmpname = ''
   if action == "remove" and os.path.exists(node_name):
       # CVS refuses to remove a file that still exists, temporarily rename
       # it.  Careful: must always move it back when an exception is thrown!
       assert_aap_dir()
       tmpname = os.path.join("aap", node_name)
       try:
           os.rename(node_name, tmpname)
       except:
           tmpname = ''

   # TODO: quoting and escaping special characters
   try:
       res = exec_cvs_cmd(serverarg, action, logentry, node_name)

       # For a remove we must commit it now, otherwise the local file will be
       # deleted when doing it later.  To be consistent, also do it for "add".
       if not res and action in [ "remove", "add" ]:
           res = exec_cvs_cmd(serverarg, "commit", logentry, node_name)
   finally:
       if tmpname:
           try:
               os.rename(tmpname, node_name)
           except StandardError, e:
               msg_error((_('Could not move file "%s" back to "%s"')
                                             % (tmpname, node_name)) + str(e))

       if cwd:
           try:
               os.chdir(cwd)
           except StandardError, e:
               msg_error((_('Could not go back to directory "%s"')
                                                              % cwd) + str(e))

   if res != 0:
       return 0

   # TODO: how to check if it really worked?
   return 1


def exec_cvs_cmd(serverarg, action, logentry, node_name):
   """Execute the CVS command for "action".  Handle failure."""

   if action == "commit":
       # If the file was never added to the repository we need to add it.
       # Since most files will exist in the repository, trying to commit and
       # handling the error is the best method.
       tmpfile = tempfname()
       try:
           cmd = ("cvs %s commit -m '%s' %s 2>&1 | tee %s"
                                  % (serverarg, logentry, node_name, tmpfile))
           msg_system(cmd)
           res = os.system(cmd)
       except:
           res = 1

       # Read the output of the command, also when it failed.
       text = ''
       try:
           f = open(tmpfile)
           text = f.read()
           f.close()
       except StandardError, e:
           msg_warning(_('Reading output of "cvs commit" failed: ') + str(e))
           res = 1
       if text:
           msg_log(text, msgt_result)
           # If the file was never in the repository CVS says "nothing known
           # about".  If it was there before "use `cvs add' to create an
           # entry".
           if not res and (string.find(text, "nothing known about") >= 0
                                        or string.find(text, "cvs add") >= 0):
               res = 1

       # always remove the tempfile, even when system() failed.
       try:
           os.remove(tmpfile)
       except:
           pass

       if not res:
           return 0

       try:
           msg_info(_("File does not appear to exist in repository, adding it"))
           logged_system("cvs %s add %s" % (serverarg, node_name))
       except StandardError, e:
           msg_warning(_('Adding file failed: ') + str(e))


   if action == "commit":
       return logged_system("cvs %s commit -m '%s' %s"
                                           % (serverarg, logentry, node_name))
   return logged_system("cvs %s %s %s" % (serverarg, action, node_name))


def cvs_list(name, commit_item, dirname, recursive):
   """Obtain a list of items in CVS for directory "dirname".
      Recursively entry directories if "recursive" is non-zero.
      "name" is not used, we don't access the server."""
   # We could use "cvs status" to obtain the actual entries in the repository,
   # but that is slow and the output is verbose and hard to parse.
   # Instead read the "CVS/Entries" file.  A disadvantage is that we might
   # list a file that is actually already removed from the repository if
   # another user removed it.
   fname = os.path.join(dirname, "CVS/Entries")
   try:
       f = open(fname)
   except StandardError, e:
       raise UserError, (_('Cannot open "%s": ') % fname) + str(e)
   try:
       lines = f.readlines()
       f.close()
   except StandardError, e:
       raise UserError, (_('Cannot read "%s": ') % fname) + str(e)

   # The format of the lines is:
   #   D/dirname////
   #   /itemname/vers/foo//
   # We only need to extract "dirname" or "itemname".
   res = []
   for line in lines:
       s = string.find(line, "/")
       if s < 0:
           continue
       s = s + 1
       e = string.find(line, "/", s)
       if e < 0:
           continue
       item = os.path.join(dirname, line[s:e])

       if line[0] == 'D' and recursive:
           res.extend(cvs_list(name, commit_item, item, 1))
       else:
           res.append(item)

   return res



# vim: set sw=4 sts=4 tw=79 fo+=l:

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.