views

Documentation

Index

• Constants
• Variables
• func All(_ process.Process) bool
• func Boolify(b bool) string
• func Convert(v float64, dp int, perUnit string) string
• func ProcessColour(p process.Process) tcell.Color
• func RoleMatch(s string) func(process.Process) bool
• func Selected(p process.Process) bool
• func Titlify(s string) string
• func UpdateBackupInstances(f func(instance []fdb.BackupInstance)) func(process.Update)
• func UpdateBackupTags(f func(instance []fdb.BackupTag)) func(process.Update)
• func UpdateClusterHealth(f func(ClusterHealth)) func(process.Update)
• func UpdateClusterStats(f func(ClusterStats)) func(process.Update)
• func UpdateDrBackupDestInstances(f func(instance []fdb.DRBackupInstance)) func(process.Update)
• func UpdateDrBackupDestTags(f func(instance []fdb.DRBackupTag)) func(process.Update)
• func UpdateDrBackupInstances(f func(instance []fdb.DRBackupInstance)) func(process.Update)
• func UpdateDrBackupTags(f func(instance []fdb.DRBackupTag)) func(process.Update)
• type ClusterHealth
• type ClusterStats
• type HelpKeys
  • func (h *HelpKeys) GetCell(_, column int) *tview.TableCell
  • func (h *HelpKeys) GetColumnCount() int
  • func (h *HelpKeys) GetRowCount() int
• type IntervalControl
  • func (i *IntervalControl) Duration() time.Duration
  • func (i *IntervalControl) Next()

Constants

const Gibibyte float64 = Mebibyte * 1024

const Kibibyte float64 = 1024

const Mebibyte float64 = Kibibyte * 1024

const None string = ""

const Tebibyte float64 = Gibibyte * 1024

Variables

var ColumnBackupInstanceConfiguredWorkers = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Workers",
	DataFn: func(instance fdb.BackupInstance) string {
		return fmt.Sprintf("%d", instance.ConfiguredWorkers)
	},
}

var ColumnBackupInstanceId = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Instance Id",
	DataFn: func(instance fdb.BackupInstance) string {
		return instance.Id
	},
}

var ColumnBackupInstanceRecentOperations = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Recent Operations",
	DataFn: func(instance fdb.BackupInstance) string {
		return fmt.Sprintf("%d Succeeded / %d Failed", int(instance.BlobStats.Recent.RequestsSuccessful), int(instance.BlobStats.Recent.RequestsFailed))
	},
}

var ColumnBackupInstanceRecentTransfer = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Recent Transfer",
	DataFn: func(instance fdb.BackupInstance) string {
		return fmt.Sprintf("%s / %s", Convert(instance.BlobStats.Recent.BytesPerSecond, 1, "s"), Convert(instance.BlobStats.Recent.BytesSent, 1, None))
	},
}

var ColumnBackupInstanceUsedMemory = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "RAM Usage",
	DataFn: func(instance fdb.BackupInstance) string {
		return Convert(instance.RSSBytes, 1, None)
	},
}

var ColumnBackupInstanceVersion = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Version",
	DataFn: func(instance fdb.BackupInstance) string {
		return instance.Version
	},
}

var ColumnBackupLogBytes = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Log Bytes",
	DataFn: func(tag fdb.BackupTag) string {
		return Convert(float64(tag.MutationLogBytesWritten), 1, None)
	},
}

var ColumnBackupRangeBytes = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Range Bytes",
	DataFn: func(tag fdb.BackupTag) string {
		return Convert(float64(tag.RangeBytesWritten), 1, None)
	},
}

var ColumnBackupRestorable = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Restorable?",
	DataFn: func(tag fdb.BackupTag) string {
		return Boolify(tag.RunningBackupIsRestorable)
	},
}

var ColumnBackupRestorableVersion = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Restorable Version",
	DataFn: func(tag fdb.BackupTag) string {
		return fmt.Sprintf("%d", tag.LastRestorableVersion)
	},
}

