Attempt at making git-drover work on Windows

git_drover.py

 #!/usr/bin/env python
 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 """git drover: A tool for merging changes to release branches."""
 
 import argparse
 import functools
 import logging
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 
 import git_common
 
 
 class Error(Exception):
   pass
 
 
+if os.name == 'nt':
+  # This is a just-good-enough emulation of os.symlink for drover to work on
+  # Windows. It uses junctioning of directories (most of the contents of
+  # the .git directory), but copies files. Note that we can't use
+  # CreateSymbolicLink or CreateHardLink here, as they both require elevation.
+  # Creating reparse points is what we want for the directories, but doing so
+  # is a relatively messy set of DeviceIoControl work at the API level, so we
+  # simply shell to `mklink /j` instead.
+  def emulate_symlink_windows(source, link_name):
+    if os.path.isdir(source):
+      subprocess.check_call(['mklink', '/j',
+                             link_name.replace('/', '\\'),
+                             source.replace('/', '\\')],
+                            shell=True)
+    else:
+      shutil.copy(source, link_name)
+  mk_symlink = emulate_symlink_windows
+else:
+  mk_symlink = os.symlink
+
+
 class _Drover(object):
 
   def __init__(self, branch, revision, parent_repo, dry_run):
     self._branch = branch
     self._branch_ref = 'refs/remotes/branch-heads/%s' % branch
     self._revision = revision
     self._parent_repo = os.path.abspath(parent_repo)
     self._dry_run = dry_run
     self._workdir = None
     self._branch_name = None
@@ skipping 32 matching lines @@
   def _cleanup(self):
     if self._branch_name:
       try:
         self._run_git_command(['cherry-pick', '--abort'])
       except Error:
         pass
       self._run_git_command(['checkout', '--detach'])
       self._run_git_command(['branch', '-D', self._branch_name])
     if self._workdir:
       logging.debug('Deleting %s', self._workdir)
-      shutil.rmtree(self._workdir)
+      if os.name == 'nt':
+        # Use rmdir to properly handle the junctions we created.
+        subprocess.check_call(['rmdir', '/s', '/q', self._workdir], shell=True)
+      else:
+        shutil.rmtree(self._workdir)
     self._dev_null_file.close()
 
   @staticmethod
   def _confirm(message):
     """Show a confirmation prompt with the given message.
 
     Returns:
       A bool representing whether the user wishes to continue.
     """
     result = ''
     while result not in ('y', 'n'):
       try:
         result = raw_input('%s Continue (y/n)? ' % message)
       except EOFError:
         result = 'n'
     return result == 'y'
 
   def _check_inputs(self):
     """Check the input arguments and ensure the parent repo is up to date."""
 
     if not os.path.isdir(self._parent_repo):
       raise Error('Invalid parent repo path %r' % self._parent_repo)
-    if not hasattr(os, 'symlink'):
-      raise Error('Symlink support is required')
 
     self._run_git_command(['--help'], error_message='Unable to run git')
     self._run_git_command(['status'],
                           error_message='%r is not a valid git repo' %
                           os.path.abspath(self._parent_repo))
     self._run_git_command(['fetch', 'origin'],
                           error_message='Failed to fetch origin')
     self._run_git_command(
         ['rev-parse', '%s^{commit}' % self._branch_ref],
         error_message='Branch %s not found' % self._branch_ref)
@@ skipping 23 matching lines @@
     differs from git-new-workdir in that the config is forked instead of shared.
     This is so the new workdir can be a sparse checkout without affecting
     |self._parent_repo|.
     """
     parent_git_dir = os.path.abspath(self._run_git_command(
         ['rev-parse', '--git-dir']).strip())
     self._workdir = tempfile.mkdtemp(prefix='drover_%s_' % self._branch)
     logging.debug('Creating checkout in %s', self._workdir)
     git_dir = os.path.join(self._workdir, '.git')
     git_common.make_workdir_common(parent_git_dir, git_dir, self.FILES_TO_LINK,
-                                   self.FILES_TO_COPY)
+                                   self.FILES_TO_COPY, mk_symlink)
     self._run_git_command(['config', 'core.sparsecheckout', 'true'])
     with open(os.path.join(git_dir, 'info', 'sparse-checkout'), 'w') as f:
       f.write('codereview.settings')
 
     branch_name = os.path.split(self._workdir)[-1]
     self._run_git_command(['checkout', '-b', branch_name, self._branch_ref])
     self._branch_name = branch_name
 
   def _prepare_cherry_pick(self):
     self._run_git_command(['cherry-pick', '-x', self._revision],
@@ skipping 91 matching lines @@
   try:
     cherry_pick_change(options.branch, options.cherry_pick,
                        options.parent_checkout, options.dry_run)
   except Error as e:
     logging.error(e.message)
     sys.exit(128)
 
 
 if __name__ == '__main__':
   main()