Merge lp:~brian.curtin/ubuntuone-windows-installer/patching into lp:ubuntuone-windows-installer

[Brian Curtin]

- Use collective.recipe.patch to more consistently setup buildout environments with dependencies we need to patch.

Using the collective.recipe.patch buildout recipe, we can take the unmodified versions of our dependencies and patch them when the buildout environment is setup. This change applies two patches to Twisted and one to keyring until versions are released which include these changes.

Note that the default operation of using the included patch.py library does not work for these diffs for whatever reason. It was easier to just set the patch-binary manually to be the "patch" application found on the path. On Windows, this requires that you have some sort of patch library installed, probably via gnuwin32 utils.

I have an outstanding pull request to collective.recipe.patch due to how it uses the close_fds argument to subprocess.Popen, which is incompatible on Windows. If the pull request is not accepted relatively soon, I will probably have to upload a fork to PyPI.

[Mike McCracken (mikemc)]

when testing this, I get this:

Download error on http://keyring-python.org/: [Errno 8] nodename nor servname provided, or not known -- Some packages may not be found!
Download error on http://home.python-keyring.org/: [Errno 8] nodename nor servname provided, or not known -- Some packages may not be found!
Download error on http://home.python-keyring.org/: [Errno 8] nodename nor servname provided, or not known -- Some packages may not be found!
Download error on http://home.python-keyring.org/: [Errno 8] nodename nor servname provided, or not known -- Some packages may not be found!
Getting distribution for 'keyring==0.7'.

not sure where that URL is coming from, but it definitely doesn't exist.
do I have an out of date setuptools or distribute or something?

review: Needs Information

[dobey (dobey)]

review: Approve

[Mike McCracken (mikemc)]

Sorry for the delay, this worked for me yesterday

review: Approve

=== modified file 'scripts/devsetup/buildout.cfg'
--- scripts/devsetup/buildout.cfg	2013-05-06 19:02:26 +0000
+++ scripts/devsetup/buildout.cfg	2013-05-06 19:02:26 +0000
@@ -26,8 +26,6 @@
 find-links =
     https://github.com/ghtdak/qtreactor/tarball/master#egg=qt4reactor
     http://launchpad.net/python-distutils-extra/trunk/2.31/+download/python-distutils-extra-2.31.tar.gz#egg=python-distutils-extra
-# Mandel's patched keyring, already built
-    http://www.briancurtin.com/canonical/deps/keyring-0.7-py2.7.egg#egg=keyring
 # Pycrypto already built using python -c "import setuptools; execfile('setup.py')" bdist_egg
     http://www.briancurtin.com/canonical/deps/pycrypto-2.6-py2.7-win32.egg#egg=pycrypto
 # Py2exe already build using python -c "import setuptools; execfile('setup.py')" bdist_egg
@@ -38,9 +36,6 @@
 # http://sourceforge.net/tracker/index.php?func=detail&aid=3036368&group_id=115265&atid=692940
     http://www.briancurtin.com/canonical/deps/comtypes-0.6.2.zip#egg=comtypes
     http://launchpad.net/configglue/trunk/1.0/+download/configglue-1.0.tar.gz#egg=configglue
-# This Twisted build includes alecu's patch which has not yet been accepted
-# http://www.twistedmatrix.com/trac/ticket/5726
-    http://www.briancurtin.com/canonical/deps/Twisted-12.3.0-py2.7-win32.egg#egg=twisted
     http://people.canonical.com/~dobey/pyflakes-0.5.0-2ubuntu2.bo2.tar.gz#egg=pyflakes
     http://u1.to/~mikemc/g/pyobjc_core-2.5.0b1-py2.7-macosx-10.6-x86_64.egg#egg=pyobjc-core-2.5.0b1
     http://u1.to/~mikemc/7/pyobjc_framework_Cocoa-2.5.0b1-py2.7-macosx-10.6-x86_64.egg#egg=pyobjc-framework-Cocoa-2.5.0b1
