googlecloud 0.0.4 → 0.0.6

data/packages/gsutil/oauth2_plugin/oauth2_plugin.py

@@ -0,0 +1,24 @@
+from boto.auth_handler import AuthHandler
+from boto.auth_handler import NotReadyToAuthenticate 
+import oauth2_client
+import oauth2_helper
+
+class OAuth2Auth(AuthHandler):
+
+  capability = ['google-oauth2', 's3']
+
+  def __init__(self, path, config, provider):
+    if (provider.name == 'google'
+        and config.has_option('Credentials', 'gs_oauth2_refresh_token')):
+
+      self.oauth2_client = oauth2_helper.OAuth2ClientFromBotoConfig(config)
+
+      self.refresh_token = oauth2_client.RefreshToken(
+          self.oauth2_client,
+          config.get('Credentials', 'gs_oauth2_refresh_token'))
+    else:
+      raise NotReadyToAuthenticate()
+
+  def add_auth(self, http_request):
+    http_request.headers['Authorization'] = \
+        self.refresh_token.GetAuthorizationHeader()

data/packages/gsutil/pkg_gen.sh

@@ -0,0 +1,54 @@
+#!/bin/sh
+
+# Utility command to generate an rpm package file for gsutil.
+# This tool takes no arguments and leaves the resulting rpm package
+# file at this location under your home rpmbuild tree: 
+# $HOME/rpmbuild/RPMS/noarch/gsutil-$VERSION-<N>.noarch.rpm
+# where <N> is the build number.
+
+SPEC_FILE_IN=gsutil.spec.in
+SPEC_FILE=gsutil.spec
+
+# Pre-process the rpm spec file.
+python pkg_util.py
+
+# Get package name and version from spec file.
+NAME=`awk <$SPEC_FILE '/^Name:/ {print $2}'`
+if [ "$NAME" = "" ]
+then
+  echo "Error: Name variable not set properly in $SPEC_FILE."
+  exit 1
+fi
+
+VERSION=`awk <$SPEC_FILE '/^Version:/ {print $2}'`
+ROOT=$NAME-$VERSION
+STAGING_DIR=$HOME/rpmbuild/SOURCES/$ROOT
+
+# Update VERSION file to reflect current version.
+echo $VERSION >VERSION
+
+# Make sure STAGING_DIR is set so we don't do a recursive rm below
+# on an indeterminate location.
+if [ "$STAGING_DIR" = "" ]
+then
+  echo "Can't proceed - STAGING_DIR not set properly."
+  exit 1
+fi
+
+# Create staging dir and copy package files there, filtering .svn dirs 
+# and .pyc files.
+rm -rf $STAGING_DIR
+mkdir -p $STAGING_DIR
+find . -print | grep -v "\.svn" | grep -v "\.pyc$" | cpio -pud $STAGING_DIR
+
+# Generate archive from staging area contents, then clean up staging area.
+CUR_DIR=$PWD
+cd $STAGING_DIR/..
+zip -r $ROOT.zip $ROOT
+
+cd $CUR_DIR
+rm -rf $STAGING_DIR
+
+# New build RPM package based on generated spec file and archive contents.
+rpmbuild -ba gsutil.spec
+