var ColumnBackupRunning = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Running?",
	DataFn: func(tag fdb.BackupTag) string {
		return Boolify(tag.RunningBackup)
	},
}

var ColumnBackupSecondsBehind = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Seconds Behind",
	DataFn: func(tag fdb.BackupTag) string {
		return fmt.Sprintf("%0.1f", tag.LastRestorableSecondsBehind)
	},
}

var ColumnBackupStatus = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Status",
	DataFn: func(tag fdb.BackupTag) string {
		return Titlify(tag.CurrentStatus)
	},
}

var ColumnBackupTagId = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Tag",
	DataFn: func(tag fdb.BackupTag) string {
		return tag.Id
	},
}

var ColumnCPUActivity = components.ColumnImpl[process.Process]{
	ColName: "CPU Activity",
	DataFn: func(pd process.Process) string {
		return fmt.Sprintf("%0.1f%%", pd.FDBData.CPU.UsageCores*100)
	},
	ColorFn: ProcessColour,
}

var ColumnClass = components.ColumnImpl[process.Process]{
	ColName: "Class",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Class
	},
	ColorFn: ProcessColour,
}

var ColumnDRBackupInstanceId = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Instance Id",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return instance.Id
	},
}

var ColumnDRBackupInstanceLastUpdated = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Last Updated",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return time.Unix(int64(instance.LastUpdated), 0).String()
	},
}

var ColumnDRBackupInstanceMainThreadCPU = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Main Thread CPU",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return fmt.Sprintf("%0.0fs", instance.MainThreadCPUSeconds)
	},
}

var ColumnDRBackupInstanceMemoryUsage = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Memory Usage",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return Convert(float64(instance.MemoryUsage), 1, None)
	},
}

var ColumnDRBackupInstanceProcessCPU = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Process CPU",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return fmt.Sprintf("%0.0fs", instance.ProcessCPUSeconds)
	},
}

var ColumnDRBackupInstanceResidentSize = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Resident Size",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return Convert(float64(instance.ResidentSize), 1, None)
	},
}

var ColumnDRBackupInstanceVersion = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Version",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return instance.Version
	},
}

var ColumnDRBackupTagId = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Tag",
	DataFn: func(instance fdb.DRBackupTag) string {
		return instance.Id
	},
}

var ColumnDRBackupTagLogBytes = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Log Bytes Written",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Convert(float64(instance.MutationLogBytesWritten), 1, None)
	},
}

var ColumnDRBackupTagMutationStream = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Mutation Stream Id",
	DataFn: func(instance fdb.DRBackupTag) string {
		return instance.MutationSteamId
	},
}

var ColumnDRBackupTagRangeBytes = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Range Bytes Written",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Convert(float64(instance.RangeBytesWritten), 1, None)
	},
}

var ColumnDRBackupTagRestorable = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Restorable",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Boolify(instance.BackupRestorable)
	},
}

var ColumnDRBackupTagRunning = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Running",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Boolify(instance.RunningBackup)
	},
}

var ColumnDRBackupTagSecondsBehind = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Seconds Behind",
	DataFn: func(instance fdb.DRBackupTag) string {
		return fmt.Sprintf("%0.1f", instance.SecondsBehind)
	},
}

var ColumnDRBackupTagState = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "State",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Titlify(instance.BackupState)
	},
}

var ColumnDiskActivity = components.ColumnImpl[process.Process]{
	ColName: "Disk Activity",
	DataFn: func(pd process.Process) string {
		busy := pd.FDBData.Disk.Busy * 100
		return fmt.Sprintf("%0.1f RPS / %0.1f WPS / %0.1f%%", pd.FDBData.Disk.Reads.Hz, pd.FDBData.Disk.Writes.Hz, busy)
	},
	ColorFn: ProcessColour,
}