@@ -78,10 +73,10 @@
 recipe = z3c.recipe.scripts
 eggs =
     ${scripty:eggs}
-    twisted
+    ${patched-twisted:egg}
+    ${patched-keyring:egg}
     qt4reactor
     python-distutils-extra
-    keyring
     pycrypto
     pyOpenSSL
     pil
@@ -110,6 +105,37 @@
      ${buildout:parts-directory}/ubuntuone-dev-tools
      ${buildout:parts-directory}/dirspec
 
+[twisted]
+recipe = z3c.recipe.scripts
+eggs =
+    twisted
+versions = versions
+interpreter = python
+
+[keyring]
+recipe = z3c.recipe.scripts
+eggs =
+    keyring
+versions = versions
+interpreter = python
+ 
+[patched-twisted]
+recipe = collective.recipe.patch
+patch-binary = patch
+egg = ${twisted:eggs}
+# Patches for http://twistedmatrix.com/trac/ticket/6462
+# and http://twistedmatrix.com/trac/ticket/5726
+patches = patches/twisted/6462.diff
+          patches/twisted/5726.diff
+
+[patched-keyring]
+recipe = collective.recipe.patch
+patch-binary = patch
+egg = ${keyring:eggs}
+# Patch generated between 0.7 and mandel's branch
+# https://bitbucket.org/mandel/pykeyring-delete-password
+patches = patches/keyring/pykeyring-delete-password.diff
+
 # Install various scripts. These are all separate sections because the
 # initialization and arguments values apply to every entry point you
 # declare in a section, and these four are incompatible. Only pyflakes
 
