model

package
v2.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 16, 2020 License: GPL-3.0, GPL-3.0-or-later Imports: 6 Imported by: 7

Documentation

Index

Constants

View Source 
const (
	AlertCategoryEngine  string = "ENGINE"
	AlertCategoryAgent   string = "AGENT"
	AlertCategoryLicense string = "LICENSE"
)
View Source 
const (
	AlertCodeNewServer               string = "NEW_SERVER"
	AlertCodeUnlistedRunningDatabase string = "UNLISTED_RUNNING_DATABASE"
	AlertCodeMissingPrimaryDatabase  string = "MISSING_PRIMARY_DATABASE"

	AlertCodeNoData string = "NO_DATA"

	AlertCodeNewDatabase string = "NEW_DATABASE"
	AlertCodeNewLicense  string = "NEW_LICENSE"
	AlertCodeNewOption   string = "NEW_OPTION"
)
View Source 
const (
	AlertSeverityInfo     string = "INFO"
	AlertSeverityWarning  string = "WARNING"
	AlertSeverityCritical string = "CRITICAL"
)
View Source 
const (
	// New contains string "NEW"
	AlertStatusNew string = "NEW"
	// Ack contains string "ACK"
	AlertStatusAck string = "ACK"
)

Alert status

View Source 
const (
	HardwareAbstractionTechnologyPhysical string = "PH"
	HardwareAbstractionTechnologyOvm      string = "OVM"
	HardwareAbstractionTechnologyVmware   string = "VMWARE"
	HardwareAbstractionTechnologyHyperv   string = "HYPERV"
	HardwareAbstractionTechnologyVmother  string = "VMOTHER"
	HardwareAbstractionTechnologyXen      string = "XEN"
	HardwareAbstractionTechnologyHpvirt   string = "HPVIRT"
)

HardwareAbstractionTechnology list

View Source 
const (
	// DiffFeatureInactive is used when the feature changes from (0/-) to 0
	DiffFeatureInactive int = -2
	// DiffFeatureDeactivated is used when the feature changes from 1 to (0/-)
	DiffFeatureDeactivated int = -1
	// DiffFeatureMissing is used when a feature is missing in the diff
	DiffFeatureMissing int = 0
	// DiffFeatureActivated is used when the feature changes from (0/-) to 1
	DiffFeatureActivated int = 1
	// DiffFeatureInactive is used when the feature changes from 1 to 1
	DiffFeatureActive int = 2
)

DiffFeature status of each feature

View Source 
const (
	AgreementPartMetricProcessorPerpetual     = "Processor Perpetual"
	AgreementPartMetricNamedUserPlusPerpetual = "Named User Plus Perpetual"
	AgreementPartMetricStreamPerpetual        = "Stream Perpetual"
	AgreementPartMetricComputerPerpetual      = "Computer Perpetual"
)

OracleDatabaseAgreementPart known metrics

View Source 
const (
	// TopicHostDataInsertion is the topic used when an hostdata is inserted in the db
	TopicHostDataInsertion string = "hostdata.insertion"
	// TopicAlertInsertion is the topic used when an alert is inserted in the db
	TopicAlertInsertion string = "alert.insertion"
)
View Source 
const (
	TechnologyOracleDatabase           string = "Oracle/Database"
	TechnologyOracleExadata            string = "Oracle/Exadata"
	TechnologyMicrosoftSQLServer       string = "Microsoft/SQLServer"
	TechnologyMariaDBFoundationMariaDB string = "MariaDBFoundation/MariaDB"
	TechnologyPostgreSQLPostgreSQL     string = "PostgreSQL/PostgreSQL"
	TechnologyOracleMySQL              string = "Oracle/MySQL"
	TechnologyOracleVM                 string = "Oracle/VM"
	TechnologyVMWare                   string = "VMWare/VMWare"
	TechnologyUnknownOperatingSystem   string = "Unknown/Unknown"
)

Technology names

View Source 
const SchemaVersion int = 1

SchemaVersion contains the version of the schema

View Source 
const ServerSchemaVersion int = 1

ServerSchemaVersion contains the version of the schema

Variables

View Source 
var (
	OracleDatabaseStatusOpen    = "OPEN"
	OracleDatabaseStatusMounted = "MOUNTED"
)
View Source 
var (
	OracleDatabaseRolePrimary         = "PRIMARY"
	OracleDatabaseRoleLogicalStandby  = "LOGICAL STANDBY"
	OracleDatabaseRolePhysicalStandby = "PHYSICAL STANDBY"
	OracleDatabaseRoleSnapshotStandby = "SNAPSHOT STANDBY"
)
View Source 
var (
	OracleDatabaseEditionEnterprise = "ENT"
	OracleDatabaseEditionExtreme    = "EXE"
	OracleDatabaseEditionStandard   = "STD"
)
View Source 
var (
	TechnologyOracleDatabasePtr           *string = str2CopyPtr(TechnologyOracleDatabase)
	TechnologyOracleExadataPtr            *string = str2CopyPtr(TechnologyOracleExadata)
	TechnologyMicrosoftSQLServerPrt       *string = str2CopyPtr(TechnologyMicrosoftSQLServer)
	TechnologyMariaDBFoundationMariaDBPrt *string = str2CopyPtr(TechnologyMariaDBFoundationMariaDB)
	TechnologyPostgreSQLPostgreSQLPrt     *string = str2CopyPtr(TechnologyPostgreSQLPostgreSQL)
	TechnologyOracleMySQLPrt              *string = str2CopyPtr(TechnologyOracleMySQL)
	TechnologyOracleVMPrt                 *string = str2CopyPtr(TechnologyOracleVM)
	TechnologyVMWarePrt                   *string = str2CopyPtr(TechnologyVMWare)
	TechnologyUnknownOperatingSystemPrt   *string = str2CopyPtr(TechnologyUnknownOperatingSystem)
)

Pointers to technology names

View Source 
var ClusterInfoBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"fetchEndpoint",
		"type",
		"name",
		"cpu",
		"sockets",
		"vms",
	},
	"properties": bson.M{
		"fetchEndpoint": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"type": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 16,
		},
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 128,
		},
		"cpu": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"sockets": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"vms": bson.M{
			"bsonType": "array",
			"items":    VMInfoBsonValidatorRules,
		},
	},
}

ClusterInfoBsonValidatorRules contains mongodb validation rules for clusterInfo

View Source 
var ClusterMembershipStatusBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"oracleClusterware",
		"veritasClusterServer",
		"sunCluster",
		"hacmp",
	},
	"properties": bson.M{
		"oracleClusterware": bson.M{
			"bsonType": "bool",
		},
		"veritasClusterServer": bson.M{
			"bsonType": "bool",
		},
		"sunCluster": bson.M{
			"bsonType": "bool",
		},
		"hacmp": bson.M{
			"bsonType": "bool",
		},
	},
}

ClusterMembershipStatusBsonValidatorRules contains mongodb validation rules for ClusterMembershipStatus

View Source 
var FeaturesBsonValidatorRules = bson.M{
	"bsonType": "object",
	"properties": bson.M{
		"oracle": bson.M{
			"anyOf": bson.A{
				bson.M{
					"bsonType": "null",
				},
				OracleFeatureBsonValidatorRules,
			},
		},
		"microsoft": bson.M{
			"anyOf": bson.A{
				bson.M{
					"bsonType": "null",
				},
				MicrosoftFeatureBsonValidatorRules,
			},
		},
	},
}

FeaturesBsonValidatorRules contains mongodb validation rules for Features

View Source 
var FilesystemBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"filesystem",
		"type",
		"size",
		"usedSpace",
		"availableSpace",
		"mountedOn",
	},
	"properties": bson.M{
		"filesystem": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"type": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 16,
		},
		"size": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"usedSpace": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"availableSpace": bson.M{
			"bsonType": "number",
		},
		"mountedOn": bson.M{
			"bsonType": "string",
		},
	},
}

FilesystemBsonValidatorRules contains mongodb validation rules for Filesystem

View Source 
var FrontendHostdataSchemaValidator string = `` /* 136957-byte string literal not displayed */
View Source 
var HostBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"hostname",
		"cpuModel",
		"cpuFrequency",
		"cpuSockets",
		"cpuCores",
		"cpuThreads",
		"threadsPerCore",
		"coresPerSocket",
		"hardwareAbstraction",
		"hardwareAbstractionTechnology",
		"kernel",
		"kernelVersion",
		"os",
		"osVersion",
		"memoryTotal",
		"swapTotal",
	},
	"properties": bson.M{
		"hostname": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 253,
			"pattern":   `^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-_]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-_]*[A-Za-z0-9])$`,
		},
		"cpuModel": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
			"pattern":   "^[^\n]+$",
		},
		"cpuFrequency": bson.M{
			"bsonType":  "string",
			"minLength": 3,
			"maxLength": 16,
			"pattern":   "^[0-9]+([.][0-9]+)?[ ]*(?i)(GHz|MHz)$",
		},
		"cpuSockets": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"cpuCores": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"cpuThreads": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"threadsPerCore": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"coresPerSocket": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"hardwareAbstraction": bson.M{
			"bsonType": "string",
			"enum":     bson.A{"PH", "VIRT"},
		},
		"hardwareAbstractionTechnology": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
			"pattern":   "^[A-Z0-9]+$",
		},
		"kernel": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"kernelVersion": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"os": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"osVersion": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"memoryTotal": bson.M{
			"bsonType": "double",
			"minimum":  0,
		},
		"swapTotal": bson.M{
			"bsonType": "double",
			"minimum":  1,
		},
	},
}

