Golang sftp.Client類代碼示例

func sftpMkdir(path string, client *sftp.Client, fi os.FileInfo) error {
	log.Printf("[DEBUG] sftp: creating dir %s", path)

	if err := client.Mkdir(path); err != nil {
		// Do not consider it an error if the directory existed
		remoteFi, fiErr := client.Lstat(path)
		if fiErr != nil || !remoteFi.IsDir() {
			return err
		}
	}

	mode := fi.Mode().Perm()
	if err := client.Chmod(path, mode); err != nil {
		return err
	}
	return nil
}

func mkdirAll(sftpClient *sftp.Client, dir string) error {
	if dir == "/" {
		// Must always exist
		return nil
	}

	stat, err := sftpClient.Lstat(dir)
	if err == nil {
		if !stat.IsDir() {
			return fmt.Errorf("not a directory: %q", dir)
		}
		return nil
	}

	parent := path.Dir(dir)
	err = mkdirAll(sftpClient, parent)
	if err != nil {
		return err
	}

	err = sftpClient.Mkdir(dir)
	if err != nil {
		return fmt.Errorf("error creating directory %q over sftp: %v", dir, err)
	}
	return nil
}

func FileCreate(s *sftp.Client, name string) (*File, error) {
	fd, err := s.Create(name)
	if err != nil {
		return &File{}, err
	}
	return &File{fd: fd}, nil
}

// make sftp directories
func makeSftpDir(client *sftp.Client, dirs []string) error {
	for i := len(dirs) - 1; i >= 0; i-- {
		if err := client.Mkdir(dirs[i]); err != nil {
			return err
		}
	}
	return nil
}

func putDir(p file, client *sftp.Client, basepath string, dryRun bool) {
	if dryRun {
		log.Info("!MKDIR", "path", p.relPath)
		return
	}

	log.Info("MKDIR", "path", p.relPath)
	err := client.Mkdir(basepath + "/" + p.relPath)
	if err != nil {
		log.Warn("MKDIR", "path", p.relPath, "err", err)
		return
	}
}

func putFile(p file, client *sftp.Client, basepath string, dryRun bool) {
	if dryRun {
		if p.offset > 0 {
			log.Info("!APPEND", "path", p.relPath, "size", p.size)
		} else {
			log.Info("!PUT", "path", p.relPath, "size", p.size)
		}
		return
	}

	var remote *sftp.File
	var err error
	if p.offset > 0 {
		log.Info("APPEND", "path", p.relPath, "size", p.size)
		remote, err = client.OpenFile(basepath+"/"+p.relPath, os.O_RDWR|os.O_APPEND)
	} else {
		log.Info("PUT", "path", p.relPath, "size", p.size)
		remote, err = client.Create(basepath + "/" + p.relPath)
	}
	if err != nil {
		log.Warn("PUT", "path", p.relPath, "size", p.size, "err", err)
		return
	}

	defer remote.Close()

	local, err := os.Open(p.path)
	if err != nil {
		log.Warn("PUT", "path", p.relPath, "size", p.size, "err", err)
		return
	}

	defer local.Close()

	if p.offset > 0 {
		_, err := local.Seek(p.offset, os.SEEK_SET)
		if err != nil {
			log.Warn("Seek error", "err", err)
			return
		}
	}

	_, err = io.Copy(remote, local)
	if err != nil {
		log.Warn("PUT", "path", p.relPath, "size", p.size, "err", err)
		return
	}
}

func (conn *SshConfig) GlobHandler(rPath string, sftp *sftp.Client, env *Enviroment) error {
	rPaths := make([]string, 0)

	files, err := sftp.ReadDir(PathCutFile(rPath))
	if err != nil {
		return err
	}

	for _, file := range files {
		if glob.Glob(PathChomp(rPath), file.Name()) {

			if IsRegularFile(file) {
				rPaths = append(rPaths, JoinPath(rPath, file.Name()))
			}
		}
	}

	if len(rPaths) > 0 {
		if _, err := os.Stat(conn.Name); os.IsNotExist(err) {
			os.Mkdir(conn.Name, 0755)
		}

		for _, rp := range rPaths {
			conn.GetFile(rp, filepath.Join(conn.Name, PathChomp(rp)), sftp, env)
		}
	}

	return nil
}

func ProcessDelete(client *sftp.Client, dc <-chan file, dryRun bool, done chan<- bool) {
	for d := range dc {
		if dryRun {
			log.Info("!DEL", "path", d.relPath, "size", d.size)
			continue
		}

		log.Info("DEL", "path", d.relPath)
		err := client.Remove(d.path)
		if err != nil {
			log.Warn("DEL", "path", d.relPath, "err", err)
			continue
		}
	}

	done <- true
}

func (ssc *SSHConfig) CopyFile(local_path, remote_path string) (err tree_lib.TreeError) {
	var (
		sft       *sftp.Client
		f         *sftp.File
		file_data []byte
	)
	err.From = tree_lib.FROM_SSH_COPY_FILE
	sft, err.Err = sftp.NewClient(ssc.conn)
	if !err.IsNull() {
		return
	}
	defer sft.Close()

	file_data, err.Err = ioutil.ReadFile(local_path)
	if !err.IsNull() {
		return
	}

	f, err.Err = sft.Create(remote_path)
	if !err.IsNull() {
		return
	}

	_, err.Err = f.Write(file_data)
	f.Close()
	sft.Close()
	return
}

