| // Copyright ©2015 The Go Authors |
| // Copyright ©2015 Steve Francia <spf@spf13.com> |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package afero |
| |
| import ( |
| "bytes" |
| "io" |
| "os" |
| "path/filepath" |
| "sort" |
| "strconv" |
| "sync" |
| "time" |
| ) |
| |
| // byName implements sort.Interface. |
| type byName []os.FileInfo |
| |
| func (f byName) Len() int { return len(f) } |
| func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() } |
| func (f byName) Swap(i, j int) { f[i], f[j] = f[j], f[i] } |
| |
| // ReadDir reads the directory named by dirname and returns |
| // a list of sorted directory entries. |
| func (a Afero) ReadDir(dirname string) ([]os.FileInfo, error) { |
| return ReadDir(a.Fs, dirname) |
| } |
| |
| func ReadDir(fs Fs, dirname string) ([]os.FileInfo, error) { |
| f, err := fs.Open(dirname) |
| if err != nil { |
| return nil, err |
| } |
| list, err := f.Readdir(-1) |
| f.Close() |
| if err != nil { |
| return nil, err |
| } |
| sort.Sort(byName(list)) |
| return list, nil |
| } |
| |
| // ReadFile reads the file named by filename and returns the contents. |
| // A successful call returns err == nil, not err == EOF. Because ReadFile |
| // reads the whole file, it does not treat an EOF from Read as an error |
| // to be reported. |
| func (a Afero) ReadFile(filename string) ([]byte, error) { |
| return ReadFile(a.Fs, filename) |
| } |
| |
| func ReadFile(fs Fs, filename string) ([]byte, error) { |
| f, err := fs.Open(filename) |
| if err != nil { |
| return nil, err |
| } |
| defer f.Close() |
| // It's a good but not certain bet that FileInfo will tell us exactly how much to |
| // read, so let's try it but be prepared for the answer to be wrong. |
| var n int64 |
| |
| if fi, err := f.Stat(); err == nil { |
| // Don't preallocate a huge buffer, just in case. |
| if size := fi.Size(); size < 1e9 { |
| n = size |
| } |
| } |
| // As initial capacity for readAll, use n + a little extra in case Size is zero, |
| // and to avoid another allocation after Read has filled the buffer. The readAll |
| // call will read into its allocated internal buffer cheaply. If the size was |
| // wrong, we'll either waste some space off the end or reallocate as needed, but |
| // in the overwhelmingly common case we'll get it just right. |
| return readAll(f, n+bytes.MinRead) |
| } |
| |
| // readAll reads from r until an error or EOF and returns the data it read |
| // from the internal buffer allocated with a specified capacity. |
| func readAll(r io.Reader, capacity int64) (b []byte, err error) { |
| buf := bytes.NewBuffer(make([]byte, 0, capacity)) |
| // If the buffer overflows, we will get bytes.ErrTooLarge. |
| // Return that as an error. Any other panic remains. |
| defer func() { |
| e := recover() |
| if e == nil { |
| return |
| } |
| if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge { |
| err = panicErr |
| } else { |
| panic(e) |
| } |
| }() |
| _, err = buf.ReadFrom(r) |
| return buf.Bytes(), err |
| } |
| |
| // ReadAll reads from r until an error or EOF and returns the data it read. |
| // A successful call returns err == nil, not err == EOF. Because ReadAll is |
| // defined to read from src until EOF, it does not treat an EOF from Read |
| // as an error to be reported. |
| func ReadAll(r io.Reader) ([]byte, error) { |
| return readAll(r, bytes.MinRead) |
| } |
| |
| // WriteFile writes data to a file named by filename. |
| // If the file does not exist, WriteFile creates it with permissions perm; |
| // otherwise WriteFile truncates it before writing. |
| func (a Afero) WriteFile(filename string, data []byte, perm os.FileMode) error { |
| return WriteFile(a.Fs, filename, data, perm) |
| } |
| |
| func WriteFile(fs Fs, 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 |
| } |
| |
| // Random number state. |
| // We generate random temporary file names so that there's a good |
| // chance the file doesn't exist yet - keeps the number of tries in |
| // TempFile to a minimum. |
| var rand uint32 |
| var randmu sync.Mutex |
| |
| func reseed() uint32 { |
| return uint32(time.Now().UnixNano() + int64(os.Getpid())) |
| } |
| |
| func nextSuffix() string { |
| randmu.Lock() |
| r := rand |
| if r == 0 { |
| r = reseed() |
| } |
| r = r*1664525 + 1013904223 // constants from Numerical Recipes |
| rand = r |
| randmu.Unlock() |
| return strconv.Itoa(int(1e9 + r%1e9))[1:] |
| } |
| |
| // TempFile creates a new temporary file in the directory dir |
| // with a name beginning with prefix, opens the file for reading |
| // and writing, and returns the resulting *File. |
| // If dir is the empty string, TempFile uses the default directory |
| // for temporary files (see os.TempDir). |
| // Multiple programs calling TempFile simultaneously |
| // will not choose the same file. The caller can use f.Name() |
| // to find the pathname of the file. It is the caller's responsibility |
| // to remove the file when no longer needed. |
| func (a Afero) TempFile(dir, prefix string) (f File, err error) { |
| return TempFile(a.Fs, dir, prefix) |
| } |
| |
| func TempFile(fs Fs, dir, prefix string) (f File, err error) { |
| if dir == "" { |
| dir = os.TempDir() |
| } |
| |
| nconflict := 0 |
| for i := 0; i < 10000; i++ { |
| name := filepath.Join(dir, prefix+nextSuffix()) |
| f, err = fs.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600) |
| if os.IsExist(err) { |
| if nconflict++; nconflict > 10 { |
| randmu.Lock() |
| rand = reseed() |
| randmu.Unlock() |
| } |
| continue |
| } |
| break |
| } |
| return |
| } |
| |
| // TempDir creates a new temporary directory in the directory dir |
| // with a name beginning with prefix and returns the path of the |
| // new directory. If dir is the empty string, TempDir uses the |
| // default directory for temporary files (see os.TempDir). |
| // Multiple programs calling TempDir simultaneously |
| // will not choose the same directory. It is the caller's responsibility |
| // to remove the directory when no longer needed. |
| func (a Afero) TempDir(dir, prefix string) (name string, err error) { |
| return TempDir(a.Fs, dir, prefix) |
| } |
| func TempDir(fs Fs, dir, prefix string) (name string, err error) { |
| if dir == "" { |
| dir = os.TempDir() |
| } |
| |
| nconflict := 0 |
| for i := 0; i < 10000; i++ { |
| try := filepath.Join(dir, prefix+nextSuffix()) |
| err = fs.Mkdir(try, 0700) |
| if os.IsExist(err) { |
| if nconflict++; nconflict > 10 { |
| randmu.Lock() |
| rand = reseed() |
| randmu.Unlock() |
| } |
| continue |
| } |
| if err == nil { |
| name = try |
| } |
| break |
| } |
| return |
| } |