HostBsonValidatorRules contains mongodb validation rules for host

View Source 
var HostDataBEBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"archived",
		"createdAt",
		"serverVersion",
		"serverSchemaVersion",

		"hostname",
		"location",
		"environment",
		"tags",
		"agentVersion",
		"info",
		"clusterMembershipStatus",
		"features",
		"filesystems",
	},
	"properties": bson.M{
		"hostname": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 253,
			"pattern":   `^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-_]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-_]*[A-Za-z0-9])$`,
		},
		"location": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
			"pattern":   "^[a-zA-Z0-9-]+$",
		},
		"environment": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 16,
			"pattern":   "^[A-Z0-9]+$",
		},
		"tags": bson.M{
			"bsonType": "array",
			"items": bson.M{
				"bsonType":  "string",
				"minLength": 1,
				"maxLength": 64,
				"pattern":   "^[a-zA-Z0-9-]+$",
			},
			"uniqueItems": true,
		},
		"agentVersion": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
			"pattern":   "^(([0-9]+([.][0-9]+)*)|(git-[0-9a-f]+)|(latest))$",
		},
		"info":                    HostBsonValidatorRules,
		"clusterMembershipStatus": ClusterMembershipStatusBsonValidatorRules,
		"features":                FeaturesBsonValidatorRules,
		"clusters": bson.M{
			"anyOf": bson.A{
				bson.M{"bsonType": "null"},
				bson.M{
					"bsonType": "array",
					"items":    ClusterInfoBsonValidatorRules,
				},
			},
		},
		"archived": bson.M{
			"bsonType": "bool",
		},
		"createdAt": bson.M{
			"bsonType": "date",
		},
		"serverVersion": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
			"pattern":   "^(([0-9]+([.][0-9]+)*)|(git-[0-9a-f]+)|(latest))$",
		},
		"serverSchemaVersion": bson.M{
			"bsonType": "number",
			"minimum":  1,
			"maximum":  1,
		},
	},
}

HostDataBEBsonValidatorRules contains mongodb validation rules for HostDataBE

View Source 
var MicrosoftFeatureBsonValidatorRules = bson.M{
	"bsonType": "object",
	"properties": bson.M{
		"sqlServer": bson.M{
			"anyOf": bson.A{
				bson.M{"bsonType": "null"},
				MicrosoftSQLServerFeatureBsonValidatorRules,
			},
		},
	},
}

MicrosoftFeatureBsonValidatorRules contains mongodb validation rules for MicrosoftFeature

View Source 
var MicrosoftSQLServerDatabaseBackupBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"backupType",
		"hour",
		"weekDays",
		"avgBckSize",
	},
	"properties": bson.M{
		"backupType": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"Database",
				"Log",
				"File or filegroup",
				"Differential database",
				"Differential file",
				"Differential partial",
				"Partial",
			},
		},
		"hour": bson.M{
			"bsonType":  "string",
			"minLength": 5,
			"maxLength": 5,
			"pattern":   "^[0-9]{2}:[0-9]{2}$",
		},
		"weekDays": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"Monday",
				"Tuesday",
				"Wednesday",
				"Thursday",
				"Friday",
				"Saturday",
				"Sunday",
			},
			"uniqueItems": true,
		},
		"avgBckSize": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
	},
}

MicrosoftSQLServerDatabaseBackupBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerDatabaseBackup

View Source 
var MicrosoftSQLServerDatabaseBsonValidatorRules = bson.M{
	"bsonType": "object",

	"properties": bson.M{
		"databaseID": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"collationName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"status": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"ONLINE",
				"RESTORING",
				"RECOVERING",
				"RECOVERY_PENDING",
				"SUSPECT",
				"EMERGENCY",
				"OFFLINE",
				"COPYING",
				"OFFLINE_SECONDARY",
			},
		},
		"recoveryModel": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"FULL",
				"BULK_LOGGED",
				"SIMPLE",
			},
		},
		"blockSize": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"schedulersCount": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"affinityMask": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"minServerMemory": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"maxServerMemory": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"ctp": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"maxDop": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"alloc": bson.M{
			"bsonType": "double",
			"minimum":  0,
		},
		"backups": bson.M{
			"bsonType": "array",
			"items":    MicrosoftSQLServerDatabaseBackupBsonValidatorRules,
		},
		"schemas": bson.M{
			"bsonType": "array",
			"items":    MicrosoftSQLServerDatabaseSchemaBsonValidatorRules,
		},
		"tablespaces": bson.M{
			"bsonType": "array",
			"items":    MicrosoftSQLServerDatabaseTablespaceBsonValidatorRules,
		},
	},
}

MicrosoftSQLServerDatabaseBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerDatabase

View Source 
var MicrosoftSQLServerDatabaseSchemaBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"allocationType",
		"usedSpace",
		"allocatedSpace",
	},
	"properties": bson.M{
		"allocationType": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"Clustered Index Data",
				"Non Clustered Index Data",
				"LOB data",
				"Table Data",
			},
		},
		"usedSpace": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"allocatedSpace": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
	},
}

MicrosoftSQLServerDatabaseSchemaBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerDatabaseSchema

View Source 
var MicrosoftSQLServerDatabaseTablespaceBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"filename",
		"alloc",
		"used",
		"growth",
		"growthUnit",
		"fileType",
		"status",
	},
	"properties": bson.M{
		"filename": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"alloc": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"used": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"growth": bson.M{
			"bsonType": "double",
		},
		"growthUnit": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"%",
				"MB",
			},
		},
		"fileType": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"ROWS",
				"LOG",
				"FILESTREAM",
				"FULLTEXT",
			},
		},
		"status": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"ONLINE",
				"RESTORING",
				"RECOVERING",
				"RECOVERY_PENDING",
				"SUSPECT",
				"OFFLINE",
				"DEFUNCT",
			},
		},
	},
}

MicrosoftSQLServerDatabaseTablespaceBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerDatabaseTablespace

View Source 
var MicrosoftSQLServerFeatureBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"instances",
		"features",
		"patches",
	},
	"properties": bson.M{
		"instances": bson.M{
			"bsonType": "array",
			"items":    MicrosoftSQLServerInstanceBsonValidatorRules,
		},
		"features": bson.M{
			"bsonType": "array",
			"items":    MicrosoftSQLServerProductFeatureBsonValidatorRules,
		},
		"patches": bson.M{
			"bsonType": "array",
			"items":    MicrosoftSQLServerPatchBsonValidatorRules,
		},
	},
}

MicrosoftSQLServerFeatureBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerFeature

View Source 
var MicrosoftSQLServerInstanceBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"status",
		"name",
		"displayName",
		"serverName",
		"databaseID",
		"stateDesc",
		"version",
		"platform",
		"collationName",
		"edition",
		"editionType",
		"productCode",
		"licensingInfo",
		"databases",
	},
	"properties": bson.M{
		"status": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"Running",
				"Stopped",
				"ContinuePending",
				"Paused",
				"PausePending",
				"StartPending",
				"StopPending",
			},
		},
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"displayName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"serverName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"databaseID": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"stateDesc": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"ONLINE",
				"RESTORING",
				"RECOVERING",
				"RECOVERY_PENDING",
				"SUSPECT",
				"EMERGENCY",
				"OFFLINE",
				"COPYING",
				"OFFLINE_SECONDARY",
			},
		},
		"version": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"platform": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 16,
		},
		"collationName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"edition": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"ENT",
				"EXP",
				"STD",
				"BI",
				"DEV",
				"WEB",
				"AZU",
			},
		},
		"editionType": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"productCode": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
			"pattern":   "^\\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\\}$",
		},
		"licensingInfo": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 512,
		},
		"databases": bson.M{
			"bsonType": "array",
			"items":    MicrosoftSQLServerDatabaseBsonValidatorRules,
		},
	},
}

MicrosoftSQLServerInstanceBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerInstance

View Source 
var MicrosoftSQLServerPatchBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"displayName",
		"displayVersion",
		"installDate",
	},
	"properties": bson.M{
		"displayName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"displayVersion": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"installDate": bson.M{
			"bsonType": "string",
			"pattern":  "[0-9]{4}-[0-9]{2}-[0-9]{2}",
		},
	},
}

MicrosoftSQLServerPatchBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerPatch

View Source 
var MicrosoftSQLServerProductFeatureBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"product",
		"feature",
		"language",
		"edition",
		"version",
		"clustered",
		"configured",
	},
	"properties": bson.M{
		"product": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"feature": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"language": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 16,
		},
		"edition": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"version": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"clustered": bson.M{
			"bsonType": "bool",
		},
		"configured": bson.M{
			"bsonType": "bool",
		},
	},
}

MicrosoftSQLServerProductFeatureBsonValidatorRules contains mongodb validation rules for MicrosoftSQLServerProductFeature

View Source 
var OracleDatabaseAddmBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"finding",
		"recommendation",
		"action",
		"benefit",
	},
	"properties": bson.M{
		"finding": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 256,
		},
		"recommendation": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"action": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 256,
		},
		"benefit": bson.M{
			"bsonType": "string",
			"minimum":  0,
			"maximum":  100,
		},
	},
}

OracleDatabaseAddmBsonValidatorRules contains mongodb validation rules for OracleDatabaseAddm