func uploadFile(name, dir string, sc *sftp.Client) error {
	f, err := os.Open(name)
	if err != nil {
		return err
	}
	defer f.Close()
	of, err := sc.Create(path.Join(dir, filepath.Base(name)))
	if err != nil {
		return err
	}
	defer of.Close()
	bufp := copyBufPool.Get().(*[]byte)
	defer copyBufPool.Put(bufp)
	if _, err := io.CopyBuffer(of, f, *bufp); err != nil {
		return err
	}
	return of.Close()
}

func readSFTPTree(sftpClient *sftp.Client, p *SSHPath, dest *[]Path) error {
	files, err := sftpClient.ReadDir(p.path)
	if err != nil {
		return err
	}
	for _, f := range files {
		child := NewSSHPath(p.client, p.server, path.Join(p.path, f.Name()), p.sudo)

		*dest = append(*dest, child)

		if f.IsDir() {
			err = readSFTPTree(sftpClient, child, dest)
			if err != nil {
				return err
			}
		}
	}
	return nil
}

func (conn *SshConfig) GetFile(rPath, lPath string, sftp *sftp.Client, env *Enviroment) error {
	remoteFile, err := sftp.Open(rPath)
	if err != nil {
		return err
	}

	localFile, err := os.OpenFile(lPath, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0755)
	if err != nil {
		return err
	}

	defer localFile.Close()

	if env.filter.on {
		// filter lines in the file that match the filter key
		fmt.Printf("downloading and applying filter to %s:%s\n", conn.Name, rPath)

		scanner := bufio.NewScanner(remoteFile)
		for scanner.Scan() {
			if LineMatch(scanner.Bytes(), env.filter.key) {

				if _, err = localFile.Write([]byte(scanner.Text() + "\n")); err != nil {
					return err
				}

			}
		}

		srcStat, err := localFile.Stat()
		if err != nil {
			return err
		}

		if (srcStat.Size()) == 0 {
			localFile.Write([]byte("No matches found."))
		}

		return nil
	}

	srcStat, err := remoteFile.Stat()
	if err != nil {
		return err
	}

	writer := io.Writer(localFile)

	io.Copy(writer, remoteFile)
	fmt.Printf("%s @filesize %dB <-- %s\n", lPath, srcStat.Size(), PathChomp(rPath))

	localFile.Sync()

	return nil
}

// Scp one cpFile to destination.
// If destination is not exist, be regarded as a dir default, then make it.
// If destination is a dir, make file in it.
// If destination is a file, cover it.
func (t *SSHClient) scp2Dest(client *sftp.Client, cpFile *CpFile) (string, bool) {
	filename := cpFile.Filename
	dest := cpFile.Destination
	content := cpFile.Content

	// Dest dir not exist, make it.
	destType := "file"
	if fi, err := client.Lstat(dest); err != nil { // Dest not exist，make as a dir.
		if err := client.Mkdir(dest); err != nil {
			return fmt.Sprintf("mkdir %s, %s", dest, err.Error()), false
		}
	} else {
		if fi.IsDir() == true {
			destType = "dir"
		}
	}
	destF := dest
	if destType == "dir" { // dir, build filepath
		destF = fmt.Sprintf("%s/%s", dest, filename)
	}

	f, err := client.Create(destF)
	if err != nil {
		return fmt.Sprintf("create: %s, %s", destF, err.Error()), false
	}
	if _, err := f.Write(content); err != nil {
		return fmt.Sprintf("write: %s, %s", destF, err.Error()), false
	}
	return fmt.Sprintf("cp: %s, %s => %s", filename, t.host, dest), true
}

func sftpUploadFile(path string, input io.Reader, client *sftp.Client, fi *os.FileInfo) error {
	log.Printf("[DEBUG] sftp: uploading %s", path)

	f, err := client.Create(path)
	if err != nil {
		return err
	}
	defer f.Close()

	if _, err = io.Copy(f, input); err != nil {
		return err
	}

	if fi != nil && (*fi).Mode().IsRegular() {
		mode := (*fi).Mode().Perm()
		err = client.Chmod(path, mode)
		if err != nil {
			return err
		}
	}

	return nil
}

func (ft *SftpTask) uploadDiffFiles(client *sftp.Client, ctx *builder.Context) error {
	return ctx.Diff.Walk(func(name string, entry *builder.DiffEntry) error {
		rel, _ := filepath.Rel(ctx.DstDir, name)
		rel = filepath.ToSlash(rel)

		if entry.Behavior == builder.DIFF_REMOVE {
			log15.Debug("Deploy.Sftp.Delete", "file", rel)
			return client.Remove(path.Join(ft.opt.Directory, rel))
		}

		target := path.Join(ft.opt.Directory, rel)
		if entry.Behavior == builder.DIFF_KEEP {
			if fi, _ := client.Stat(target); fi != nil {
				// entry file should be older than uploaded file
				if entry.Time.Sub(fi.ModTime()).Seconds() < 0 {
					return nil
				}
			}
		}

		dirs := getDirs(path.Dir(rel))
		for i := len(dirs) - 1; i >= 0; i-- {
			client.Mkdir(path.Join(ft.opt.Directory, dirs[i]))
		}

		// upload file
		f, err := os.Open(name)
		if err != nil {
			return err
		}
		defer f.Close()

		f2, err := client.Create(target)
		if err != nil {
			return err
		}
		defer f2.Close()

		if _, err = io.Copy(f2, f); err != nil {
			return err
		}
		log15.Debug("Deploy.Sftp.Stor", "file", rel)
		return nil
	})
}