Verzeichnisübertragungen auf paramiko

Wie verwenden Sie paramiko komplette Verzeichnisse?
Ich versuche zu verwenden:

sftp.put("/Folder1","/Folder2")

ist mir dieser Fehler -

Error : [Errno 21] Is a directory

InformationsquelleAutor der Frage fixxxer | 2010-12-10

paramiko python

4

Müssen Sie tun nur so als würden Sie lokal mit python (wenn du nicht mit shutils).

Kombinieren os.walk() mit sftp.mkdir() und sftp.put(). Sie können auch prüfen wollen jedem Datei-und Verzeichnis-mit os.path.islink() je nachdem, ob Sie möchten, um zu beheben, symlinks oder nicht.

InformationsquelleAutor der Antwort JimB

Können Sie eine Unterklasse paramiko.SFTPClient und fügen Sie die folgende Methode:

import paramiko
import os

class MySFTPClient(paramiko.SFTPClient):
    def put_dir(self, source, target):
        ''' Uploads the contents of the source directory to the target path. The
            target directory needs to exists. All subdirectories in source are 
            created under target.
        '''
        for item in os.listdir(source):
            if os.path.isfile(os.path.join(source, item)):
                self.put(os.path.join(source, item), '%s/%s' % (target, item))
            else:
                self.mkdir('%s/%s' % (target, item), ignore_existing=True)
                self.put_dir(os.path.join(source, item), '%s/%s' % (target, item))

    def mkdir(self, path, mode=511, ignore_existing=False):
        ''' Augments mkdir by adding an option to not fail if the folder exists  '''
        try:
            super(MySFTPClient, self).mkdir(path, mode)
        except IOError:
            if ignore_existing:
                pass
            else:
                raise

InformationsquelleAutor der Antwort skoll

Könnten Sie ersetzen sftp = self.client.open_sftp() mit paramiko ein und loszuwerden libcloud hier.

import os.path
from stat import S_ISDIR
from libcloud.compute.ssh import SSHClient
from paramiko.sftp import SFTPError

class CloudSSHClient(SSHClient):


    @staticmethod
    def normalize_dirpath(dirpath):
        while dirpath.endswith("/"):
            dirpath = dirpath[:-1]
        return dirpath


    def mkdir(self, sftp, remotepath, mode=0777, intermediate=False):
        remotepath = self.normalize_dirpath(remotepath)
        if intermediate:
            try:
                sftp.mkdir(remotepath, mode=mode)
            except IOError, e:
                self.mkdir(sftp, remotepath.rsplit("/", 1)[0], mode=mode,
                           intermediate=True)
                return sftp.mkdir(remotepath, mode=mode)
        else:
            sftp.mkdir(remotepath, mode=mode)


    def put_dir_recursively(self,  localpath, remotepath, preserve_perm=True):
        "upload local directory to remote recursively"

        assert remotepath.startswith("/"), "%s must be absolute path" % remotepath

        # normalize
        localpath = self.normalize_dirpath(localpath)
        remotepath = self.normalize_dirpath(remotepath)

        sftp = self.client.open_sftp()

        try:
            sftp.chdir(remotepath)
            localsuffix = localpath.rsplit("/", 1)[1]
            remotesuffix = remotepath.rsplit("/", 1)[1]
            if localsuffix != remotesuffix:
                remotepath = os.path.join(remotepath, localsuffix)
        except IOError, e:
            pass

        for root, dirs, fls in os.walk(localpath):
            prefix = os.path.commonprefix([localpath, root])
            suffix = root.split(prefix, 1)[1]
            if suffix.startswith("/"):
                suffix = suffix[1:]

            remroot = os.path.join(remotepath, suffix)

            try:
                sftp.chdir(remroot)
            except IOError, e:
                if preserve_perm:
                    mode = os.stat(root).st_mode & 0777
                else:
                    mode = 0777
                self.mkdir(sftp, remroot, mode=mode, intermediate=True)
                sftp.chdir(remroot)

            for f in fls:
                remfile = os.path.join(remroot, f)
                localfile = os.path.join(root, f)
                sftp.put(localfile, remfile)
                if preserve_perm:
                    sftp.chmod(remfile, os.stat(localfile).st_mode & 0777)