View Source 
var OracleDatabaseBackupBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"backupType",
		"hour",
		"weekDays",
		"avgBckSize",
		"retention",
	},
	"properties": bson.M{
		"backupType": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"Archivelog",
				"Full",
				"Level0",
				"Level1",
				"Incr Lvl 0",
				"Incr Lvl 1",
			},
		},
		"hour": bson.M{
			"bsonType":  "string",
			"minLength": 5,
			"maxLength": 5,
			"pattern":   "^[0-9]{2}:[0-9]{2}$",
		},
		"weekDays": bson.M{
			"bsonType": "array",
			"items": bson.M{
				"bsonType": "string",
				"enum": bson.A{
					"Monday",
					"Tuesday",
					"Wednesday",
					"Thursday",
					"Friday",
					"Saturday",
					"Sunday",
				},
			},
			"uniqueItems": true,
		},
		"avgBckSize": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"retention": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 16,
		},
	},
}

OracleDatabaseBackupBsonValidatorRules contains mongodb validation rules for OracleDatabaseBackup

View Source 
var OracleDatabaseBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"instanceNumber",
		"instanceName",
		"name",
		"uniqueName",
		"status",
		"dbID",
		"role",
		"isCDB",
		"version",
		"platform",
		"archivelog",
		"charset",
		"nCharset",
		"blockSize",
		"cpuCount",
		"sgaTarget",
		"pgaTarget",
		"memoryTarget",
		"sgaMaxSize",
		"segmentsSize",
		"datafileSize",
		"allocable",
		"elapsed",
		"dbTime",
		"dailyCPUUsage",
		"work",
		"asm",
		"dataguard",
		"patches",
		"tablespaces",
		"schemas",
		"licenses",
		"addms",
		"segmentAdvisors",
		"psus",
		"backups",
		"featureUsageStats",
		"pdbs",
		"services",
	},
	"properties": bson.M{
		"instanceNumber": bson.M{
			"bsonType": "number",
			"minimum":  1,
		},
		"instanceName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"uniqueName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"status": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"OPEN",
				"MOUNTED",
			},
		},
		"dbID": bson.M{
			"bsonType": "int",
		},
		"role": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"PRIMARY",
				"LOGICAL STANDBY",
				"PHYSICAL STANDBY",
				"SNAPSHOT STANDBY",
			},
		},
		"isCDB": bson.M{
			"bsonType": "bool",
		},
		"version": bson.M{
			"bsonType":  "string",
			"minLength": 8,
			"maxLength": 64,
		},
		"platform": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"archivelog": bson.M{
			"bsonType": "bool",
		},
		"charset": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"nCharset": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"blockSize": bson.M{
			"bsonType": "string",
			"minimum":  1,
		},
		"cpuCount": bson.M{
			"bsonType": "string",
			"minimum":  1,
		},
		"sgaTarget": bson.M{
			"bsonType": "number",
		},
		"pgaTarget": bson.M{
			"bsonType": "number",
		},
		"memoryTarget": bson.M{
			"bsonType": "number",
		},
		"sgaMaxSize": bson.M{
			"bsonType": "number",
		},
		"segmentsSize": bson.M{
			"bsonType": "number",
		},
		"datafileSize": bson.M{
			"bsonType": "number",
		},
		"allocable": bson.M{
			"bsonType": "number",
		},
		"elapsed": bson.M{
			"anyOf": bson.A{
				bson.M{"type": "null"},
				bson.M{"type": "number"},
			},
		},
		"dbTime": bson.M{
			"anyOf": bson.A{
				bson.M{"type": "null"},
				bson.M{"type": "number"},
			},
		},
		"dailyCPUUsage": bson.M{
			"anyOf": bson.A{
				bson.M{"type": "null"},
				bson.M{"type": "number"},
			},
		},
		"work": bson.M{
			"anyOf": bson.A{
				bson.M{"type": "null"},
				bson.M{"type": "number"},
			},
		},
		"asm": bson.M{
			"bsonType": "bool",
		},
		"dataguard": bson.M{
			"bsonType": "bool",
		},
		"patches": bson.M{
			"bsonType": "array",
			"items":    OracleDatabasePatchBsonValidatorRules,
		},
		"tablespaces": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseTablespaceBsonValidatorRules,
		},
		"schemas": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseSchemaBsonValidatorRules,
		},
		"licenses": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseLicenseBsonValidatorRules,
		},
		"addms": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseAddmBsonValidatorRules,
		},
		"segmentAdvisors": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseSegmentAdvisorBsonValidatorRules,
		},
		"psus": bson.M{
			"bsonType": "array",
			"items":    OracleDatabasePSUBsonValidatorRules,
		},
		"backups": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseBackupBsonValidatorRules,
		},
		"featureUsageStats": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseFeatureUsageStatBsonValidatorRules,
		},
		"services": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseServiceBsonValidatorRules,
		},
		"pdbs": bson.M{
			"bsonType": "array",
			"items":    OracleDatabasePluggableDatabaseBsonValidatorRules,
		},
	},
}

OracleDatabaseBsonValidatorRules contains mongodb validation rules for OracleDatabase

View Source 
var OracleDatabaseFeatureBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"databases",
		"unlistedRunningDatabases",
	},
	"properties": bson.M{
		"databases": bson.M{
			"bsonType": "array",
			"items":    OracleDatabaseBsonValidatorRules,
		},
		"unlistedRunningDatabases": bson.M{
			"bsonType": "array",
			"items": bson.M{
				"bsonType":  "string",
				"minLength": 1,
				"maxLength": 64,
			},
			"uniqueItems": true,
		},
	},
}

OracleDatabaseFeatureBsonValidatorRules contains mongodb validation rules for OracleDatabaseFeature

View Source 
var OracleDatabaseFeatureUsageStatBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"product",
		"feature",
		"detectedUsages",
		"currentlyUsed",
		"firstUsageDate",
		"lastUsageDate",
		"extraFeatureInfo",
	},
	"properties": bson.M{
		"product": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"feature": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"detectedUsages": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"currentlyUsed": bson.M{
			"bsonType": "bool",
		},
		"firstUsageDate": bson.M{
			"bsonType": "date",
		},
		"lastUsageDate": bson.M{
			"bsonType": "date",
		},
		"extraFeatureInfo": bson.M{
			"bsonType":  "string",
			"maxLength": 64,
		},
	},
}

OracleDatabaseFeatureUsageStatBsonValidatorRules contains mongodb validation rules for OracleDatabaseFeatureUsageStat

View Source 
var OracleDatabaseLicenseBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"name",
		"count",
	},
	"properties": bson.M{
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"count": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
	},
}

OracleDatabaseLicenseBsonValidatorRules contains mongodb validation rules for OracleDatabaseLicense

View Source 
var OracleDatabasePSUBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"date",
		"description",
	},
	"properties": bson.M{
		"date": bson.M{
			"bsonType": "string",
			"pattern":  "[0-9]{4}-[0-9]{2}-[0-9]{2}",
		},
		"description": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 128,
		},
	},
}

OracleDatabasePSUBsonValidatorRules contains mongodb validation rules for OracleDatabasePSU

View Source 
var OracleDatabasePatchBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"version",
		"patchID",
		"action",
		"description",
		"date",
	},
	"properties": bson.M{
		"version": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 16,
		},
		"patchID": bson.M{
			"bsonType": "number",
		},
		"action": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 128,
		},
		"description": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 256,
		},
		"date": bson.M{
			"bsonType": "string",
			"pattern":  "[0-9]{4}-[0-9]{2}-[0-9]{2}",
		},
	},
}

OracleDatabasePatchBsonValidatorRules contains mongodb validation rules for OracleDatabasePatch

View Source 
var OracleDatabasePluggableDatabaseBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"name",
		"status",
		"tablespaces",
		"schemas",
		"services",
	},
	"properties": bson.M{
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"status": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"OPEN",
				"READ WRITE",
				"MOUNTED",
			},
		},
		"tablespaces": OracleDatabaseTablespaceBsonValidatorRules,
		"schemas":     OracleDatabaseSchemaBsonValidatorRules,
		"services":    OracleDatabaseServiceBsonValidatorRules,
	},
}

OracleDatabasePluggableDatabaseBsonValidatorRules contains mongodb validation rules for OracleDatabasePluggableDatabase

View Source 
var OracleDatabaseSchemaBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"indexes",
		"LOB",
		"tables",
		"total",
		"user",
	},
	"properties": bson.M{
		"indexes": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"LOB": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"tables": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"total": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"user": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
	},
}

OracleDatabaseSchemaBsonValidatorRules contains mongodb validation rules for OracleDatabaseSchema

View Source 
var OracleDatabaseSegmentAdvisorBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"segmentOwner",
		"segmentName",
		"segmentType",
		"partitionName",
		"reclaimable",
		"recommendation",
	},
	"properties": bson.M{
		"segmentOwner": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"segmentName": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"segmentType": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"partitionName": bson.M{
			"bsonType":  "string",
			"maxLength": 32,
		},
		"reclaimable": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"recommendation": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 256,
		},
	},
}

OracleDatabaseSegmentAdvisorBsonValidatorRules contains mongodb validation rules for OracleDatabaseSegmentAdvisor

View Source 
var OracleDatabaseServiceBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"name",
	},
	"properties": bson.M{
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
	},
}

OracleDatabaseServiceBsonValidatorRules contains mongodb validation rules for OracleDatabaseService

View Source 
var OracleDatabaseTablespaceBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"name",
		"maxSize",
		"total",
		"used",
		"usedPerc",
		"status",
	},
	"properties": bson.M{
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"maxSize": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"total": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"used": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"usedPerc": bson.M{
			"bsonType": "number",
			"minimum":  0,
			"maximum":  100,
		},
		"status": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"ONLINE",
				"OFFLINE",
			},
		},
	},
}

