# Part of the A-A-P recipe executive: Store signatures

# 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

#
# This module handles remembering signatures of targets and sources.
#

import os
import os.path
import string

from Util import *
from Message import *

# Both "signatures" dictionaries are indexed by the name of the target Node
# (file or directory).
# For non-virtual nodes the absulute name is used.
# Each entry is a dictionary indexed by the source-name@check-name and has a
# string value.
# The "buildcheck" entry is used for the build commands.
# The "dir" entry is used to remember the sign file that stores the signatures
# for this target.
# "old_signatures" is for the signatures when we started.
# "upd_signatures" is for the signatures of items for which the build commands
# were successfully executed and are to be stored for the next time.
# Example:
# {"/aa/bb/file.o" : {  "dir" : "/aa/bb",
#                       "/aa/bb/file.c@md5" : "13a445e5",
#                       "buildcheck" : "-O2"},
#  "/aa/bb/bar.o"  : {  "dir" : "/aa/bb",
#                       "/aa/bb/bar-debug.c@time" : "143234",
#                       "aa/bb/bar.h@time" : "423421"}}
old_signatures = {}
upd_signatures = {}

# "new_signatures" caches the signatures we computed this invocation.  It is a
# dictionary of dictionaries.  The key for the toplevel dictionary is the Node
# name.  The key for the second level is the check name.  The target name isn't
# used here.
new_signatures = {}

# Name for the sign file relative to the directory of the target or the recipe.
sign_file_name = "aap/sign"

# Remember for which directories the sign file has been read.
# Also when the file couldn't actually be read, so that we remember to write
# this file when signs have been updated.
# An entry exists when the file has been read.  It's non-zero when the file
# should be written back.
sign_dirs = {}

def get_sign_file(target, update):
   """Get the sign file that is used for "target" if it wasn't done already.
      When "update" is non-zero, mark the file needs writing."""
   dir = target.get_sign_dir()
   if not sign_dirs.has_key(dir):
       sign_dirs[dir] = update
       sign_read(dir)
   elif update and not sign_dirs[dir]:
       sign_dirs[dir] = 1


# In the sign files, file names are stored with a leading "-" for a virtual
# node and "=" for a file name.  Expand to an absolute name for non-virtual
# nodes.
def sign_expand_name(dir, name):
   """Expand "name", which is used in a sign file in directory "dir"."""
   n = name[1:]
   if name[0] == '-':
       return n
   if os.path.isabs(n):
       return n
   return os.path.normpath(os.path.join(dir, n))

def sign_reduce_name(dir, name):
   """Reduce "name" to what is used in a sign file."""
   if os.path.isabs(name):
       return '=' + shorten_name(name, dir)
   return '-' + name

#
# A sign file stores the signatures for items (sources and targets) with the
# values they when they were computed in the past.
# The format of each line is:
#       =foo.o<ESC>=foo.c@md5_c=012346<ESC>...<ESC>\n
# "md5_c" can be "md5", "time", etc.  Note that it's not always equal to
# the "check" attribute, both "time" and "older" use "time" here.

def sign_read(dir):
   """Read the signature file for directory "dir" into our dictionary of
   signatures."""
   fname = os.path.join(dir, sign_file_name)
   try:
       f = open(fname, "rb")
       for line in f.readlines():
           e = string.find(line, "\033")
           if e > 0:   # Only use lines with an ESC
               name = sign_expand_name(dir, line[:e])
               old_signatures[name] = {"dir" : dir}
               while 1:
                   s = e + 1
                   e = string.find(line, "\033", s)
                   if e < 1:
                       break
                   i = string.rfind(line, "=", s, e)
                   if i < 1:
                       break
                   old_signatures[name][sign_expand_name(dir, line[s:i])] \
                                                               = line[i + 1:e]
       f.close()
   except StandardError, e:
       # TODO: handle errors?  It's not an error if the file does not exist.
       msg_warning((_('Cannot read sign file "%s": ')
                                              % shorten_name(fname)) + str(e))


def sign_write_all():
   """Write all updated signature files from our dictionary of signatures."""

   # This assumes we are the only one updating this signature file, thus there
   # is no locking.  It wouldn't make sense sharing with others, since
   # building would fail as well.
   for dir in sign_dirs.keys():
       if sign_dirs[dir]:
           # This sign file needs to be written.
           sign_write(dir)


