gatherers

var (
	AscsErsClusterDecodingError = entities.FactGatheringError{
		Type:    "ascsers-cluster-decoding-error",
		Message: "error decoding cibadmin output",
	}

	AscsErsClusterCibError = entities.FactGatheringError{
		Type:    "ascsers-cluster-cib-error",
		Message: "error parsing cibadmin output",
	}
)

var (
	CibAdminCommandError = entities.FactGatheringError{
		Type:    "cibadmin-command-error",
		Message: "error running cibadmin command",
	}

	CibAdminDecodingError = entities.FactGatheringError{
		Type:    "cibadmin-decoding-error",
		Message: "error decoding cibadmin output",
	}
)

var (
	CorosyncCmapCtlValueNotFound = entities.FactGatheringError{
		Type:    "corosync-cmapctl-value-not-found",
		Message: "requested value not found in corosync-cmapctl output",
	}

	CorosyncCmapCtlCommandError = entities.FactGatheringError{
		Type:    "corosync-cmapctl-command-error",
		Message: "error while executing corosynccmap-ctl",
	}

	CorosyncCmapCtlMissingArgument = entities.FactGatheringError{
		Type:    "corosync-cmapctl-missing-argument",
		Message: "missing required argument",
	}
)

var (
	CorosyncConfFileError = entities.FactGatheringError{
		Type:    "corosync-conf-file-error",
		Message: "error reading corosync.conf file",
	}

	CorosyncConfDecodingError = entities.FactGatheringError{
		Type:    "corosync-conf-decoding-error",
		Message: "error decoding corosync.conf file",
	}
)

var (
	DirScanMissingArgumentError = entities.FactGatheringError{
		Type:    "dir-scan-missing-argument",
		Message: "missing required argument",
	}

	DirScanOpenError = entities.FactGatheringError{
		Type:    "dir-scan-open-error",
		Message: "could not open the provided directory",
	}

	DirScanScanningError = entities.FactGatheringError{
		Type:    "dir-scan-scanning-error",
		Message: "error during directory scanning",
	}
)

var (
	DispWorkFileSystemError = entities.FactGatheringError{
		Type:    "dispwork-file-system-error",
		Message: "error reading the file system",
	}

	DispWorkCommandError = entities.FactGatheringError{
		Type:    "dispwork-command-error",
		Message: "error running disp+work command",
	}

	DispWorkDecodingError = entities.FactGatheringError{
		Type:    "dispwork-decoding-error",
		Message: "error decoding disp+work output",
	}
)

var (
	FstabFileError = entities.FactGatheringError{
		Type:    "fstab-file-error",
		Message: "error reading /etc/fstab file",
	}

	FstabFileDecodingError = entities.FactGatheringError{
		Type:    "fstab-decoding-error",
		Message: "error decoding fstab file",
	}
)

var (
	GroupsFileError = entities.FactGatheringError{
		Type:    "groups-file-error",
		Message: "error reading /etc/group file",
	}

	GroupsFileDecodingError = entities.FactGatheringError{
		Type:    "groups-decoding-error",
		Message: "error deconding groups file",
	}
)

var (
	HostsFileError = entities.FactGatheringError{
		Type:    "hosts-file-error",
		Message: "error reading /etc/hosts file",
	}

	HostsFileDecodingError = entities.FactGatheringError{
		Type:    "hosts-file-decoding-error",
		Message: "error decoding /etc/hosts file",
	}

	HostsFileEntryNotFoundError = entities.FactGatheringError{
		Type:    "hosts-file-value-not-found",
		Message: "requested field value not found in /etc/hosts file",
	}
)

var (
	MountInfoParsingError = entities.FactGatheringError{
		Type:    "mount-info-parsing-error",
		Message: "error parsing mount information",
	}

	MountInfoMissingArgumentError = entities.FactGatheringError{
		Type:    "mount-info-missing-argument",
		Message: "missing required argument",
	}

	MountInfoDecodingError = entities.FactGatheringError{
		Type:    "mount-info-decoding-error",
		Message: "error decoding mount information",
	}
)

var (
	OSReleaseFileError = entities.FactGatheringError{
		Type:    "os-release-file-error",
		Message: "error reading /etc/os-release file",
	}

	OSReleaseDecodingError = entities.FactGatheringError{
		Type:    "os-release-decoding-error",
		Message: "error decoding file content",
	}
)

var (
	PackageVersionRpmCommandError = entities.FactGatheringError{
		Type:    "package-version-rpm-cmd-error",
		Message: "error while fetching package version",
	}

	PackageVersionZypperCommandError = entities.FactGatheringError{
		Type:    "package-version-zypper-cmd-error",
		Message: "error while executing zypper",
	}

	PackageVersionMissingArgument = entities.FactGatheringError{
		Type:    "package-version-missing-argument",
		Message: "missing required argument",
	}
)

var (
	PasswdFileError = entities.FactGatheringError{
		Type:    "passwd-file-error",
		Message: "error reading /etc/passwd file",
	}

	PasswdDecodingError = entities.FactGatheringError{
		Type:    "passwd-decoding-error",
		Message: "error decoding file content",
	}
)

var (
	ProductsFolderMissingError = entities.FactGatheringError{
		Type:    "products-folder-missing-error",
		Message: "products folder does not exist",
	}

	ProductsFolderReadingError = entities.FactGatheringError{
		Type:    "products-folder-reading-error",
		Message: "error reading the products folder",
	}

	ProductsFileReadingError = entities.FactGatheringError{
		Type:    "products-file-reading-error",
		Message: "error reading the products file",
	}
)

var (
	SapcontrolFileSystemError = entities.FactGatheringError{
		Type:    "sapcontrol-file-system-error",
		Message: "error in the SAP file system",
	}

	SapcontrolArgumentUnsupported = entities.FactGatheringError{
		Type:    "sapcontrol-unsupported-argument",
		Message: "the requested argument is not currently supported",
	}

	SapcontrolMissingArgument = entities.FactGatheringError{
		Type:    "sapcontrol-missing-argument",
		Message: "missing required argument",
	}

	SapcontrolWebmethodError = entities.FactGatheringError{
		Type:    "sapcontrol-webmethod-error",
		Message: "error executing sapcontrol webmethod",
	}

	SapcontrolDecodingError = entities.FactGatheringError{
		Type:    "sapcontrol-decoding-error",
		Message: "error decoding sapcontrol output",
	}
)

var (
	SapHostCtrlCommandError = entities.FactGatheringError{
		Type:    "saphostctrl-cmd-error",
		Message: "error executing saphostctrl command",
	}

	SapHostCtrlUnsupportedFunction = entities.FactGatheringError{
		Type:    "saphostctrl-webmethod-error",
		Message: "requested webmethod not supported",
	}

	SapHostCtrlParseError = entities.FactGatheringError{
		Type:    "saphostctrl-parse-error",
		Message: "error while parsing saphostctrl output",
	}

	SapHostCtrlMissingArgument = entities.FactGatheringError{
		Type:    "saphostctrl-missing-argument",
		Message: "missing required argument",
	}
)

var (
	SapInstanceHostnameResolverDetailsError = entities.FactGatheringError{
		Type:    "sapinstance-hostname-resolver-details-error",
		Message: "error gathering details",
	}
	SapInstanceHostnameResolverGathererDecodingError = entities.FactGatheringError{
		Type:    "sapinstance-hostname-resolver-decoding-error",
		Message: "error decoding output to FactValue",
	}
)

var (
	SapProfilesFileSystemError = entities.FactGatheringError{
		Type:    "sap-profiles-file-system-error",
		Message: "error reading the sap profiles file system",
	}

	SapProfilesDecodingError = entities.FactGatheringError{
		Type:    "sap-profiles-decoding-error",
		Message: "error deconding sap profiles content",
	}
)

