Przenoszenie katalogów na paramiko

Question

Jak korzystać z paramiko do przesyłania pełnych katalogów? Próbuję użyć:

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

który daje mi ten błąd -

Error : [Errno 21] Is a directory 

Answer 1

Będziesz musiał to zrobić tak, jakbyś był lokalnie z pytonem (jeśli nie używasz shutils).

Połącz os.walk(), z sftp.mkdir() i sftp.put(). Możesz także sprawdzić każdy plik i katalog z w zależności od tego, czy chcesz rozwiązać dowiązania symboliczne, czy nie.

Answer 2

I nie sądzę, że można to zrobić. Wyszukaj dokumentację dla os.walk i skopiuj każdy plik "ręcznie".

Answer 3

O ile mi wiadomo, Paramiko nie obsługuje rekurencyjnego przesyłania plików. Jednak znalazłem solution for recursive upload using Paramiko here. Następujący fragment swojej funkcji rekurencyjnej Dodano:

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]) 

można spróbować użyć ich funkcję SCPClient.put powołując się na powyższą funkcję rekurencyjną przesyłania lub wprowadzania go na własną rękę.

Answer 4

Możesz zastąpić sftp = self.client.open_sftp() paramiko jeden i pozbyć się libcloud tutaj.

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) 

Answer 5

Można podklasy paramiko.SFTPClient i dodać do niego następujące metody:

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 

Answer 6

działa na mnie robi coś takiego, wszystko folderu i pliki są kopiowane do zdalnego serwera.

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)) 

Answer 7

Oto mój kawałek kodu:

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 

Answer 8

To mój pierwszy StackOverflow odpowiedź. Miałem dzisiaj zadanie podobne do tego. Tak więc, próbowałem znaleźć bezpośredni sposób na skopiowanie całego folderu z Windows na Linuxa przy pomocy Pythona i Paramiko. Po drobnych badaniach opracowałem rozwiązanie, które działa dla mniejszych folderów z podfolderami i plikami.

To rozwiązanie najpierw tworzy plik zip dla bieżącego folderu (os.walk() jest bardzo pomocny), a następnie kopiuje do serwera docelowego i tam rozpakowuje.