src/scripts/setupRepo.py

   1 #!/usr/bin/env python
   2
   3 import os
   4 import tempfile
   5
   6 from git import Repo
   7
   8 testPath = os.path.join(tempfile.gettempdir(), "testrepo")
   9 metricsPath = os.path.join(tempfile.gettempdir(), "metricsrepo")
  10
  11 class InitializationException(Exception):
  12   """This exception is raised when something goes wrong during initialization.
  13   """
  14
  15 def setupRepo(path):
  16   """Creates a fresh repo under the specified path
  17
  18   If the specified path exists an exception is raised.
  19
  20   Args:
  21     path: The path where the new repo should be created at.
  22   """
  23
  24   print("Creating a new repository in " + path)
  25
  26   # Check if the path exists already, if so bail out
  27   if os.path.exists(path):
  28     raise InitializationException(
  29         "The specified path, " + path + ", exists already, "
  30         "please remove it or change the target path.")
  31
  32   # Create a new repo
  33   repo = Repo.create(path)
  34   os.chdir(path)
  35
  36 def setDefaultTime():
  37   """Configures GIT_COMMITTER_DATE and GIT_AUTHOR_DATE to a default value
  38
  39   The actual date set is 2005-05-26 23:30, which was taken
  40   from t/t1400-update-ref.sh and then converted to UNIX
  41   time manually.
  42   """
  43
  44   os.environ["GIT_COMMITTER_DATE"] = "1211844600"
  45   os.environ["GIT_AUTHOR_DATE"] = "1211844600"
  46   os.environ["TZ"] = "UTC"
  47
  48 def setDefaultInfo():
  49   """Configures GIT_COMMITTER_NAME etc. to a default value.
  50
  51   These values are taken from t/test-lib.sh from git.git.
  52   """
  53
  54   os.environ["GIT_COMMITTER_NAME"] = "C O Mitter"
  55   os.environ["GIT_COMMITTER_EMAIL"] = "committer@example.com"
  56   os.environ["GIT_AUTHOR_NAME"] = "A U Thor"
  57   os.environ["GIT_AUTHOR_EMAIL"] = "author@example.com"
  58
  59 def setSecondaryInfo():
  60   """Configures GIT_COMMITTER_NAME etc. to a secondary value.
  61
  62   The values are the default values but in reverse.
  63   """
  64
  65   os.environ["GIT_COMMITTER_NAME"] = "Retti Mmoc"
  66   os.environ["GIT_COMMITTER_EMAIL"] = "retti.mmoc@example.com"
  67   os.environ["GIT_AUTHOR_NAME"] = "Roh Tua"
  68   os.environ["GIT_AUTHOR_EMAIL"] = "roh.tua@example.com"
  69
  70 def bumpTime(amount = 60*60):
  71   """Bumps the date in GIT_AUTHOR_DATE and GIT_COMMITTER_DATE
  72
  73   Args:
  74     amount: The amount by which they should be bumped.
  75   """
  76
  77   time = os.environ["GIT_AUTHOR_DATE"]
  78   time = int(time)
  79   time += amount
  80   time = str(time)
  81
  82   os.environ["GIT_AUTHOR_DATE"] = time
  83   os.environ["GIT_COMMITTER_DATE"] = time
  84
  85
  86 def addFile(filename, createFile=True, commit=True):
  87   """Adds the specified file
  88
  89   Args:
  90     filename: The name of the file to add.
  91     createFile: Whether the file should be created.
  92   """
  93
  94   if createFile:
  95       file = open(filename, "w")
  96       file.close()
  97
  98   git = Repo(".").git
  99
 100   git.add(filename)
 101
 102   if commit:
 103     git.commit("-m", "Added file " + filename)
 104     bumpTime()
 105
 106 def deleteFile(filename, leaveOnDisk=False):
 107   """Deletes the specified file
 108
 109   Args:
 110     filename: The name of the file to delete.
 111     leaveOnDisk: Whether the file should not be physically deleted.
 112   """
 113
 114   args = []
 115
 116   # If the file should not be deleted, tell 'git rm' so
 117   if leaveOnDisk:
 118     args.append("--cached")
 119
 120   args.append(filename)
 121
 122   git = Repo(".").git
 123
 124   git.rm(*args)
 125
 126   git.commit("-m", "Deleted file " + filename)
 127   bumpTime()
 128
 129 def createLinearHistory(filename, createFile=False, initialCommit=False, start=1, count=10, finalCommit=False):
 130   """Creates a linear history in the directory of the current repository.
 131
 132   The history is fairly simple and is all acted upon the specified file.
 133   Any exceptions thrown during IO operations are _not_ cought.
 134
 135   Params:
 136     filename: The name of the file in which to generate the history.
 137     createFile: Whether the specified file has to be created first.
 138     initialCommit: Whether to create an initial commit.
 139     start: Which commit to start the history at.
 140     count: The size of the history.
 141     finalCommit: Whether to create a final commit.
 142   """
 143
 144   git = Repo(".").git
 145
 146   stop = start + count
 147
 148   if createFile:
 149     addFile(filename, commit=False)
 150
 151   # Create or open the content file
 152   file = open(filename, "a")
 153
 154   if initialCommit:
 155     # Start out with an initial change
 156     file.write("Initial change\n")
 157     file.flush()
 158
 159     # Add the file and create the initial commit
 160     git.commit("-a", "-m", "Initial commit")
 161     bumpTime()
 162
 163   # Create a linear history
 164   for i in range(start, stop):
 165     file.write("Change " + str(i) + "\n")
 166     file.flush()
 167
 168     git.commit("-a", "-m", "Commit " + str(i))
 169     bumpTime()
 170
 171   if finalCommit:
 172     # Finish it up with a final change
 173     file.write("Last change\n")
 174     file.flush()
 175
 176     # And a final commit
 177     git.commit("-a", "-m", "Last commit")
 178     bumpTime()
 179
 180 def createBranch(name, checkout=True):
 181   """Creates a branch with the specified name and optionally checks it out
 182
 183   Params:
 184     name: The name of the new branch.
 185     checkout: Whether to perform a checkout of the branch.
 186   """
 187
 188   git = Repo(".").git
 189
 190   git.branch(name)
 191   bumpTime()
 192
 193   if checkout:
 194     checkoutBranch(name)
 195
 196 def deleteBranch(name):
 197   """Deletes a branch
 198
 199   The branch that is to be deleted should be a subset of the current branch.
 200
 201   Params:
 202     name: The name of the branch to delete.
 203   """
 204
 205   git = Repo(".").git
 206
 207   git.branch("-d", name)
 208   bumpTime()
 209
 210 def createDir(name, changeDir=False):
 211   """Creates a directory with the specified name
 212
 213   Args:
 214     name: The name of the directory
 215   """
 216
 217   os.mkdir(name)
 218
 219 def checkoutBranch(name):
 220   """Switches to the specified branch
 221
 222   Params:
 223     name: The name of the branch to be switched to.
 224   """
 225
 226   git = Repo(".").git
 227
 228   git.checkout(name)
 229
 230 def checkoutRelease(release):
 231   """Switches to the specified release
 232
 233   Params:
 234     release: The release to check out
 235   """
 236
 237   checkoutBranch('v' + str(release))
 238
 239 def mergeBranch(name):
 240   """Merges the current branch with the specified branch
 241
 242   Params:
 243     name: The name of the branch to merge with.
 244   """
 245
 246   git = Repo(".").git
 247
 248   git.merge(name)
 249   bumpTime()
 250
 251 def revertLastCommit(commitChanges=True):
 252   """Reverts the last commit made
 253
 254   Params:
 255     commitChanges: Whether to commit the revert.
 256   """
 257
 258   git = Repo(".").git
 259
 260   options = ["--no-edit", "HEAD"]
 261
 262   if not commitChanges:
 263     options.append("-n")
 264
 265   git.revert(*options)
 266
 267   if commitChanges:
 268     bumpTime()
 269
 270 def tagRelease(releaseNumber, head="HEAD"):
 271   """Tags a release.
 272
 273   The created tag is 'v' + releaseNumber.
 274
 275   Params:
 276     releaseNumber: The number of the release.
 277   """
 278
 279   git = Repo(".").git
 280
 281   git.tag('v' + str(releaseNumber), head)
 282
 283 def createRemoteBranch(name, start="HEAD"):
 284   """Creates a new remote branch with the specified name
 285
 286   Args:
 287     name: The plain name of the remote (no '/refs/remotes/' prefix)
 288     start: The revision to branch off from
 289   """
 290
 291   git = Repo(".").git
 292
 293   git.update_ref('refs/remotes/' + name, start)
 294   bumpTime()
 295
 296 def checkHead(HEAD):
 297   """Verifies that the HEAD is as expected.
 298
 299   Params:
 300     HEAD: The expected value of HEAD.
 301   """
 302
 303   git = Repo(".").git
 304
 305   result = git.rev_parse("HEAD")
 306
 307   # Eat the trailing newline
 308   currentHEAD = result[:-1]
 309
 310   scriptSuccessful = (HEAD == currentHEAD)
 311
 312   if scriptSuccessful:
 313     print("Done, repo created successfully")
 314     return True
 315   else:
 316     print("Something went wrong, current HEAD doesn't match.")
 317     print("Expected: '" + HEAD + "'.")
 318     print("Actual: '" + currentHEAD + "'.")
 319     return False
 320
 321 def createTestRepository():
 322   """Creates a test repository under setupRepo.testpath
 323   """
 324
 325   # Directories
 326   d = "docs"
 327
 328   # Files
 329   c = "content.txt"
 330   n = "notes.txt"
 331   t = "test.c"
 332   r = os.path.join(d, "README.txt")
 333
 334  # Branches
 335   m = "master"
 336   mt = "maint"
 337   p = "pu"
 338   e = "erase"
 339   j = "junio"
 340
 341   # Start afresh
 342   setupRepo(testPath)
 343
 344   # Set the default author/committer
 345   setDefaultInfo()
 346   setDefaultTime()
 347
 348   # Create some linear history
 349   createLinearHistory(c, createFile=True, initialCommit=True, finalCommit=True)
 350
 351   # Create a maintenance branch
 352   createBranch(mt)
 353
 354   # Create some history there too
 355   createLinearHistory(n, createFile=True, count=3)
 356
 357   # Go back to master and merge with maint
 358   checkoutBranch(m)
 359   mergeBranch(mt)
 360
 361   # Create a playground branch and create some history
 362   # This branch will be left 'dead', e.g., unused after this
 363   createBranch(p)
 364   createLinearHistory(t, createFile=True, count=7, finalCommit=True)
 365
 366   # Start out with release 0
 367   tagRelease(0, head="HEAD~3")
 368
 369   # Revert that commit
 370   revertLastCommit()
 371
 372   # Go back to master and continue some history
 373   checkoutBranch(m)
 374   createLinearHistory(c, start=10, count=5)
 375
 376   # Yay, our first release!
 377   tagRelease(1)
 378
 379   # Merge current master into maint
 380   checkoutBranch(mt)
 381   mergeBranch(m)
 382
 383   # Ouch! Brown paper bag fix there, correct it and merge into master
 384   revertLastCommit(commitChanges=False)
 385   createLinearHistory(c, start=42, count=1)
 386   checkoutBranch(m)
 387   mergeBranch(mt)
 388
 389   # Continue some work on master
 390   createLinearHistory(c, start=16, count=6)
 391
 392   # Have someone else do some work on master
 393   setSecondaryInfo()
 394   createLinearHistory(c, start=22, count=2)
 395
 396   # Go back to the initial data
 397   setDefaultInfo()
 398
 399   # Create a directory for the documentation
 400   createDir(d)
 401
 402   # Create a readme and add some content to it
 403   createLinearHistory(r, createFile=True, count=5, finalCommit=True)
 404   tagRelease(2)
 405
 406   # Ah, but that last one was bad, we don't want it
 407   revertLastCommit()
 408
 409   # Instead, continue the linear history
 410   createLinearHistory(r, start=6, count=1)
 411   tagRelease(3)
 412
 413   # Come to think of it, that -was- a really good change after all
 414   revertLastCommit()
 415
 416   # Reinstate that final commit
 417   createLinearHistory(r, count=0, finalCommit=True)
 418
 419   tagRelease(4, head="HEAD~1")
 420
 421   # Create a branch to delete a file on
 422   createBranch(e)
 423
 424   # Remove a file from git
 425   deleteFile(r, leaveOnDisk=True)
 426
 427   # Only to add it back later so that we don't have any dangling files
 428   addFile(r, createFile=False)
 429
 430   # Create a release at this point for easy switching later
 431   tagRelease(5)
 432
 433   # Switch back to master for the test suite
 434   checkoutBranch(m)
 435
 436   # Create a remote branch
 437   createRemoteBranch(j, start="HEAD^")
 438
 439   return 0
 440
 441 def createMetricsRepository():
 442   """Creates a metrics repository in setupRepo.metricspath
 443   """
 444
 445   # files
 446   c = "content.txt"
 447   n = "notes.txt"
 448   r = "README"
 449   l = "limbo.dat"
 450
 451   # branches
 452   m = "master"
 453   mt = "maint"
 454   h = "help"
 455   s = "side"
 456
 457   # Create a repository to work in
 458   setupRepo(metricsPath)
 459
 460   # Set the info
 461   setDefaultInfo()
 462   setDefaultTime()
 463
 464   # And create some history
 465   createLinearHistory(c, createFile=True, count=2)
 466
 467   # Mark this commit so that we can jump back to it later
 468   tagRelease(1)
 469
 470   # And create some more history
 471   createLinearHistory(c, start=3, count=3)
 472
 473   # Go back to that marked commit
 474   checkoutRelease(1)
 475
 476   # Now create a new branch to work on
 477   createBranch(mt)
 478
 479   # Fix us up some more history
 480   createLinearHistory(n, createFile=True, count=2)
 481
 482   # Mark this commit too so we can jump back
 483   tagRelease(2)
 484
 485   # And make some more history
 486   createLinearHistory(n, start=2, count=1)
 487
 488   # Now merge this back into master
 489   checkoutBranch(m)
 490   mergeBranch(mt)
 491
 492   # Go back to maint to create some more there
 493   checkoutBranch(mt)
 494   createLinearHistory(n, start=3, count=1)
 495
 496   # Now let's go back and fix that one commit
 497   checkoutRelease(2)
 498   createBranch(h)
 499   createLinearHistory(r, createFile=True, count=2)
 500
 501   # Go back to maint, and merge it in
 502   checkoutBranch(mt)
 503   mergeBranch(h)
 504
 505   # Now that we merged that one in, kick it out
 506   deleteBranch(h)
 507
 508   # We can create some more history here
 509   createLinearHistory(n, start=4, count=3)
 510
 511   # Remember for branching off later
 512   tagRelease(3)
 513
 514   # And a healthy bit of content on master too
 515   checkoutBranch(m)
 516   createLinearHistory(c, start=6, count=4)
 517
 518   # Create one more commit
 519   checkoutBranch(mt)
 520   createLinearHistory(n, start=7, count=1)
 521
 522   # Merge master in here
 523   mergeBranch(m)
 524
 525   # And create another commit
 526   createLinearHistory(n, start=8, count=1)
 527
 528   # Hacking on master some more
 529   checkoutBranch(m)
 530   createLinearHistory(c, start=10, count=4)
 531
 532   # Go back a bit and branch off
 533   checkoutRelease(3)
 534   createBranch(s)
 535   createLinearHistory(l, createFile=True, count=3)
 536
 537   # Merge back into maint and work some more
 538   checkoutBranch(mt)
 539   mergeBranch(s)
 540   createLinearHistory(n, start=9, count=1)
 541
 542   # Merge that into master and finish up
 543   checkoutBranch(m)
 544   mergeBranch(mt)
 545   createLinearHistory(c, start=14, count=1)
 546
 547   # Finish side branch
 548   checkoutBranch(s)
 549   createLinearHistory(l, start=4, count=4)
 550
 551   # Lastly finish up maint
 552   checkoutBranch(mt)
 553   createLinearHistory(n, start=10, count=2)
 554
 555   return 0
 556
 557 def main(args):
 558   """Creates a test and a metrics repository
 559
 560   Args:
 561     args: An array of arguments, when 2 in size the second
 562     element should either be 'test' to just create the test
 563     repo, or 'metrics' to just create the metrics
 564     repository. If both should be created then the size of
 565     args should be 1. When the third argument is 'path',
 566     instead of creating the repository the path where it
 567     will be created is printed. If there is a fourth
 568     argument it is interpreted as the path where the
 569     repository should be created. The first element in the
 570     array is always ignored.
 571
 572   Returns: 0 upon success, or nonzero upon failure.
 573   """
 574
 575   global testPath
 576   global metricsPath
 577
 578   size = len(args)
 579
 580   def printUsage():
 581     str = "Please specify either 'test', 'metrics', or nothing to run both." \
 582     "\nSuffix with 'path' to print the path where the repo will be created." \
 583     "\nAs third argument you may provide the path to create the repo in."
 584
 585     print(str)
 586
 587   if size > 4:
 588     printUsage()
 589     return 129
 590
 591   if size == 3:
 592     if args[2] != "path":
 593       printUsage()
 594       return 129
 595
 596   createTestRepo = False
 597   createMetricsRepo = False
 598   printTestRepoPath = False
 599   printMetricsRepoPath = False
 600
 601   if size == 1:
 602     createTestRepo = True
 603     createMetricsRepo = True
 604
 605   if size == 2 or size == 4:
 606     if args[1] == "test":
 607       createTestRepo = True
 608
 609     if args[1] == "metrics":
 610       createMetricsRepo = True
 611
 612   if size == 3:
 613     if args[1] == "test":
 614       printTestRepoPath = True
 615
 616     if args[1] == "metrics":
 617       printMetricsRepoPath = True
 618
 619   if not createTestRepo and not createMetricsRepo \
 620       and not printTestRepoPath and not printMetricsRepoPath:
 621         printUsage()
 622         return 129
 623
 624   if createTestRepo:
 625     if size == 4:
 626       testPath = args[3]
 627
 628     ret = createTestRepository()
 629     if ret != 0:
 630       return ret
 631
 632   if createMetricsRepo:
 633     if size == 4:
 634       metricsPath = args[3]
 635
 636     ret = createMetricsRepository()
 637     if ret != 0:
 638       return ret
 639
 640   if printTestRepoPath:
 641     print(testPath)
 642
 643   if printMetricsRepoPath:
 644     print(metricsPath)
 645
 646   return 0
 647
 648 if __name__ == '__main__':
 649   import sys
 650   ret = main(sys.argv)
 651   sys.exit(ret)
 652