model

package
v0.0.0-...-cc99bfc 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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL