fuse

type CommitRequest struct {
	Mount string `json:"mount"`
}

type ConfigRequest struct {
	PachdAddress string `json:"pachd_address"`
	ServerCas    string `json:"server_cas"`
}

type DatumState struct {
	Datums           []*pps.DatumInfo
	PaginationMarker string
	DatumInput       *pps.Input
	// SimpleInput tracks whether 'DatumInput' is simple (i.e. not a group by or
	// join). This is set by 'parseInput', and later read by 'GetDatums' to
	// decide whether to list datums using Pachyderm's 'GlobFile' or 'ListDatum'
	// call
	SimpleInput       bool
	DatumInputToNames map[string][]string
	DatumIdx          int
	AllDatumsReceived bool
}

type DatumsResponse struct {
	NumDatums         int        `json:"num_datums"`
	Input             *pps.Input `json:"input"`
	Idx               int        `json:"idx"`
	AllDatumsReceived bool       `json:"all_datums_received"`
}

type ListMountResponse struct {
	Mounted   []MountState   `json:"mounted"`
	Unmounted []RepoResponse `json:"unmounted"`
}

type ListRepoResponse []RepoResponse

type MountDatumResponse struct {
	// We'll return this as empty string until #ListDatumPagination since we don't know the
	// ID for datums we artificially constructed in CreateDatums()
	Id                string `json:"id"`
	Idx               int    `json:"idx"`
	NumDatums         int    `json:"num_datums"`
	AllDatumsReceived bool   `json:"all_datums_received"`
}

type MountInfo struct {
	Name    string `json:"name"`
	Project string `json:"project"`
	Repo    string `json:"repo"`
	Branch  string `json:"branch"`
	Commit  string `json:"commit"` // "" for no commit (commit as noun)
	Path    string `json:"path"`
	Mode    string `json:"mode"` // "ro", "rw"
}

type MountManager struct {
	Client *client.APIClient
	// only put a value into the States map when we have a goroutine running for
	// it. i.e. when we try to mount it for the first time.
	States map[string]*MountStateMachine
	DatumState

	Cleanup chan struct{}
	// contains filtered or unexported fields
}

type MountRequest struct {
	Mounts []*MountInfo `json:"mounts"`
}

type MountState struct {
	MountInfo         // mount details. written by client
	State      string `json:"state"`      // "unmounted", "mounting", "mounted", "pushing", "unmounted", "error". written by fsm
	Status     string `json:"status"`     // human readable string with additional info wrt State, e.g. an error message for the error state. written by fsm
	Mountpoint string `json:"mountpoint"` // where on the filesystem it's mounted. written by fsm. can also be derived from {MountDir}/{Name}
	// the following are used by the "refresh" button feature in the jupyter plugin
	LatestCommit         string `json:"latest_commit"`           // the latest available commit on the branch, last time RefreshMountState() was called. written by fsm
	HowManyCommitsBehind int    `json:"how_many_commits_behind"` // how many commits are behind the latest commit on the branch. written by fsm
}

type MountStateMachine struct {
	MountState
	// contains filtered or unexported fields
}

type Options struct {
	Fuse *fs.Options

	// Write indicates that the pfs mount should allow writes.
	// Writes will be written back to the filesystem.
	Write bool

	// RepoOptions is a map from mount names to options associated with them.
	RepoOptions map[string]*RepoOptions

	// Unmount is a channel that will be closed when the filesystem has been
	// unmounted. It can be nil in which case it's ignored.
	Unmount chan struct{}
}

type RepoOptions struct {
	// Name is the name _of the mount_. This is needed because the mount might
	// have a different name to the repo, to support mounting multiple versions
	// of the same repo at the same time.
	Name string

	File *pfs.File
	// Repo is the name of the repo to mount
	// Repo string
	// Branch is the branch of the repo to mount
	// Branch string
	// Commit is a specific commit on the branch to mount
	// Commit string
	// Write indicates that the repo should be mounted for writing.
	Write bool
}

type RepoResponse struct {
	Project       string   `json:"project"`
	Repo          string   `json:"repo"`
	Branches      []string `json:"branches"`
	Authorization string   `json:"authorization"` // "off", "none", "read", "write"

}

type Request struct {
	*MountInfo
	Action string // default empty, set to "commit" if we want to commit (verb) a mounted branch
}

type Response struct {
	Project    string
	Repo       string
	Branch     string
	Commit     string // "" for no commit
	Name       string
	MountState MountState
	Error      error
}

type ServerOptions struct {
	// MountDir is the directory where the mount will be created (the most
	// conventional and typically most useful value for this field is '/pfs',
	// causing mount-server to lay out files in the same way as Pachyderm's worker
	// binary. Code that correctly reads and writes data in this configuration can
	// then be run inside a Pachyderm pipeline without modification).
	MountDir string
	// Unmount is a channel that will be closed when the filesystem has been
	// unmounted. It can be nil, in which case it's ignored.
	Unmount chan struct{}
	// AllowOther, if true, configures mount-server to give read and write
	// permissions to "other" on the mount point ('chmod u+rw /pfs', effectively)
	AllowOther bool
	// SockPath, if set, configures mount-server to serve over a Unix socket at
	// the path it contains.
	SockPath string
}

type StateFn func(*MountStateMachine) StateFn

type UnmountRequest struct {
	Mounts []string `json:"mounts"`
}