so9p

type AttachArgs ¶

type AttachArgs struct {
	Name string
	Args []string
}

AttachArgs is used in an attach, and has a server name type and args.

type Attachresp ¶

type Attachresp struct {
	FI  FileInfo
	Fid Fid
}

Attachresp is the resonse to an attach.

type ClientConn ¶

type ClientConn struct {
	*Conn
	FI  FileInfo
	Fid Fid
}

Client is a client struct for a file fid. It's not clear we should have embedded the Conn.

func NewClientConn(c *Conn) *ClientConn

func (client *ClientConn) Attach(name string, args ...string) error

func (client *ClientConn) Create(Fid Fid, name string, mode int, perm os.FileMode) (*File, error)

func (client *ClientConn) Open(Fid Fid, mode int) (*File, error)

func (client *ClientConn) Readdir() ([]FileInfo, error)

func (client *ClientConn) Readlink(Fid Fid) (string, error)

func (client *ClientConn) Stat(Fid Fid, name string) (FileInfo, error)

type Conn ¶

type Conn struct {
	*rpc.Client
}

Conn is a connection to a server from a client.

type FIresp ¶

type FIresp struct {
	FI []FileInfo
}

FIresp is the response to a stat or readdir.

type FS ¶

type FS interface {
	Attach(...string) (Node, error)
}

FS holds information about file servers

func GetFS(aFid Fid) (FS, error)

type Fid ¶

type Fid uuid.UUID

type File ¶

type File struct {
	*ClientConn
	Fid Fid
	Off int64
	EOF bool
}

File is the client struct for a file. cureent ops are ReadAt, WriteAt, Read, Write, Statx

func (client *File) Close() error

func (client *File) Read(b []byte) (int, error)

func (client *File) ReadAt(b []byte, Off int64) (int, error)

func (client *File) Write(b []byte) (int, error)

func (client *File) WriteAt(Data []byte, Off int64) (int, error)

type FileInfo ¶

type FileInfo struct {
	Stat syscall.Stat_t
	Name string
	Fid  Fid
}

FileInfo has a stat, name, and Fid

type Ioargs ¶

type Ioargs struct {
	Fid  Fid
	Len  int
	Off  int64
	Data []byte
}

Ioargs are args for an IO, either read or write.

type Ioresp ¶

type Ioresp struct {
	Len  int
	Data []byte
	EOF  bool
}

Ioresp is the response to an IO.

type NameArgs ¶

type NameArgs struct {
	Name string
	Fid  Fid
	Mode int
}

NameArgs have a Name, Fid, and mode.

type Nameresp ¶

type Nameresp struct {
	FI  FileInfo
	Fid Fid
}

Nameresp is a response for operations on names. It has a FI and Fid.

type NewArgs ¶

type NewArgs struct {
	Name string
	Fid  Fid
	NFid Fid
	Perm os.FileMode
	Mode int
}

NewArgs are the args for creation.

type Node ¶

type Node interface {
	Stat() (*FileInfo, error)
	Sys() FileInfo
	Readdir() ([]Node, error)
}

Node is the interface for a server, requiring implementations for Attach and FI.

func GetServerNode(f Fid) (Node, error)

type Server ¶

type Server struct {
	Fid    Fid
	Server *rpc.Server
	Fs     fileFS
}

Server contains data for a server instance

func (server *Server) Attach(Args *AttachArgs, Resp *Attachresp) (err error)

func (server *Server) Readdir(Args *NameArgs, Resp *FIresp) (err error)

func (server *Server) Stat(Args *StatArgs, Resp *StatResp) (err error)

type StatArgs ¶

type StatArgs struct {
	Fid Fid
}

StatArgs have a Fid

type StatResp ¶

type StatResp struct {
	F FileInfo
}

StatResp is the response to a stat