go-mfs: github.com/ipfs/go-mfs Index | Files

package mfs

import "github.com/ipfs/go-mfs"

Index

Package Files

dir.go fd.go file.go inode.go ops.go options.go repub.go root.go

Variables

❖
var ErrClosed = errors.New("file closed")
❖
var ErrDirExists = errors.New("directory already has entry by that name")
❖
var ErrInvalidChild = errors.New("invalid child node")
❖
var ErrIsDirectory = errors.New("error: is a directory")

TODO: Remove if not used.

❖
var ErrNotExist = errors.New("no such rootfs")

TODO: Remove if not used.

❖
var ErrNotYetImplemented = errors.New("not yet implemented")

func FlushPath Uses

❖
func FlushPath(ctx context.Context, rt *Root, pth string) (ipld.Node, error)

TODO: Document this function and link its functionality with the republisher.

func IsDir Uses

❖
func IsDir(fsn FSNode) bool

IsDir checks whether the FSNode is dir type

func IsFile Uses

❖
func IsFile(fsn FSNode) bool

IsFile checks whether the FSNode is file type

func Mkdir Uses

❖
func Mkdir(r *Root, pth string, opts MkdirOpts) error

Mkdir creates a directory at 'path' under the directory 'd', creating intermediary directories as needed if 'mkparents' is set to true

func Mv Uses

❖
func Mv(r *Root, src, dst string) error

Mv moves the file or directory at 'src' to 'dst' TODO: Document what the strings 'src' and 'dst' represent.

func PutNode Uses

❖
func PutNode(r *Root, path string, nd ipld.Node) error

