~bmerry/duplicity/pydrive-regular

        try:

            if os.path.isfile("/etc/ssh/ssh_known_hosts"):

                self.client.load_system_host_keys("/etc/ssh/ssh_known_hosts")

            raise BackendException("could not load /etc/ssh/ssh_known_hosts, maybe corrupt?")

        try:

            # use load_host_keys() to signal it's writable to paramiko

                self.client.load_host_keys(file)

            else:

                self.client._host_keys_filename = file

            raise BackendException("could not load ~/.ssh/known_hosts, maybe corrupt?")

 

        """ the next block reorganizes all host parameters into a

                                allow_agent=True, 

                                look_for_keys=True,

                                key_filename=self.config['identityfile'])

            raise BackendException("ssh connection to %s@%s:%d failed: %s" % (

                                    self.config['user'],

                                    self.config['hostname'],

        else:

            try:

                self.sftp=self.client.open_sftp()

                raise BackendException("sftp negotiation failed: %s" % e)

 

 

                        continue

                    try:

                        attrs=self.sftp.stat(d)

                        if e.errno == errno.ENOENT:

                            try:

                                self.sftp.mkdir(d)

                                raise BackendException("sftp mkdir %s failed: %s" % (self.sftp.normalize(".")+"/"+d,e))

                        else:

                            raise BackendException("sftp stat %s failed: %s" % (self.sftp.normalize(".")+"/"+d,e))

                    try:

                        self.sftp.chdir(d)

                        raise BackendException("sftp chdir to %s failed: %s" % (self.sftp.normalize(".")+"/"+d,e))

 

    def put(self, source_path, remote_filename = None):

                        chan=self.client.get_transport().open_session()

                        chan.settimeout(globals.timeout)

                        chan.exec_command("scp -t '%s'" % self.remote_dir) # scp in sink mode uses the arg as base directory

                        raise BackendException("scp execution failed: %s" % e)

                    # scp protocol: one 0x0 after startup, one after the Create meta, one after saving

                    # if there's a problem: 0x1 or 0x02 and some error text

                    try:

                        self.sftp.put(source_path.name,remote_filename)

                        return

                        raise BackendException("sftp put of %s (as %s) failed: %s" % (source_path.name,remote_filename,e))

                log.Warn("%s (Try %d of %d) Will retry in %d seconds." % (e,n,globals.num_retries,self.retry_delay))

        raise BackendException("Giving up trying to upload '%s' after %d attempts" % (remote_filename,n))

 

                        chan=self.client.get_transport().open_session()

                        chan.settimeout(globals.timeout)

                        chan.exec_command("scp -f '%s/%s'" % (self.remote_dir,remote_filename))

                        raise BackendException("scp execution failed: %s" % e)

 

                    chan.send('\0')     # overall ready indicator

                            buff=chan.recv(blocksize)

                            f.write(buff)

                            togo-=len(buff)

                        raise BackendException("scp get %s failed: %s" % (remote_filename,e))

 

                    msg=chan.recv(1)    # check the final status

                    try:

                        self.sftp.get(remote_filename,local_path.name)

                        return

                        raise BackendException("sftp get of %s (to %s) failed: %s" % (remote_filename,local_path.name,e))

                local_path.setdata()

                log.Warn("%s (Try %d of %d) Will retry in %d seconds." % (e,n,globals.num_retries,self.retry_delay))

        raise BackendException("Giving up trying to download '%s' after %d attempts" % (remote_filename,n))

 

                else:

                    try:

                        return self.sftp.listdir()

                        raise BackendException("sftp listing of %s failed: %s" % (self.sftp.getcwd(),e))

                log.Warn("%s (Try %d of %d) Will retry in %d seconds." % (e,n,globals.num_retries,self.retry_delay))

        raise BackendException("Giving up trying to list '%s' after %d attempts" % (self.remote_dir,n))

 

                    else:

                        try:

                            self.sftp.remove(fn)

                            raise BackendException("sftp rm %s failed: %s" % (fn,e))

 

                    # If we get here, we deleted this file successfully. Move on to the next one.

                    break

                    if n == globals.num_retries:

                        log.FatalError(str(e), log.ErrorCode.backend_error)

                    else:

            chan=self.client.get_transport().open_session()

            chan.settimeout(globals.timeout)

            chan.exec_command(cmd)

            raise BackendException("%sexecution failed: %s" % (errorprefix,e))

        output=chan.recv(-1)

        res=chan.recv_exit_status()

        sshconfig = paramiko.SSHConfig()

        try:

            sshconfig.parse(open(file))

            raise BackendException("could not load '%s', maybe corrupt?" % (file))

        

        return sshconfig.lookup(host)