func writeFile(fs vfs.Filesystem, name string, flags int, mode os.FileMode, b []byte) (int, error) {
f, err := fs.OpenFile(name, flags, mode)
if err != nil {
return 0, err
}
return f.Write(b)
}
func readFile(fs vfs.Filesystem, name string) ([]byte, error) {
f, err := fs.OpenFile(name, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
return ioutil.ReadAll(f)
}
func GetInputPath(fs vfs.Filesystem, env venv.Env) string {
var fn string
fn = env.Getenv("TF_STATE")
if fn != "" {
return fn
}
fn = env.Getenv("TI_TFSTATE")
if fn != "" {
return fn
}
fn = "terraform.tfstate"
_, err := fs.Stat(fn)
if err == nil {
return fn
}
fn = ".terraform/terraform.tfstate"
_, err = fs.Stat(fn)
if err == nil {
return fn
}
return ""
}
func ExampleMyFilesystem() {
// Simply bootstrap your filesystem
var fs vfs.Filesystem = MyFS()
err := fs.Mkdir("/tmp", 0777)
if err != nil {
fatal("Error will be: Not implemented yet!")
}
}
func ExampleMyWrapper() {
// Disable Mkdirs on the OS Filesystem
var fs vfs.Filesystem = NoNewDirs(vfs.OS())
err := fs.Mkdir("/tmp", 0777)
if err != nil {
fatal("Mkdir disabled!")
}
}
func ExampleOsFS_myWrapper() {
// Disable Mkdirs on the OS Filesystem
var fs vfs.Filesystem = NoNewDirs(vfs.OS())
err := fs.Mkdir("/tmp", 0777)
if err != nil {
fmt.Printf("Mkdir disabled!\n")
}
}
// port of ioutil.Writefile for vfs
func writeFile(fs vfs.Filesystem, filename string, data []byte, perm os.FileMode) error {
f, err := fs.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
if err != nil {
return err
}
n, err := f.Write(data)
if err == nil && n < len(data) {
err = io.ErrShortWrite
}
if err1 := f.Close(); err == nil {
err = err1
}
return err
}
func ExampleDummyFS() {
// Simply bootstrap your filesystem
var fs vfs.Filesystem = MyFS()
// Your mkdir implementation
fs.Mkdir("/tmp", 0777)
// All necessary methods like OpenFile (therefor Create) are stubbed
// and return the dummys error
_, err := vfs.Create(fs, "/tmp/vfs/example.txt")
if err != nil {
fmt.Printf("Error will be: Not implemented yet!\n")
}
}
func Example() {
// Create a vfs accessing the filesystem of the underlying OS
var osfs vfs.Filesystem = vfs.OS()
osfs.Mkdir("/tmp", 0777)
// Make the filesystem read-only:
osfs = vfs.ReadOnly(osfs) // Simply wrap filesystems to change its behaviour
// os.O_CREATE will fail and return vfs.ErrReadOnly
// os.O_RDWR is supported but Write(..) on the file is disabled
f, _ := osfs.OpenFile("/tmp/example.txt", os.O_RDWR, 0)
// Return vfs.ErrReadOnly
_, err := f.Write([]byte("Write on readonly fs?"))
if err != nil {
fmt.Errorf("Filesystem is read only!\n")
}
// Create a fully writable filesystem in memory
mfs := memfs.Create()
mfs.Mkdir("/root", 0777)
// Create a vfs supporting mounts
// The root fs is accessing the filesystem of the underlying OS
fs := mountfs.Create(osfs)
// Mount a memfs inside /memfs
// /memfs may not exist
fs.Mount(mfs, "/memfs")
// This will create /testdir inside the memfs
fs.Mkdir("/memfs/testdir", 0777)
// This would create /tmp/testdir inside your OS fs
// But the rootfs `osfs` is read-only
fs.Mkdir("/tmp/testdir", 0777)
}
func listCollect(fs vfs.Filesystem, realPath, virtualPath string, filter FilterFile) ([]string, error) {
files := []string{}
contents, err := fs.ReadDir(realPath)
if err != nil {
return nil, err
}
sort.Sort(byName(contents))
for _, content := range contents {
if content.IsDir() {
if filter(virtualPath+content.Name(), true) {
subfiles, err := listCollect(fs, realPath+content.Name()+"/", virtualPath+content.Name()+"/", filter)
if err != nil {
return nil, err
}
files = append(files, subfiles...)
}
} else {
if filter(virtualPath+content.Name(), false) {
files = append(files, virtualPath+content.Name())
}
}
}
return files, nil
}
func TestInterface(t *testing.T) {
var fs vfs.Filesystem
fs = Create()
fs.Mkdir("/tmp", 0777)
}