data/packages/gsutil/pkg_util.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+# Utilities to facilitate maintaining one master list of package contents 
+# in MANIFEST.in and allow us to import that list into various packaging 
+# tools (e.g. rpmbuid and setup.py).
+
+# Define the file in which we maintain package contents. Rather than 
+# hard-coding our package contents, to ease maintenance we read the 
+# manifest file to obtain the list of files and directories to include.
+MANIFEST_IN = 'MANIFEST.in'
+
+# Define input and output files for customizing the rpm package spec.
+SPEC_IN = 'gsutil.spec.in'
+SPEC_OUT = 'gsutil.spec'
+
+# Root of rpmbuild tree for file enumeration in gsutil.spec file.
+RPM_ROOT = '%{_datadir}/%{name}/'
+
+def parse_manifest(files, dirs):
+  '''Parse contents of manifest file and append results to passed lists
+     of files and directories.
+  '''
+  f = open(MANIFEST_IN, 'r')
+  for line in f:
+    line = line.strip()
+    # Skip empty or comment lines.
+    if (len(line) <= 0) or (line[0] == '#'):
+      continue
+    tokens = line.split()
+    if len(tokens) >= 0:
+      if tokens[0] == 'include':
+        files.extend(tokens[1:])
+      elif tokens[0] == 'recursive-include' and tokens[2] == '*':
+        dirs.append(tokens[1])
+      else:
+        err = 'Unsupported type ' + tokens[0] + ' in ' + MANIFEST_IN + ' file.'
+        raise Exception(err)
+  f.close()
+
+# When executed as a separate script, create a dynamically generated rpm 
+# spec file. Otherwise, when loaded as a module by another script, no
+# specific actions are taken, other than making utility functions available
+# to the loading script.
+if __name__ == '__main__':
+  # Running as main so generate a new rpm spec file.
+  files = []
+  dirs = []
+  parse_manifest(files, dirs)
+  fin = open(SPEC_IN, 'r')
+  fout = open(SPEC_OUT, 'w')
+  for line in fin:
+    if line.strip() == '###FILES_GO_HERE###':
+      for file in files:
+        fout.write(RPM_ROOT + file + '\n')
+      for dir in dirs:
+        fout.write(RPM_ROOT + dir + '/\n')
+    else:
+      fout.write(line)
+  fout.close()
+  fin.close()

data/packages/gsutil/setup.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+# coding=utf8
+# Copyright 2011 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''Distutils setup.py script for Google Cloud Storage command line tool.'''
+
+import glob
+import sys
+import os
+import platform
+from distutils.core import setup
+from pkg_util import parse_manifest
+
+print '''
+NOTE: Enterprise mode (installing gsutil via setup.py) is no longer officially 
+supported - unpacking the zip file into a directory is the preferred method 
+for installing gsutil for both shared and private configurations. See README 
+and README.pkg for further details.
+'''
+
+# Command name and target directory.
+NAME = 'gsutil'
+TARGET = '/usr/share/gsutil'
+BINDIR = '/usr/bin'
+
+# Enterprise mode (shared/central) installation is not supported
+# on Windows.
+system = platform.system()
+if system.lower().startswith('windows'):
+  error = 'ERROR: enterprise (shared/central) installation is not ' \
+          'supported on Windows.'
+  exit(error)
+
+def walk(dir, paths):
+  '''Do a recursive file tree walk, adding files found to passed dict.'''
+  for file in os.listdir(dir):
+    # Skip "dot files".
+    if file[0] == '.':
+      continue
+    path = dir + '/' + file
+    if os.path.isdir(path):
+      walk(path, paths)
+    else:
+      if dir not in paths:
+        paths[dir] = []
+      paths[dir].append(path)
+
+def first_token(filename):
+  '''Open file, read first line, parse & return first token to caller.'''
+  token = None
+  f = open(filename, 'r')
+  line = f.readline().strip()
+  tokens = line.split()
+  token = tokens[0]
+  f.close()
+  return token
+
+# Validate python version.
+if sys.version_info <= (2, 6):
+  error = 'ERROR: gsutil requires Python Version 2.6 or above...exiting.'
+  exit(error)
+
+# Rather than hard-coding package contents here, we read the manifest 
+# file to obtain the list of files and directories to include.
+files = []
+dirs = []
+parse_manifest(files, dirs)
+
+# Build list of data files dynamically.
+data_files = [(TARGET, files)]
+paths = {}
+for dir in dirs:
+  walk(dir, paths)
+for path in paths:
+  data_files += (os.path.join(TARGET, path), paths[path]),
+
+long_desc = '''
+GSUtil is a Python application that lets you access Google Cloud Storage 
+from the command line. You can use GSUtil to do a wide range of bucket and 
+object management tasks, including:
+- Creating and deleting buckets.
+- Uploading, downloading, and deleting objects.
+- Listing buckets and objects.
+- Moving, copying, and renaming objects.
+- Setting object and bucket ACLs.
+'''
+
+VERSION = first_token('VERSION')
+if not VERSION:
+  error = 'ERROR: can\'t find gsutil version...exiting.'
+  exit(error)
+
+# This is the main function call that installs the gsutil package. See
+# distutil documentation for details on this function and its arguments.
+setup(name = NAME,
+      version = VERSION,
+      license = 'Apache 2.0',
+      author = 'Google',
+      author_email = 'gs-team@google.com',
+      url = 'http://code.google.com/apis/storage/docs/gsutil.html',
+      description = 'gsutil - command line utility for Google Cloud Storage',
+      long_description = long_desc,
+      data_files = data_files,
+      # Dependency on boto commented out for now because initially we plan to 
+      # bundle boto with this package, however, when we're ready to depend on 
+      # a separate boto rpm package, this line should be uncommented.
+      #requires = ['boto (>=2.0)'],
+      )
+
+# Create symlink from /usr/bin/gsutil to /usr/share/gsutil/gsutil but
+# only run directly in enterprise mode (see README.pkg). When run by
+# rpmbuild we don't want to create this link because it's done by the 
+# rpm spec file slightly differently (using a relative link). Same story 
+# for permission setting, which is only needed if not run by rpmbuild.
+if not os.environ.get('RPM_BUILD_ROOT'):
+  link = os.path.join(BINDIR, NAME)
+  dest = os.path.join(TARGET, NAME)
+  if not os.path.exists(link):
+    os.symlink(dest, link)
+  # Make all files and dirs in install area readable by other
+  # and make all directories executable by other. These steps
+  # are performed in support of the enterprise (shared/central)
+  # installation mode, in which users with different user/group
+  # than the installation user/group must be able to run gsutil.
+  os.system('chmod -R o+r ' + TARGET)
+  os.system('find ' + TARGET + ' -type d | xargs chmod o+x')
+  # Make main gsutil script readable and executable by other.
+  os.system('chmod o+rx ' + os.path.join(TARGET, NAME))
+

