"""Print the time in the requested format. T is a dfxml time value"""

global options

if t is None:

return None

elif "options" in globals() and options.timestamp:

return str(t.timestamp())

else:

if options.html:

print("""<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN http://www.w3.org/TR/html4/loose.dtd">

global options

if "options" in globals() and options.html:

print("<h1>%s</h1>" % title)

return

global options

if "options" in globals() and options.html:

print("<h2>%s</h2>" % title)

return

import sys

global options

def alldigits(x):

if type(x)!=str: return False

for ch in x:

if ch.isdigit()==False: return False

return True

def fmt(x):

if x==None: return ""

if type(x)==int or alldigits(x):

return "{0:>12}".format(x)

return str(x)

if "options" in globals() and options.html:

print("<table>")

for row in rows:

print("<tr>")

if not styles:

styles = [""]*len(rows)

for (col,style) in zip(row,styles):

sys.stdout.write("<td class='%s'>%s</td>" % (style,col))

print("<tr>")

print("</table>")

return

lastRowCol0 = None

for row in rows:

# Insert a blank line if this row[0] is not the same as last row[0]

if row[0]!=lastRowCol0 and break_on_change:

sys.stdout.write("\n")

lastRowCol0 = row[0]

# Write the row.

# This won't generate a unicode encoding error because the strings are valid unicode.

sys.stdout.write("\t".join([fmt(col) for col in row]))

global options

def __init__(self,notimeline=False):

self.new_cnames = dict() # maps from cell full path -> cell

self.notimeline = notimeline

self.next()

def next(self):

"""Called when the next image is processed."""

self.cnames = self.new_cnames

self.new_cnames = dict()

self.new_files = set() # set of file objects

self.changed_content = set() # set of (oldfile,newfile) file objects

self.changed_properties = set() # list of (oldfile,newfile) file objects

if self.notimeline:

self.timeline = None

else:

self.timeline = set()

def process_cell(self,cell):

dprint("processing %s" % str(cell))

# See if the filename changed its hash code

changed = False

# Remember the file for the next generation

self.new_cnames[cell.full_path()] = cell

#new_inodes from idifference translates to ... well, there is no 'inode' in the Registry. There's hive identifier and full path. Values are small and thus more likely to appear in multiple places. Skip translating

# See if this filename changed or was resized

ocell = self.cnames.get(cell.full_path(),None)

if ocell:

dprint(" found ocell: " + cell.full_path())

if ocell.sha1()!=cell.sha1():

dprint(" >>> sha1 changed")

self.changed_content.add((ocell,cell))

if ocell.mtime() != cell.mtime():

dprint(" >>> Mtime changed")

self.changed_properties.add((ocell,cell))

elif ocell.type() != cell.type():

dprint(" >>> Cell content type changed")

self.changed_properties.add((ocell,cell))

elif type(ocell) != type(cell):

dprint(" >>> Cell structural type changed")

self.changed_properties.add((ocell,cell))

elif ( (ocell.parent_key and ocell.parent_key.mtime()) or None ) != ( (cell.parent_key and cell.parent_key.mtime()) or None ):

dprint(" >>> Parent mtimes changed")

self.changed_properties.add((ocell,cell))

# If a new file, note that (and optionally add to the timeline)

if not ocell:

self.new_files.add(cell)

if self.timeline:

modify_time = cell.mtime()

self.timeline.add((modify_time,cell.full_path(),"modified"))

# Delete files we have seen (so we can find out the files that were deleted)

if cell.full_path() in self.cnames:

del self.cnames[cell.full_path()]

def process(self,fname):

self.current_fname = fname

if fname.endswith(".regxml"):

reader = dfxml.read_regxml(xmlfile=open(fname,'rb'), callback=self.process_cell)

def print_cells(self,title,cells):

h2(title)

def cdate(cell):

try:

return str(ptime(cell.mtime()))

except TypeError:

return "n/a"

res = [(cdate(cell),cell.full_path()) for cell in cells]

if res:

table(sorted(res))

def print_cell2(self,title,cell2s):

def prtime(t):

return "%d (%s)" % (t,ptime(t))

h2(title)

res = set()

for(ocell,cell) in cell2s:

if ocell.sha1() != cell.sha1():

res.add((ocell.full_path(),"SHA1 changed",ocell.sha1(),"->",cell.sha1()))

if self.timeline: self.timeline.add((cell.mtime(),cell.full_path(),"SHA1 changed",ocell.sha1(),"->",cell.sha1()))

if ocell.mtime() != cell.mtime():

res.add((ocell.full_path(),"mtime changed",ptime(ocell.mtime()),"->",ptime(cell.mtime())))

if self.timeline: self.timeline.add((cell.mtime(),cell.full_path(),"mtime changed",prtime(ocell.mtime()),"->",prtime(cell.mtime())))

if ocell.type() != cell.type():

res.add((ocell.full_path(),"cell type changed",ocell.type(),"->",cell.type()))

if self.timeline: self.timeline.add((cell.mtime(),cell.full_path(),"cell type changed",prtime(ocell.mtime()),"->",prtime(cell.mtime())))

if res:

table(sorted(res),break_on_change=True)

def print_timeline(self):

prt = []

# Make the dates printable

for line in sorted(self.timeline):

prt.append([ptime(line[0])]+list(line[1:]))

h2("Timeline")

table(prt)

def report(self):

header()

h1("RegXML file:"+self.current_fname)

self.print_cells("New Files:",self.new_files)

self.print_cells("Deleted Files:",self.cnames.values())

self.print_cell2("Files with modified content:",self.changed_content)

self.print_cell2("Files with changed file properties:",self.changed_properties)

if self.timeline: self.print_timeline()

def output_archive(self,tarname=None,zipname=None):

"""Write the changed and/or new files to a tarfile or a ZIP file. """

import zipfile, tarfile, StringIO, datetime

tfile = None

zfile = None

to_archive = self.new_files.copy()

to_archive = to_archive.union(set([val[1] for val in self.changed_content]))

to_archive = to_archive.union(set([val[1] for val in self.changed_properties]))

if len(to_archive)==0:

print("No archive created, as no allocated files created or modified")

return

if tarname:

print(">>> Creating tar file: %s" % tarname)

tfile = tarfile.TarFile(tarname,mode="w")

if zipname:

print(">>> Creating zip file: %s" % zipname)

zfile = zipfile.ZipFile(zipname,mode="w",allowZip64=True)

files_written=set()

content_error_log = []

for fi in to_archive:

filename = fi.filename()

fncount = 1

while filename in files_written:

filename = "%s.%d" % (fi.filename(),fnperm)

fncount+= 1

contents = None

try:

contents = fi.contents(imagefile)

except ValueError as ve:

if ve.message.startswith("icat error"):

#Some files cannot be recovered, even from images that do not seem corrupted; log the icat command that failed.

content_error_log.append(ve.message)

else:

#This is a more interesting error, so have process die to report immediately.

raise

if contents:

if tfile:

info = tarfile.TarInfo(name=filename)

info.mtime = fi.mtime()

info.atime = fi.atime()

info.ctime = fi.ctime()

info.uid = fi.uid()

info.gid = fi.gid()

info.size = fi.filesize()

# addfile requires a 'file', so let's make one

string = StringIO.StringIO()

string.write(contents)

string.seek(0)

tfile.addfile(tarinfo=info,fileobj=string)

if zfile:

mtimestamp = fi.mtime().timestamp()

info = zipfile.ZipInfo(filename)

if mtimestamp:

#mtime might be null

info.date_time = datetime.datetime.fromtimestamp(mtimestamp).utctimetuple()

info.internal_attr = 1

info.external_attr = 2175008768 # specifies mode 0644

zfile.writestr(info,contents)

if tfile: tfile.close()

if zfile: zfile.close()

if len(content_error_log) > 0:

sys.stderr.write("Errors retrieving file contents:\n")

sys.stderr.write("\n".join(content_error_log))