var ColumnDiskUsage = components.ColumnImpl[process.Process]{
	ColName: "Disk Usage",
	DataFn: func(pd process.Process) string {
		usedBytes := pd.FDBData.Disk.TotalBytes - pd.FDBData.Disk.FreeBytes
		diskUsage := float64(usedBytes) / float64(pd.FDBData.Disk.TotalBytes)
		return fmt.Sprintf("%0.1f%% (%s of %s)", diskUsage*100, Convert(float64(usedBytes), 1, None), Convert(float64(pd.FDBData.Disk.TotalBytes), 1, None))
	},
	ColorFn: ProcessColour,
}

var ColumnIPAddressPort = components.ColumnImpl[process.Process]{
	ColName: "IP Address:Port",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Address
	},
	ColorFn: ProcessColour,
}

var ColumnKVStorage = components.ColumnImpl[process.Process]{
	ColName: "KV Storage",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return Convert(pd.FDBData.Roles[idx].KVUsedBytes, 1, None)
	},
	ColorFn: ProcessColour,
}

var ColumnLocality = components.ColumnImpl[process.Process]{
	ColName: "Locality",
	DataFn: func(pd process.Process) string {
		return fmt.Sprintf("%s / %s", pd.FDBData.Locality[fdb.LocalityDataHall], pd.FDBData.Locality[fdb.LocalityDataCenter])
	},
	ColorFn: ProcessColour,
}

var ColumnLogDurabilityRate = components.ColumnImpl[process.Process]{
	ColName: "Input / Durable Rate",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "log")
		return fmt.Sprintf("%s / %s", Convert(pd.FDBData.Roles[idx].InputBytes.Hz, 1, "s"), Convert(pd.FDBData.Roles[idx].DurableBytes.Hz, 1, "s"))
	},
	ColorFn: ProcessColour,
}

var ColumnLogQueueLength = components.ColumnImpl[process.Process]{
	ColName: "Queue Length",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "log")
		length := pd.FDBData.Roles[idx].InputBytes.Counter - pd.FDBData.Roles[idx].DurableBytes.Counter
		return Convert(length, 1, None)
	},
	ColorFn: ProcessColour,
}

var ColumnLogQueueStorage = components.ColumnImpl[process.Process]{
	ColName: "Queue Storage",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "log")
		return Convert(pd.FDBData.Roles[idx].QueueUsedBytes, 1, None)
	},
	ColorFn: ProcessColour,
}

var ColumnMachine = components.ColumnImpl[process.Process]{
	ColName: "Machine",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Locality[fdb.LocalityMachineID]
	},
	ColorFn: ProcessColour,
}

var ColumnNetworkActivity = components.ColumnImpl[process.Process]{
	ColName: "Network Activity",
	DataFn: func(pd process.Process) string {
		return fmt.Sprintf("%0.1f Mbps / %0.1f Mbps", pd.FDBData.Network.MegabitsSent.Hz, pd.FDBData.Network.MegabitsReceived.Hz)
	},
	ColorFn: ProcessColour,
}

var ColumnRAMUsage = components.ColumnImpl[process.Process]{
	ColName: "RAM Usage",
	DataFn: func(pd process.Process) string {
		memUsage := float64(pd.FDBData.Memory.RSSBytes) / float64(pd.FDBData.Memory.AvailableBytes)
		return fmt.Sprintf("%0.1f%% (%s of %s)", memUsage*100, Convert(float64(pd.FDBData.Memory.RSSBytes), 1, None), Convert(float64(pd.FDBData.Memory.AvailableBytes), 1, None))
	},
	ColorFn: ProcessColour,
}

var ColumnRoles = components.ColumnImpl[process.Process]{
	ColName: "Roles",
	DataFn: func(pd process.Process) string {
		var roles []string

		for _, role := range pd.FDBData.Roles {
			roles = append(roles, role.Role)
		}

		return strings.Join(roles, ", ")
	},
	ColorFn: ProcessColour,
}

var ColumnSelected = components.ColumnImpl[process.Process]{
	ColName: " ",
	DataFn: func(pd process.Process) string {
		if pd.Metadata.Selected {
			return "*"
		}
		return " "
	},
	ColorFn: func(pd process.Process) tcell.Color {
		if pd.Metadata.Selected {
			return tcell.ColorGreen
		}
		return ProcessColour(pd)
	},
}