OracleDatabaseTablespaceBsonValidatorRules contains mongodb validation rules for OracleDatabaseTablespace

View Source 
var OracleExadataCellDiskBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"errCount",
		"name",
		"status",
		"usedPerc",
	},
	"properties": bson.M{
		"errCount": bson.M{
			"bsonType": "number",
			"minimum":  0,
		},
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 64,
		},
		"status": bson.M{
			"bsonType": "string",
		},
		"usedPerc": bson.M{
			"bsonType": "number",
			"minimum":  0,
			"maximum":  100,
		},
	},
}

OracleExadataCellDiskBsonValidatorRules contains mongodb validation rules for OracleExadataCellDisk

View Source 
var OracleExadataComponentBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"hostname",
		"serverType",
		"model",
		"swVersion",
		"swReleaseDate",
		"runningCPUCount",
		"totalCPUCount",
		"memory",
		"status",
		"runningPowerSupply",
		"totalPowerSupply",
		"powerStatus",
		"runningFanCount",
		"totalFanCount",
		"fanStatus",
		"tempActual",
		"tempStatus",
		"cellsrvServiceStatus",
		"msServiceStatus",
		"rsServiceStatus",
		"flashcacheMode",
		"cellDisks",
	},
	"properties": bson.M{
		"hostname": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 253,
			"pattern":   `^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-_]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-_]*[A-Za-z0-9])$`,
		},
		"serverType": bson.M{
			"bsonType": "string",
			"enum": bson.A{
				"StorageServer",
				"DBServer",
				"IBSwitch",
			},
		},
		"model": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"swVersion": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 32,
		},
		"swReleaseDate": bson.M{
			"bsonType": "string",
			"pattern":  "[0-9]{4}-[0-9]{2}-[0-9]{2}",
		},
		"runningCPUCount": bson.M{
			"bsonType": bson.A{"null", "number"},
			"minimum":  1,
		},
		"totalCPUCount": bson.M{
			"bsonType": bson.A{"null", "number"},
			"minimum":  1,
		},
		"memory": bson.M{
			"bsonType": bson.A{"null", "number"},
			"minimum":  0,
		},
		"status": bson.M{
			"anyOf": bson.A{
				bson.M{"bsonType": "null"},
				bson.M{
					"bsonType": "string",
					"enum": bson.A{
						"online",
						"offline",
					},
				},
			},
		},
		"runningPowerSupply": bson.M{
			"bsonType": bson.A{"null", "number"},
			"minimum":  1,
		},
		"totalPowerSupply": bson.M{
			"bsonType": bson.A{"null", "number"},
			"minimum":  1,
		},
		"powerStatus": bson.M{
			"bsonType": bson.A{"null", "string"},
		},
		"runningFanCount": bson.M{
			"bsonType": bson.A{"null", "number"},
			"minimum":  1,
		},
		"totalFanCount": bson.M{
			"bsonType": bson.A{"null", "number"},
			"minimum":  1,
		},
		"fanStatus": bson.M{
			"bsonType": bson.A{"null", "string"},
		},
		"tempActual": bson.M{
			"bsonType": bson.A{"null", "number"},
		},
		"tempStatus": bson.M{
			"bsonType": bson.A{"null", "string"},
		},
		"cellsrvServiceStatus": bson.M{
			"bsonType": bson.A{"null", "string"},
		},
		"msServiceStatus": bson.M{
			"bsonType": bson.A{"null", "string"},
		},
		"rsServiceStatus": bson.M{
			"bsonType": bson.A{"null", "string"},
		},
		"flashcacheMode": bson.M{
			"anyOf": bson.A{
				bson.M{"bsonType": "null"},
				bson.M{
					"bsonType": "string",
					"enum": bson.A{
						"WriteBack",
						"WriteThrough",
					},
				},
			},
		},
		"cellDisks": bson.M{
			"bsonType": bson.A{"array", "null"},
			"items":    OracleExadataCellDiskBsonValidatorRules,
		},
	},
}

OracleExadataComponentBsonValidatorRules contains mongodb validation rules for OracleExadataComponentBsonValidatorRules

View Source 
var OracleExadataFeatureBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"components",
	},
	"properties": bson.M{
		"components": bson.M{
			"bsonType": "array",
			"items":    OracleExadataComponentBsonValidatorRules,
		},
	},
}

OracleExadataFeatureBsonValidatorRules contains mongodb validation rules for OracleExadataFeature

View Source 
var OracleFeatureBsonValidatorRules = bson.M{
	"bsonType": "object",
	"properties": bson.M{
		"oracle": bson.M{
			"anyOf": bson.A{
				bson.M{"bsonType": "null"},
				OracleDatabaseFeatureBsonValidatorRules,
			},
		},
		"exadata": bson.M{
			"anyOf": bson.A{
				bson.M{"bsonType": "null"},
				OracleExadataFeatureBsonValidatorRules,
			},
		},
	},
}

OracleFeatureBsonValidatorRules contains mongodb validation rules for OracleFeature

View Source 
var PatchingFunctionBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"hostname",
		"createdAt",
		"code",
	},
	"properties": bson.M{
		"hostname": bson.M{
			"bsonType": "string",
		},
		"createdAt": bson.M{
			"bsonType": "date",
		},
		"code": bson.M{
			"bsonType": "string",
		},
		"vars": bson.M{
			"bsonType": "object",
		},
	},
}

PatchingFunctionBsonValidatorRules contains mongodb validation rules for patching function

View Source 
var TechnologiesSupportedMetricsMap map[string]TechnologySupportedMetrics = map[string]TechnologySupportedMetrics{
	TechnologyOracleDatabase: {
		Product: TechnologyOracleDatabase,
		Metrics: []string{"work", "version"},
	},
}

TechnologiesSupportedMetricsMap contains all metrics of all technology

View Source 
var VMInfoBsonValidatorRules = bson.M{
	"bsonType": "object",
	"required": bson.A{
		"name",
		"hostname",
		"cappedCPU",
		"virtualizationNode",
	},
	"properties": bson.M{
		"name": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 128,
		},
		"hostname": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 253,
			"pattern":   `^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-_]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-_]*[A-Za-z0-9])$`,
		},
		"cappedCPU": bson.M{
			"bsonType": "bool",
		},
		"virtualizationNode": bson.M{
			"bsonType":  "string",
			"minLength": 1,
			"maxLength": 253,
			"pattern":   `^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-_]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-_]*[A-Za-z0-9])$`,
		},
	},
}

VMInfoBsonValidatorRules contains mongodb validation rules for VMInfo

Functions

func DatabasesArrayAsMap 

func DatabasesArrayAsMap(dbs []OracleDatabase) map[string]OracleDatabase

DatabasesArrayAsMap return the equivalent map of the database array with Database.Name as Key

func DiffLicenses 

func DiffLicenses(oldLicenses []OracleDatabaseLicense, newLicenses []OracleDatabaseLicense) map[string]int

DiffLicenses return a map that contains the difference of status between the oldLicenses and newLicenses

func HasEnterpriseLicense 

func HasEnterpriseLicense(db OracleDatabase) bool

HasEnterpriseLicense return true if the database has enterprise license.

Types

type Alert 

type Alert struct {
	ID                      primitive.ObjectID     `json:"id" bson:"_id"`
	AlertCategory           string                 `json:"alertCategory" bson:"alertCategory"`
	AlertAffectedTechnology *string                `json:"alertAffectedTechnology" bson:"alertAffectedTechnology"`
	AlertCode               string                 `json:"alertCode" bson:"alertCode"`
	AlertSeverity           string                 `json:"alertSeverity" bson:"alertSeverity"`
	AlertStatus             string                 `json:"alertStatus" bson:"alertStatus"`
	Description             string                 `json:"description" bson:"description"`
	Date                    time.Time              `json:"date" bson:"date"`
	OtherInfo               map[string]interface{} `json:"otherInfo" bson:"otherInfo"`
}

Alert holds informations about a alert

func (Alert) IsValid 

func (alert Alert) IsValid() bool

type AssociatedPart 

type AssociatedPart struct {
	ID                 primitive.ObjectID `json:"id" bson:"_id"`
	OracleDatabasePart `bson:",inline"`
	ReferenceNumber    string   `json:"referenceNumber" bson:"referenceNumber"`
	Unlimited          bool     `json:"unlimited" bson:"unlimited"`
	Count              int      `json:"count" bson:"count"`
	CatchAll           bool     `json:"catchAll" bson:"catchAll"` //TODO Rename in IsBasket ?
	Hosts              []string `json:"hosts" bson:"hosts"`
}

AssociatedPart describe a Part associated to an Agreement

type ClusterInfo 

type ClusterInfo struct {
	FetchEndpoint string                 `json:"fetchEndpoint" bson:"fetchEndpoint"`
	Type          string                 `json:"type" bson:"type"`
	Name          string                 `json:"name" bson:"name"`
	CPU           int                    `json:"cpu" bson:"cpu"`
	Sockets       int                    `json:"sockets" bson:"sockets"`
	VMs           []VMInfo               `json:"vms" bson:"vms"`
	OtherInfo     map[string]interface{} `json:"-" bson:"-"`
}

ClusterInfo hold informations about a cluster

func (ClusterInfo) MarshalBSON 

func (v ClusterInfo) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (ClusterInfo) MarshalJSON 

func (v ClusterInfo) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*ClusterInfo) UnmarshalBSON 

func (v *ClusterInfo) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*ClusterInfo) UnmarshalJSON 

