buildtools/scripts/change-svn-wc-format.py

   1 #!/usr/bin/env python
   2 #
   3 # change-svn-wc-format.py: Change the format of a Subversion working copy.
   4 #
   5 # ====================================================================
   6 #    Licensed to the Subversion Corporation (SVN Corp.) under one
   7 #    or more contributor license agreements.  See the NOTICE file
   8 #    distributed with this work for additional information
   9 #    regarding copyright ownership.  The SVN Corp. licenses this file
  10 #    to you under the Apache License, Version 2.0 (the
  11 #    "License"); you may not use this file except in compliance
  12 #    with the License.  You may obtain a copy of the License at
  13 #
  14 #      http://www.apache.org/licenses/LICENSE-2.0
  15 #
  16 #    Unless required by applicable law or agreed to in writing,
  17 #    software distributed under the License is distributed on an
  18 #    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  19 #    KIND, either express or implied.  See the License for the
  20 #    specific language governing permissions and limitations
  21 #    under the License.
  22 # ====================================================================
  23
  24 import sys
  25 import os
  26 import getopt
  27 try:
  28   my_getopt = getopt.gnu_getopt
  29 except AttributeError:
  30   my_getopt = getopt.getopt
  31
  32 ### The entries file parser in subversion/tests/cmdline/svntest/entry.py
  33 ### handles the XML-based WC entries file format used by Subversion
  34 ### 1.3 and lower.  It could be rolled into this script.
  35
  36 LATEST_FORMATS = { "1.4" : 8,
  37                    "1.5" : 9,
  38                    "1.6" : 10,
  39                    # Do NOT add format 11 here.  See comment in must_retain_fields
  40                    # for why.
  41                  }
  42
  43 def usage_and_exit(error_msg=None):
  44   """Write usage information and exit.  If ERROR_MSG is provide, that
  45   error message is printed first (to stderr), the usage info goes to
  46   stderr, and the script exits with a non-zero status.  Otherwise,
  47   usage info goes to stdout and the script exits with a zero status."""
  48   progname = os.path.basename(sys.argv[0])
  49
  50   stream = error_msg and sys.stderr or sys.stdout
  51   if error_msg:
  52     stream.write("ERROR: %s\n\n" % error_msg)
  53   stream.write("""\
  54 usage: %s WC_PATH SVN_VERSION [--verbose] [--force] [--skip-unknown-format]
  55        %s --help
  56
  57 Change the format of a Subversion working copy to that of SVN_VERSION.
  58
  59   --skip-unknown-format    : skip directories with unknown working copy
  60                              format and continue the update
  61
  62 """ % (progname, progname))
  63   stream.flush()
  64   sys.exit(error_msg and 1 or 0)
  65
  66 def get_adm_dir():
  67   """Return the name of Subversion's administrative directory,
  68   adjusted for the SVN_ASP_DOT_NET_HACK environment variable.  See
  69   <http://svn.collab.net/repos/svn/trunk/notes/asp-dot-net-hack.txt>
  70   for details."""
  71   return "SVN_ASP_DOT_NET_HACK" in os.environ and "_svn" or ".svn"
  72
  73 class WCFormatConverter:
  74   "Performs WC format conversions."
  75   root_path = None
  76   error_on_unrecognized = True
  77   force = False
  78   verbosity = 0
  79
  80   def write_dir_format(self, format_nbr, dirname, paths):
  81     """Attempt to write the WC format FORMAT_NBR to the entries file
  82     for DIRNAME.  Throws LossyConversionException when not in --force
  83     mode, and unconvertable WC data is encountered."""
  84
  85     # Avoid iterating in unversioned directories.
  86     if not (get_adm_dir() in paths):
  87       del paths[:]
  88       return
  89
  90     # Process the entries file for this versioned directory.
  91     if self.verbosity:
  92       print("Processing directory '%s'" % dirname)
  93     entries = Entries(os.path.join(dirname, get_adm_dir(), "entries"))
  94     entries_parsed = True
  95     if self.verbosity:
  96       print("Parsing file '%s'" % entries.path)
  97     try:
  98       entries.parse(self.verbosity)
  99     except UnrecognizedWCFormatException, e:
 100       if self.error_on_unrecognized:
 101         raise
 102       sys.stderr.write("%s, skipping\n" % e)
 103       sys.stderr.flush()
 104       entries_parsed = False
 105
 106     if entries_parsed:
 107       format = Format(os.path.join(dirname, get_adm_dir(), "format"))
 108       if self.verbosity:
 109         print("Updating file '%s'" % format.path)
 110       format.write_format(format_nbr, self.verbosity)
 111     else:
 112       if self.verbosity:
 113         print("Skipping file '%s'" % format.path)
 114
 115     if self.verbosity:
 116       print("Checking whether WC format can be converted")
 117     try:
 118       entries.assert_valid_format(format_nbr, self.verbosity)
 119     except LossyConversionException, e:
 120       # In --force mode, ignore complaints about lossy conversion.
 121       if self.force:
 122         print("WARNING: WC format conversion will be lossy. Dropping "\
 123               "field(s) %s " % ", ".join(e.lossy_fields))
 124       else:
 125         raise
 126
 127     if self.verbosity:
 128       print("Writing WC format")
 129     entries.write_format(format_nbr)
 130
 131   def change_wc_format(self, format_nbr):
 132     """Walk all paths in a WC tree, and change their format to
 133     FORMAT_NBR.  Throw LossyConversionException or NotImplementedError
 134     if the WC format should not be converted, or is unrecognized."""
 135     for dirpath, dirs, files in os.walk(self.root_path):
 136       self.write_dir_format(format_nbr, dirpath, dirs + files)
 137
 138 class Entries:
 139   """Represents a .svn/entries file.
 140
 141   'The entries file' section in subversion/libsvn_wc/README is a
 142   useful reference."""
 143
 144   # The name and index of each field composing an entry's record.
 145   entry_fields = (
 146     "name",
 147     "kind",
 148     "revision",
 149     "url",
 150     "repos",
 151     "schedule",
 152     "text-time",
 153     "checksum",
 154     "committed-date",
 155     "committed-rev",
 156     "last-author",
 157     "has-props",
 158     "has-prop-mods",
 159     "cachable-props",
 160     "present-props",
 161     "conflict-old",
 162     "conflict-new",
 163     "conflict-wrk",
 164     "prop-reject-file",
 165     "copied",
 166     "copyfrom-url",
 167     "copyfrom-rev",
 168     "deleted",
 169     "absent",
 170     "incomplete",
 171     "uuid",
 172     "lock-token",
 173     "lock-owner",
 174     "lock-comment",
 175     "lock-creation-date",
 176     "changelist",
 177     "keep-local",
 178     "working-size",
 179     "depth",
 180     "tree-conflicts",
 181     "file-external",
 182   )
 183
 184   # The format number.
 185   format_nbr = -1
 186
 187   # How many bytes the format number takes in the file.  (The format number
 188   # may have leading zeroes after using this script to convert format 10 to
 189   # format 9 -- which would write the format number as '09'.)
 190   format_nbr_bytes = -1
 191
 192   def __init__(self, path):
 193     self.path = path
 194     self.entries = []
 195
 196   def parse(self, verbosity=0):
 197     """Parse the entries file.  Throw NotImplementedError if the WC
 198     format is unrecognized."""
 199
 200     input = open(self.path, "r")
 201
 202     # Read WC format number from INPUT.  Validate that it
 203     # is a supported format for conversion.
 204     format_line = input.readline()
 205     try:
 206       self.format_nbr = int(format_line)
 207       self.format_nbr_bytes = len(format_line.rstrip()) # remove '\n'
 208     except ValueError:
 209       self.format_nbr = -1
 210       self.format_nbr_bytes = -1
 211     if not self.format_nbr in LATEST_FORMATS.values():
 212       raise UnrecognizedWCFormatException(self.format_nbr, self.path)
 213
 214     # Parse file into individual entries, to later inspect for
 215     # non-convertable data.
 216     entry = None
 217     while True:
 218       entry = self.parse_entry(input, verbosity)
 219       if entry is None:
 220         break
 221       self.entries.append(entry)
 222
 223     input.close()
 224
 225   def assert_valid_format(self, format_nbr, verbosity=0):
 226     if verbosity >= 2:
 227       print("Validating format for entries file '%s'" % self.path)
 228     for entry in self.entries:
 229       if verbosity >= 3:
 230         print("Validating format for entry '%s'" % entry.get_name())
 231       try:
 232         entry.assert_valid_format(format_nbr)
 233       except LossyConversionException:
 234         if verbosity >= 3:
 235           sys.stderr.write("Offending entry:\n%s\n" % entry)
 236           sys.stderr.flush()
 237         raise
 238
 239   def parse_entry(self, input, verbosity=0):
 240     "Read an individual entry from INPUT stream."
 241     entry = None
 242
 243     while True:
 244       line = input.readline()
 245       if line in ("", "\x0c\n"):
 246         # EOF or end of entry terminator encountered.
 247         break
 248
 249       if entry is None:
 250         entry = Entry()
 251
 252       # Retain the field value, ditching its field terminator ("\x0a").
 253       entry.fields.append(line[:-1])
 254
 255     if entry is not None and verbosity >= 3:
 256       sys.stdout.write(str(entry))
 257       print("-" * 76)
 258     return entry
 259
 260   def write_format(self, format_nbr):
 261     # Overwrite all bytes of the format number (which are the first bytes in
 262     # the file).  Overwrite format '10' by format '09', which will be converted
 263     # to '9' by Subversion when it rewrites the file.  (Subversion 1.4 and later
 264     # ignore leading zeroes in the format number.)
 265     assert len(str(format_nbr)) <= self.format_nbr_bytes
 266     format_string = '%0' + str(self.format_nbr_bytes) + 'd'
 267
 268     os.chmod(self.path, 0600)
 269     output = open(self.path, "r+", 0)
 270     output.write(format_string % format_nbr)
 271     output.close()
 272     os.chmod(self.path, 0400)
 273
 274 class Entry:
 275   "Describes an entry in a WC."
 276
 277   # Maps format numbers to indices of fields within an entry's record that must
 278   # be retained when downgrading to that format.
 279   must_retain_fields = {
 280       # Not in 1.4: changelist, keep-local, depth, tree-conflicts, file-externals
 281       8  : (30, 31, 33, 34, 35),
 282       # Not in 1.5: tree-conflicts, file-externals
 283       9  : (34, 35),
 284       10 : (),
 285       # Downgrading from format 11 (1.7-dev) to format 10 is not possible,
 286       # because 11 does not use has-props and cachable-props (but 10 does).
 287       # Naively downgrading in that situation causes properties to disappear
 288       # from the wc.
 289       #
 290       # Downgrading from the 1.7 SQLite-based format to format 10 is not
 291       # implemented.
 292       }
 293
 294   def __init__(self):
 295     self.fields = []
 296
 297   def assert_valid_format(self, format_nbr):
 298     "Assure that conversion will be non-lossy by examining fields."
 299
 300     # Check whether lossy conversion is being attempted.
 301     lossy_fields = []
 302     for field_index in self.must_retain_fields[format_nbr]:
 303       if len(self.fields) - 1 >= field_index and self.fields[field_index]:
 304         lossy_fields.append(Entries.entry_fields[field_index])
 305     if lossy_fields:
 306       raise LossyConversionException(lossy_fields,
 307         "Lossy WC format conversion requested for entry '%s'\n"
 308         "Data for the following field(s) is unsupported by older versions "
 309         "of\nSubversion, and is likely to be subsequently discarded, and/or "
 310         "have\nunexpected side-effects: %s\n\n"
 311         "WC format conversion was cancelled, use the --force option to "
 312         "override\nthe default behavior."
 313         % (self.get_name(), ", ".join(lossy_fields)))
 314
 315   def get_name(self):
 316     "Return the name of this entry."
 317     return len(self.fields) > 0 and self.fields[0] or ""
 318
 319   def __str__(self):
 320     "Return all fields from this entry as a multi-line string."
 321     rep = ""
 322     for i in range(0, len(self.fields)):
 323       rep += "[%s] %s\n" % (Entries.entry_fields[i], self.fields[i])
 324     return rep
 325
 326 class Format:
 327   """Represents a .svn/format file."""
 328
 329   def __init__(self, path):
 330     self.path = path
 331
 332   def write_format(self, format_nbr, verbosity=0):
 333     format_string = '%d\n'
 334     if os.path.exists(self.path):
 335       if verbosity >= 1:
 336         print("%s will be updated." % self.path)
 337       os.chmod(self.path,0600)
 338     else:
 339       if verbosity >= 1:
 340         print("%s does not exist, creating it." % self.path)
 341     format = open(self.path, "w")
 342     format.write(format_string % format_nbr)
 343     format.close()
 344     os.chmod(self.path, 0400)
 345
 346 class LocalException(Exception):
 347   """Root of local exception class hierarchy."""
 348   pass
 349
 350 class LossyConversionException(LocalException):
 351   "Exception thrown when a lossy WC format conversion is requested."
 352   def __init__(self, lossy_fields, str):
 353     self.lossy_fields = lossy_fields
 354     self.str = str
 355   def __str__(self):
 356     return self.str
 357
 358 class UnrecognizedWCFormatException(LocalException):
 359   def __init__(self, format, path):
 360     self.format = format
 361     self.path = path
 362   def __str__(self):
 363     return ("Unrecognized WC format %d in '%s'; "
 364             "only formats 8, 9, and 10 can be supported") % (self.format, self.path)
 365
 366
 367 def main():
 368   try:
 369     opts, args = my_getopt(sys.argv[1:], "vh?",
 370                            ["debug", "force", "skip-unknown-format",
 371                             "verbose", "help"])
 372   except:
 373     usage_and_exit("Unable to process arguments/options")
 374
 375   converter = WCFormatConverter()
 376
 377   # Process arguments.
 378   if len(args) == 2:
 379     converter.root_path = args[0]
 380     svn_version = args[1]
 381   else:
 382     usage_and_exit()
 383
 384   # Process options.
 385   debug = False
 386   for opt, value in opts:
 387     if opt in ("--help", "-h", "-?"):
 388       usage_and_exit()
 389     elif opt == "--force":
 390       converter.force = True
 391     elif opt == "--skip-unknown-format":
 392       converter.error_on_unrecognized = False
 393     elif opt in ("--verbose", "-v"):
 394       converter.verbosity += 1
 395     elif opt == "--debug":
 396       debug = True
 397     else:
 398       usage_and_exit("Unknown option '%s'" % opt)
 399
 400   try:
 401     new_format_nbr = LATEST_FORMATS[svn_version]
 402   except KeyError:
 403     usage_and_exit("Unsupported version number '%s'; "
 404                    "only 1.4, 1.5, and 1.6 can be supported" % svn_version)
 405
 406   try:
 407     converter.change_wc_format(new_format_nbr)
 408   except LocalException, e:
 409     if debug:
 410       raise
 411     sys.stderr.write("%s\n" % e)
 412     sys.stderr.flush()
 413     sys.exit(1)
 414
 415   print("Converted WC at '%s' into format %d for Subversion %s" % \
 416         (converter.root_path, new_format_nbr, svn_version))
 417
 418 if __name__ == "__main__":
 419   main()