var ColumnStatus = components.ColumnImpl[process.Process]{
	ColName: "Status",
	DataFn: func(pd process.Process) string {
		var statuses []string

		if pd.FDBData.Excluded {
			statuses = append(statuses, "Excluded")
		}

		if pd.FDBData.Degraded {
			statuses = append(statuses, "Degraded")
		}

		if pd.FDBData.UnderMaintenance {
			statuses = append(statuses, "Maintenance")
		}

		if len(pd.FDBData.Messages) > 0 {
			statuses = append(statuses, "Message")
		}

		return strings.Join(statuses, " / ")
	},
	ColorFn: ProcessColour,
}

var ColumnStorageDurabilityRate = components.ColumnImpl[process.Process]{
	ColName: "Input / Durable Rate",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return fmt.Sprintf("%s / %s", Convert(pd.FDBData.Roles[idx].InputBytes.Hz, 1, "s"), Convert(pd.FDBData.Roles[idx].DurableBytes.Hz, 1, "s"))
	},
	ColorFn: ProcessColour,
}

var ColumnStorageLag = components.ColumnImpl[process.Process]{
	ColName: "Data / Durability Lag",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return fmt.Sprintf("%0.1fs / %0.1fs", pd.FDBData.Roles[idx].DataLag.Seconds, pd.FDBData.Roles[idx].DurabilityLag.Seconds)
	},
	ColorFn: ProcessColour,
}

var ColumnStorageTotalQueries = components.ColumnImpl[process.Process]{
	ColName: "Queries",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return fmt.Sprintf("%0.1f/s", pd.FDBData.Roles[idx].TotalQueries.Hz)
	},
	ColorFn: ProcessColour,
}

var ColumnUptime = components.ColumnImpl[process.Process]{
	ColName: "Uptime",
	DataFn: func(process process.Process) string {
		return (time.Duration(process.FDBData.Uptime) * time.Second).String()
	},
	ColorFn: ProcessColour,
}

var ColumnVersion = components.ColumnImpl[process.Process]{
	ColName: "Version",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Version
	},
	ColorFn: ProcessColour,
}

var StatBytesRead = components.ColumnImpl[ClusterStats]{
	ColName: "Bytes Read",
	DataFn: func(cs ClusterStats) string {
		return Convert(cs.BytesRead, 1, "s")
	},
}

var StatBytesWritten = components.ColumnImpl[ClusterStats]{
	ColName: "Bytes Written",
	DataFn: func(cs ClusterStats) string {
		return Convert(cs.BytesWritten, 1, "s")
	},
}

var StatClusterHealth = components.ColumnImpl[ClusterHealth]{
	ColName: "Healthy",
	DataFn: func(h ClusterHealth) string {
		return h.Health
	},
	ColorFn: func(h ClusterHealth) tcell.Color {
		if h.Healthy {
			return tcell.ColorGreen
		} else {
			return tcell.ColorRed
		}
	},
}

var StatDatabaseLocked = components.ColumnImpl[ClusterHealth]{
	ColName: "Database Locked",
	DataFn: func(h ClusterHealth) string {
		return Boolify(h.DatabaseLocked)
	},
	ColorFn: func(h ClusterHealth) tcell.Color {
		if h.DatabaseLocked {
			return tcell.ColorRed
		} else {
			return tcell.ColorWhite
		}
	},
}

var StatEmpty = components.ColumnImpl[ClusterHealth]{
	ColName: "",
	DataFn: func(h ClusterHealth) string {
		return ""
	},
}

var StatReads = components.ColumnImpl[ClusterStats]{
	ColName: "Reads",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.Reads)
	},
}

var StatRebalanceInflight = components.ColumnImpl[ClusterHealth]{
	ColName: "Rebalance In-flight",
	DataFn: func(h ClusterHealth) string {
		return Convert(float64(h.RebalanceInFlight), 1, None)
	},
}