func (v *ClusterInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type ClusterMembershipStatus 

type ClusterMembershipStatus struct {
	OracleClusterware    bool                   `json:"oracleClusterware" bson:"oracleClusterware"`
	VeritasClusterServer bool                   `json:"veritasClusterServer" bson:"veritasClusterServer"`
	SunCluster           bool                   `json:"sunCluster" bson:"sunCluster"`
	HACMP                bool                   `json:"hacmp" bson:"hacmp"`
	OtherInfo            map[string]interface{} `json:"-" bson:"-"`
}

ClusterMembershipStatus hold informations about the cluster membership

func (ClusterMembershipStatus) MarshalBSON 

func (v ClusterMembershipStatus) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (ClusterMembershipStatus) MarshalJSON 

func (v ClusterMembershipStatus) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*ClusterMembershipStatus) UnmarshalBSON 

func (v *ClusterMembershipStatus) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*ClusterMembershipStatus) UnmarshalJSON 

func (v *ClusterMembershipStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type Features 

type Features struct {
	Oracle    *OracleFeature         `json:"oracle,omitempty" bson:"oracle,omitempty"`
	Microsoft *MicrosoftFeature      `json:"microsoft,omitempty" bson:"microsoft,omitempty"`
	OtherInfo map[string]interface{} `json:"-" bson:"-"`
}

Features holds various informations about the features of the host.

func (Features) MarshalBSON 

func (v Features) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (Features) MarshalJSON 

func (v Features) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*Features) UnmarshalBSON 

func (v *Features) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*Features) UnmarshalJSON 

func (v *Features) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type Filesystem 

type Filesystem struct {
	Filesystem     string                 `json:"filesystem" bson:"filesystem"`
	Type           string                 `json:"type" bson:"type"`
	Size           int64                  `json:"size" bson:"size"`
	UsedSpace      int64                  `json:"usedSpace" bson:"usedSpace"`
	AvailableSpace int64                  `json:"availableSpace" bson:"availableSpace"`
	MountedOn      string                 `json:"mountedOn" bson:"mountedOn"`
	OtherInfo      map[string]interface{} `json:"-" bson:"-"`
}

Filesystem holds information about mounted filesystem and used space

func (Filesystem) MarshalBSON 

func (v Filesystem) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (Filesystem) MarshalJSON 

func (v Filesystem) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*Filesystem) UnmarshalBSON 

func (v *Filesystem) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*Filesystem) UnmarshalJSON 

func (v *Filesystem) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type Host 

type Host struct {
	Hostname                      string                 `json:"hostname" bson:"hostname"`
	CPUModel                      string                 `json:"cpuModel" bson:"cpuModel"`
	CPUFrequency                  string                 `json:"cpuFrequency" bson:"cpuFrequency"`
	CPUSockets                    int                    `json:"cpuSockets" bson:"cpuSockets"`
	CPUCores                      int                    `json:"cpuCores" bson:"cpuCores"`
	CPUThreads                    int                    `json:"cpuThreads" bson:"cpuThreads"`
	ThreadsPerCore                int                    `json:"threadsPerCore" bson:"threadsPerCore"`
	CoresPerSocket                int                    `json:"coresPerSocket" bson:"coresPerSocket"`
	HardwareAbstraction           string                 `json:"hardwareAbstraction" bson:"hardwareAbstraction"`
	HardwareAbstractionTechnology string                 `json:"hardwareAbstractionTechnology" bson:"hardwareAbstractionTechnology"`
	Kernel                        string                 `json:"kernel" bson:"kernel"`
	KernelVersion                 string                 `json:"kernelVersion" bson:"kernelVersion"`
	OS                            string                 `json:"os" bson:"os"`
	OSVersion                     string                 `json:"osVersion" bson:"osVersion"`
	MemoryTotal                   float64                `json:"memoryTotal" bson:"memoryTotal"`
	SwapTotal                     float64                `json:"swapTotal" bson:"swapTotal"`
	OtherInfo                     map[string]interface{} `json:"-" bson:"-"`
}

Host contains info about the host

func (Host) MarshalBSON 

func (v Host) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (Host) MarshalJSON 

func (v Host) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*Host) UnmarshalBSON 

func (v *Host) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*Host) UnmarshalJSON 

func (v *Host) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type HostData 

type HostData struct {
	Hostname                string                  `json:"hostname"`
	Location                string                  `json:"location"`
	Environment             string                  `json:"environment"`
	Tags                    []string                `json:"tags"`
	AgentVersion            string                  `json:"agentVersion"`
	SchemaVersion           int                     `json:"schemaVersion"`
	Info                    Host                    `json:"info"`
	ClusterMembershipStatus ClusterMembershipStatus `json:"clusterMembershipStatus"`
	Features                Features                `json:"features"`
	Filesystems             []Filesystem            `json:"filesystems"`
	Clusters                []ClusterInfo           `json:"clusters"`
	OtherInfo               map[string]interface{}  `json:"-"`
}

HostData holds all informations about a host & services

func (HostData) MarshalBSON 

func (v HostData) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (HostData) MarshalJSON 

func (v HostData) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*HostData) UnmarshalBSON 

func (v *HostData) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*HostData) UnmarshalJSON 

func (v *HostData) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type HostDataBE 

type HostDataBE struct {
	ID                  primitive.ObjectID `json:"id" bson:"_id"`
	Archived            bool               `json:"archived" bson:"archived"`
	CreatedAt           time.Time          `json:"createdAt" bson:"createdAt"`
	ServerVersion       string             `json:"serverVersion" bson:"serverVersion"`
	ServerSchemaVersion int                `json:"serverSchemaVersion" bson:"serverSchemaVersion"`

	Hostname                string                  `json:"hostname" bson:"hostname"`
	Location                string                  `json:"location" bson:"location"`
	Environment             string                  `json:"environment" bson:"environment"`
	AgentVersion            string                  `json:"agentVersion" bson:"agentVersion"`
	Tags                    []string                `json:"tags" bson:"tags"`
	Info                    Host                    `json:"info" bson:"info"`
	ClusterMembershipStatus ClusterMembershipStatus `json:"clusterMembershipStatus" bson:"clusterMembershipStatus"`
	Features                Features                `json:"features" bson:"features"`
	Filesystems             []Filesystem            `json:"filesystems" bson:"filesystems"`
	Clusters                []ClusterInfo           `json:"clusters" bson:"clusters"`
	OtherInfo               map[string]interface{}  `json:"-" bson:"-"`
}

HostDataBE holds all informations about a host & services

func (HostDataBE) MarshalBSON 

func (v HostDataBE) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (HostDataBE) MarshalJSON 

func (v HostDataBE) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*HostDataBE) UnmarshalBSON 

func (v *HostDataBE) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*HostDataBE) UnmarshalJSON 

func (v *HostDataBE) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftFeature 

type MicrosoftFeature struct {
	SQLServer *MicrosoftSQLServerFeature `json:"sqlServer,omitempty" bson:"sqlServer,omitempty"`
	OtherInfo map[string]interface{}     `json:"-" bson:"-"`
}

func (MicrosoftFeature) MarshalBSON 

func (v MicrosoftFeature) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftFeature) MarshalJSON 

func (v MicrosoftFeature) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftFeature) UnmarshalBSON 

func (v *MicrosoftFeature) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftFeature) UnmarshalJSON 

func (v *MicrosoftFeature) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerDatabase 

type MicrosoftSQLServerDatabase struct {
	DatabaseID      int                                    `json:"databaseID" bson:"databaseID"`
	Name            string                                 `json:"name" bson:"name"`
	CollationName   string                                 `json:"collationName" bson:"collationName"`
	Status          string                                 `json:"status" bson:"status"`
	RecoveryModel   string                                 `json:"recoveryModel" bson:"recoveryModel"`
	BlockSize       int                                    `json:"blockSize" bson:"blockSize"`
	SchedulersCount int                                    `json:"schedulersCount" bson:"schedulersCount"`
	AffinityMask    int                                    `json:"affinityMask" bson:"affinityMask"`
	MinServerMemory int                                    `json:"minServerMemory" bson:"minServerMemory"`
	MaxServerMemory int                                    `json:"maxServerMemory" bson:"maxServerMemory"`
	CTP             int                                    `json:"ctp" bson:"ctp"`
	MaxDop          int                                    `json:"maxDop" bson:"maxDop"`
	Alloc           float64                                `json:"alloc" bson:"alloc"`
	Backups         []MicrosoftSQLServerDatabaseBackup     `json:"backups" bson:"backups"`
	Schemas         []MicrosoftSQLServerDatabaseSchema     `json:"schemas" bson:"schemas"`
	Tablespaces     []MicrosoftSQLServerDatabaseTablespace `json:"tablespaces" bson:"tablespaces"`
	OtherInfo       map[string]interface{}                 `json:"-" bson:"-"`
}

func (MicrosoftSQLServerDatabase) MarshalBSON 

func (v MicrosoftSQLServerDatabase) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerDatabase) MarshalJSON 

func (v MicrosoftSQLServerDatabase) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerDatabase) UnmarshalBSON 

func (v *MicrosoftSQLServerDatabase) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerDatabase) UnmarshalJSON 

func (v *MicrosoftSQLServerDatabase) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerDatabaseBackup 

type MicrosoftSQLServerDatabaseBackup struct {
	BackupType string                 `json:"backupType" bson:"backupType"`
	Hour       string                 `json:"hour" bson:"hour"`
	WeekDays   []string               `json:"weekDays" bson:"weekDays"`
	AvgBckSize float64                `json:"avgBckSize" bson:"avgBckSize"`
	OtherInfo  map[string]interface{} `json:"-" bson:"-"`
}

func (MicrosoftSQLServerDatabaseBackup) MarshalBSON 

func (v MicrosoftSQLServerDatabaseBackup) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerDatabaseBackup) MarshalJSON 

func (v MicrosoftSQLServerDatabaseBackup) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerDatabaseBackup) UnmarshalBSON 

func (v *MicrosoftSQLServerDatabaseBackup) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerDatabaseBackup) UnmarshalJSON 

func (v *MicrosoftSQLServerDatabaseBackup) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerDatabaseSchema 

type MicrosoftSQLServerDatabaseSchema struct {
	AllocationType string                 `json:"allocationType" bson:"allocationType"`
	UsedSpace      int                    `json:"usedSpace" bson:"usedSpace"`
	AllocatedSpace int                    `json:"allocatedSpace" bson:"allocatedSpace"`
	OtherInfo      map[string]interface{} `json:"-" bson:"-"`
}

func (MicrosoftSQLServerDatabaseSchema) MarshalBSON 

func (v MicrosoftSQLServerDatabaseSchema) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerDatabaseSchema) MarshalJSON 

func (v MicrosoftSQLServerDatabaseSchema) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerDatabaseSchema) UnmarshalBSON 

func (v *MicrosoftSQLServerDatabaseSchema) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerDatabaseSchema) UnmarshalJSON 

func (v *MicrosoftSQLServerDatabaseSchema) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerDatabaseTablespace 

type MicrosoftSQLServerDatabaseTablespace struct {
	Filename   string                 `json:"filename" bson:"filename"`
	Alloc      int                    `json:"alloc" bson:"alloc"`
	Used       int                    `json:"used" bson:"used"`
	Growth     float64                `json:"growth" bson:"growth"`
	GrowthUnit string                 `json:"growthUnit" bson:"growthUnit"`
	FileType   string                 `json:"fileType" bson:"fileType"`
	Status     string                 `json:"status" bson:"status"`
	OtherInfo  map[string]interface{} `json:"-" bson:"-"`
}

func (MicrosoftSQLServerDatabaseTablespace) MarshalBSON 

func (v MicrosoftSQLServerDatabaseTablespace) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerDatabaseTablespace) MarshalJSON 

func (v MicrosoftSQLServerDatabaseTablespace) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerDatabaseTablespace) UnmarshalBSON 

func (v *MicrosoftSQLServerDatabaseTablespace) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerDatabaseTablespace) UnmarshalJSON 

func (v *MicrosoftSQLServerDatabaseTablespace) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerFeature 

type MicrosoftSQLServerFeature struct {
	Instances []MicrosoftSQLServerInstance       `json:"instances" bson:"instances"`
	Features  []MicrosoftSQLServerProductFeature `json:"features" bson:"features"`
	Patches   []MicrosoftSQLServerPatch          `json:"patches" bson:"patches"`
	OtherInfo map[string]interface{}             `json:"-" bson:"-"`
}

func (MicrosoftSQLServerFeature) MarshalBSON 

func (v MicrosoftSQLServerFeature) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerFeature) MarshalJSON 

func (v MicrosoftSQLServerFeature) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerFeature) UnmarshalBSON 

func (v *MicrosoftSQLServerFeature) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerFeature) UnmarshalJSON 

func (v *MicrosoftSQLServerFeature) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerInstance 

type MicrosoftSQLServerInstance struct {
	Status        string                       `json:"status" bson:"status"`
	Name          string                       `json:"name" bson:"name"`
	DisplayName   string                       `json:"displayName" bson:"displayName"`
	ServerName    string                       `json:"serverName" bson:"serverName"`
	DatabaseID    int                          `json:"databaseID" bson:"databaseID"`
	StateDesc     string                       `json:"stateDesc" bson:"stateDesc"`
	Version       string                       `json:"version" bson:"version"`
	Platform      string                       `json:"platform" bson:"platform"`
	CollationName string                       `json:"collationName" bson:"collationName"`
	Edition       string                       `json:"edition" bson:"edition"`
	EditionType   string                       `json:"editionType" bson:"editionType"`
	ProductCode   string                       `json:"productCode" bson:"productCode"`
	LicensingInfo string                       `json:"licensingInfo" bson:"licensingInfo"`
	Databases     []MicrosoftSQLServerDatabase `json:"databases" bson:"databases"`
	OtherInfo     map[string]interface{}       `json:"-" bson:"-"`
}

func (MicrosoftSQLServerInstance) MarshalBSON 

func (v MicrosoftSQLServerInstance) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerInstance) MarshalJSON 

func (v MicrosoftSQLServerInstance) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerInstance) UnmarshalBSON 

func (v *MicrosoftSQLServerInstance) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerInstance) UnmarshalJSON 

func (v *MicrosoftSQLServerInstance) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerPatch 

type MicrosoftSQLServerPatch struct {
	DisplayName    string                 `json:"displayName" bson:"displayName"`
	DisplayVersion string                 `json:"displayVersion" bson:"displayVersion"`
	InstallDate    string                 `json:"installDate" bson:"installDate"`
	OtherInfo      map[string]interface{} `json:"-" bson:"-"`
}

func (MicrosoftSQLServerPatch) MarshalBSON 

func (v MicrosoftSQLServerPatch) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerPatch) MarshalJSON 

func (v MicrosoftSQLServerPatch) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerPatch) UnmarshalBSON 

func (v *MicrosoftSQLServerPatch) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerPatch) UnmarshalJSON 

func (v *MicrosoftSQLServerPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type MicrosoftSQLServerProductFeature 

type MicrosoftSQLServerProductFeature struct {
	Product    string                 `json:"product" bson:"product"`
	Feature    string                 `json:"feature" bson:"feature"`
	Language   string                 `json:"language" bson:"language"`
	Edition    string                 `json:"edition" bson:"edition"`
	Version    string                 `json:"version" bson:"version"`
	Clustered  bool                   `json:"clustered" bson:"clustered"`
	Configured bool                   `json:"configured" bson:"configured"`
	OtherInfo  map[string]interface{} `json:"-" bson:"-"`
}

func (MicrosoftSQLServerProductFeature) MarshalBSON 

func (v MicrosoftSQLServerProductFeature) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (MicrosoftSQLServerProductFeature) MarshalJSON 

func (v MicrosoftSQLServerProductFeature) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*MicrosoftSQLServerProductFeature) UnmarshalBSON 

func (v *MicrosoftSQLServerProductFeature) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*MicrosoftSQLServerProductFeature) UnmarshalJSON 

func (v *MicrosoftSQLServerProductFeature) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabase 

type OracleDatabase struct {
	InstanceNumber    int                               `json:"instanceNumber" bson:"instanceNumber"`
	InstanceName      string                            `json:"instanceName" bson:"instanceName"`
	Name              string                            `json:"name" bson:"name"`
	UniqueName        string                            `json:"uniqueName" bson:"uniqueName"`
	Status            string                            `json:"status" bson:"status"`
	DbID              uint                              `json:"dbID" bson:"dbID"`
	Role              string                            `json:"role" bson:"role"`
	IsCDB             bool                              `json:"isCDB" bson:"isCDB"`
	Version           string                            `json:"version" bson:"version"`
	Platform          string                            `json:"platform" bson:"platform"`
	Archivelog        bool                              `json:"archivelog" bson:"archivelog"`
	Charset           string                            `json:"charset" bson:"charset"`
	NCharset          string                            `json:"nCharset" bson:"nCharset"`
	BlockSize         int                               `json:"blockSize" bson:"blockSize"`
	CPUCount          int                               `json:"cpuCount" bson:"cpuCount"`
	SGATarget         float64                           `json:"sgaTarget" bson:"sgaTarget"`
	PGATarget         float64                           `json:"pgaTarget" bson:"pgaTarget"`
	MemoryTarget      float64                           `json:"memoryTarget" bson:"memoryTarget"`
	SGAMaxSize        float64                           `json:"sgaMaxSize" bson:"sgaMaxSize"`
	SegmentsSize      float64                           `json:"segmentsSize" bson:"segmentsSize"`
	DatafileSize      float64                           `json:"datafileSize" bson:"datafileSize"`
	Allocable         float64                           `json:"allocable" bson:"allocable"`
	Elapsed           *float64                          `json:"elapsed" bson:"elapsed"`
	DBTime            *float64                          `json:"dbTime" bson:"dbTime"`
	DailyCPUUsage     *float64                          `json:"dailyCPUUsage" bson:"dailyCPUUsage"`
	Work              *float64                          `json:"work" bson:"work"`
	ASM               bool                              `json:"asm" bson:"asm"`
	Dataguard         bool                              `json:"dataguard" bson:"dataguard"`
	Patches           []OracleDatabasePatch             `json:"patches" bson:"patches"`
	Tablespaces       []OracleDatabaseTablespace        `json:"tablespaces" bson:"tablespaces"`
	Schemas           []OracleDatabaseSchema            `json:"schemas" bson:"schemas"`
	Licenses          []OracleDatabaseLicense           `json:"licenses" bson:"licenses"`
	ADDMs             []OracleDatabaseAddm              `json:"addms" bson:"addms"`
	SegmentAdvisors   []OracleDatabaseSegmentAdvisor    `json:"segmentAdvisors" bson:"segmentAdvisors"`
	PSUs              []OracleDatabasePSU               `json:"psus" bson:"psus"`
	Backups           []OracleDatabaseBackup            `json:"backups" bson:"backups"`
	FeatureUsageStats []OracleDatabaseFeatureUsageStat  `json:"featureUsageStats" bson:"featureUsageStats"`
	PDBs              []OracleDatabasePluggableDatabase `json:"pdbs" bson:"pdbs"`
	Services          []OracleDatabaseService           `json:"services" bson:"services"`
	OtherInfo         map[string]interface{}            `json:"-" bson:"-"`
}