InformationsquelleAutor der Antwort Andrey Gerzhov

2

Ich glaube nicht, dass Sie das tun können. Schauen Sie die Dokumentation für os.walk und kopieren Sie jede Datei "manuell".

InformationsquelleAutor der Antwort Martijn

Wirkt für mich etwas wie das zu tun, alle Ordner und Dateien auf dem remote-server.

parent = os.path.expanduser("~")
for dirpath, dirnames, filenames in os.walk(parent):
    remote_path = os.path.join(remote_location, dirpath[len(parent)+1:])
        try:
            ftp.listdir(remote_path)
        except IOError:
            ftp.mkdir(remote_path)

        for filename in filenames:
            ftp.put(os.path.join(dirpath, filename), os.path.join(remote_path, filename))

InformationsquelleAutor der Antwort Zaffalon

Hier ist mein code:

import errno
import os
import stat

def download_files(sftp_client, remote_dir, local_dir):
    if not exists_remote(sftp_client, remote_dir):
        return

    if not os.path.exists(local_dir):
        os.mkdir(local_dir)

    for filename in sftp_client.listdir(remote_dir):
        if stat.S_ISDIR(sftp_client.stat(remote_dir + filename).st_mode):
            # uses '/' path delimiter for remote server
            download_file(sftp_client, remote_dir + filename + '/', os.path.join(local_dir, filename))
        else:
            if not os.path.isfile(os.path.join(local_dir, filename)):
                sftp_client.get(remote_dir + filename, os.path.join(local_dir, filename))


def exists_remote(sftp_client, path):
    try:
        sftp_client.stat(path)
    except IOError, e:
        if e.errno == errno.ENOENT:
            return False
        raise
    else:
        return True

InformationsquelleAutor der Antwort Alexandr Nikitin

Soweit ich weiß, Paramiko nicht unterstützt rekursive Datei-upload. Aber, ich habe gefunden ein Lösung für rekursive upload mit Paramiko hier. Folgt ein Auszug Ihrer rekursiven upload-Funktion:

   def _send_recursive(self, files):
        for base in files:
            lastdir = base
            for root, dirs, fls in os.walk(base):
                # pop back out to the next dir in the walk
                while lastdir != os.path.commonprefix([lastdir, root]):
                    self._send_popd()
                    lastdir = os.path.split(lastdir)[0]
                self._send_pushd(root)
                lastdir = root
                self._send_files([os.path.join(root, f) for f in fls])

Können Sie versuchen, verwenden Sie entweder Ihre Funktion SCPClient.put Aufruf der oben genannten Funktion für rekursive hochladen oder implementieren Sie es auf Ihrem eigenen.

InformationsquelleAutor der Antwort Martin Kosek

Dies ist meine erste StackOverflow Antwort. Ich hatte eine Aufgabe heute, die ist ähnlich wie diese. So, ich habe versucht zu finden, einen direkten Weg zu kopieren ganze Ordner von windows auf linux mit python paramiko. Nach ein wenig Forschung, ich kam mit dieser Lösung, die funktioniert für kleinere Ordner mit Unterordnern und Dateien in es.

Diese Lösung macht erst die zip-Datei für den aktuellen Ordner (os.walk() ist sehr hilfreich hier), dann die Kopien an den Zielserver herunter und entpacken Sie es.

zipHere = zipfile.ZipFile("file_to_copy.zip", "w")

for root, folders, files in os.walk(FILE_TO_COPY_PATH):
    for file in files:
        zipHere.write(os.path.join(root, file), arcname=os.path.join(os.path.relpath(root, os.path.dirname(FILE_TO_COPY_PATH)), file))
    for folder in folders:
        zipHere.write(os.path.join(root, folder), arcname=os.path.join(os.path.relpath(root, os.path.dirname(FILE_TO_COPY_PATH)), folder))
zipHere.close()

# sftp is the paramiko.SFTPClient connection
sftp.put('local_zip_file_location','remote_zip_file_location')

# telnet_conn is the telnetlib.Telnet connection
telnet_conn.write('cd cd_to_zip_file_location')
telnet_conn.write('unzip -o file_to_copy.zip')

InformationsquelleAutor der Antwort Raj401

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.