ressyncsymsnapvx

Documentation

Index

• Variables
• func New() resource.Driver
• type T
  • func (t T) Info(ctx context.Context) (resource.InfoKeys, error)
  • func (t T) Label() string
  • func (t *T) List() ([]XSnapshot, error)
  • func (t T) Manifest() *manifest.T
  • func (t T) Provisioned() (provisioned.T, error)
  • func (t T) ScheduleOptions() resource.ScheduleOptions
  • func (t *T) Status(ctx context.Context) status.T
  • func (t *T) Update(ctx context.Context) error
• type XInqDevice
• type XInqInquiry
• type XInqPdevfile
• type XSnapshot
• type XSnapvx
• type XSnapvxList
• type XSymmetrix

Variables

var (
	Keywords = []keywords.Keyword{
		{
			Attr:     "Name",
			Example:  "prod_db1_weekly",
			Option:   "name",
			Scopable: true,
			Text:     keywords.NewText(fs, "text/kw/name"),
		},
		{
			Attr:     "SymID",
			Example:  "0000001234",
			Option:   "symid",
			Required: true,
			Scopable: true,
			Text:     keywords.NewText(fs, "text/kw/symid"),
		},
		{
			Attr:      "Devices",
			Converter: converters.List,
			Example:   "012a 012b",
			Option:    "devs",
			Scopable:  true,
			Text:      keywords.NewText(fs, "text/kw/devs"),
		},
		{
			Attr:      "DevicesFrom",
			Converter: converters.List,
			Example:   "disk#0 disk#1",
			Option:    "devs_from",
			Scopable:  true,
			Text:      keywords.NewText(fs, "text/kw/devs_from"),
		},
		{
			Attr:      "Secure",
			Converter: converters.Bool,
			Option:    "secure",
			Scopable:  true,
			Text:      keywords.NewText(fs, "text/kw/secure"),
		},
		{
			Attr:     "Absolute",
			Example:  "12:15",
			Option:   "absolute",
			Scopable: true,
			Text:     keywords.NewText(fs, "text/kw/absolute"),
		},
		{
			Attr:     "Delta",
			Example:  "00:15",
			Option:   "delta",
			Scopable: true,
			Text:     keywords.NewText(fs, "text/kw/delta"),
		},
	}
)

Functions

func New

func New() resource.Driver

Types

type T

type T struct {
	ressync.T
	Absolute    string
	Devices     []string
	DevicesFrom []string
	Delta       string
	Name        string
	ObjectFQDN  string
	Secure      bool
	SymID       string
}

T is the driver structure.

func (T) Info

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

func (T) Label

func (t T) Label() string

Label returns a formatted short description of the Resource

func (*T) List

func (t *T) List() ([]XSnapshot, error)

func (T) Manifest

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

Manifest ...

func (T) Provisioned

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

func (T) ScheduleOptions

func (t T) ScheduleOptions() resource.ScheduleOptions

func (*T) Status

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

func (*T) Update

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

type XInqDevice

type XInqDevice struct {
	XMLName  xml.Name `xml:"Device"`
	SymID    string   `xml:"symid"`
	DevName  string   `xml:"dev_name"`
	Director string   `xml:"director"`
	Port     int      `xml:"port"`
}

T is the driver structure.

type XInqInquiry

type XInqInquiry struct {
	XMLName xml.Name     `xml:"Inquiry"`
	Devices []XInqDevice `xml:"Device"`
}

T is the driver structure.

type XInqPdevfile

type XInqPdevfile struct {
	XMLName xml.Name    `xml:"SymCLI_ML"`
	Inquiry XInqInquiry `xml:"Inquiry"`
}

Example xml output:

<?xml version="1.0" standalone="yes" ?>
<SymCLI_ML>
  <Inquiry>
    <Device>
      <symid>000000000016</symid>
      <pd_name>/dev/rdsk/c0t60000000000000000006533030334233d0s2</pd_name>
      <dev_name>003B3</dev_name>
      <director>1D</director>
      <port>8</port>
    </Device>
  </Inquiry>
</SymCLI_ML>

type XSnapshot

type XSnapshot struct {
	XMLName        xml.Name `xml:"Snapshot"`
	Source         string   `xml:"source"`
	SnapshotName   string   `xml:"snapshot_name"`
	LastTimestamp  string   `xml:"last_timestamp"`
	NumGenerations int      `xml:"num_generations"`
	Link           string   `xml:"link"`
	Restore        string   `xml:"restore"`
	Failed         string   `xml:"failed"`
	ErrorReason    string   `xml:"error_reason"`
	Secured        string   `xml:"secured"`
	Expanded       string   `xml:"expanded"`
}

T is the driver structure.

type XSnapvx

type XSnapvx struct {
	XMLName   xml.Name    `xml:"Snapvx"`
	Snapshots []XSnapshot `xml:"Snapshot"`
}

T is the driver structure.

type XSnapvxList

type XSnapvxList struct {
	XMLName   xml.Name   `xml:"SymCLI_ML"`
	Symmetrix XSymmetrix `xml:"Symmetrix"`
}

Example: symsnapvx list -output xml_e

<?xml version="1.0" standalone="yes" ?> <SymCLI_ML>

<Symmetrix>
  <Symm_Info>
    <symid>000111111111</symid>
    <microcode_version>5978</microcode_version>
  </Symm_Info>
  <Snapvx>
    <Snapshot>
      <source>00097</source>
      <snapshot_name>SNAP_1</snapshot_name>
      <last_timestamp>Fri May 31 06:15:05 2024</last_timestamp>
      <num_generations>20</num_generations>
      <link>No</link>
      <restore>No</restore>
      <failed>No</failed>
      <error_reason>NA</error_reason>
      <GCM>False</GCM>
      <zDP>False</zDP>
      <secured>Yes</secured>
      <expanded>No</expanded>
      <bgdefinprog>No</bgdefinprog>
      <policy>No</policy>
      <persistent>No</persistent>
      <cloud>No</cloud>
    </Snapshot>

type XSymmetrix

type XSymmetrix struct {
	XMLName xml.Name `xml:"Symmetrix"`
	Snapvx  XSnapvx  `xml:"Snapvx"`
}

T is the driver structure.