var (
	SapServicesParsingError = entities.FactGatheringError{
		Type:    "sap-services-parsing-error",
		Message: "error parsing the sapservices file",
	}
	SapServicesFileError = entities.FactGatheringError{
		Type:    "sap-services-reading-error",
		Message: "error reading the sapservices file",
	}
	SapstartSIDExtractionPattern = regexp.MustCompile(`(?s)pf=[^[:space:]]+/(.*?)_.*_.*`)
	SystemdSIDExtractionPattern  = regexp.MustCompile(`(?s)start SAP(.*?)_.*`)
)

var (
	SaptuneNotInstalled = entities.FactGatheringError{
		Type:    "saptune-not-installed",
		Message: "saptune is not installed",
	}

	SaptuneVersionUnsupported = entities.FactGatheringError{
		Type:    "saptune-version-not-supported",
		Message: "currently installed version of saptune is not supported",
	}

	SaptuneArgumentUnsupported = entities.FactGatheringError{
		Type:    "saptune-unsupported-argument",
		Message: "the requested argument is not currently supported",
	}

	SaptuneMissingArgument = entities.FactGatheringError{
		Type:    "saptune-missing-argument",
		Message: "missing required argument",
	}

	SaptuneCommandError = entities.FactGatheringError{
		Type:    "saptune-cmd-error",
		Message: "error executing saptune command",
	}
)

var (
	SBDConfigFileError = entities.FactGatheringError{
		Type:    "sbd-config-file-error",
		Message: "error reading sbd configuration file",
	}

	SBDConfigValueNotFoundError = entities.FactGatheringError{
		Type:    "sbd-config-value-not-found",
		Message: "requested field value not found",
	}

	SBDConfigMissingArgument = entities.FactGatheringError{
		Type:    "sbd-config-missing-argument",
		Message: "missing required argument",
	}
)

var (
	SBDDevicesLoadingError = entities.FactGatheringError{
		Type:    "sbd-devices-loading-error",
		Message: "error loading the configured sbd devices",
	}

	SBDDumpCommandError = entities.FactGatheringError{
		Type:    "sbd-dump-command-error",
		Message: "error while executing sbd dump",
	}
)

var (
	SysctlValueNotFound = entities.FactGatheringError{
		Type:    "sysctl-value-not-found",
		Message: "requested value not found in sysctl output",
	}

	SysctlCommandError = entities.FactGatheringError{
		Type:    "sysctl-cmd-error",
		Message: "error executing sysctl command",
	}

	SysctlMissingArgument = entities.FactGatheringError{
		Type:    "sysctl-missing-argument",
		Message: "missing required argument",
	}
)

var (
	SystemDNotInitializedError = entities.FactGatheringError{
		Type:    "systemd-dbus-not-initialized",
		Message: "systemd gatherer not initialized properly",
	}

	SystemDListUnitsError = entities.FactGatheringError{
		Type:    "systemd-list-units-error",
		Message: "error getting unit states",
	}

	SystemDMissingArgument = entities.FactGatheringError{
		Type:    "systemd-missing-argument",
		Message: "missing required argument",
	}
)

var (
	SystemDUnitError = entities.FactGatheringError{
		Type:    "systemd-unit-error",
		Message: "error getting systemd unit properties",
	}

	SystemDDecodingError = entities.FactGatheringError{
		Type:    "systemd-decoding-error",
		Message: "error decoding systemd unit status",
	}
)

var (
	VerifyPasswordInvalidUsername = entities.FactGatheringError{
		Type:    "verify-password-invalid-username",
		Message: "requested user is not whitelisted for password check",
	}

	VerifyPasswordShadowError = entities.FactGatheringError{
		Type:    "verify-password-shadow-error",
		Message: "error getting shadow output",
	}

	VerifyPasswordPasswordBlocked = entities.FactGatheringError{
		Type:    "verify-password-password-blocked",
		Message: "password authentication blocked for user",
	}

	VerifyPasswordPasswordNotSet = entities.FactGatheringError{
		Type:    "verify-password-password-not-set",
		Message: "password not set for user",
	}

	VerifyPasswordCryptError = entities.FactGatheringError{
		Type:    "verify-password-crypt-error",
		Message: "error while verifying the password for user",
	}
)

var ImplementationError = entities.FactGatheringError{
	Type:    "implemetation-error",
	Message: "implementation error",
}