resfshost

Documentation

Index

• Variables
• func New() resource.Driver
• func NewF(s string) func() resource.Driver
• type IsFormateder
• type MKFSer
• type T
  • func (t *T) ClaimedDevices() device.L
  • func (t *T) Head() string
  • func (t *T) Info(ctx context.Context) (resource.InfoKeys, error)
  • func (t *T) Label() string
  • func (t *T) Manifest() *manifest.T
  • func (t *T) Provision(ctx context.Context) error
  • func (t *T) ProvisionLeader(ctx context.Context) error
  • func (t *T) Provisioned() (provisioned.T, error)
  • func (t *T) ReservableDevices() device.L
  • func (t *T) Start(ctx context.Context) error
  • func (t *T) Status(ctx context.Context) status.T
  • func (t *T) Stop(ctx context.Context) error
  • func (t *T) SubDevices() device.L
  • func (t *T) Unprovision(ctx context.Context) error

Variables

var (
	KeywordDevice = keywords.Keyword{
		Attr:     "Device",
		Example:  "/dev/disk/by-id/nvme-eui.002538ba11b75ec8",
		Option:   "dev",
		Required: true,
		Scopable: true,
		Text:     keywords.NewText(fs, "text/kw/dev"),
	}
	KeywordMKFSOptions = keywords.Keyword{
		Attr:         "MKFSOptions",
		Converter:    converters.Shlex,
		Default:      "",
		Option:       "mkfs_opt",
		Provisioning: true,
		Scopable:     true,
		Text:         keywords.NewText(fs, "text/kw/mkfs_opt"),
	}
	KeywordStatTimeout = keywords.Keyword{
		Attr:      "StatTimeout",
		Converter: converters.Duration,
		Default:   "5s",
		Option:    "stat_timeout",
		Scopable:  true,
		Text:      keywords.NewText(fs, "text/kw/stat_timeout"),
	}
	KeywordMountPoint = keywords.Keyword{
		Attr:     "MountPoint",
		Example:  "/srv/{fqdn}",
		Option:   "mnt",
		Required: true,
		Scopable: true,
		Text:     keywords.NewText(fs, "text/kw/mnt"),
	}
	KeywordMountOptions = keywords.Keyword{
		Attr:     "MountOptions",
		Option:   "mnt_opt",
		Scopable: true,
		Text:     keywords.NewText(fs, "text/kw/mnt_opt"),
	}
	KeywordPromoteRW = keywords.Keyword{
		Attr:      "PromoteRW",
		Converter: converters.Bool,
		Option:    "promote_rw",
		Text:      keywords.NewText(fs, "text/kw/promote_rw"),
	}
	KeywordZone = keywords.Keyword{
		Attr:     "Zone",
		Option:   "zone",
		Scopable: true,
		Text:     keywords.NewText(fs, "text/kw/zone"),
	}
	KeywordUser = keywords.Keyword{
		Attr:      "User",
		Converter: converters.User,
		Example:   "root",
		Option:    "user",
		Scopable:  true,
		Text:      keywords.NewText(fs, "text/kw/user"),
	}
	KeywordGroup = keywords.Keyword{
		Attr:      "Group",
		Converter: converters.Group,
		Example:   "sys",
		Option:    "group",
		Scopable:  true,
		Text:      keywords.NewText(fs, "text/kw/group"),
	}
	KeywordPerm = keywords.Keyword{
		Attr:      "Perm",
		Converter: converters.FileMode,
		Example:   "1777",
		Option:    "perm",
		Scopable:  true,
		Text:      keywords.NewText(fs, "text/kw/group"),
	}
	KeywordCheckRead = keywords.Keyword{
		Attr:      "CheckRead",
		Converter: converters.Bool,
		Option:    "check_read",
		Scopable:  true,
		Text:      keywords.NewText(fs, "text/kw/check_read"),
	}

	KeywordsVirtual = []keywords.Keyword{
		KeywordMountPoint,
		KeywordMountOptions,
		KeywordDevice,
		KeywordStatTimeout,
		KeywordZone,
		KeywordCheckRead,
	}

	KeywordsBase = []keywords.Keyword{
		KeywordMountPoint,
		KeywordDevice,
		KeywordMountOptions,
		KeywordStatTimeout,
		manifest.KWSCSIPersistentReservationKey,
		manifest.KWSCSIPersistentReservationEnabled,
		manifest.KWSCSIPersistentReservationNoPreemptAbort,
		KeywordPromoteRW,
		KeywordMKFSOptions,
		KeywordZone,
		KeywordUser,
		KeywordGroup,
		KeywordPerm,
		KeywordCheckRead,
	}

	KeywordsPooling = []keywords.Keyword{
		KeywordMountPoint,
		KeywordDevice,
		KeywordMountOptions,
		KeywordStatTimeout,
		KeywordMKFSOptions,
		KeywordZone,
		KeywordUser,
		KeywordGroup,
		KeywordPerm,
		KeywordCheckRead,
	}
)

Functions

func New

func New() resource.Driver

func NewF

func NewF(s string) func() resource.Driver

Types

type IsFormateder

type IsFormateder interface {
	IsFormated(string) (bool, error)
}

type MKFSer

type MKFSer interface {
	MKFS(string, []string) error
}

type T

type T struct {
	resource.T
	resource.SCSIPersistentReservation
	Path            naming.Path
	MountPoint      string         `json:"mnt"`
	Device          string         `json:"dev"`
	Type            string         `json:"type"`
	MountOptions    string         `json:"mnt_opt"`
	StatTimeout     *time.Duration `json:"stat_timeout"`
	Zone            string         `json:"zone"`
	PRKey           string         `json:"prkey"`
	MKFSOptions     []string       `json:"mkfs_opt"`
	User            *user.User     `json:"user"`
	Group           *user.Group    `json:"group"`
	Perm            *os.FileMode   `json:"perm"`
	SCSIReservation bool           `json:"scsireserv"`
	NoPreemptAbort  bool           `json:"no_preempt_abort"`
	PromoteRW       bool           `json:"promote_rw"`
	CheckRead       bool           `json:"check_read"`
}

func (*T) ClaimedDevices

func (t *T) ClaimedDevices() device.L

func (*T) Head

func (t *T) Head() string

func (*T) Info

func (t *T) Info(ctx context.Context) (resource.InfoKeys, error)

func (*T) Label

func (t *T) Label() string

func (*T) Manifest

func (t *T) Manifest() *manifest.T

Manifest exposes to the core the input expected by the driver.

func (*T) Provision

func (t *T) Provision(ctx context.Context) error

func (*T) ProvisionLeader

func (t *T) ProvisionLeader(ctx context.Context) error

func (*T) Provisioned

func (t *T) Provisioned() (provisioned.T, error)

func (*T) ReservableDevices

func (t *T) ReservableDevices() device.L

func (*T) Start

func (t *T) Start(ctx context.Context) error

func (*T) Status

func (t *T) Status(ctx context.Context) status.T

func (*T) Stop

func (t *T) Stop(ctx context.Context) error

func (*T) SubDevices

func (t *T) SubDevices() device.L

func (*T) Unprovision

func (t *T) Unprovision(ctx context.Context) error