var StatRebalanceQueued = components.ColumnImpl[ClusterHealth]{
	ColName: "Rebalance Queued",
	DataFn: func(h ClusterHealth) string {
		return Convert(float64(h.RebalanceQueued), 1, None)
	},
}

var StatRecoveryDescription = components.ColumnImpl[ClusterHealth]{
	ColName: "Recovery Description",
	DataFn: func(h ClusterHealth) string {
		return h.RecoveryDescription
	},
}

var StatRecoveryState = components.ColumnImpl[ClusterHealth]{
	ColName: "Recovery State",
	DataFn: func(h ClusterHealth) string {
		return h.RecoveryState
	},
}

var StatReplicasRemaining = components.ColumnImpl[ClusterHealth]{
	ColName: "Replicas Remaining",
	DataFn: func(h ClusterHealth) string {
		return fmt.Sprintf("%d", h.MinReplicas)
	},
}

var StatTxCommitted = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Committed",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxCommitted)
	},
}

var StatTxConflicted = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Conflicted",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxConflicted)
	},
}

var StatTxRejected = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Rejected",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxRejected)
	},
}

var StatTxStarted = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Started",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxStarted)
	},
}

var StatWrites = components.ColumnImpl[ClusterStats]{
	ColName: "Writes",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.Writes)
	},
}

Functions

func All

func All(_ process.Process) bool

func Boolify

func Boolify(b bool) string

func Convert

func Convert(v float64, dp int, perUnit string) string

func ProcessColour

func ProcessColour(p process.Process) tcell.Color

func RoleMatch

func RoleMatch(s string) func(process.Process) bool

func Selected

func Selected(p process.Process) bool

func Titlify

func Titlify(s string) string

func UpdateBackupInstances

func UpdateBackupInstances(f func(instance []fdb.BackupInstance)) func(process.Update)

func UpdateBackupTags

func UpdateBackupTags(f func(instance []fdb.BackupTag)) func(process.Update)

func UpdateClusterHealth

func UpdateClusterHealth(f func(ClusterHealth)) func(process.Update)

func UpdateClusterStats

func UpdateClusterStats(f func(ClusterStats)) func(process.Update)

func UpdateDrBackupDestInstances

func UpdateDrBackupDestInstances(f func(instance []fdb.DRBackupInstance)) func(process.Update)

func UpdateDrBackupDestTags

func UpdateDrBackupDestTags(f func(instance []fdb.DRBackupTag)) func(process.Update)

func UpdateDrBackupInstances

func UpdateDrBackupInstances(f func(instance []fdb.DRBackupInstance)) func(process.Update)

func UpdateDrBackupTags

func UpdateDrBackupTags(f func(instance []fdb.DRBackupTag)) func(process.Update)

Types

type ClusterHealth

type ClusterHealth struct {
	Healthy     bool
	Health      string
	MinReplicas int

	RebalanceInFlight int
	RebalanceQueued   int

	RecoveryState       string
	RecoveryDescription string

	DatabaseLocked bool
}

type ClusterStats

type ClusterStats struct {
	TxStarted    float64
	TxCommitted  float64
	TxConflicted float64
	TxRejected   float64

	Reads        float64
	Writes       float64
	BytesRead    float64
	BytesWritten float64
}

type HelpKeys

type HelpKeys struct {
	tview.TableContentReadOnly

	Sorter   *process.SortControl
	Interval *IntervalControl
	HasEM    bool
}

func (*HelpKeys) GetCell

func (h *HelpKeys) GetCell(_, column int) *tview.TableCell

func (*HelpKeys) GetColumnCount

func (h *HelpKeys) GetColumnCount() int

func (*HelpKeys) GetRowCount

func (h *HelpKeys) GetRowCount() int

type IntervalControl

type IntervalControl struct {
	// contains filtered or unexported fields
}

func (*IntervalControl) Duration

func (i *IntervalControl) Duration() time.Duration

func (*IntervalControl) Next

func (i *IntervalControl) Next()