code: def sync(self, localpath, href, exclude=None, block=True):
          
          logger.info(u("sync: %s %s") % (localpath, href))
          try:
              localpath = _(localpath)
              href = remote(href)
              localRoot, localFolders, localFiles = next(os.walk(localpath))
              remoteFolders, remoteFiles = self.list(href)
              if remoteFiles is None or remoteFolders is None:
                  remoteFiles = {}
                  remoteFolders = {}
                  self.mkdir(href)
  
              def norm(folder):
                  path = os.path.join(href, _(folder))
                  if path[len(path) - 1] != os.path.sep:
                      path += u("/")
                  return path
  
              foldersToCreate = filter(
                  lambda folderPath: folderPath not in remoteFolders,
                  map(norm, localFolders)
              )
              apply_async("mkdir", lambda path: self.mkdir(path), foldersToCreate, self.limit)
  
              filesToSync = filter(
                  lambda lFile: os.path.join(href, _(lFile)) not in remoteFiles,
                  localFiles
              )
              fileArgs = [(os.path.join(localpath, f), os.path.join(href, f))
                          for f in filesToSync]
              apply_async("upload", lambda s, t: self.upload(s, t), fileArgs, self.limit)
  
              for folder in localFolders:
                  localFolderPath = os.path.join(localpath, folder)
                  remoteFolderPath = os.path.join(href, folder)
                  if exclude:
                      bSync = exclude(localFolderPath, remoteFolderPath)
                  else:
                      bSync = True
                  if bSync:
                      apply_async(
                          "sync",
                          lambda localpath, href: self.sync(localpath, href, exclude, False),
                          [(localFolderPath, remoteFolderPath), ]
                      )
          except ConnectionException:
              raise
          except Exception:
              e = sys.exc_info()[1]
              logger.exception(e)
          if block:
              qWork.join()
docs: Sync local and remote folders
          :param localpath: local folder
          :param href: remote folder
          :param exclude: filter folder which need to exlude
          :return: respose