PutNode inserts 'nd' at 'path' in the given mfs TODO: Rename or clearly document that this is not about nodes but actually MFS files/directories (that in the underlying representation can be considered as just nodes). TODO: Document why are we handling IPLD nodes in the first place when we are actually referring to files/directories (that is, it can't be any node, it has to have a specific format). TODO: Can this function add directories or just files? What would be the difference between adding a directory with this method and creating it with `Mkdir`.

type Directory Uses

❖
type Directory struct {
    // contains filtered or unexported fields
}

TODO: There's too much functionality associated with this structure, let's organize it (and if possible extract part of it elsewhere) and document the main features of `Directory` here.

func NewDirectory Uses

❖
func NewDirectory(ctx context.Context, name string, node ipld.Node, parent parent, dserv ipld.DAGService) (*Directory, error)

NewDirectory constructs a new MFS directory.

You probably don't want to call this directly. Instead, construct a new root using NewRoot.

func (*Directory) AddChild Uses

❖
func (d *Directory) AddChild(name string, nd ipld.Node) error

AddChild adds the node 'nd' under this directory giving it the name 'name'

func (*Directory) Child Uses

❖
func (d *Directory) Child(name string) (FSNode, error)

Child returns the child of this directory by the given name

func (*Directory) Flush Uses

❖
func (d *Directory) Flush() error

func (*Directory) ForEachEntry Uses

❖
func (d *Directory) ForEachEntry(ctx context.Context, f func(NodeListing) error) error

func (*Directory) GetCidBuilder Uses

❖
func (d *Directory) GetCidBuilder() cid.Builder

GetCidBuilder gets the CID builder of the root node

func (*Directory) GetNode Uses

❖
func (d *Directory) GetNode() (ipld.Node, error)

func (*Directory) List Uses

❖
func (d *Directory) List(ctx context.Context) ([]NodeListing, error)

func (*Directory) ListNames Uses

❖
func (d *Directory) ListNames(ctx context.Context) ([]string, error)

func (*Directory) Mkdir Uses

❖
func (d *Directory) Mkdir(name string) (*Directory, error)

func (*Directory) Path Uses

❖
func (d *Directory) Path() string

func (*Directory) SetCidBuilder Uses

❖
func (d *Directory) SetCidBuilder(b cid.Builder)

SetCidBuilder sets the CID builder

func (*Directory) Type Uses

❖
func (d *Directory) Type() NodeType

func (*Directory) Uncache Uses

❖
func (d *Directory) Uncache(name string)
❖
func (d *Directory) Unlink(name string) error

type FSNode Uses

❖
type FSNode interface {
    GetNode() (ipld.Node, error)

    Flush() error
    Type() NodeType
}

FSNode abstracts the `Directory` and `File` structures, it represents any child node in the MFS (i.e., all the nodes besides the `Root`). It is the counterpart of the `parent` interface which represents any parent node in the MFS (`Root` and `Directory`). (Not to be confused with the `unixfs.FSNode`.)

func DirLookup Uses

❖
func DirLookup(d *Directory, pth string) (FSNode, error)

DirLookup will look up a file or directory at the given path under the directory 'd'

func Lookup Uses

❖
func Lookup(r *Root, path string) (FSNode, error)

Lookup extracts the root directory and performs a lookup under it. TODO: Now that the root is always a directory, can this function be collapsed with `DirLookup`? Or at least be made a method of `Root`?

type File Uses

❖
type File struct {
    RawLeaves bool
    // contains filtered or unexported fields
}

File represents a file in the MFS, its logic its mainly targeted to coordinating (potentially many) `FileDescriptor`s pointing to it.

func NewFile Uses

❖
func NewFile(name string, node ipld.Node, parent parent, dserv ipld.DAGService) (*File, error)

NewFile returns a NewFile object with the given parameters. If the Cid version is non-zero RawLeaves will be enabled.

func (*File) Flush Uses

❖
func (fi *File) Flush() error

TODO: Tight coupling with the `FileDescriptor`, at the very least this should be an independent function that takes a `File` argument and automates the open/flush/close operations. TODO: Why do we need to flush a file that isn't opened? (the `OpenWriteOnly` seems to implicitly be targeting a closed file, a file we forgot to flush? can we close a file without flushing?)

func (*File) GetNode Uses

❖
func (fi *File) GetNode() (ipld.Node, error)

GetNode returns the dag node associated with this file TODO: Use this method and do not access the `nodeLock` directly anywhere else.

func (*File) Open Uses

❖
func (fi *File) Open(flags Flags) (_ FileDescriptor, _retErr error)

func (*File) Size Uses

❖
func (fi *File) Size() (int64, error)

Size returns the size of this file TODO: Should we be providing this API? TODO: There's already a `FileDescriptor.Size()` that through the `DagModifier`'s `fileSize` function is doing pretty much the same thing as here, we should at least call that function and wrap the `ErrNotUnixfs` with an MFS text.

func (*File) Sync Uses

❖
func (fi *File) Sync() error

func (*File) Type Uses

❖
func (fi *File) Type() NodeType

Type returns the type FSNode this is

type FileDescriptor Uses

❖
type FileDescriptor interface {
    io.Reader
    CtxReadFull(context.Context, []byte) (int, error)

    io.Writer
    io.WriterAt

    io.Closer
    io.Seeker

    Truncate(int64) error
    Size() (int64, error)
    Flush() error
}

One `File` can have many `FileDescriptor`s associated to it (only one if it's RW, many if they are RO, see `File.desclock`). A `FileDescriptor` contains the "view" of the file (through an instance of a `DagModifier`), that's why it (and not the `File`) has the responsibility to `Flush` (which crystallizes that view in the `File`'s `Node`).

type Flags Uses

❖
type Flags struct {
    Read  bool
    Write bool
    Sync  bool
}

type MkdirOpts Uses

❖
type MkdirOpts struct {
    Mkparents  bool
    Flush      bool
    CidBuilder cid.Builder
}

MkdirOpts is used by Mkdir

type NodeListing Uses

❖
type NodeListing struct {
    Name string
    Type int
    Size int64
    Hash string
}

type NodeType Uses

❖
type NodeType int
❖
const (
    TFile NodeType = iota
    TDir
)

type PubFunc Uses

❖
type PubFunc func(context.Context, cid.Cid) error

PubFunc is the user-defined function that determines exactly what logic entails "publishing" a `Cid` value.

type Republisher Uses

❖
type Republisher struct {
    TimeoutLong  time.Duration
    TimeoutShort time.Duration
    RetryTimeout time.Duration
    // contains filtered or unexported fields
}

Republisher manages when to publish a given entry.

func NewRepublisher Uses

❖
func NewRepublisher(ctx context.Context, pf PubFunc, tshort, tlong time.Duration) *Republisher

NewRepublisher creates a new Republisher object to republish the given root using the given short and long time intervals.

func (*Republisher) Close Uses

❖
func (rp *Republisher) Close() error

func (*Republisher) Run Uses

❖
func (rp *Republisher) Run(lastPublished cid.Cid)

Run contains the core logic of the `Republisher`. It calls the user-defined `pubfunc` function whenever the `Cid` value is updated to a *new* value. The complexity comes from the fact that `pubfunc` may be slow so we need to batch updates.

Algorithm: 

1. When we receive the first update after publishing, we set a `longer` timer.
2. When we receive any update, we reset the `quick` timer.
3. If either the `quick` timeout or the `longer` timeout elapses,
   we call `publish` with the latest updated value.

The `longer` timer ensures that we delay publishing by at most `TimeoutLong`. The `quick` timer allows us to publish sooner if it looks like there are no more updates coming down the pipe.

Note: If a publish fails, we retry repeatedly every TimeoutRetry.

func (*Republisher) Update Uses

❖
func (rp *Republisher) Update(c cid.Cid)

Update the current value. The value will be published after a delay but each consecutive call to Update may extend this delay up to TimeoutLong.

func (*Republisher) WaitPub Uses

❖
func (rp *Republisher) WaitPub(ctx context.Context) error

WaitPub waits for the current value to be published (or returns early if it already has).

type Root Uses

❖
type Root struct {
    // contains filtered or unexported fields
}

Root represents the root of a filesystem tree.

func NewRoot Uses

❖
func NewRoot(parent context.Context, ds ipld.DAGService, node *dag.ProtoNode, pf PubFunc) (*Root, error)

NewRoot creates a new Root and starts up a republisher routine for it.

func (*Root) Close Uses

❖
func (kr *Root) Close() error

func (*Root) Flush Uses

❖
func (kr *Root) Flush() error

Flush signals that an update has occurred since the last publish, and updates the Root republisher. TODO: We are definitely abusing the "flush" terminology here.

func (*Root) FlushMemFree Uses

❖
func (kr *Root) FlushMemFree(ctx context.Context) error

FlushMemFree flushes the root directory and then uncaches all of its links. This has the effect of clearing out potentially stale references and allows them to be garbage collected. CAUTION: Take care not to ever call this while holding a reference to any child directories. Those directories will be bad references and using them may have unintended racy side effects. A better implemented mfs system (one that does smarter internal caching and refcounting) shouldnt need this method. TODO: Review the motivation behind this method once the cache system is refactored.

func (*Root) GetDirectory Uses

❖
func (kr *Root) GetDirectory() *Directory

GetDirectory returns the root directory.

Package mfs imports 18 packages (graph) and is imported by 38 packages. Updated 2019-09-20. Refresh now. Tools for package owners.