filesystem.go

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gps

import (
	"os"
	"path/filepath"
	"strings"

	"github.com/pkg/errors"
)

// fsLink represents a symbolic link.
type fsLink struct {
	path string
	to   string

	// circular denotes if evaluating the symlink fails with "too many links" error.
	// This error means that it's very likely that the symlink has a circular reference.
	circular bool

	// broken denotes that attempting to resolve the link fails, most likely because
	// the destaination doesn't exist.
	broken bool
}

// filesystemState represents the state of a file system.
type filesystemState struct {
	root  string
	dirs  []string
	files []string
	links []fsLink
}

func (s filesystemState) setup() error {
	for _, dir := range s.dirs {
		p := filepath.Join(s.root, dir)

		if err := os.MkdirAll(p, 0777); err != nil {
			return errors.Errorf("os.MkdirAll(%q, 0777) err=%q", p, err)
		}
	}

	for _, file := range s.files {
		p := filepath.Join(s.root, file)

		f, err := os.Create(p)
		if err != nil {
			return errors.Errorf("os.Create(%q) err=%q", p, err)
		}

		if err := f.Close(); err != nil {
			return errors.Errorf("file %q Close() err=%q", p, err)
		}
	}

	for _, link := range s.links {
		p := filepath.Join(s.root, link.path)

		// On Windows, relative symlinks confuse filepath.Walk. So, we'll just sigh
		// and do absolute links, assuming they are relative to the directory of
		// link.path.
		//
		// Reference: https://github.com/golang/go/issues/17540
		//
		// TODO(ibrasho): This was fixed in Go 1.9. Remove this when support for
		// 1.8 is dropped.
		dir := filepath.Dir(p)
		to := ""
		if link.to != "" {
			to = filepath.Join(dir, link.to)
		}

		if err := os.Symlink(to, p); err != nil {
			return errors.Errorf("os.Symlink(%q, %q) err=%q", to, p, err)
		}
	}

	return nil
}

// deriveFilesystemState returns a filesystemState based on the state of
// the filesystem on root.
func deriveFilesystemState(root string) (filesystemState, error) {
	fs := filesystemState{root: root}

	err := filepath.Walk(fs.root, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if path == fs.root {
			return nil
		}

		relPath, err := filepath.Rel(fs.root, path)
		if err != nil {
			return err
		}

		if (info.Mode() & os.ModeSymlink) != 0 {
			l := fsLink{path: relPath}

			l.to, err = filepath.EvalSymlinks(path)
			if err != nil && strings.HasSuffix(err.Error(), "too many links") {
				l.circular = true
			} else if err != nil && os.IsNotExist(err) {
				l.broken = true
			} else if err != nil {
				return err
			}

			fs.links = append(fs.links, l)

			return nil
		}

		if info.IsDir() {
			fs.dirs = append(fs.dirs, relPath)

			return nil
		}

		fs.files = append(fs.files, relPath)

		return nil
	})

	if err != nil {
		return filesystemState{}, err
	}

	return fs, nil
}