def sign_write(dir):
   """Write one updated signature file."""
   fname = os.path.join(dir, sign_file_name)

   sign_dir = os.path.dirname(fname)
   if not os.path.exists(sign_dir):
       try:
           os.makedirs(sign_dir)
       except StandardError, e:
           msg_warning((_('Cannot create directory for signature file "%s": ')
                                                            % fname) + str(e))
   try:
       f = open(fname, "wb")
   except StandardError, e:
       msg_warning((_('Cannot open signature file for writing: "%s": '),
                                                              fname) + str(e))
       return

   def write_sign_line(f, dir, s, old, new):
       """Write a line to sign file "f" in directory "dir" for item "s", with
       checks from "old", using checks from "new" if they are present."""
       f.write(sign_reduce_name(dir, s) + "\033")

       # Go over all old checks, write all of them, using the new value
       # if it is available.
       for c in old.keys():
           if c != "dir":
               if new and new.has_key(c):
                   val = new[c]
               else:
                   val = old[c]
               f.write("%s=%s\033" % (sign_reduce_name(dir, c), val))

       # Go over all new checks, write the ones for which there is no old
       # value.
       if new:
           for c in new.keys():
               if c != "dir" and not old.has_key(c):
                   f.write("%s=%s\033" % (sign_reduce_name(dir, c), new[c]))

       f.write("\n")

   try:
       # Go over all old signatures, write all of them, using checks from
       # upd_signatures when they are present.
       # When the item is in upd_signatures, use the directory specified
       # there, otherwise use the directory of old_signatures.
       for s in old_signatures.keys():
           if upd_signatures.has_key(s):
               if upd_signatures[s]["dir"] != dir:
                   continue
               new = upd_signatures[s]
           else:
               if old_signatures[s]["dir"] != dir:
                   continue
               new = None
           write_sign_line(f, dir, s, old_signatures[s], new)


       # Go over all new signatures, write only the ones for which there is no
       # old signature.
       for s in upd_signatures.keys():
           if (not old_signatures.has_key(s)
                                         and upd_signatures[s]["dir"] == dir):
               write_sign_line(f, dir, s, upd_signatures[s], None)

       f.close()
   except StandardError, e:
       msg_warning((_('Write error for signature file "%s": '),
                                                              fname) + str(e))

def hexdigest(m):
   """Turn an md5 object into a string of hex characters."""
   # NOTE:  This routine is a method in the Python 2.0 interface
   # of the native md5 module, not in Python 1.5.
   h = string.hexdigits
   r = ''
   for c in m.digest():
       i = ord(c)
       r = r + h[(i >> 4) & 0xF] + h[i & 0xF]
   return r


def check_md5(fname):
   import md5
   try:
       f = open(fname, "rb")
       m = md5.new()
       while 1:
           # Read big blocks at a time for speed, but don't read the whole
           # file at once to reduce memory usage.
           data = f.read(32768)
           if not data:
               break
           m.update(data)
       f.close()
       res = hexdigest(m)
   except:
       # Can't open a URL here.
       # TODO: error message?
       res = "unknown"
   return res


def buildcheckstr2sign(str):
   """Compute a signature from a string for the buildcheck."""
   import md5
   return hexdigest(md5.new(str))


def _sign_lookup(signatures, name, key):
   """Get the "key" signature for item "name" from dictionary "signatures"."""
   if not signatures.has_key(name):
       return ''
   s = signatures[name]
   if not s.has_key(key):
       return ''
   return s[key]


def sign_clear(name):
   """Clear the new signatures of an item.  Used when it has been build."""
   if new_signatures.has_key(name):
       new_signatures[name] = {}


def get_new_sign(globals, name, check):
   """Get the current "check" signature for the item "name".
      "name" is the absolute name for non-virtual nodes.
      This doesn't depend on the target.  "name" can be a URL.
      Returns a string (also for timestamps)."""
   key = check
   res = _sign_lookup(new_signatures, name, key)
   if not res:
       # Compute the signature now
       # TODO: other checks!  User defined?
       if check == "time":
           from Remote import url_time
           res = str(url_time(globals, name))
       elif check == "md5":
           res = check_md5(name)
       elif check == "c_md5":
           # TODO: filter out comments en spans of white space
           res = check_md5(name)
       else:
           res = "unknown"

       # Store the new signature to avoid recomputing it many times.
       if not new_signatures.has_key(name):
           new_signatures[name] = {}
       new_signatures[name][key] = res

   return res

def sign_clear_target(target):
   """Called to clear old signatures after successfully executing build rules
      for "target".  sign_updated() should be called next for each source."""
   get_sign_file(target, 1)
   target_name = target.get_name()
   if old_signatures.has_key(target_name):
       del old_signatures[target_name]
   if upd_signatures.has_key(target_name):
       del upd_signatures[target_name]


def _sign_upd_sign(target, key, value):
   """Update signature for node "target" with "key" to "value"."""
   get_sign_file(target, 1)
   target_name = target.get_name()
   if not upd_signatures.has_key(target_name):
       upd_signatures[target_name] = {"dir": target.get_sign_dir()}
   upd_signatures[target_name][key] = value


def sign_updated(globals, name, check, target):
   """Called after successfully executing build rules for "target" from item
      "name", using "check"."""
   res = get_new_sign(globals, name, check)
   _sign_upd_sign(target, name + '@' + check, res)


def buildcheck_updated(target, value):
   """Called after successfully executing build rules for node "target" with
      the new buildcheck signature "value"."""
   _sign_upd_sign(target, '@buildcheck', value)


def get_old_sign(name, check, target):
   """Get the old "check" signature for item "name" and target node "target".
      If it doesn't exist an empty string is returned."""
   get_sign_file(target, 0)
   key = name + '@' + check
   return _sign_lookup(old_signatures, target.get_name(), key)

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