OracleDatabase holds information about an Oracle database.

func (OracleDatabase) CoreFactor 

func (v OracleDatabase) CoreFactor(host Host) float64

func (OracleDatabase) Edition 

func (v OracleDatabase) Edition() (dbEdition string)

func (OracleDatabase) MarshalBSON 

func (v OracleDatabase) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabase) MarshalJSON 

func (v OracleDatabase) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabase) UnmarshalBSON 

func (v *OracleDatabase) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabase) UnmarshalJSON 

func (v *OracleDatabase) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseAddm 

type OracleDatabaseAddm struct {
	Finding        string                 `json:"finding" bson:"finding"`
	Recommendation string                 `json:"recommendation" bson:"recommendation"`
	Action         string                 `json:"action" bson:"action"`
	Benefit        float64                `json:"benefit" bson:"benefit"`
	OtherInfo      map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseAddm contains info about a addm

func (OracleDatabaseAddm) MarshalBSON 

func (v OracleDatabaseAddm) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseAddm) MarshalJSON 

func (v OracleDatabaseAddm) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseAddm) UnmarshalBSON 

func (v *OracleDatabaseAddm) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseAddm) UnmarshalJSON 

func (v *OracleDatabaseAddm) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseAgreement 

type OracleDatabaseAgreement struct {
	ID          primitive.ObjectID `json:"id" bson:"_id"`
	AgreementID string             `json:"agreementID" bson:"agreementID"`
	CSI         string             `json:"csi" bson:"csi"`
	Parts       []AssociatedPart   `json:"parts" bson:"parts"`
}

OracleDatabaseAgreement holds informations about a sigle OracleDatabaseAgreement

func (*OracleDatabaseAgreement) AssociatedPartByID 

func (agreement *OracleDatabaseAgreement) AssociatedPartByID(associatedPartID primitive.ObjectID,
) (associatedPart *AssociatedPart)

AssociatedPartByID getter

type OracleDatabaseBackup 

type OracleDatabaseBackup struct {
	BackupType string                 `json:"backupType" bson:"backupType"`
	Hour       string                 `json:"hour" bson:"hour"`
	WeekDays   []string               `json:"weekDays" bson:"weekDays"`
	AvgBckSize float64                `json:"avgBckSize" bson:"avgBckSize"`
	Retention  string                 `json:"retention" bson:"retention"`
	OtherInfo  map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseBackup holds informations about a backup

func (OracleDatabaseBackup) MarshalBSON 

func (v OracleDatabaseBackup) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseBackup) MarshalJSON 

func (v OracleDatabaseBackup) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseBackup) UnmarshalBSON 

func (v *OracleDatabaseBackup) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseBackup) UnmarshalJSON 

func (v *OracleDatabaseBackup) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseFeature 

type OracleDatabaseFeature struct {
	Databases                []OracleDatabase       `json:"databases" bson:"databases"`
	UnlistedRunningDatabases []string               `json:"unlistedRunningDatabases" bson:"unlistedRunningDatabases"`
	OtherInfo                map[string]interface{} `json:"-" bson:"-"`
}

func (OracleDatabaseFeature) MarshalBSON 

func (v OracleDatabaseFeature) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseFeature) MarshalJSON 

func (v OracleDatabaseFeature) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseFeature) UnmarshalBSON 

func (v *OracleDatabaseFeature) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseFeature) UnmarshalJSON 

func (v *OracleDatabaseFeature) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseFeatureUsageStat 

type OracleDatabaseFeatureUsageStat struct {
	Product          string                 `json:"product" bson:"product"`
	Feature          string                 `json:"feature" bson:"feature"`
	DetectedUsages   int64                  `json:"detectedUsages" bson:"detectedUsages"`
	CurrentlyUsed    bool                   `json:"currentlyUsed" bson:"currentlyUsed"`
	FirstUsageDate   time.Time              `json:"firstUsageDate" bson:"firstUsageDate"`
	LastUsageDate    time.Time              `json:"lastUsageDate" bson:"lastUsageDate"`
	ExtraFeatureInfo string                 `json:"extraFeatureInfo" bson:"extraFeatureInfo"`
	OtherInfo        map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseFeatureUsageStat holds information about an Oracle database feature usage stat.

func (OracleDatabaseFeatureUsageStat) MarshalBSON 

func (v OracleDatabaseFeatureUsageStat) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseFeatureUsageStat) MarshalJSON 

func (v OracleDatabaseFeatureUsageStat) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseFeatureUsageStat) UnmarshalBSON 

func (v *OracleDatabaseFeatureUsageStat) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseFeatureUsageStat) UnmarshalJSON 

func (v *OracleDatabaseFeatureUsageStat) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseLicense 

type OracleDatabaseLicense struct {
	Name      string                 `json:"name" bson:"name"`
	Count     float64                `json:"count" bson:"count"`
	OtherInfo map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseLicense holds information about an Oracle database license

func (OracleDatabaseLicense) MarshalBSON 

func (v OracleDatabaseLicense) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseLicense) MarshalJSON 

func (v OracleDatabaseLicense) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseLicense) UnmarshalBSON 

func (v *OracleDatabaseLicense) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseLicense) UnmarshalJSON 

func (v *OracleDatabaseLicense) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabasePSU 

type OracleDatabasePSU struct {
	Date        string                 `json:"date" bson:"date"`
	Description string                 `json:"description" bson:"description"`
	OtherInfo   map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabasePSU holds information about a OracleDatabasePSU

func (OracleDatabasePSU) MarshalBSON 

func (v OracleDatabasePSU) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabasePSU) MarshalJSON 

func (v OracleDatabasePSU) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabasePSU) UnmarshalBSON 

func (v *OracleDatabasePSU) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabasePSU) UnmarshalJSON 

func (v *OracleDatabasePSU) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabasePart 

type OracleDatabasePart struct {
	PartID          string   `json:"partID" bson:"partID"`
	ItemDescription string   `json:"itemDescription" bson:"itemDescription"`
	Metric          string   `json:"metric" bson:"metric"`
	Cost            float64  `json:"cost" bson:"cost"`
	Aliases         []string `json:"aliases" bson:"aliases"`
}

OracleDatabasePart holds informations about a single OracleDatabasePart

type OracleDatabasePatch 

type OracleDatabasePatch struct {
	Version     string                 `json:"version" bson:"version"`
	PatchID     int                    `json:"patchID" bson:"patchID"`
	Action      string                 `json:"action" bson:"action"`
	Description string                 `json:"description" bson:"description"`
	Date        string                 `json:"date" bson:"date"`
	OtherInfo   map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabasePatch holds information about an Oracle database patch

func (OracleDatabasePatch) MarshalBSON 

func (v OracleDatabasePatch) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabasePatch) MarshalJSON 

func (v OracleDatabasePatch) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabasePatch) UnmarshalBSON 

func (v *OracleDatabasePatch) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabasePatch) UnmarshalJSON 

func (v *OracleDatabasePatch) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabasePluggableDatabase 

type OracleDatabasePluggableDatabase struct {
	Name        string                     `json:"name" bson:"name"`
	Status      string                     `json:"status" bson:"status"`
	Tablespaces []OracleDatabaseTablespace `json:"tablespaces" bson:"tablespaces"`
	Schemas     []OracleDatabaseSchema     `json:"schemas" bson:"schemas"`
	Services    []OracleDatabaseService    `json:"services" bson:"services"`
	OtherInfo   map[string]interface{}     `json:"-" bson:"-"`
}

OracleDatabasePluggableDatabase holds information about an Oracle pluggable database.

func (OracleDatabasePluggableDatabase) MarshalBSON 

func (v OracleDatabasePluggableDatabase) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabasePluggableDatabase) MarshalJSON 

func (v OracleDatabasePluggableDatabase) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabasePluggableDatabase) UnmarshalBSON 

func (v *OracleDatabasePluggableDatabase) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabasePluggableDatabase) UnmarshalJSON 

func (v *OracleDatabasePluggableDatabase) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseSchema 

type OracleDatabaseSchema struct {
	Indexes   int                    `json:"indexes" bson:"indexes"`
	LOB       int                    `json:"lob" bson:"lob"`
	Tables    int                    `json:"tables" bson:"tables"`
	Total     int                    `json:"total" bson:"total"`
	User      string                 `json:"user" bson:"user"`
	OtherInfo map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseSchema holds information about Oracle database schema.

func (OracleDatabaseSchema) MarshalBSON 

func (v OracleDatabaseSchema) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseSchema) MarshalJSON 

func (v OracleDatabaseSchema) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseSchema) UnmarshalBSON 

func (v *OracleDatabaseSchema) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseSchema) UnmarshalJSON 

func (v *OracleDatabaseSchema) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseSegmentAdvisor 

