Remove telemetry/third_party/gsutilz

tools/telemetry/third_party/gsutilz/third_party/boto/boto/manage/cmdshell.py

Index: tools/telemetry/third_party/gsutilz/third_party/boto/boto/manage/cmdshell.py
diff --git a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/manage/cmdshell.py b/tools/telemetry/third_party/gsutilz/third_party/boto/boto/manage/cmdshell.py
deleted file mode 100644
index f53227763a08a4c9c1beb94e585ab04c0e4dce40..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/manage/cmdshell.py
+++ /dev/null
@@ -1,407 +0,0 @@
-# Copyright (c) 2006-2009 Mitch Garnaat http://garnaat.org/
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-"""
-The cmdshell module uses the paramiko package to create SSH connections
-to the servers that are represented by instance objects. The module has
-functions for running commands, managing files, and opening interactive
-shell sessions over those connections.
-"""
-from boto.mashups.interactive import interactive_shell
-import boto
-import os
-import time
-import shutil
-import paramiko
-import socket
-import subprocess
-
-from boto.compat import StringIO
-
-class SSHClient(object):
-    """
-    This class creates a paramiko.SSHClient() object that represents
-    a session with an SSH server. You can use the SSHClient object to send
-    commands to the remote host and manipulate files on the remote host. 
-    
-    :ivar server: A Server object or FakeServer object.
-    :ivar host_key_file: The path to the user's .ssh key files.
-    :ivar uname: The username for the SSH connection. Default = 'root'.
-    :ivar timeout: The optional timeout variable for the TCP connection.
-    :ivar ssh_pwd: An optional password to use for authentication or for
-                    unlocking the private key.
-    """
-    def __init__(self, server,
-                 host_key_file='~/.ssh/known_hosts',
-                 uname='root', timeout=None, ssh_pwd=None):
-        self.server = server
-        self.host_key_file = host_key_file
-        self.uname = uname
-        self._timeout = timeout
-        self._pkey = paramiko.RSAKey.from_private_key_file(server.ssh_key_file,
-                                                           password=ssh_pwd)
-        self._ssh_client = paramiko.SSHClient()
-        self._ssh_client.load_system_host_keys()
-        self._ssh_client.load_host_keys(os.path.expanduser(host_key_file))
-        self._ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-        self.connect()
-
-    def connect(self, num_retries=5):
-        """
-        Connect to an SSH server and authenticate with it.
-        
-        :type num_retries: int
-        :param num_retries: The maximum number of connection attempts.
-        """
-        retry = 0
-        while retry < num_retries:
-            try:
-                self._ssh_client.connect(self.server.hostname,
-                                         username=self.uname,
-                                         pkey=self._pkey,
-                                         timeout=self._timeout)
-                return
-            except socket.error as xxx_todo_changeme:
-                (value, message) = xxx_todo_changeme.args
-                if value in (51, 61, 111):
-                    print('SSH Connection refused, will retry in 5 seconds')
-                    time.sleep(5)
-                    retry += 1
-                else:
-                    raise
-            except paramiko.BadHostKeyException:
-                print("%s has an entry in ~/.ssh/known_hosts and it doesn't match" % self.server.hostname)
-                print('Edit that file to remove the entry and then hit return to try again')
-                raw_input('Hit Enter when ready')
-                retry += 1
-            except EOFError:
-                print('Unexpected Error from SSH Connection, retry in 5 seconds')
-                time.sleep(5)
-                retry += 1
-        print('Could not establish SSH connection')
-
-    def open_sftp(self):
-        """
-        Open an SFTP session on the SSH server.
-        
-        :rtype: :class:`paramiko.sftp_client.SFTPClient`
-        :return: An SFTP client object.
-        """
-        return self._ssh_client.open_sftp()
-
-    def get_file(self, src, dst):
-        """
-        Open an SFTP session on the remote host, and copy a file from
-        the remote host to the specified path on the local host.
-        
-        :type src: string
-        :param src: The path to the target file on the remote host.
-        
-        :type dst: string
-        :param dst: The path on your local host where you want to
-                    store the file.
-        """
-        sftp_client = self.open_sftp()
-        sftp_client.get(src, dst)
-
-    def put_file(self, src, dst):
-        """
-        Open an SFTP session on the remote host, and copy a file from
-        the local host to the specified path on the remote host.
-        
-        :type src: string
-        :param src: The path to the target file on your local host.
-        
-        :type dst: string
-        :param dst: The path on the remote host where you want to store
-                    the file.
-        """
-        sftp_client = self.open_sftp()
-        sftp_client.put(src, dst)
-
-    def open(self, filename, mode='r', bufsize=-1):
-        """
-        Open an SFTP session to the remote host, and open a file on
-        that host.
-        
-        :type filename: string
-        :param filename: The path to the file on the remote host.
-        
-        :type mode: string
-        :param mode: The file interaction mode.
-        
-        :type bufsize: integer
-        :param bufsize: The file buffer size.
-        
-        :rtype: :class:`paramiko.sftp_file.SFTPFile`
-        :return: A paramiko proxy object for a file on the remote server.
-        """
-        sftp_client = self.open_sftp()
-        return sftp_client.open(filename, mode, bufsize)
-
-    def listdir(self, path):
-        """
-        List all of the files and subdirectories at the specified path
-        on the remote host.
-        
-        :type path: string
-        :param path: The base path from which to obtain the list.
-          
-        :rtype: list
-        :return: A list of files and subdirectories at the specified path.
-        """
-        sftp_client = self.open_sftp()
-        return sftp_client.listdir(path)
-
-    def isdir(self, path):
-        """
-        Check the specified path on the remote host to determine if
-        it is a directory.
-        
-        :type path: string
-        :param path: The path to the directory that you want to check.
-        
-        :rtype: integer
-        :return: If the path is a directory, the function returns 1.
-                If the path is a file or an invalid path, the function
-                returns 0.
-        """
-        status = self.run('[ -d %s ] || echo "FALSE"' % path)
-        if status[1].startswith('FALSE'):
-            return 0
-        return 1
-
-    def exists(self, path):
-        """
-        Check the remote host for the specified path, or a file
-        at the specified path. This function returns 1 if the
-        path or the file exist on the remote host, and returns 0 if
-        the path or the file does not exist on the remote host.
-        
-        :type path: string
-        :param path: The path to the directory or file that you want to check.
-        
-        :rtype: integer
-        :return: If the path or the file exist, the function returns 1.
-                If the path or the file do not exist on the remote host,
-                the function returns 0.
-        """
-        
-        status = self.run('[ -a %s ] || echo "FALSE"' % path)
-        if status[1].startswith('FALSE'):
-            return 0
-        return 1
-
-    def shell(self):
-        """
-        Start an interactive shell session with the remote host.
-        """
-        channel = self._ssh_client.invoke_shell()
-        interactive_shell(channel)
-
-    def run(self, command):
-        """
-        Run a command on the remote host.
-        
-        :type command: string
-        :param command: The command that you want to send to the remote host.
-
-        :rtype: tuple
-        :return: This function returns a tuple that contains an integer status,
-                the stdout from the command, and the stderr from the command.
-
-        """
-        boto.log.debug('running:%s on %s' % (command, self.server.instance_id))
-        status = 0
-        try:
-            t = self._ssh_client.exec_command(command)
-        except paramiko.SSHException:
-            status = 1
-        std_out = t[1].read()
-        std_err = t[2].read()
-        t[0].close()
-        t[1].close()
-        t[2].close()
-        boto.log.debug('stdout: %s' % std_out)
-        boto.log.debug('stderr: %s' % std_err)
-        return (status, std_out, std_err)
-
-    def run_pty(self, command):
-        """
-        Request a pseudo-terminal from a server, and execute a command on that
-        server.
-
-        :type command: string
-        :param command: The command that you want to run on the remote host.
-        
-        :rtype: :class:`paramiko.channel.Channel`
-        :return: An open channel object.
-        """
-        boto.log.debug('running:%s on %s' % (command, self.server.instance_id))
-        channel = self._ssh_client.get_transport().open_session()
-        channel.get_pty()
-        channel.exec_command(command)
-        return channel
-
-    def close(self):
-        """
-        Close an SSH session and any open channels that are tied to it.
-        """
-        transport = self._ssh_client.get_transport()
-        transport.close()
-        self.server.reset_cmdshell()
-
-class LocalClient(object):
-    """
-    :ivar server: A Server object or FakeServer object.
-    :ivar host_key_file: The path to the user's .ssh key files.
-    :ivar uname: The username for the SSH connection. Default = 'root'.
-    """
-    def __init__(self, server, host_key_file=None, uname='root'):
-        self.server = server
-        self.host_key_file = host_key_file
-        self.uname = uname
-
-    def get_file(self, src, dst):
-        """
-        Copy a file from one directory to another.
-        """
-        shutil.copyfile(src, dst)
-
-    def put_file(self, src, dst):
-        """
-        Copy a file from one directory to another.
-        """
-        shutil.copyfile(src, dst)
-
-    def listdir(self, path):
-        """
-        List all of the files and subdirectories at the specified path.
-        
-        :rtype: list
-        :return: Return a list containing the names of the entries
-                in the directory given by path.
-        """
-        return os.listdir(path)
-
-    def isdir(self, path):
-        """
-        Check the specified path to determine if it is a directory.
-        
-        :rtype: boolean
-        :return: Returns True if the path is an existing directory.
-        """
-        return os.path.isdir(path)
-
-    def exists(self, path):
-        """
-        Check for the specified path, or check a file at the specified path.
-        
-        :rtype: boolean
-        :return: If the path or the file exist, the function returns True.
-        """
-        return os.path.exists(path)
-
-    def shell(self):
-        raise NotImplementedError('shell not supported with LocalClient')
-
-    def run(self):
-        """
-        Open a subprocess and run a command on the local host.
-        
-        :rtype: tuple
-        :return: This function returns a tuple that contains an integer status
-                and a string with the combined stdout and stderr output.
-        """
-        boto.log.info('running:%s' % self.command)
-        log_fp = StringIO()
-        process = subprocess.Popen(self.command, shell=True, stdin=subprocess.PIPE,
-                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        while process.poll() is None:
-            time.sleep(1)
-            t = process.communicate()
-            log_fp.write(t[0])
-            log_fp.write(t[1])
-        boto.log.info(log_fp.getvalue())
-        boto.log.info('output: %s' % log_fp.getvalue())
-        return (process.returncode, log_fp.getvalue())
-
-    def close(self):
-        pass
-
-class FakeServer(object):
-    """
-    This object has a subset of the variables that are normally in a
-    :class:`boto.manage.server.Server` object. You can use this FakeServer
-    object to create a :class:`boto.manage.SSHClient` object if you
-    don't have a real Server object.
-    
-    :ivar instance: A boto Instance object.
-    :ivar ssh_key_file: The path to the SSH key file.
-    """
-    def __init__(self, instance, ssh_key_file):
-        self.instance = instance
-        self.ssh_key_file = ssh_key_file
-        self.hostname = instance.dns_name
-        self.instance_id = self.instance.id
-
-def start(server):
-    """
-    Connect to the specified server.
-
-    :return: If the server is local, the function returns a 
-            :class:`boto.manage.cmdshell.LocalClient` object.
-            If the server is remote, the function returns a
-            :class:`boto.manage.cmdshell.SSHClient` object.
-    """
-    instance_id = boto.config.get('Instance', 'instance-id', None)
-    if instance_id == server.instance_id:
-        return LocalClient(server)
-    else:
-        return SSHClient(server)
-
-def sshclient_from_instance(instance, ssh_key_file,
-                            host_key_file='~/.ssh/known_hosts',
-                            user_name='root', ssh_pwd=None):
-    """
-    Create and return an SSHClient object given an
-    instance object.
-
-    :type instance: :class`boto.ec2.instance.Instance` object
-    :param instance: The instance object.
-
-    :type ssh_key_file: string
-    :param ssh_key_file: A path to the private key file that is 
-                        used to log into the instance.
-
-    :type host_key_file: string
-    :param host_key_file: A path to the known_hosts file used
-                          by the SSH client.
-                          Defaults to ~/.ssh/known_hosts
-    :type user_name: string
-    :param user_name: The username to use when logging into
-                      the instance.  Defaults to root.
-
-    :type ssh_pwd: string
-    :param ssh_pwd: The passphrase, if any, associated with
-                    private key.
-    """
-    s = FakeServer(instance, ssh_key_file)
-    return SSHClient(s, host_key_file, user_name, ssh_pwd)