README
¶
go-libipfs/files
File interfaces and utils used in GO implementations of IPFS
Documentation
https://pkg.go.dev/github.com/ipfs/go-libipfs/files
Contribute
Feel free to join in. All welcome. Open an issue!
This repository falls under the IPFS Code of Conduct.
Want to hack on IPFS?
License
MIT
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
var ( ErrNotDirectory = errors.New("file isn't a directory") ErrNotReader = errors.New("file isn't a regular file") ErrNotSupported = errors.New("operation not supported") )
var ErrInvalidDirectoryEntry = errors.New("invalid directory entry name")
var ErrPathExistsOverwrite = errors.New("path already exists and overwriting is not allowed")
var (
ErrUnixFSPathOutsideRoot = errors.New("relative UnixFS paths outside the root are now allowed, use CAR instead")
)
Functions ¶
Types ¶
type DirEntry ¶
type DirEntry interface {
// Name returns base name of this entry, which is the base name of referenced
// file
Name() string
// Node returns the file referenced by this DirEntry
Node() Node
}
DirEntry exposes information about a directory entry
type DirIterator ¶
type DirIterator interface {
// DirEntry holds information about current directory entry.
// Note that after creating new iterator you MUST call Next() at least once
// before accessing these methods. Calling these methods without prior calls
// to Next() and after Next() returned false may result in undefined behavior
DirEntry
// Next advances iterator to the next file.
Next() bool
// Err may return an error after previous call to Next() returned `false`.
// If previous call to Next() returned `true`, Err() is guaranteed to
// return nil
Err() error
}
DirIterator is a iterator over directory entries. See Directory.Entries for more
type Directory ¶
type Directory interface {
Node
// Entries returns a stateful iterator over directory entries. The iterator
// may consume the Directory state so it must be called only once (this
// applies specifically to the multipartIterator).
//
// Example usage:
//
// it := dir.Entries()
// for it.Next() {
// name := it.Name()
// file := it.Node()
// [...]
// }
// if it.Err() != nil {
// return err
// }
//
// Note that you can't store the result of it.Node() and use it after
// advancing the iterator
Entries() DirIterator
}
Directory is a special file which can link to any number of files.
func DirFromEntry ¶
DirFromEntry calls ToDir on Node in the given entry
func NewFileFromPartReader ¶
NewFileFromPartReader creates a Directory from a multipart reader.
func NewMapDirectory ¶
func NewSliceDirectory ¶
type File ¶
Node represents a regular Unix file
func FileFromEntry ¶
FileFromEntry calls ToFile on Node in the given entry
func NewBytesFile ¶
func NewReaderFile ¶
type FileInfo ¶
type FileInfo interface {
Node
// AbsPath returns full real file path.
AbsPath() string
// Stat returns os.Stat of this file, may be nil for some files
Stat() os.FileInfo
}
FileInfo exposes information on files in local filesystem
type Filter ¶
type Filter struct {
// IncludeHidden - Include hidden files
IncludeHidden bool
// Rules - File filter rules
Rules *ignore.GitIgnore
}
Filter represents a set of rules for determining if a file should be included or excluded. A rule follows the syntax for patterns used in .gitgnore files for specifying untracked files. Examples: foo.txt *.app bar/ **/baz fizz/**
func NewFilter ¶
NewFilter creates a new file filter from a .gitignore file and/or a list of ignore rules. An ignoreFile is a path to a file with .gitignore-style patterns to exclude, one per line rules is an array of strings representing .gitignore-style patterns For reference on ignore rule syntax, see https://git-scm.com/docs/gitignore
type MultiFileReader ¶
MultiFileReader reads from a `commands.Node` (which can be a directory of files or a regular file) as HTTP multipart encoded data.
func NewMultiFileReader ¶
func NewMultiFileReader(file Directory, form bool) *MultiFileReader
NewMultiFileReader constructs a MultiFileReader. `file` can be any `commands.Directory`. If `form` is set to true, the Content-Disposition will be "form-data". Otherwise, it will be "attachment".
func (*MultiFileReader) Boundary ¶
func (mfr *MultiFileReader) Boundary() string
Boundary returns the boundary string to be used to separate files in the multipart data
type Node ¶
type Node interface {
io.Closer
// Size returns size of this file (if this file is a directory, total size of
// all files stored in the tree should be returned). Some implementations may
// choose not to implement this
Size() (int64, error)
}
Node is a common interface for files, directories and other special files
func NewSerialFile ¶
NewSerialFile takes a filepath, a bool specifying if hidden files should be included, and a fileInfo and returns a Node representing file, directory or special file.
func NewSerialFileWithFilter ¶
NewSerialFileWith takes a filepath, a filter for determining which files should be operated upon if the filepath is a directory, and a fileInfo and returns a Node representing file, directory or special file.
type ReaderFile ¶
type ReaderFile struct {
// contains filtered or unexported fields
}
ReaderFile is a implementation of File created from an `io.Reader`. ReaderFiles are never directories, and can be read from and closed.
func NewReaderPathFile ¶
func NewReaderPathFile(path string, reader io.ReadCloser, stat os.FileInfo) (*ReaderFile, error)
func (*ReaderFile) AbsPath ¶
func (f *ReaderFile) AbsPath() string
func (*ReaderFile) Close ¶
func (f *ReaderFile) Close() error
func (*ReaderFile) Size ¶
func (f *ReaderFile) Size() (int64, error)
func (*ReaderFile) Stat ¶
func (f *ReaderFile) Stat() os.FileInfo
type SliceFile ¶
type SliceFile struct {
// contains filtered or unexported fields
}
SliceFile implements Node, and provides simple directory handling. It contains children files, and is created from a `[]Node`. SliceFiles are always directories, and can't be read from or closed.
func (*SliceFile) Entries ¶
func (f *SliceFile) Entries() DirIterator
type TarWriter ¶
func NewTarWriter ¶
NewTarWriter wraps given io.Writer into a new tar writer
type WebFile ¶
type WebFile struct {
// contains filtered or unexported fields
}
WebFile is an implementation of File which reads it from a Web URL (http). A GET request will be performed against the source when calling Read().
func NewWebFile ¶
NewWebFile creates a WebFile with the given URL, which will be used to perform the GET request on Read().
func (*WebFile) Read ¶
Read reads the File from it's web location. On the first call to Read, a GET request will be performed against the WebFile's URL, using Go's default HTTP client. Any further reads will keep reading from the HTTP Request body.
Source Files