data/packages/gsutil/third_party/fancy_urllib/README

@@ -0,0 +1,21 @@
+The fancy_urllib library was obtained from
+http://googleappengine.googlecode.com/svn/trunk/python/lib/fancy_urllib/fancy_urllib/__init__.py
+under the following license (http://googleappengine.googlecode.com/svn/trunk/python/LICENSE):
+
+
+GOOGLE APP ENGINE SDK
+=====================
+Copyright 2008 Google Inc.
+All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/packages/gsutil/third_party/fancy_urllib/__init__.py

@@ -0,0 +1,398 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Python Software
+# Foundation; All Rights Reserved
+
+"""A HTTPSConnection/Handler with additional proxy and cert validation features.
+
+In particular, monkey patches in Python r74203 to provide support for CONNECT
+proxies and adds SSL cert validation if the ssl module is present.
+"""
+
+__author__ = "{frew,nick.johnson}@google.com (Fred Wulff and Nick Johnson)"
+
+import base64
+import httplib
+import logging
+import re
+import socket
+import urllib2
+
+from urllib import splittype
+from urllib import splituser
+from urllib import splitpasswd
+
+class InvalidCertificateException(httplib.HTTPException):
+  """Raised when a certificate is provided with an invalid hostname."""
+
+  def __init__(self, host, cert, reason):
+    """Constructor.
+
+    Args:
+      host: The hostname the connection was made to.
+      cert: The SSL certificate (as a dictionary) the host returned.
+    """
+    httplib.HTTPException.__init__(self)
+    self.host = host
+    self.cert = cert
+    self.reason = reason
+
+  def __str__(self):
+    return ('Host %s returned an invalid certificate (%s): %s\n'
+            'To learn more, see '
+            'http://code.google.com/appengine/kb/general.html#rpcssl' %
+            (self.host, self.reason, self.cert))
+
+def can_validate_certs():
+  """Return True if we have the SSL package and can validate certificates."""
+  try:
+    import ssl
+    return True
+  except ImportError:
+    return False
+
+def _create_fancy_connection(tunnel_host=None, key_file=None,
+                             cert_file=None, ca_certs=None):
+  # This abomination brought to you by the fact that
+  # the HTTPHandler creates the connection instance in the middle
+  # of do_open so we need to add the tunnel host to the class.
+
+  class PresetProxyHTTPSConnection(httplib.HTTPSConnection):
+    """An HTTPS connection that uses a proxy defined by the enclosing scope."""
+
+    def __init__(self, *args, **kwargs):
+      httplib.HTTPSConnection.__init__(self, *args, **kwargs)
+
+      self._tunnel_host = tunnel_host
+      if tunnel_host:
+        logging.debug("Creating preset proxy https conn: %s", tunnel_host)
+
+      self.key_file = key_file
+      self.cert_file = cert_file
+      self.ca_certs = ca_certs
+      try:
+        import ssl
+        if self.ca_certs:
+          self.cert_reqs = ssl.CERT_REQUIRED
+        else:
+          self.cert_reqs = ssl.CERT_NONE
+      except ImportError:
+        pass
+
+    def _tunnel(self):
+      self._set_hostport(self._tunnel_host, None)
+      logging.info("Connecting through tunnel to: %s:%d",
+                   self.host, self.port)
+      self.send("CONNECT %s:%d HTTP/1.0\r\n\r\n" % (self.host, self.port))
+      response = self.response_class(self.sock, strict=self.strict,
+                                     method=self._method)
+      (_, code, message) = response._read_status()
+
+      if code != 200:
+        self.close()
+        raise socket.error, "Tunnel connection failed: %d %s" % (
+            code, message.strip())
+
+      while True:
+        line = response.fp.readline()
+        if line == "\r\n":
+          break
+
+    def _get_valid_hosts_for_cert(self, cert):
+      """Returns a list of valid host globs for an SSL certificate.
+
+      Args:
+        cert: A dictionary representing an SSL certificate.
+      Returns:
+        list: A list of valid host globs.
+      """
+      if 'subjectAltName' in cert:
+        return [x[1] for x in cert['subjectAltName'] if x[0].lower() == 'dns']
+      else:
+        # Return a list of commonName fields
+        return [x[0][1] for x in cert['subject']
+                if x[0][0].lower() == 'commonname']
+
+    def _validate_certificate_hostname(self, cert, hostname):
+      """Validates that a given hostname is valid for an SSL certificate.
+
+      Args:
+        cert: A dictionary representing an SSL certificate.
+        hostname: The hostname to test.
+      Returns:
+        bool: Whether or not the hostname is valid for this certificate.
+      """
+      hosts = self._get_valid_hosts_for_cert(cert)
+      for host in hosts:
+        # Convert the glob-style hostname expression (eg, '*.google.com') into a
+        # valid regular expression.
+        host_re = host.replace('.', '\.').replace('*', '[^.]*')
+        if re.search('^%s$' % (host_re,), hostname, re.I):
+          return True
+      return False
+
+
+    def connect(self):
+      # TODO(frew): When we drop support for <2.6 (in the far distant future),
+      # change this to socket.create_connection.
+      self.sock = _create_connection((self.host, self.port))
+
+      if self._tunnel_host:
+        self._tunnel()
+
+      # ssl and FakeSocket got deprecated. Try for the new hotness of wrap_ssl,
+      # with fallback.
+      try:
+        import ssl
+        self.sock = ssl.wrap_socket(self.sock,
+                                    keyfile=self.key_file,
+                                    certfile=self.cert_file,
+                                    ca_certs=self.ca_certs,
+                                    cert_reqs=self.cert_reqs)
+
+        if self.cert_reqs & ssl.CERT_REQUIRED:
+          cert = self.sock.getpeercert()
+          hostname = self.host.split(':', 0)[0]
+          if not self._validate_certificate_hostname(cert, hostname):
+            raise InvalidCertificateException(hostname, cert,
+                                              'hostname mismatch')
+      except ImportError:
+        ssl = socket.ssl(self.sock,
+                         keyfile=self.key_file,
+                         certfile=self.cert_file)
+        self.sock = httplib.FakeSocket(self.sock, ssl)
+
+  return PresetProxyHTTPSConnection
+
+
+# Here to end of _create_connection copied wholesale from Python 2.6"s socket.py
+_GLOBAL_DEFAULT_TIMEOUT = object()
+
+
+def _create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT):
+  """Connect to *address* and return the socket object.
+
+  Convenience function.  Connect to *address* (a 2-tuple ``(host,
+  port)``) and return the socket object.  Passing the optional
+  *timeout* parameter will set the timeout on the socket instance
+  before attempting to connect.  If no *timeout* is supplied, the
+  global default timeout setting returned by :func:`getdefaulttimeout`
+  is used.
+  """
+
+  msg = "getaddrinfo returns an empty list"
+  host, port = address
+  for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
+    af, socktype, proto, canonname, sa = res
+    sock = None
+    try:
+      sock = socket.socket(af, socktype, proto)
+      if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
+        sock.settimeout(timeout)
+      sock.connect(sa)
+      return sock
+
+    except socket.error, msg:
+      if sock is not None:
+        sock.close()
+
+  raise socket.error, msg
+
+
+class FancyRequest(urllib2.Request):
+  """A request that allows the use of a CONNECT proxy."""
+
+  def __init__(self, *args, **kwargs):
+    urllib2.Request.__init__(self, *args, **kwargs)
+    self._tunnel_host = None
+    self._key_file = None
+    self._cert_file = None
+    self._ca_certs = None
+
+  def set_proxy(self, host, type):
+    saved_type = None
+
+    if self.get_type() == "https" and not self._tunnel_host:
+      self._tunnel_host = self.get_host()
+      saved_type = self.get_type()
+    urllib2.Request.set_proxy(self, host, type)
+
+    if saved_type:
+      # Don't set self.type, we want to preserve the
+      # type for tunneling.
+      self.type = saved_type
+
+  def set_ssl_info(self, key_file=None, cert_file=None, ca_certs=None):
+    self._key_file = key_file
+    self._cert_file = cert_file
+    self._ca_certs = ca_certs
+
+
+class FancyProxyHandler(urllib2.ProxyHandler):
+  """A ProxyHandler that works with CONNECT-enabled proxies."""
+
+  # Taken verbatim from /usr/lib/python2.5/urllib2.py
+  def _parse_proxy(self, proxy):
+    """Return (scheme, user, password, host/port) given a URL or an authority.
+
+    If a URL is supplied, it must have an authority (host:port) component.
+    According to RFC 3986, having an authority component means the URL must
+    have two slashes after the scheme:
+
+    >>> _parse_proxy('file:/ftp.example.com/')
+    Traceback (most recent call last):
+    ValueError: proxy URL with no authority: 'file:/ftp.example.com/'
+
+    The first three items of the returned tuple may be None.
+
+    Examples of authority parsing:
+
+    >>> _parse_proxy('proxy.example.com')
+    (None, None, None, 'proxy.example.com')
+    >>> _parse_proxy('proxy.example.com:3128')
+    (None, None, None, 'proxy.example.com:3128')
+
+    The authority component may optionally include userinfo (assumed to be
+    username:password):
+
+    >>> _parse_proxy('joe:password@proxy.example.com')
+    (None, 'joe', 'password', 'proxy.example.com')
+    >>> _parse_proxy('joe:password@proxy.example.com:3128')
+    (None, 'joe', 'password', 'proxy.example.com:3128')
+
+    Same examples, but with URLs instead:
+
+    >>> _parse_proxy('http://proxy.example.com/')
+    ('http', None, None, 'proxy.example.com')
+    >>> _parse_proxy('http://proxy.example.com:3128/')
+    ('http', None, None, 'proxy.example.com:3128')
+    >>> _parse_proxy('http://joe:password@proxy.example.com/')
+    ('http', 'joe', 'password', 'proxy.example.com')
+    >>> _parse_proxy('http://joe:password@proxy.example.com:3128')
+    ('http', 'joe', 'password', 'proxy.example.com:3128')
+
+    Everything after the authority is ignored:
+
+    >>> _parse_proxy('ftp://joe:password@proxy.example.com/rubbish:3128')
+    ('ftp', 'joe', 'password', 'proxy.example.com')
+
+    Test for no trailing '/' case:
+
+    >>> _parse_proxy('http://joe:password@proxy.example.com')
+    ('http', 'joe', 'password', 'proxy.example.com')
+
+    """
+    scheme, r_scheme = splittype(proxy)
+    if not r_scheme.startswith("/"):
+      # authority
+      scheme = None
+      authority = proxy
+    else:
+      # URL
+      if not r_scheme.startswith("//"):
+        raise ValueError("proxy URL with no authority: %r" % proxy)
+      # We have an authority, so for RFC 3986-compliant URLs (by ss 3.
+      # and 3.3.), path is empty or starts with '/'
+      end = r_scheme.find("/", 2)
+      if end == -1:
+        end = None
+      authority = r_scheme[2:end]
+    userinfo, hostport = splituser(authority)
+    if userinfo is not None:
+      user, password = splitpasswd(userinfo)
+    else:
+      user = password = None
+    return scheme, user, password, hostport
+
+  def proxy_open(self, req, proxy, type):
+    # This block is copied wholesale from Python2.6 urllib2.
+    # It is idempotent, so the superclass method call executes as normal
+    # if invoked.
+    orig_type = req.get_type()
+    proxy_type, user, password, hostport = self._parse_proxy(proxy)
+    if proxy_type is None:
+      proxy_type = orig_type
+    if user and password:
+      user_pass = "%s:%s" % (urllib2.unquote(user), urllib2.unquote(password))
+      creds = base64.b64encode(user_pass).strip()
+      # Later calls overwrite earlier calls for the same header
+      req.add_header("Proxy-authorization", "Basic " + creds)
+    hostport = urllib2.unquote(hostport)
+    req.set_proxy(hostport, proxy_type)
+    # This condition is the change
+    if orig_type == "https":
+      return None
+
+    return urllib2.ProxyHandler.proxy_open(self, req, proxy, type)
+
+
+class FancyHTTPSHandler(urllib2.HTTPSHandler):
+  """An HTTPSHandler that works with CONNECT-enabled proxies."""
+
+  def do_open(self, http_class, req):
+    # Intentionally very specific so as to opt for false negatives
+    # rather than false positives.
+    try:
+      return urllib2.HTTPSHandler.do_open(
+          self,
+          _create_fancy_connection(req._tunnel_host,
+                                   req._key_file,
+                                   req._cert_file,
+                                   req._ca_certs),
+          req)
+    except urllib2.URLError, url_error:
+      try:
+        import ssl
+        if (type(url_error.reason) == ssl.SSLError and
+            url_error.reason.args[0] == 1):
+          # Display the reason to the user. Need to use args for python2.5
+          # compat.
+          raise InvalidCertificateException(req.host, '',
+                                            url_error.reason.args[1])
+      except ImportError:
+        pass
+
+      raise url_error
+
+
+# We have to implement this so that we persist the tunneling behavior
+# through redirects.
+class FancyRedirectHandler(urllib2.HTTPRedirectHandler):
+  """A redirect handler that persists CONNECT-enabled proxy information."""
+
+  def redirect_request(self, req, *args, **kwargs):
+    new_req = urllib2.HTTPRedirectHandler.redirect_request(
+        self, req, *args, **kwargs)
+    # Same thing as in our set_proxy implementation, but in this case
+    # we"ve only got a Request to work with, so it was this or copy
+    # everything over piecemeal.
+    #
+    # Note that we do not persist tunneling behavior from an http request
+    # to an https request, because an http request does not set _tunnel_host.
+    #
+    # Also note that in Python < 2.6, you will get an error in
+    # FancyHTTPSHandler.do_open() on an https urllib2.Request that uses an http
+    # proxy, since the proxy type will be set to http instead of https.
+    # (FancyRequest, and urllib2.Request in Python >= 2.6 set the proxy type to
+    # https.)  Such an urllib2.Request could result from this redirect
+    # if you are redirecting from an http request (since an an http request
+    # does not have _tunnel_host set, and thus you will not set the proxy
+    # in the code below), and if you have defined a proxy for https in, say,
+    # FancyProxyHandler, and that proxy has type http.
+    if hasattr(req, "_tunnel_host") and isinstance(new_req, urllib2.Request):
+      if new_req.get_type() == "https":
+        if req._tunnel_host:
+          # req is proxied, so copy the proxy info.
+          new_req._tunnel_host = new_req.get_host()
+          new_req.set_proxy(req.host, "https")
+        else:
+          # req is not proxied, so just make sure _tunnel_host is defined.
+          new_req._tunnel_host = None
+        new_req.type = "https"
+    if hasattr(req, "_key_file") and isinstance(new_req, urllib2.Request):
+      # Copy the auxiliary data in case this or any further redirect is https
+      new_req._key_file = req._key_file
+      new_req._cert_file = req._cert_file
+      new_req._ca_certs = req._ca_certs
+
+    return new_req