type OracleDatabaseSegmentAdvisor struct {
	SegmentOwner   string                 `json:"segmentOwner" bson:"segmentOwner"`
	SegmentName    string                 `json:"segmentName" bson:"segmentName"`
	SegmentType    string                 `json:"segmentType" bson:"segmentType"`
	PartitionName  string                 `json:"partitionName" bson:"partitionName"`
	Reclaimable    float64                `json:"reclaimable" bson:"reclaimable"`
	Recommendation string                 `json:"recommendation" bson:"recommendation"`
	OtherInfo      map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseSegmentAdvisor holds information about a segment advisor

func (OracleDatabaseSegmentAdvisor) MarshalBSON 

func (v OracleDatabaseSegmentAdvisor) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseSegmentAdvisor) MarshalJSON 

func (v OracleDatabaseSegmentAdvisor) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseSegmentAdvisor) UnmarshalBSON 

func (v *OracleDatabaseSegmentAdvisor) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseSegmentAdvisor) UnmarshalJSON 

func (v *OracleDatabaseSegmentAdvisor) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseService 

type OracleDatabaseService struct {
	Name      string                 `json:"name" bson:"name"`
	OtherInfo map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseService holds information about an Oracle database service

func (OracleDatabaseService) MarshalBSON 

func (v OracleDatabaseService) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseService) MarshalJSON 

func (v OracleDatabaseService) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseService) UnmarshalBSON 

func (v *OracleDatabaseService) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseService) UnmarshalJSON 

func (v *OracleDatabaseService) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleDatabaseTablespace 

type OracleDatabaseTablespace struct {
	Name      string                 `json:"name" bson:"name"`
	MaxSize   float64                `json:"maxSize" bson:"maxSize"`
	Total     float64                `json:"total" bson:"total"`
	Used      float64                `json:"used" bson:"used"`
	UsedPerc  float64                `json:"usedPerc" bson:"usedPerc"`
	Status    string                 `json:"status" bson:"status"`
	OtherInfo map[string]interface{} `json:"-" bson:"-"`
}

OracleDatabaseTablespace holds the informations about a tablespace.

func (OracleDatabaseTablespace) MarshalBSON 

func (v OracleDatabaseTablespace) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleDatabaseTablespace) MarshalJSON 

func (v OracleDatabaseTablespace) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleDatabaseTablespace) UnmarshalBSON 

func (v *OracleDatabaseTablespace) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleDatabaseTablespace) UnmarshalJSON 

func (v *OracleDatabaseTablespace) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleExadataCellDisk 

type OracleExadataCellDisk struct {
	ErrCount  int                    `json:"errCount" bson:"errCount"`
	Name      string                 `json:"name" bson:"name"`
	Status    string                 `json:"status" bson:"status"`
	UsedPerc  int                    `json:"usedPerc" bson:"usedPerc"`
	OtherInfo map[string]interface{} `json:"-" bson:"-"`
}

OracleExadataCellDisk holds info about a exadata cell disk

func (OracleExadataCellDisk) MarshalBSON 

func (v OracleExadataCellDisk) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleExadataCellDisk) MarshalJSON 

func (v OracleExadataCellDisk) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleExadataCellDisk) UnmarshalBSON 

func (v *OracleExadataCellDisk) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleExadataCellDisk) UnmarshalJSON 

func (v *OracleExadataCellDisk) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleExadataComponent 

type OracleExadataComponent struct {
	Hostname             string                   `json:"hostname" bson:"hostname"`
	ServerType           string                   `json:"serverType" bson:"serverType"`
	Model                string                   `json:"model" bson:"model"`
	SwVersion            string                   `json:"swVersion" bson:"swVersion"`
	SwReleaseDate        string                   `json:"swReleaseDate" bson:"swReleaseDate"`
	RunningCPUCount      *int                     `json:"runningCPUCount" bson:"runningCPUCount"`
	TotalCPUCount        *int                     `json:"totalCPUCount" bson:"totalCPUCount"`
	Memory               *int                     `json:"memory" bson:"memory"`
	Status               *string                  `json:"status" bson:"status"`
	RunningPowerSupply   *int                     `json:"runningPowerSupply" bson:"runningPowerSupply"`
	TotalPowerSupply     *int                     `json:"totalPowerSupply" bson:"totalPowerSupply"`
	PowerStatus          *string                  `json:"powerStatus" bson:"powerStatus"`
	RunningFanCount      *int                     `json:"runningFanCount" bson:"runningFanCount"`
	TotalFanCount        *int                     `json:"totalFanCount" bson:"totalFanCount"`
	FanStatus            *string                  `json:"fanStatus" bson:"fanStatus"`
	TempActual           *float64                 `json:"tempActual" bson:"tempActual"`
	TempStatus           *string                  `json:"tempStatus" bson:"tempStatus"`
	CellsrvServiceStatus *string                  `json:"cellsrvServiceStatus" bson:"cellsrvServiceStatus"`
	MsServiceStatus      *string                  `json:"msServiceStatus" bson:"msServiceStatus"`
	RsServiceStatus      *string                  `json:"rsServiceStatus" bson:"rsServiceStatus"`
	FlashcacheMode       *string                  `json:"flashcacheMode" bson:"flashcacheMode"`
	CellDisks            *[]OracleExadataCellDisk `json:"cellDisks" bson:"cellDisks"`
	OtherInfo            map[string]interface{}   `json:"-" bson:"-"`
}

OracleExadataComponent holds informations about a device in a exadata

func (OracleExadataComponent) MarshalBSON 

func (v OracleExadataComponent) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleExadataComponent) MarshalJSON 

func (v OracleExadataComponent) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleExadataComponent) UnmarshalBSON 

func (v *OracleExadataComponent) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleExadataComponent) UnmarshalJSON 

func (v *OracleExadataComponent) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleExadataFeature 

type OracleExadataFeature struct {
	Components []OracleExadataComponent `json:"components" bson:"components"`
	OtherInfo  map[string]interface{}   `json:"-" bson:"-"`
}

OracleExadataFeature holds specific informations about a exadata.

func (OracleExadataFeature) MarshalBSON 

func (v OracleExadataFeature) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleExadataFeature) MarshalJSON 

func (v OracleExadataFeature) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleExadataFeature) UnmarshalBSON 

func (v *OracleExadataFeature) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleExadataFeature) UnmarshalJSON 

func (v *OracleExadataFeature) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type OracleFeature 

type OracleFeature struct {
	Database  *OracleDatabaseFeature `json:"database,omitempty" bson:"database,omitempty"`
	Exadata   *OracleExadataFeature  `json:"exadata,omitempty" bson:"exadata,omitempty"`
	OtherInfo map[string]interface{} `json:"-" bson:"-"`
}

func (OracleFeature) MarshalBSON 

func (v OracleFeature) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (OracleFeature) MarshalJSON 

func (v OracleFeature) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*OracleFeature) UnmarshalBSON 

func (v *OracleFeature) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*OracleFeature) UnmarshalJSON 

func (v *OracleFeature) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

type PatchingFunction 

type PatchingFunction struct {
	ID        *primitive.ObjectID `json:"id" bson:"_id"`
	Hostname  string              `json:"hostname" bson:"hostname"`
	CreatedAt time.Time           `json:"createdAt" bson:"createdAt"`
	// PatchingFunction contains the javascript code that patch the hostdata
	// the hostdata is given via the hostdata global variable.
	// the static vars is given via the vars global variable
	// The function should be idempotent and reversible
	// e.g. PF(hostdata) == PF(PF(hostdata)) && ∃ PF⁻¹ | PF⁻¹(patchedHostData) == hostdata
	Code string                 `json:"code" bson:"code"`
	Vars map[string]interface{} `json:"vars" bson:"vars"`
}

PatchingFunction holds all informations about a patching function

type RawObject 

type RawObject map[string]interface{}

RawObject contains a object

type TechnologyInfo 

type TechnologyInfo struct {
	Product    string `json:"product"`
	PrettyName string `json:"prettyName"`
	Color      string `json:"color"`
}

TechnologyInfo contains the informations about a technology

type TechnologyStatus 

type TechnologyStatus struct {
	Product             string  `json:"product"`
	ConsumedByHosts     float64 `json:"-"`
	CoveredByAgreements float64 `json:"-"`
	TotalCost           float64 `json:"-"`
	PaidCost            float64 `json:"-"`
	Compliance          float64 `json:"compliance"`
	UnpaidDues          float64 `json:"unpaidDues"`
	HostsCount          int     `json:"hostsCount"`
}

TechnologyStatus represent usage status of a technology

type TechnologySupportedMetrics 

type TechnologySupportedMetrics struct {
	Product string   `json:"product"`
	Metrics []string `json:"metrics"`
}

TechnologySupportedMetrics contains the informations about the supported metrics of a technology

type VMInfo 

type VMInfo struct {
	Name               string                 `json:"name" bson:"name"`
	Hostname           string                 `json:"hostname" bson:"hostname"` //Hostname or IP address
	CappedCPU          bool                   `json:"cappedCPU" bson:"cappedCPU"`
	VirtualizationNode string                 `json:"virtualizationNode" bson:"virtualizationNode"`
	OtherInfo          map[string]interface{} `json:"-" bson:"-"`
}

VMInfo holds info about the vm

func (VMInfo) MarshalBSON 

func (v VMInfo) MarshalBSON() ([]byte, error)

MarshalBSON return the BSON rappresentation of this

func (VMInfo) MarshalJSON 

func (v VMInfo) MarshalJSON() ([]byte, error)

MarshalJSON return the JSON rappresentation of this

func (*VMInfo) UnmarshalBSON 

func (v *VMInfo) UnmarshalBSON(data []byte) error

UnmarshalBSON parse the BSON content in data and set the fields in v appropriately

func (*VMInfo) UnmarshalJSON 

func (v *VMInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON parse the JSON content in data and set the fields in v appropriately

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.