gcloud 0.0.7 → 0.1.0

data/packages/gsutil/oauth2_plugin/oauth2_plugin.py

@@ -1,24 +0,0 @@
-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

@@ -1,54 +0,0 @@
-#!/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

@@ -1,60 +0,0 @@
-#!/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

@@ -1,141 +0,0 @@
-#!/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

@@ -1,21 +0,0 @@
-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

@@ -1,398 +0,0 @@
-#!/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