=== added directory 'scripts/devsetup/patches'
=== added directory 'scripts/devsetup/patches/keyring'
=== added file 'scripts/devsetup/patches/keyring/pykeyring-delete-password.diff'
--- scripts/devsetup/patches/keyring/pykeyring-delete-password.diff	1970-01-01 00:00:00 +0000
+++ scripts/devsetup/patches/keyring/pykeyring-delete-password.diff	2013-05-06 19:02:26 +0000
@@ -0,0 +1,517 @@
+--- keyring/__init__.py	2013-04-16 10:04:36.000000000 -0500
++++ keyring/__init__.py	2013-04-12 09:26:11.848796300 -0500
+@@ -6,5 +6,6 @@
+ import logging
+ logger = logging.getLogger('keyring')
+ 
+-from keyring.core import set_keyring, get_keyring, set_password, get_password
++from core import (set_keyring, get_keyring, set_password, get_password,
++                  delete_password)
+ from keyring.getpassbackend import get_password as get_pass_get_password
+--- keyring/backend.py	2013-04-16 10:04:36.000000000 -0500
++++ keyring/backend.py	2013-04-12 09:26:11.877792300 -0500
+@@ -8,7 +8,6 @@
+ import os
+ import sys
+ import ConfigParser
+-import base64
+ 
+ from keyring.util.escape import escape as escape_for_ini
+ from keyring.util import properties
+@@ -36,10 +35,17 @@
+ _BLOCK_SIZE = 32
+ _PADDING = '0'
+ 
++
+ class PasswordSetError(Exception):
+     """Raised when the password can't be set.
+     """
+ 
++
++class PasswordDeleteError(Exception):
++    """Raised when the password can't be deleted.
++    """
++
++
+ class KeyringBackend(object):
+     """The abstract base class of the keyring, every backend must implement
+     this interface.
+@@ -67,6 +73,13 @@
+         """
+         raise PasswordSetError("reason")
+ 
++    @abstractmethod
++    def delete_password(self, service, username):
++        """Delete the password for the username of the service.
++        """
++        raise PasswordDeleteError("reason")
++
++
+ class _ExtensionKeyring(KeyringBackend):
+     """_ExtensionKeyring is a adaptor class for the platform related keyring
+     backends.
+@@ -112,7 +125,16 @@
+         try:
+             self.keyring_impl.password_set(service, username, password)
+         except OSError, e:
+-            raise PasswordSetError(e.message)
++            raise PasswordSetError(e)
++
++    def delete_password(self, service, username):
++        """Override the delete_password in KeyringBackend.
++        """
++        try:
++            self.keyring_impl.password_delete(service, username)
++        except OSError, e:
++            raise PasswordDeleteError(e)
++
+ 
+ class OSXKeychain(_ExtensionKeyring):
+     """Mac OS X Keychain"""
+@@ -127,6 +149,7 @@
+         """
+         return sys.platform == 'darwin'
+ 
++
+ class GnomeKeyring(KeyringBackend):
+     """Gnome Keyring"""
+ 
+@@ -174,8 +197,22 @@
+             # The user pressed "Cancel" when prompted to unlock their keyring.
+             raise PasswordSetError("cancelled by user")
+ 
++    def delete_password(self, service, username):
++        """Delete the password for the username of the service.
++        """
++        try:
++            items = gnomekeyring.find_network_password_sync(username, service)
++            for current in items:
++                gnomekeyring.item_delete_sync(current['keyring'],
++                                              current['item_id'])
++        except gnomekeyring.NoMatchError:
++            raise PasswordDeleteError("can't found the password")
++        except gnomekeyring.CancelledError:
++            raise PasswordDeleteError("cancelled by user")
++
+ kwallet = None
+ 
++
+ def open_kwallet(kwallet_module=None, qt_module=None):
+ 
+     # If we specified the kwallet_module and/or qt_module, surely we won't need
+@@ -224,7 +261,7 @@
+     """KDE KWallet"""
+ 
+     def supported(self):
+-        if kwallet_support and os.environ.has_key('KDE_SESSION_UID'):
++        if kwallet_support and 'KDE_SESSION_UID' in os.environ:
+             return 1
+         elif kwallet_support:
+             return 0
+@@ -249,7 +286,16 @@
+         """Set password for the username of the service
+         """
+         wallet = open_kwallet()
+-        wallet.writePassword(username+'@'+service, password)
++        wallet.writePassword(username + '@' + service, password)
++
++    def delete_password(self, service, username):
++        """Delete the password for the username of the service.
++        """
++        key = username + '@' + service
++        if kwallet.keyDoesNotExist(kwallet.walletName(), 'Python', key):
++            raise PasswordDeleteError("can't found the password")
++        kwallet.removeEntry(key)
++
+ 
+ class BasicFileKeyring(KeyringBackend):
+     """BasicFileKeyring is a file-based implementation of keyring.
+@@ -297,11 +343,11 @@
+ 
+         # fetch the password
+         try:
+-            password_base64 = config.get(service, username).encode()
++            password_base64 = config.get(service, username)
+             # decode with base64
+-            password_encrypted = base64.decodestring(password_base64)
++            password_encrypted = password_base64.decode("base64")
+             # decrypted the password
+-            password = self.decrypt(password_encrypted).decode('utf-8')
++            password = self.decrypt(password_encrypted)
+         except (ConfigParser.NoOptionError, ConfigParser.NoSectionError):
+             password = None
+         return password
+@@ -313,21 +359,35 @@
+         username = escape_for_ini(username)
+ 
+         # encrypt the password
+-        password_encrypted = self.encrypt(password.encode('utf-8'))
++        password_encrypted = self.encrypt(password)
+         # load the password from the disk
+         config = ConfigParser.RawConfigParser()
+         if os.path.exists(self.file_path):
+             config.read(self.file_path)
+ 
+         # encode with base64
+-        password_base64 = base64.encodestring(password_encrypted).decode()
++        password_base64 = password_encrypted.encode("base64")
+         # write the modification
+         if not config.has_section(service):
+             config.add_section(service)
+         config.set(service, username, password_base64)
+-        config_file = open(self.file_path,'w')
++        config_file = open(self.file_path, 'w')
+         config.write(config_file)
+ 
++    def delete_password(self, service, username):
++        """Delete the password for the username of the service.
++        """
++        service = escape_for_ini(service)
++        config = ConfigParser.RawConfigParser()
++        if os.path.exists(self.file_path):
++            config.read(self.file_path)
++        if not config.remove_section(service):
++            raise PasswordDeleteError("can't found the password")
++        # update the file
++        config_file = open(self.file_path, 'w')
++        config.write(config_file)
++
++
+ class UncryptedFileKeyring(BasicFileKeyring):
+     """Uncrypted File Keyring"""
+ 
+@@ -348,6 +408,7 @@
+         """
+         return 0
+ 
++
+ class CryptedFileKeyring(BasicFileKeyring):
+     """PyCrypto File Keyring"""
+ 
+@@ -377,7 +438,8 @@
+         password = None
+         while 1:
+             if not password:
+-                password = self._getpass("Please set a password for your new keyring")
++                password = self._getpass("Please set a password"
++                                         " for your new keyring")
+                 password2 = self._getpass('Password (again): ')
+                 if password != password2:
+                     sys.stderr.write("Error: Your passwords didn't match\n")
+@@ -404,7 +466,7 @@
+         config.add_section(_KEYRING_SETTING)
+         config.set(_KEYRING_SETTING, _CRYPTED_PASSWORD, self.crypted_password)
+ 
+-        config_file = open(self.file_path,'w')
++        config_file = open(self.file_path, 'w')
+         config.write(config_file)
+ 
+         if config_file:
+@@ -519,7 +581,9 @@
+     def __init__(self):
+         super(WinVaultKeyring, self).__init__()
+         try:
+-            import pywintypes, win32cred
++            import pywintypes
++            import win32cred
++
+             self.win32cred = win32cred
+             self.pywintypes = pywintypes
+         except ImportError:
+@@ -558,7 +622,7 @@
+                 TargetName=target,
+             )
+         except self.pywintypes.error, e:
+-            if e.winerror == 1168 and e.funcname == 'CredRead': # not found
++            if e[:2] == (1168, 'CredRead'):  # not found
+                 return None
+             raise
+         return res
+@@ -583,6 +647,8 @@
+         self.win32cred.CredWrite(credential, 0)
+ 
+     def delete_password(self, service, username):
++        """Delete the password for the username of the service.
++        """
+         compound = self._compound_name(username, service)
+         for target in service, compound:
+             existing_pw = self._get_password(target)
+@@ -590,11 +656,13 @@
+                 self._delete_password(target)
+ 
+     def _delete_password(self, target):
++        """Call win32 api to delete the password."""
+         self.win32cred.CredDelete(
+             Type=self.win32cred.CRED_TYPE_GENERIC,
+             TargetName=target,
+         )
+ 
++
+ class Win32CryptoRegistry(KeyringBackend):
+     """Win32CryptoRegistry is a keyring which use Windows CryptAPI to encrypt
+     the user's passwords and store them under registry keys
+@@ -633,33 +701,47 @@
+             hkey = OpenKey(HKEY_CURRENT_USER, key)
+             password_base64 = QueryValueEx(hkey, username)[0]
+             # decode with base64
+-            password_encrypted = base64.encodestring(password_base64)
++            password_encrypted = password_base64.decode("base64")
+             # decrypted the password
+             password = self.crypt_handler.decrypt(password_encrypted)
+         except EnvironmentError:
+             password = None
+         return password
+ 
+-
+     def set_password(self, service, username, password):
+         """Write the password to the registry
+         """
+         # encrypt the password
+         password_encrypted = self.crypt_handler.encrypt(password)
+         # encode with base64
+-        password_base64 = base64.encodestring(password_encrypted)
++        password_base64 = password_encrypted.encode("base64")
+ 
+         # store the password
+         from _winreg import HKEY_CURRENT_USER, CreateKey, SetValueEx, REG_SZ
+         hkey = CreateKey(HKEY_CURRENT_USER, r'Software\%s\Keyring' % service)
+         SetValueEx(hkey, username, 0, REG_SZ, password_base64)
+ 
++    def delete_password(self, service, username):
++        """Delete the password for the username of the service.
++        """
++        from _winreg import (KEY_ALL_ACCESS, HKEY_CURRENT_USER, DeleteValue,
++                             OpenKey)
++        try:
++            key = r'Software\%s\Keyring' % service
++            hkey = OpenKey(HKEY_CURRENT_USER, key, 0, KEY_ALL_ACCESS)
++            DeleteValue(hkey, username)
++        except WindowsError, e:
++            raise PasswordDeleteError(e)
++
++
+ def select_windows_backend():
+     if os.name != 'nt':
+         return None
+     major, minor, build, platform, text = sys.getwindowsversion()
+     try:
+-        import pywintypes, win32cred
++        import pywintypes
++        import win32cred
++
+         if (major, minor) >= (5, 1):
+             # recommend for windows xp+
+             return 'cred'
+@@ -683,14 +765,14 @@
+ 
+ _all_keyring = None
+ 
++
+ def get_all_keyring():
+     """Return the list of all keyrings in the lib
+     """
+     global _all_keyring
+     if _all_keyring is None:
+-        _all_keyring = [ OSXKeychain(), GnomeKeyring(), KDEKWallet(),
+-                         CryptedFileKeyring(), UncryptedFileKeyring(),
+-                         Win32CryptoKeyring(), Win32CryptoRegistry(),
+-                         WinVaultKeyring()]
++        _all_keyring = [OSXKeychain(), GnomeKeyring(), KDEKWallet(),
++                        CryptedFileKeyring(), UncryptedFileKeyring(),
++                        Win32CryptoKeyring(), Win32CryptoRegistry(),
++                        WinVaultKeyring()]
+     return _all_keyring
+-
+--- keyring/cli.py	2013-04-16 10:04:36.000000000 -0500
++++ keyring/cli.py	2013-04-12 09:26:11.906770400 -0500
+@@ -11,7 +11,8 @@
+ 
+ class CommandLineTool(object):
+     def __init__(self):
+-        self.parser = OptionParser(usage="%prog [get|set] SERVICE USERNAME")
++        self.parser = OptionParser(
++                        usage="%prog [get|set|del] SERVICE USERNAME")
+         self.parser.add_option("-p", "--keyring-path",
+                                dest="keyring_path", default=None,
+                                help="Path to the keyring backend")
+@@ -45,7 +46,6 @@
+                 # So, we play on the safe side, and catch everything.
+                 self.parser.error("Unable to load specified keyring: %s" % e)
+ 
+-
+         if kind == 'get':
+             password = keyring.get_password(service, username)
+             if password is None:
+@@ -60,8 +60,14 @@
+             keyring.set_password(service, username, password)
+             return 0
+ 
++        elif kid == 'del':
++            password = input_password("Deleting password for '%s' in '%s': " %
++                                      (username, service))
++            keyring.delete_password(service, username)
++            return 0
++
+         else:
+-            self.parser.error("You can only 'get' or 'set' a password.")
++            self.parser.error("You can only 'get', 'del' or 'set' a password.")
+             pass
+ 
+     def input_password(self, prompt):
+@@ -72,7 +78,6 @@
+ 
+         return getpass.getpass(prompt)
+ 
+-
+     def output_password(self, password):
+         """Output the password to the user.
+ 
+@@ -85,7 +90,6 @@
+ def main(argv=None):
+     """Main command line interface."""
+ 
+-
+     if argv is None:
+         argv = sys.argv[1:]
+ 
+--- keyring/core.py	2013-04-16 10:04:36.000000000 -0500
++++ keyring/core.py	2013-04-12 09:26:11.937796900 -0500
+@@ -4,16 +4,14 @@
+ Created by Kang Zhang on 2009-07-09
+ """
+ import os
+-try:
+-	import configparser as config_parser
+-except ImportError:
+-	import ConfigParser as config_parser
++import ConfigParser
+ import imp
+ import sys
+ 
+ from keyring import logger
+ from keyring import backend
+ 
++
+ def set_keyring(keyring):
+     """Set current keyring backend.
+     """
+@@ -23,21 +21,31 @@
+     else:
+         raise TypeError("The keyring must be a subclass of KeyringBackend")
+ 
++
+ def get_keyring():
+     """Get current keyring backend.
+     """
+     return _keyring_backend
+ 
++
+ def get_password(service_name, username):
+-    """Get password from the specified service
++    """Get password from the specified service.
+     """
+     return _keyring_backend.get_password(service_name, username)
+ 
++
+ def set_password(service_name, username, password):
+-    """Set password for the user in the specified service
++    """Set password for the user in the specified service.
+     """
+     _keyring_backend.set_password(service_name, username, password)
+ 
++
++def delete_password(service_name, username):
++    """Delete the password for the user in the specified service.
++    """
++    _keyring_backend.delete_password(service_name, username)
++
++
+ def init_backend():
+     """Load a keyring from a config file or for the default platform.
+ 
+@@ -52,7 +60,7 @@
+ 
+         keyrings = backend.get_all_keyring()
+         # rank according to the supported result
+-        keyrings.sort(key = lambda x: -x.supported())
++        keyrings.sort(lambda x, y: y.supported() - x.supported())
+         # get the most recommended one
+         keyring = keyrings[0]
+ 
+@@ -95,10 +103,10 @@
+         # avoid import the imported modules
+         module = sys.modules[keyring_name[:keyring_name.rfind('.')]]
+     except KeyError:
+-        module = load_module(keyring_name, sys.path+[keyring_path])
++        module = load_module(keyring_name, sys.path + [keyring_path])
+ 
+     keyring_class = keyring_name.split('.')[-1].strip()
+-    keyring_temp = getattr(module, keyring_class)()
++    exec  "keyring_temp = module." + keyring_class + "() " in locals()
+ 
+     return keyring_temp
+ 
+@@ -123,7 +131,7 @@
+             break
+ 
+     if os.path.exists(keyring_cfg):
+-        config = config_parser.RawConfigParser()
++        config = ConfigParser.RawConfigParser()
+         config.read(keyring_cfg)
+         # load the keyring-path option
+         try:
+@@ -131,7 +139,7 @@
+                 keyring_path = config.get("backend", "keyring-path").strip()
+             else:
+                 keyring_path = None
+-        except config_parser.NoOptionError:
++        except ConfigParser.NoOptionError:
+             keyring_path = None
+ 
+         # load the keyring class name, and then load this keyring
+@@ -139,10 +147,10 @@
+             if config.has_section("backend"):
+                 keyring_name = config.get("backend", "default-keyring").strip()
+             else:
+-                raise config_parser.NoOptionError('backend', 'default-keyring')
++                raise ConfigParser.NoOptionError('backend', 'default-keyring')
+ 
+             keyring = load_keyring(keyring_path, keyring_name)
+-        except (config_parser.NoOptionError, ImportError):
++        except (ConfigParser.NoOptionError, ImportError):
+             logger.warning("Keyring config file contains incorrect values.\n" +
+                            "Config file: %s" % keyring_cfg)
+ 
+--- keyring/getpassbackend.py	2013-04-16 10:04:36.000000000 -0500
++++ keyring/getpassbackend.py	2013-04-12 09:26:11.962790900 -0500
+@@ -4,10 +4,10 @@
+ 
+ import keyring.core
+ 
++
+ def get_password(prompt='Password: ', stream=None,
+                  service_name='Python',
+                  username=None):
+     if username is None:
+         username = getpass.getuser()
+     return keyring.core.get_password(service_name, username)
+-
+--- keyring/http.py	2013-04-16 10:04:36.000000000 -0500
++++ keyring/http.py	2013-04-12 09:26:11.989799600 -0500
+@@ -7,7 +7,7 @@
+     handlers = [urllib2.HTTPBasicAuthHandler(PasswordMgr())]
+     urllib2.install_opener(handlers)
+     urllib2.urlopen(...)
+-    
++
+ This will prompt for a password if one is required and isn't already
+ in the keyring. Then, it adds it to the keyring for subsequent use.
+ """
+@@ -15,6 +15,7 @@
+ import keyring
+ import getpass
+ 
++
+ class PasswordMgr(object):
+     def get_username(self, realm, authuri):
+         return getpass.getuser()
 
=== added directory 'scripts/devsetup/patches/twisted'
=== added file 'scripts/devsetup/patches/twisted/5726.diff'
--- scripts/devsetup/patches/twisted/5726.diff	1970-01-01 00:00:00 +0000
+++ scripts/devsetup/patches/twisted/5726.diff	2013-05-06 19:02:26 +0000
@@ -0,0 +1,91 @@
+=== modified file 'twisted/internet/_dumbwin32proc.py'
+--- twisted/internet/_dumbwin32proc.py	2011-10-02 01:01:47 +0000
++++ twisted/internet/_dumbwin32proc.py	2012-07-16 21:39:49 +0000
+@@ -172,8 +172,9 @@
+         cmdline = quoteArguments(args)
+         # TODO: error detection here.  See #2787 and #4184.
+         def doCreate():
++            flags = win32con.CREATE_NO_WINDOW
+             self.hProcess, self.hThread, self.pid, dwTid = win32process.CreateProcess(
+-                command, cmdline, None, None, 1, 0, env, path, StartupInfo)
++                command, cmdline, None, None, 1, flags, env, path, StartupInfo)
+         try:
+             try:
+                 doCreate()
+
+=== modified file 'twisted/test/test_process.py'
+--- twisted/test/test_process.py	2012-07-08 18:39:59 +0000
++++ twisted/test/test_process.py	2012-07-19 05:27:43 +0000
+@@ -27,7 +27,7 @@
+ from twisted.python.log import msg
+ from twisted.internet import reactor, protocol, error, interfaces, defer
+ from twisted.trial import unittest
+-from twisted.python import util, runtime, procutils
++from twisted.python import filepath, util, runtime, procutils
+ from twisted.python.compat import set
+ 
+ 
+@@ -2350,6 +2350,48 @@
+ 
+ 
+ 
++class Win32CreateProcessFlagsTest(unittest.TestCase):
++    """
++    Check the flags passed to CreateProcess.
++    """
++
++    @defer.inlineCallbacks
++    def test_flags(self):
++        """
++        Verify that the flags passed to win32process.CreateProcess() prevent a
++        new console window from being created. See bug #5726 for a script to
++        test this interactively.
++        """
++        from twisted.internet import _dumbwin32proc
++        flags = []
++        real_CreateProcess = _dumbwin32proc.win32process.CreateProcess
++
++        def fake_createprocess(_appName, _commandLine, _processAttributes,
++                            _threadAttributes, _bInheritHandles, creationFlags,
++                            _newEnvironment, _currentDirectory, startupinfo):
++            """Store the creationFlags for later comparing."""
++            flags.append(creationFlags)
++            return real_CreateProcess(_appName, _commandLine,
++                            _processAttributes, _threadAttributes,
++                            _bInheritHandles, creationFlags, _newEnvironment,
++                            _currentDirectory, startupinfo)
++
++        self.patch(_dumbwin32proc.win32process, "CreateProcess",
++                   fake_createprocess)
++        exe = sys.executable
++        scriptPath = filepath.FilePath(__file__).sibling("process_cmdline.py")
++
++        d = defer.Deferred()
++        processProto = TrivialProcessProtocol(d)
++        comspec = str(os.environ["COMSPEC"])
++        cmd = [comspec, "/c", exe, scriptPath.path]
++        _dumbwin32proc.Process(reactor, processProto, None, cmd, {}, None)
++        yield d
++        self.assertEqual(flags,
++                         [_dumbwin32proc.win32process.CREATE_NO_WINDOW])
++
++
++
+ class UtilTestCase(unittest.TestCase):
+     """
+     Tests for process-related helper functions (currently only
+@@ -2553,6 +2595,7 @@
+     Win32ProcessTestCase.skip = skipMessage
+     TestTwoProcessesNonPosix.skip = skipMessage
+     Dumbwin32procPidTest.skip = skipMessage
++    Win32CreateProcessFlagsTest.skip = skipMessage
+     Win32UnicodeEnvironmentTest.skip = skipMessage
+ 
+ if not interfaces.IReactorProcess(reactor, None):
+
+=== added file 'twisted/topfiles/5726.bugfix'
+--- twisted/topfiles/5726.bugfix	1970-01-01 00:00:00 +0000
++++ twisted/topfiles/5726.bugfix	2012-07-16 22:43:20 +0000
+@@ -0,0 +1,1 @@
++spawnProcess no longer opens an unwanted console on Windows
+
 
=== added file 'scripts/devsetup/patches/twisted/6462.diff'
--- scripts/devsetup/patches/twisted/6462.diff	1970-01-01 00:00:00 +0000
+++ scripts/devsetup/patches/twisted/6462.diff	2013-05-06 19:02:26 +0000
@@ -0,0 +1,57 @@
+Index: twisted/internet/_dumbwin32proc.py
+===================================================================
+--- twisted/internet/_dumbwin32proc.py	(revision 38219)
++++ twisted/internet/_dumbwin32proc.py	(working copy)
+@@ -7,6 +7,7 @@
+ """
+ 
+ import os
++import sys
+ 
+ # Win32 imports
+ import win32api
+@@ -184,8 +185,9 @@
+                               'all must be unicode',):
+                     raise
+                 newenv = {}
++                encoding = sys.getfilesystemencoding()
+                 for key, value in env.items():
+-                    newenv[unicode(key)] = unicode(value)
++                    newenv[key.decode(encoding)] = value.decode(encoding)
+                 env = newenv
+                 doCreate()
+         except pywintypes.error, pwte:
+Index: twisted/test/test_process.py
+===================================================================
+--- twisted/test/test_process.py	(revision 38219)
++++ twisted/test/test_process.py	(working copy)
+@@ -2293,6 +2293,7 @@
+     """
+     goodKey = u'UNICODE'
+     goodValue = u'UNICODE'
++    encodedValue = u'jalape\xf1o'.encode("mbcs")
+ 
+     def test_encodableUnicodeEnvironment(self):
+         """
+@@ -2311,8 +2312,21 @@
+                 self.goodValue.encode('ascii'))
+         return p.getResult().addCallback(gotEnvironment)
+ 
++    def test_decodableUnicodeEnvironment(self):
++        """
++        Test C{os.environ} (inherited by every subprocess on Windows) that
++        contains an MBCS encoded byte string value."""
++        os.environ[self.goodKey] = self.encodedValue
++        self.addCleanup(operator.delitem, os.environ, self.goodKey)
+ 
++        p = GetEnvironmentDictionary.run(reactor, [], {})
++        def gotEnvironment(environ):
++            self.assertEqual(
++                environ[self.goodKey.encode('ascii')],
++                self.encodedValue)
++        return p.getResult().addCallback(gotEnvironment)
+ 
++
+ class Dumbwin32procPidTest(unittest.TestCase):
+     """
+     Simple test for the pid attribute of Process on win32.